Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
const basename = pair[1];
const rule = require(path.resolve(filename));
likely benign
LLM, confidence 0.80
Makefile.js dynamically requires a rule file resolved from a local path.
Reasoning
Build script requiring a rule file resolved from a filename argument; the build tooling loads local rule files, which is normal for ESLint's Makefile.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
);
const data = require(filePath);
const { items } = data;
likely benign
LLM, confidence 0.80
Makefile.js requires a local data file at a computed path.
Reasoning
Build script loading a local JSON/data file from a computed path in the ESLint repo's maintenance tooling; no network or encoded payload involved.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
const docsPackagePath = path.join(__dirname, "docs", "package.json");
const docsPackage = require(docsPackagePath);
docsPackage.version = releaseInfo.version;
likely benign
LLM, confidence 0.85
Release script requires docs package.json by computed path to set its version.
Reasoning
Requires docs/package.json from a path built with __dirname to update the version; ordinary release scripting.
-
`require` called with a non-literal specifier (ast pass, confidence 0.80)
try {
const template = require(`../messages/${error.messageTemplate}.js`);
return template(error.messageData || {});
likely benign
LLM, confidence 0.85
CLI loads an internal message template file using a templated filename.
Reasoning
Loads a message template by name from the project's messages directory; the template name is internal error metadata, so this is a normal plugin-style lookup, though the name is not strictly validated.
-
file mixes tab and space indentation (8 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)
module.exports = md => {
const defaultFenceRenderer = md.renderer.rules.fence;
md.renderer.rules.fence = (...args) => {
-
1312 of 2868 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)
-
U+200C ZERO WIDTH NON-JOINER in source (in string/comment) (raw pass, confidence 0.45)
.replace(/"(?:\\"|[^"])*"|'(?:\\'|[^'])*'/g, function (e) {
return e.replace(/,/g, "⟨U+200C⟩");
})
.split(/\s*(?![^(]*\)),\s*/)
-
85 of 197 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)
-
file mixes tab and space indentation (146 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)
const resultsLiveRegion = document.querySelector(
"#search-results-announcement",
);
const searchInput = document.querySelector("#search");
-
[embedded javascript] mean non-conventional identifier length 1.93 over 30 names (token pass, confidence 0.50)
-
[embedded javascript] mean non-conventional identifier length 1.67 over 39 names (token pass, confidence 0.50)
-
[embedded javascript] mean non-conventional identifier length 1.69 over 29 names (token pass, confidence 0.50)
-
[embedded javascript] `require` called with a non-literal specifier (ast pass, confidence 0.60)
var getModule = (name) => require(name);
dismissed
LLM, confidence 0.95
Docs example showing a non-literal require inside an arrow function.
Reasoning
Documentation example illustrating a rule's bad pattern inside a markdown code block; not executed code.
-
[embedded javascript] `require` called with a non-literal specifier (ast pass, confidence 0.60)
function getModule(name) {
return require(name);
}
dismissed
LLM, confidence 0.95
Docs example of require(name) inside a function body.
Reasoning
Rule documentation snippet demonstrating what is disallowed; illustrative only.
-
[embedded javascript] `require` called with a non-literal specifier (ast pass, confidence 0.60)
try {
require(unsafeModule);
} catch (e) {
console.log(e);
dismissed
LLM, confidence 0.95
Docs example of a require inside try block for a rule description.
Reasoning
Rule documentation example in a markdown code block showing incorrect usage.
-
[embedded javascript] mean non-conventional identifier length 1.00 over 30 names (token pass, confidence 0.50)
-
[embedded javascript] mean non-conventional identifier length 1.05 over 20 names (token pass, confidence 0.50)
-
[embedded javascript] mean non-conventional identifier length 1.90 over 20 names (token pass, confidence 0.50)
-
[embedded javascript] 27 of 63 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)
-
[embedded javascript] `eval` called with a non-literal expression (ast pass, confidence 0.90)
key = "x",
value = eval("obj." + key);
dismissed
LLM, confidence 0.95
Docs example showing eval usage that the no-eval rule flags.
Reasoning
Documentation example for the no-eval rule in markdown; the eval is illustrative, not executed.
-
[embedded javascript] `eval` called with a non-literal expression (ast pass, confidence 0.90)
key = "x",
value = eval("obj." + key);
(0, eval)("const a = 0");
dismissed
LLM, confidence 0.95
Docs example of indirect eval for the no-eval rule.
Reasoning
Same no-eval rule documentation example; illustrative only.
-
[embedded javascript] `eval` called with a non-literal expression (ast pass, confidence 0.90)
key = "x",
value = eval("obj." + key);
dismissed
LLM, confidence 0.95
Docs example of eval in the no-eval rule page.
Reasoning
Rule documentation code sample in markdown, not live code.
-
[embedded javascript] `setTimeout` called with a string argument — string form evaluates as code (ast pass, confidence 0.75)
setTimeout("alert('Hi!');", 100);
dismissed
LLM, confidence 0.95
Docs example of setTimeout with a string argument.
Reasoning
Markdown documentation sample demonstrating a disallowed pattern for the no-implied-eval rule.
-
[embedded javascript] `setTimeout` called with a string argument — string form evaluates as code (ast pass, confidence 0.75)
setTimeout("alert('Hi!');", 100);
setInterval("alert('Hi!');", 100);
dismissed
LLM, confidence 0.95
Docs example of setTimeout with a string argument.
Reasoning
Documentation example for no-implied-eval; illustrative only.
-
[embedded javascript] `setInterval` called with a string argument — string form evaluates as code (ast pass, confidence 0.75)
setInterval("alert('Hi!');", 100);
execScript("alert('Hi!')");
dismissed
LLM, confidence 0.95
Docs example of setInterval with a string argument.
Reasoning
Documentation example for no-implied-eval; illustrative only.
-
[embedded javascript] dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
import( './locale/en');
dismissed
LLM, confidence 0.95
Docs example of dynamic import with webpack magic comment.
Reasoning
Markdown example of a dynamic import with a webpack chunk comment; documentation, not executed.
-
[embedded javascript] U+200B ZERO WIDTH SPACE in source (in string/comment) (raw pass, confidence 0.45)
const foo = function() {
return '⟨U+200B⟩<ZWSP>thing';
}
-
[embedded javascript] orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
new RegExp("[\ud83d" + "\udc4d]");
const pattern = "[\ud83d\udc4d]";
-
[embedded javascript] orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
new RegExp("[\ud83d" + "\udc4d]");
const pattern = "[\ud83d\udc4d]";
-
[embedded javascript] surrogate pair \uD83D\uDC4D (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)
const pattern = "[\ud83d\udc4d]";
new RegExp(pattern);
-
[embedded javascript] mean non-conventional identifier length 1.75 over 32 names (token pass, confidence 0.50)
-
[embedded javascript] mean non-conventional identifier length 1.77 over 47 names (token pass, confidence 0.50)
-
[embedded javascript] mean non-conventional identifier length 1.67 over 30 names (token pass, confidence 0.50)
-
[embedded javascript] `require` called with a non-literal specifier (ast pass, confidence 0.60)
foo = require('./foo'), bar = require(getName()), baz = 42, bam;
dismissed
LLM, confidence 0.95
Docs example mixing require declarations for the no-mixed-requires rule.
Reasoning
Documentation example for no-mixed-requires showing computed require in a markdown code block.
-
[embedded javascript] `require` called with a non-literal specifier (ast pass, confidence 0.60)
util = require('util'),
bar = require(getBarModuleName());
dismissed
LLM, confidence 0.95
Docs example of computed require in no-mixed-requires page.
Reasoning
Documentation example of require calls in markdown for the rule description.
-
[embedded javascript] `require` called with a non-literal specifier (ast pass, confidence 0.80)
var foo = require('foo' + VERSION),
bar = require(getBarModuleName()),
baz = require();
dismissed
LLM, confidence 0.95
Docs example with computed require declarations.
Reasoning
Documentation example in markdown; not executable code.
-
[embedded javascript] `require` called with a non-literal specifier (ast pass, confidence 0.60)
var foo = require('foo' + VERSION),
bar = require(getBarModuleName()),
baz = require();
likely benign
LLM, confidence 0.90
Doc example of mixed require calls with computed specifiers.
Reasoning
Markdown documentation showing an anti-pattern example of require calls with non-literal specifiers. It is illustrative prose, not executable code in the package.
-
[embedded javascript] `require` called with a non-literal specifier (ast pass, confidence 0.60)
var foo = require('foo'),
bar = require(getBarModuleName());
likely benign
LLM, confidence 0.90
Doc example of a require call with a computed specifier.
Reasoning
Same documentation example pattern as the sibling finding; it is an illustrative snippet in a rule doc.
-
[embedded javascript] mean non-conventional identifier length 1.96 over 52 names (token pass, confidence 0.50)
-
[embedded javascript] 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)
-
[embedded javascript] 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)
-
[embedded javascript] 17 of 39 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)
-
[embedded javascript] 20 of 41 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)
-
line length 649 characters (raw pass, confidence 0.50)
This rule additionally supports TypeScript type syntax. There are multiple ways to declare global variables in TypeScript. Only using `var` works for all cases. See this [TypeScript playground](https://www.typescriptlang.org/play/?#code/PQgEB4CcFMDNpgOwMbVAGwJYCMC8AiAEwHsBbfUYAPgFgAoew6ZdAQxlAHN1jtX1QAb3qhRGaABdQAGUkAu
-
base64-like blob (234 bytes, compression ratio 0.88) (raw pass, confidence 0.60)
playground](https://www.typescriptlang.org/play/?#code/PQgEB4CcFMDNpgOwMbVAGwJYCMC8AiAEwHsBbfUYAPgFgAoew6ZdAQxlAHN1jtX1QAb3qhRGaABdQAGUkAuUAGcJkTIk4ixAN3agAauwXLV6+ptFqJCWK1SgA6mpIB3IebGjHiIyrUa6HgC+9MEMdGDcvPygtqiKivSyEvQGkPReZuHAoM5OxK6ckvS5iC4AdEnFec5lqVWl+WUZYWAlLkpFdG2NSaC4oADkA-XlqX2Dw13VTWrjQ5kRPHzoACoAFpiKXJ2Ry
likely benign
LLM, confidence 0.85
Base64-like compressed code in a playground link within the docs.
Reasoning
The blob is a compressed TypeScript playground code parameter inside a documentation URL, a common way to share code. It is not a payload.
-
base64-like blob (89 bytes, compression ratio 1.03) (raw pass, confidence 0.60)
piKXJ2Ry+ubFTtL-PuKtez0uycbZ830i1GrNx3JdFdPB73982-HH2djb6Td6nGaIOaTe7ZRTQdCwbavGFww6I2Gwc5pOhI9F3LIdOEvejYlEQolojGkrHkryU+jQAAeAAdiJApIJAkA) for reference.
likely benign
LLM, confidence 0.85
Base64-like segment of a playground share URL in the docs.
Reasoning
Continuation of the same playground URL in the docs; a compressed share parameter, not executable malicious content.
-
[embedded javascript] 20 of 43 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
-
[embedded javascript] 20 of 47 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)
-
[embedded javascript] mean non-conventional identifier length 1.68 over 22 names (token pass, confidence 0.50)
-
[embedded javascript] 17 of 31 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)
-
[embedded javascript] 29 of 52 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)
-
[embedded javascript] 24 of 40 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)
-
[embedded javascript] U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (raw pass, confidence 0.75)
```js
⟨U+FEFF⟩// U+FEFF at the beginning
/*eslint unicode-bom: ["error", "always"]*/
dismissed
LLM, confidence 0.90
Intentional BOM character inside a rule doc example.
Reasoning
The BOM is intentionally included in a markdown example demonstrating the unicode-bom rule. It is documentation of the rule's behavior.
-
[embedded javascript] U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (raw pass, confidence 0.75)
```js
⟨U+FEFF⟩// U+FEFF at the beginning
/*eslint unicode-bom: ["error", "never"]*/
dismissed
LLM, confidence 0.90
Intentional BOM character inside a rule doc example.
Reasoning
Intentional BOM in a doc example for the 'never' option of the unicode-bom rule.
-
U+200B ZERO WIDTH SPACE in source (raw pass, confidence 0.75)
⟨U+200B⟩What changed:⟨U+200B⟩⟨U+200B⟩
- Previously, valid test cases could include `errors` or `output` properties, which were ignored.
likely benign
LLM, confidence 0.80
Zero-width space characters in migration guide prose.
Reasoning
Zero-width spaces in markdown prose around 'What changed'. Likely an editing artifact rather than an attack; it has no code effect in a migration guide.
-
U+200B ZERO WIDTH SPACE in source (raw pass, confidence 0.75)
⟨U+200B⟩What changed:⟨U+200B⟩⟨U+200B⟩
- Previously, valid test cases could include `errors` or `output` properties, which were ignored.
likely benign
LLM, confidence 0.80
Zero-width space in migration guide prose.
Reasoning
Another zero-width space in the same prose line; a doc editing artifact with no functional effect.
-
U+200B ZERO WIDTH SPACE in source (raw pass, confidence 0.75)
⟨U+200B⟩What changed:⟨U+200B⟩⟨U+200B⟩
- Previously, valid test cases could include `errors` or `output` properties, which were ignored.
likely benign
LLM, confidence 0.80
Zero-width space in migration guide prose.
Reasoning
Another zero-width space in the same prose line; a doc editing artifact with no functional effect.
-
U+200B ZERO WIDTH SPACE in source (raw pass, confidence 0.75)
Example of invalid usage:⟨U+200B⟩
```js
likely benign
LLM, confidence 0.80
Zero-width space in migration guide prose before a code example.
Reasoning
Zero-width space in prose just before a js code block; likely a copy-paste artifact in documentation, not executable code.
-
line length 515 characters (raw pass, confidence 0.50)
**Related issue(s):** [#12490](https://github.com/eslint/eslint/pull/12490), [#12608](https://github.com/eslint/eslint/pull/12608), [#12670](https://github.com/eslint/eslint/pull/12670), [#12701](https://github.com/eslint/eslint/pull/12701), [#12765](https://github.com/eslint/eslint/pull/12765), [#12837](https://github
-
file mixes tab and space indentation (95 tab-indented and 131 space-indented lines) (raw pass, confidence 0.40)
const encodeHTML = (function () {
const encodeHTMLRules = {
"&": "&",
"<": "<",
-
base64-like blob (1600 bytes, compression ratio 0.77) (raw pass, confidence 0.60)
mage/png" sizes="any" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAACXBIWXMAAAHaAAAB2gGFomX7AAAAGXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAABD1JREFUWMPFl11sk2UUx3/nbYtjxS1MF7MLMTECMgSTtSSyrQkLhAj7UBPnDSEGoxegGzMwojhXVpmTAA5iYpSoMQa8GBhFOrMFk03buei6yRAlcmOM0SEmU9d90b19jxcM1o5+sGnsc/e+z/
dismissed
LLM, confidence 0.90
Embedded base64 PNG image data URI in the HTML formatter template.
Reasoning
A base64-encoded PNG data URI for an embedded favicon/logo in the HTML formatter's output template. This is standard image embedding.
-
dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
async function dynamicImportConfig(filePath, fileURL, mtime) {
const module = await import(fileURL.href);
importedConfigFileModificationTime.set(filePath, mtime);
likely benign
LLM, confidence 0.85
Dynamic import of a user config module from its file URL.
Reasoning
ESLint loads user config files via dynamic import of a file URL to support ESM configs. This is the expected behavior of a config loader, with the path coming from the user's own project.
-
dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
async function loadOptionsFromModule(optionsURL) {
return (await import(optionsURL)).default;
}
likely benign
LLM, confidence 0.85
Dynamic import of an options module from a URL.
Reasoning
Loads an options module from a URL for ESLint's config handling; a legitimate feature with a user-controlled path, not an attacker-controlled payload.
-
dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
try {
formatter = (await import(pathToFileURL(formatterPath))).default;
} catch (ex) {
likely benign
LLM, confidence 0.85
Dynamic import of a formatter module from a resolved path.
Reasoning
Loads a formatter module by path, a documented ESLint extension point. The non-literal specifier is inherent to plugin/formatter loading.
-
file mixes tab and space indentation (2 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)
module.exports = function (it) {
const { pattern } = it;
return `
-
file mixes tab and space indentation (8 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)
module.exports = function ({ key, objectKey }) {
const isParser =
objectKey === "parser" && (key === "parse" || key === "parseForESLint");
-
file mixes tab and space indentation (2 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)
module.exports = function ({ plugins }) {
const isArrayOfStrings = typeof plugins[0] === "string";
return `
-
file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)
module.exports = function ({ ruleId, value }) {
return `
Configuration for rule "${ruleId}" is invalid. Each rule must have a severity ("off", 0, "warn", 1, "error", or 2) and may be followed by additional options for the rule.
-
file mixes tab and space indentation (2 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)
module.exports = function (it) {
const { directoryPath } = it;
return `
-
file mixes tab and space indentation (2 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)
module.exports = function (it) {
const { pluginName, resolvePluginsRelativeTo, importerName } = it;
return `
-
file mixes tab and space indentation (1 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)
module.exports = function ({ ruleIds, language }) {
return `
The following rules do not support the language "${language}":
${ruleIds.map(id => `\t- "${id}"`).join("\n")}
-
`Function(...)` called with a non-literal body (ast pass, confidence 0.75)
try {
render = new Function(
settings.variable || "obj",
"_",
likely benign
LLM, confidence 0.80
new Function used for template compilation inside a bench fixture.
Reasoning
Bundled benchmark fixture containing a template engine that compiles templates with new Function, typical of lodash-style template code. It is a benchmark input, not a dropper.
-
file mixes tab and space indentation (1 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)
function leftpad(str, len, ch){
str = ("" + str);
-
file mixes tab and space indentation (1 tab-indented and 20 space-indented lines) (raw pass, confidence 0.40)
try {
foo = "Hello";
} catch (err) {
foo = "World";
-
file mixes tab and space indentation (1 tab-indented and 20 space-indented lines) (raw pass, confidence 0.40)
try {
await import("./foo.js");
} catch (err) {
await import("./bar.js");
-
file mixes tab and space indentation (1 tab-indented and 19 space-indented lines) (raw pass, confidence 0.40)
try {
obj.foo;
} catch (err) {
obj.bar;
-
file mixes tab and space indentation (2 tab-indented and 19 space-indented lines) (raw pass, confidence 0.40)
try {
new Foo();
} catch (err) {
new Bar();
-
file mixes tab and space indentation (4 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)
module.exports = {
languageOptions: {
ecmaVersion: 5,
sourceType: "script",
-
line length 1971 characters (raw pass, confidence 0.50)
ast: { type: "Program", start: 0, end: 15, loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 15 } }, comments: [], tokens: [{ type: "Punctuator", value: "@", start: 0, end: 1, loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 1 } }, range: [0, 1] }, { type: "Identifier", value: "foo", st
-
line length 1974 characters (raw pass, confidence 0.50)
const ast = { type: "Program", start: 0, end: 15, loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 15 } }, comments: [], tokens: [{ type: "Punctuator", value: "@", start: 0, end: 1, loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 1 } }, range: [0, 1] }, { type: "Identifier", value: "foo",
-
file mixes tab and space indentation (10 tab-indented and 231 space-indented lines) (raw pass, confidence 0.40)
exports.parseForESLint = () => ({
ast: {
"kind": "Document",
"definitions": [
-
base64-like blob (75 bytes, compression ratio 1.15) (in comment) (raw pass, confidence 0.36)
}`
// obtained from https://typescript-eslint.io/play/#ts=5.4.3&showAST=es&fileType=.tsx&code=FAb2AJwQwdyhLALuArgZ3gOwObgB7gC84AtlANYCmAIvGgA4D2aUARgDaUAUAlANzAAvkA&eslintrc=N4KABGBEBOCuA2BTAzpAXGYBfEWg&tsconfig=N4KABGBEDGD2C2AHAlgGwKYCcDyiAuysAdgM6QBcYoEEkJemy0eAcgK6qoDCAFutAGsylBm3TgwAXxCSgA&tokens=false
-
base64-like blob (91 bytes, compression ratio 1.02) (in comment) (raw pass, confidence 0.36)
}`
// obtained from https://typescript-eslint.io/play/#ts=5.4.3&showAST=es&fileType=.tsx&code=FAb2AJwQwdyhLALuArgZ3gOwObgB7gC84AtlANYCmAIvGgA4D2aUARgDaUAUAlANzAAvkA&eslintrc=N4KABGBEBOCuA2BTAzpAXGYBfEWg&tsconfig=N4KABGBEDGD2C2AHAlgGwKYCcDyiAuysAdgM6QBcYoEEkJemy0eAcgK6qoDCAFutAGsylBm3TgwAXxCSgA&tokens=false
-
base64-like blob (66 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)
}`
// obtained from https://typescript-eslint.io/play/#ts=5.4.3&showAST=es&fileType=.tsx&code=FAb2AJwVwZwSwHYHNwA9wF5wFsCGBrAUwBE4YAHAexlwCMAbQgCgEoBuYAXyA&eslintrc=N4KABGBEBOCuA2BTAzpAXGYBfEWg&tsconfig=N4KABGBEDGD2C2AHAlgGwKYCcDyiAuysAdgM6QBcYoEEkJemy0eAcgK6qoDCAFutAGsylBm3TgwAXxCSgA&tokens=false
-
base64-like blob (91 bytes, compression ratio 1.02) (in comment) (raw pass, confidence 0.36)
}`
// obtained from https://typescript-eslint.io/play/#ts=5.4.3&showAST=es&fileType=.tsx&code=FAb2AJwVwZwSwHYHNwA9wF5wFsCGBrAUwBE4YAHAexlwCMAbQgCgEoBuYAXyA&eslintrc=N4KABGBEBOCuA2BTAzpAXGYBfEWg&tsconfig=N4KABGBEDGD2C2AHAlgGwKYCcDyiAuysAdgM6QBcYoEEkJemy0eAcgK6qoDCAFutAGsylBm3TgwAXxCSgA&tokens=false
-
318 of 509 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)
-
318 of 509 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)
-
318 of 509 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)
-
318 of 509 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)
-
compression ratio 0.865 is >2σ above file mean 0.711 (raw pass, confidence 0.50)
const exitCode = await cli.execute(
"--concurrency=2 --no-config-lookup --no-ignore --rule 'no-fallthrough: [error, { commentPattern: \"#?\" }]' tests/fixtures/passing.js",
);
-
file mixes tab and space indentation (13449 tab-indented and 265 space-indented lines) (raw pass, confidence 0.40)
const {
calculateWorkerCount,
shouldUseFlatConfig,
} = require("../../../lib/eslint/eslint");
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
plugins: {
test: require(
path.join(
cwd,
likely benign
LLM, confidence 0.90
Test plugin loaded via require with a path built from the test directory.
Reasoning
Test fixture defining a plugin via require of a path joined from a test cwd. Test scaffolding with no malicious behavior.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(filePath),
},
},
likely benign
LLM, confidence 0.90
Test loads a parser module from a file path variable.
Reasoning
Requiring a parser by a computed file path is a normal ESLint test pattern for loading fixture parsers; no malicious sink or encoding involved.
-
compression ratio 0.875 is >2σ above file mean 0.717 (raw pass, confidence 0.50)
it('should load eslint.config.ts with CJS-ESM mixed syntax (import and module.exports), "type": "commonjs" in nearest `package.json`', async () => {
const cwd = getFixturePath(
"ts-config-files",
-
compression ratio 0.884 is >2σ above file mean 0.717 (raw pass, confidence 0.50)
it('should load eslint.config.ts with CJS-ESM mixed syntax (require and export default), "type": "commonjs" in nearest `package.json`', async () => {
const cwd = getFixturePath(
"ts-config-files",
-
compression ratio 0.869 is >2σ above file mean 0.717 (raw pass, confidence 0.50)
it('should load eslint.config.ts with CJS-ESM mixed syntax (import assignment and export default), "type": "module" in nearest `package.json`', async () => {
const cwd = getFixturePath(
"ts-config-files",
-
compression ratio 0.863 is >2σ above file mean 0.717 (raw pass, confidence 0.50)
it('should load eslint.config.ts with CJS-ESM mixed syntax (import assignment and export default), "type": "commonjs" in nearest `package.json`', async () => {
const cwd = getFixturePath(
"ts-config-files",
-
compression ratio 0.876 is >2σ above file mean 0.717 (raw pass, confidence 0.50)
it('should load eslint.config.ts with CJS-ESM mixed syntax (import and export assignment), "type": "module" in nearest `package.json`', async () => {
const cwd = getFixturePath(
"ts-config-files",
-
compression ratio 0.870 is >2σ above file mean 0.717 (raw pass, confidence 0.50)
it('should load eslint.config.ts with CJS-ESM mixed syntax (import and export assignment), "type": "commonjs" in nearest `package.json`', async () => {
const cwd = getFixturePath(
"ts-config-files",
-
dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
);
const { customPlugin } = await import(optionsURL);
const engine = await ESLint.fromOptionsModule(optionsURL);
likely benign
LLM, confidence 0.85
Test dynamically imports an options module from a URL variable.
Reasoning
Dynamic import of an options module URL in an ESLint test that exercises fromOptionsModule; expected for testing config loading from a fixture path.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
plugins: {
test: require(
path.join(
cwd,
likely benign
LLM, confidence 0.90
Test requires a plugin module from a joined fixture path.
Reasoning
Plugin loaded via require with path.join from a test cwd; standard fixture loading in ESLint tests.
-
file mixes tab and space indentation (208 tab-indented and 148 space-indented lines) (raw pass, confidence 0.40)
const assert = require("node:assert"),
{ Linter } = require("../../../../lib/linter");
const linter = new Linter();
-
file mixes tab and space indentation (10267 tab-indented and 228 space-indented lines) (raw pass, confidence 0.40)
const { assert } = require("chai"),
sinon = require("sinon"),
espree = require("espree"),
esprima = require("esprima"),
-
file mixes tab and space indentation (6904 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)
const sinon = require("sinon"),
EventEmitter = require("node:events"),
{ RuleTester } = require("../../../lib/rule-tester"),
assert = require("chai").assert,
-
compression ratio 0.792 is >2σ above file mean 0.704 (raw pass, confidence 0.50)
);
}, "Error Suggestion at index 1: Test has invalid messageId 'removeFoo', the rule under test allows only one of ['avoidFoo', 'unused', 'renameFoo'].");
});
-
`eval` called with a non-literal expression (ast pass, confidence 0.75)
eval(code);
assert.fail("Expected an error to be thrown");
} catch (error) {
likely benign
LLM, confidence 0.85
Test evaluates a code string under a no-eval-annotated test.
Reasoning
The eval is explicitly annotated as intentional in a test verifying that eval-based code is rejected or handled; the code is test input, not an attack payload.
-
`import(...)` specifier is a `data:` URI — executes arbitrary code without touching disk (ast pass, confidence 0.95)
const moduleURL = `data:text/javascript,${content}`;
const { runRuleTester } = await import(moduleURL);
try {
runRuleTester(ruleTester, noVar);
likely benign
LLM, confidence 0.75
Test builds a data: URI module and imports it to run a rule tester.
Reasoning
A data: URI import is used to load a rule tester module in a test harness. It does execute code, but the content is locally constructed test input; the pattern is unusual enough to warrant a look but not malicious on its face.
-
file mixes tab and space indentation (1759 tab-indented and 28 space-indented lines) (raw pass, confidence 0.40)
ruleTester.run("array-bracket-newline", rule, {
valid: [
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
function parser(name) {
return require(
path.resolve(
__dirname,
likely benign
LLM, confidence 0.90
Test helper requires a parser module by resolved path.
Reasoning
Standard ESLint rule test helper that resolves a parser fixture path via require; benign.
-
file mixes tab and space indentation (773 tab-indented and 44 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/arrow-body-style"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
function parser(name) {
return require(baseParser("arrow-parens", name));
}
likely benign
LLM, confidence 0.90
Test helper requires a parser module by name.
Reasoning
Test helper requiring a parser by name through baseParser; standard test scaffolding.
-
file mixes tab and space indentation (1231 tab-indented and 299 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/brace-style"),
RuleTester = require("../../../lib/rule-tester/rule-tester"),
{ unIndent } = require("../../_utils");
-
file mixes tab and space indentation (1599 tab-indented and 26 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/camelcase"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (1152 tab-indented and 194 space-indented lines) (raw pass, confidence 0.40)
ruleTester.run("class-methods-use-this", rule, {
valid: [
{
code: "class A { constructor() {} }",
-
file mixes tab and space indentation (2146 tab-indented and 44 space-indented lines) (raw pass, confidence 0.40)
const path = require("node:path"),
{ unIndent } = require("../../_utils"),
rule = require("../../../lib/rules/comma-dangle"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
function parser(name) {
return require(
path.resolve(
__dirname,
likely benign
LLM, confidence 0.90
Test helper requires a parser module by resolved path.
Reasoning
Same parser-loading helper pattern used across ESLint rule tests; benign.
-
file mixes tab and space indentation (437 tab-indented and 57 space-indented lines) (raw pass, confidence 0.40)
ruleTester.run("constructor-super", rule, {
valid: [
"class A { }",
-
file mixes tab and space indentation (519 tab-indented and 98 space-indented lines) (raw pass, confidence 0.40)
const ruleTester = new RuleTester({
languageOptions: { ecmaVersion: 8 },
});
-
file mixes tab and space indentation (881 tab-indented and 588 space-indented lines) (raw pass, confidence 0.40)
const LEFT_MISSING_ERROR = {
messageId: "expectedAfter",
};
const LEFT_UNEXPECTED_ERROR = {
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
fixtureParser(
"function-paren-newline",
likely benign
LLM, confidence 0.90
Test config requires a fixture parser by computed name.
Reasoning
Fixture parser loaded via require in a test config; standard ESLint testing.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
fixtureParser(
"function-paren-newline",
likely benign
LLM, confidence 0.90
Test config requires a fixture parser by computed name.
Reasoning
Fixture parser loaded via require in a test config; standard ESLint testing.
-
U+E0100 VARIATION SELECTOR SUPPLEMENT (invisible payload carrier, encodes byte 0x10) in source (in string/comment) (raw pass, confidence 0.54)
{
code: "var 葛⟨U+E0100⟩ = 2", options: [{ min: 1, max: 1 }],
languageOptions: { ecmaVersion: 6 },
-
U+E0100 VARIATION SELECTOR SUPPLEMENT (invisible payload carrier, encodes byte 0x10) in source (in string/comment) (raw pass, confidence 0.54)
{
code: "var 葛⟨U+E0100⟩ = 2", languageOptions: { ecmaVersion: 6 },
errors: [tooShortError],
-
file mixes tab and space indentation (1101 tab-indented and 57 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/id-match"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (252 tab-indented and 271 space-indented lines) (raw pass, confidence 0.40)
ruleTester.run("implicit-arrow-linebreak", rule, {
valid: [
`(foo) => {
-
file mixes tab and space indentation (5474 tab-indented and 8622 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/indent"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
const fs = require("node:fs");
const path = require("node:path");
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(parser("unknown-nodes/interface")),
},
},
likely benign
LLM, confidence 0.92
Test config requires a parser fixture for an unknown-nodes case.
Reasoning
Parser fixture loaded by name for an unknown-nodes test case; benign test scaffolding.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(parser("unknown-nodes/namespace-valid")),
},
},
likely benign
LLM, confidence 0.92
Test config requires a parser fixture for a namespace test case.
Reasoning
Parser fixture loaded by name for a test case; benign.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(parser("unknown-nodes/abstract-class-valid")),
},
},
likely benign
LLM, confidence 0.92
Test config requires a parser fixture for an abstract-class test case.
Reasoning
Parser fixture loaded by name for a test case; benign.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser("unknown-nodes/functions-with-abstract-class-valid"),
),
likely benign
LLM, confidence 0.92
Test config requires a parser fixture for a functions-with-abstract-class test case.
Reasoning
Parser fixture loaded by name for a test case; benign.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"unknown-nodes/namespace-with-functions-with-abstract-class-valid",
likely benign
LLM, confidence 0.92
Test config requires a parser fixture for a namespace-with-functions test case.
Reasoning
Parser fixture loaded by name for a test case; benign.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"unknown-nodes/variable-declarator-type-indent-two-spaces",
likely benign
LLM, confidence 0.92
Test config requires a parser fixture for a variable-declarator test case.
Reasoning
Parser fixture loaded by name for a test case; benign.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser("unknown-nodes/variable-declarator-type-no-indent"),
),
likely benign
LLM, confidence 0.92
Test config requires a parser fixture for a variable-declarator test case.
Reasoning
Parser fixture loaded by name for a test case; benign.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(parser("unknown-nodes/namespace-invalid")),
},
errors: expectedErrors([
likely benign
LLM, confidence 0.93
Test case loading a parser fixture via require(parser(...)) in ESLint's indent rule tests.
Reasoning
The require() argument is a helper call that picks a fixture parser by name, in an ESLint rule test file. The specifier comes from a test-local helper, not untrusted input, so this is a normal test-harness pattern.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(parser("unknown-nodes/abstract-class-invalid")),
},
errors: expectedErrors([
likely benign
LLM, confidence 0.93
Test case loading an unknown-nodes parser fixture via a helper-built require path.
Reasoning
Dynamic require of a parser fixture chosen by a local test helper, in an ESLint test file. The AST pass flags any non-literal require, which is expected in test harnesses.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"unknown-nodes/functions-with-abstract-class-invalid",
likely benign
LLM, confidence 0.93
Test case requiring a parser fixture through a helper for functions-with-abstract-class input.
Reasoning
Multi-line require(parser(...)) selecting a test fixture parser in an ESLint rule test. No network, shell, or decoding involved, so it is an ordinary dynamic fixture load.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"unknown-nodes/namespace-with-functions-with-abstract-class-invalid",
likely benign
LLM, confidence 0.93
Test case requiring a nested-namespace parser fixture through a helper function.
Reasoning
Same test-harness pattern: a helper resolves a fixture name and the result is passed to require. Benign in an ESLint test suite.
-
file mixes tab and space indentation (3283 tab-indented and 186 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/key-spacing"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
fixtureParser(
"keyword-spacing",
likely benign
LLM, confidence 0.92
Keyword-spacing test case loading a parser through fixtureParser.
Reasoning
require(fixtureParser(...)) in an ESLint keyword-spacing test, loading a fixture parser by name. Standard test setup with no malicious indicators.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
fixtureParser(
"keyword-spacing",
likely benign
LLM, confidence 0.92
Keyword-spacing test case loading a second fixture parser through fixtureParser.
Reasoning
Dynamic require of a fixture parser inside an ESLint rule test. The specifier comes from a local helper, so this is expected test-harness behaviour.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser("typescript-parsers/decorator-with-class"),
),
likely benign
LLM, confidence 0.92
Decorator-with-class test loading a TypeScript parser fixture.
Reasoning
require(parser(...)) loading a TypeScript parser fixture for a decorator test in ESLint. A test-helper path, not an attack.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser("typescript-parsers/decorator-with-class-methods"),
),
likely benign
LLM, confidence 0.92
Decorator-with-class-methods test loading a TypeScript parser fixture.
Reasoning
Dynamic require of a TypeScript parser fixture in an ESLint test file. The flagged pattern is routine in parser-based rule tests.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"typescript-parsers/decorator-with-static-class-methods",
likely benign
LLM, confidence 0.92
Static-class-methods decorator test loading a TypeScript parser fixture.
Reasoning
Same parser-fixture require via helper in an ESLint test. Nothing suggests obfuscation or malicious execution.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser("typescript-parsers/keyword-with-arrow-function"),
),
likely benign
LLM, confidence 0.92
Keyword-with-arrow-function test loading a TypeScript parser fixture.
Reasoning
Routine parser fixture load for an arrow-function keyword test in ESLint's test suite.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
fixtureParser(
"keyword-spacing",
likely benign
LLM, confidence 0.92
Keyword-spacing test case loading a fixture parser.
Reasoning
fixtureParser-driven require in an ESLint keyword-spacing test. Benign test harness code.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
fixtureParser(
"keyword-spacing",
likely benign
LLM, confidence 0.92
Keyword-spacing test case loading a fixture parser.
Reasoning
Another fixture parser require in the same ESLint test file. The pattern is expected for parser-specific test cases.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"typescript-parsers/decorator-with-keywords-class-method",
likely benign
LLM, confidence 0.92
Decorator-with-keywords class method test loading a TypeScript parser fixture.
Reasoning
Dynamic require of a TypeScript decorator parser fixture in an ESLint test. No malicious indicators.
-
file mixes tab and space indentation (2479 tab-indented and 272 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/lines-around-comment"),
RuleTester = require("../../../lib/rule-tester/rule-tester"),
{ unIndent } = require("../../_utils");
-
file mixes tab and space indentation (1216 tab-indented and 1108 space-indented lines) (raw pass, confidence 0.40)
ruleTester.run("lines-between-class-members", rule, {
valid: [
"class foo{}",
"class foo{;;}",
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"typescript-parsers/logical-assignment-with-assertion",
likely benign
LLM, confidence 0.92
Logical-assignment-with-assertion test loading a TypeScript parser fixture.
Reasoning
Parser fixture require via helper in an ESLint logical-assignment test. Standard test setup.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"typescript-parsers/logical-with-assignment-with-assertion-1",
likely benign
LLM, confidence 0.92
Logical-with-assignment-with-assertion test loading a TypeScript parser fixture.
Reasoning
Dynamic require of a TypeScript parser fixture in an ESLint test file. Benign test-harness usage.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"typescript-parsers/logical-with-assignment-with-assertion-2",
likely benign
LLM, confidence 0.92
Logical-with-assignment-with-assertion test loading a second TypeScript parser fixture.
Reasoning
Same fixture-parser require pattern in an ESLint test. Nothing indicates obfuscation.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"typescript-parsers/logical-with-assignment-with-assertion-3",
likely benign
LLM, confidence 0.92
Logical-with-assignment-with-assertion test loading a third TypeScript parser fixture.
Reasoning
Routine parser fixture require via helper in an ESLint test case. Benign.
-
file mixes tab and space indentation (155 tab-indented and 16 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/max-classes-per-file"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (660 tab-indented and 80 space-indented lines) (raw pass, confidence 0.40)
ruleTester.run("max-lines-per-function", rule, {
valid: [
{
-
file mixes tab and space indentation (405 tab-indented and 26 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/max-params"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (575 tab-indented and 520 space-indented lines) (raw pass, confidence 0.40)
ruleTester.run("multiline-comment-style", rule, {
valid: [
`
/*
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(parser("typescript-parsers/new-parens")),
},
},
likely benign
LLM, confidence 0.95
Test case loading a TypeScript parser fixture via require(parser(...)).
Reasoning
The require call resolves a parser fixture path through a test helper, which is the normal way ESLint rule tests load alternate parsers. The file is a test suite, and no execution or exfiltration is visible.
-
file mixes tab and space indentation (563 tab-indented and 30 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/newline-after-var"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (836 tab-indented and 135 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-array-constructor"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (236 tab-indented and 93 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-case-declarations"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (674 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)
ruleTester.run("no-dupe-class-members", rule, {
valid: [
"class A { foo() {} bar() {} }",
"class A { static foo() {} foo() {} }",
-
file mixes tab and space indentation (803 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-else-return"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (6656 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-extra-boolean-cast"),
RuleTester = require("../../../lib/rule-tester/rule-tester"),
parser = require("../../fixtures/fixture-parser");
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser("typescript-parsers/boolean-cast-with-assertion"),
),
likely benign
LLM, confidence 0.95
Test case requiring a boolean-cast-with-assertion parser fixture.
Reasoning
This is a test-case parser option that loads a fixture parser through a helper. The dynamic specifier is a test-fixture lookup, not a payload loader.
-
file mixes tab and space indentation (291 tab-indented and 14 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-extra-label"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (3924 tab-indented and 84 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-extra-parens"),
RuleTester = require("../../../lib/rule-tester/rule-tester"),
parser = require("../../fixtures/fixture-parser");
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"typescript-parsers/member-call-expr-with-assertion",
likely benign
LLM, confidence 0.95
Test case requiring a member-call-expression parser fixture.
Reasoning
The require resolves a parser fixture name inside an ESLint rule test's languageOptions. This is standard test scaffolding.
-
file mixes tab and space indentation (375 tab-indented and 120 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-fallthrough"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (193 tab-indented and 153 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-inline-comments"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
orphaned high surrogate \uD835 (no matching low surrogate) (token pass, confidence 0.65)
"new RegExp('(?<\\\\ud835\\\\udc9c>.)', 'g')",
"new RegExp('(?<\\\\u{1d49c}>.)', 'g')",
"new RegExp('(?<𝒜>.)', 'g');",
-
orphaned low surrogate \uDC9C (no preceding high surrogate) (token pass, confidence 0.65)
"new RegExp('(?<\\\\ud835\\\\udc9c>.)', 'g')",
"new RegExp('(?<\\\\u{1d49c}>.)', 'g')",
"new RegExp('(?<𝒜>.)', 'g');",
-
file mixes tab and space indentation (1158 tab-indented and 587 space-indented lines) (raw pass, confidence 0.40)
function NORMAL() {
}
-
file mixes tab and space indentation (356 tab-indented and 149 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-lone-blocks"),
RuleTester = require("../../../lib/rule-tester/rule-tester"),
parser = require("../../fixtures/fixture-parser");
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser("typescript-parsers/no-lone-blocks/using"),
),
likely benign
LLM, confidence 0.95
Test case requiring a no-lone-blocks 'using' parser fixture.
Reasoning
A parser fixture for a 'using' declaration is loaded through a test helper inside a rule test. No obfuscation or malicious behaviour is present.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser("typescript-parsers/no-lone-blocks/await-using"),
),
likely benign
LLM, confidence 0.95
Test case requiring a no-lone-blocks 'await using' parser fixture.
Reasoning
Same pattern as the sibling finding: a test helper resolves a parser fixture for an await-using case. This is expected in ESLint's test suite.
-
file mixes tab and space indentation (664 tab-indented and 226 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-loop-func"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (2170 tab-indented and 30 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-magic-numbers"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (2080 tab-indented and 27 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-misleading-character-class"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
"var r = /[👍]/u",
"var r = /[\\uD83D\\uDC4D]/u",
"var r = /[\\u{1F44D}]/u",
"var r = /❇⟨U+FE0F⟩/",
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
"var r = /[👍]/u",
"var r = /[\\uD83D\\uDC4D]/u",
"var r = /[\\u{1F44D}]/u",
"var r = /❇⟨U+FE0F⟩/",
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
"var r = /[\\uD83D]/",
"var r = /[\\uDC4D]/",
"var r = /[\\uD83D]/u",
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
"var r = /[\\uD83D]/",
"var r = /[\\uDC4D]/",
"var r = /[\\uD83D]/u",
"var r = /[\\uDC4D]/u",
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
"var r = /[\\uDC4D]/",
"var r = /[\\uD83D]/u",
"var r = /[\\uDC4D]/u",
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
"var r = /[\\uD83D]/u",
"var r = /[\\uDC4D]/u",
-
surrogate pair \uD83D\uDC4D (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)
{
code: String.raw`/[\ud83d\udc4d]/`,
options: [{ allowEscape: true }],
},
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: '/[\ud83d\\udc4d]/u // U+D83D + Backslash + "udc4d"',
options: [{ allowEscape: true }],
},
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
{
code: '/[\ud83d\\udc4d]/u // U+D83D + Backslash + "udc4d"',
options: [{ allowEscape: true }],
},
-
surrogate pair \uD83D\uDC4D (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)
{
code: String.raw`RegExp("[\uD83D\uDC4D]")`,
options: [{ allowEscape: true }],
},
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: 'RegExp(`[\\uD83D\\uDC4D]`) // Backslash + "uD83D" + Backslash + "uDC4D"',
options: [{ allowEscape: true }],
},
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
{
code: 'RegExp(`[\\uD83D\\uDC4D]`) // Backslash + "uD83D" + Backslash + "uDC4D"',
options: [{ allowEscape: true }],
},
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC4D]/",
errors: [
{
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC4D]/",
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: "var r = /[\\uD83D\\uDC4D]/u",
},
],
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: "var r = /[\\uD83D\\uDC4D]/u",
},
],
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC4D-\\uffff]/",
languageOptions: { ecmaVersion: 3, sourceType: "script" },
errors: [
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC4D-\\uffff]/",
languageOptions: { ecmaVersion: 3, sourceType: "script" },
errors: [
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /before[\\uD83D\\uDC4D]after/",
errors: [
{
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /before[\\uD83D\\uDC4D]after/",
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: "var r = /before[\\uD83D\\uDC4D]after/u",
},
],
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: "var r = /before[\\uD83D\\uDC4D]after/u",
},
],
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /[before\\uD83D\\uDC4Dafter]/",
errors: [
{
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /[before\\uD83D\\uDC4Dafter]/",
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: "var r = /[before\\uD83D\\uDC4Dafter]/u",
},
],
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: "var r = /[before\\uD83D\\uDC4Dafter]/u",
},
],
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /\\uDC4D[\\uD83D\\uDC4D]/",
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /\\uDC4D[\\uD83D\\uDC4D]/",
errors: [
{
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /\\uDC4D[\\uD83D\\uDC4D]/",
errors: [
{
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: "var r = /\\uDC4D[\\uD83D\\uDC4D]/u",
},
],
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: "var r = /\\uDC4D[\\uD83D\\uDC4D]/u",
},
],
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: "var r = /\\uDC4D[\\uD83D\\uDC4D]/u",
},
],
-
orphaned high surrogate \uD83C (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /[a\\uD83C\\uDFFB]/u",
errors: [
{
-
orphaned low surrogate \uDFFB (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /[a\\uD83C\\uDFFB]/u",
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC76\\uD83C\\uDFFB]/u",
errors: [
{
-
orphaned low surrogate \uDC76 (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC76\\uD83C\\uDFFB]/u",
errors: [
{
-
orphaned high surrogate \uD83C (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC76\\uD83C\\uDFFB]/u",
errors: [
{
-
orphaned low surrogate \uDFFB (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC76\\uD83C\\uDFFB]/u",
errors: [
{
-
orphaned high surrogate \uD83C (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83C\\uDDEF\\uD83C\\uDDF5]/u",
errors: [
{
-
orphaned low surrogate \uDDEF (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83C\\uDDEF\\uD83C\\uDDF5]/u",
errors: [
{
-
orphaned high surrogate \uD83C (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83C\\uDDEF\\uD83C\\uDDF5]/u",
errors: [
{
-
orphaned low surrogate \uDDF5 (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83C\\uDDEF\\uD83C\\uDDF5]/u",
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69\\u200D\\uD83D\\uDC66]/u",
errors: [
{
-
orphaned low surrogate \uDC68 (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69\\u200D\\uD83D\\uDC66]/u",
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69\\u200D\\uD83D\\uDC66]/u",
errors: [
{
-
orphaned low surrogate \uDC69 (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69\\u200D\\uD83D\\uDC66]/u",
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69\\u200D\\uD83D\\uDC66]/u",
errors: [
{
-
orphaned low surrogate \uDC66 (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69\\u200D\\uD83D\\uDC66]/u",
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69]/u",
errors: [
{
-
orphaned low surrogate \uDC68 (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69]/u",
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69]/u",
errors: [
{
-
orphaned low surrogate \uDC69 (no preceding high surrogate) (token pass, confidence 0.65)
{
code: "var r = /[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69]/u",
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = RegExp("[\\uD83D\\uDC4D]", "")`,
errors: [
{
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = RegExp("[\\uD83D\\uDC4D]", "")`,
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: String.raw`var r = RegExp("[\\uD83D\\uDC4D]", "u")`,
},
],
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: String.raw`var r = RegExp("[\\uD83D\\uDC4D]", "u")`,
},
],
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = RegExp("before[\\uD83D\\uDC4D]after", "")`,
errors: [
{
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = RegExp("before[\\uD83D\\uDC4D]after", "")`,
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: String.raw`var r = RegExp("before[\\uD83D\\uDC4D]after", "u")`,
},
],
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: String.raw`var r = RegExp("before[\\uD83D\\uDC4D]after", "u")`,
},
],
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = RegExp("[before\\uD83D\\uDC4Dafter]", "")`,
errors: [
{
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = RegExp("[before\\uD83D\\uDC4Dafter]", "")`,
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: String.raw`var r = RegExp("[before\\uD83D\\uDC4Dafter]", "u")`,
},
],
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: String.raw`var r = RegExp("[before\\uD83D\\uDC4Dafter]", "u")`,
},
],
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("\u1234[\\uD83D\\uDC4D]")`,
errors: [
{
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("\u1234[\\uD83D\\uDC4D]")`,
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: String.raw`var r = new RegExp("\u1234[\\uD83D\\uDC4D]", "u")`,
},
],
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
messageId: "suggestUnicodeFlag",
output: String.raw`var r = new RegExp("\u1234[\\uD83D\\uDC4D]", "u")`,
},
],
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("[\\uD83D\\uDC76\\uD83C\\uDFFB]", "u")`,
errors: [
{
-
orphaned low surrogate \uDC76 (no preceding high surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("[\\uD83D\\uDC76\\uD83C\\uDFFB]", "u")`,
errors: [
{
-
orphaned high surrogate \uD83C (no matching low surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("[\\uD83D\\uDC76\\uD83C\\uDFFB]", "u")`,
errors: [
{
-
orphaned low surrogate \uDFFB (no preceding high surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("[\\uD83D\\uDC76\\uD83C\\uDFFB]", "u")`,
errors: [
{
-
orphaned high surrogate \uD83C (no matching low surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("[\\uD83C\\uDDEF\\uD83C\\uDDF5]", "u")`,
errors: [
{
-
orphaned low surrogate \uDDEF (no preceding high surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("[\\uD83C\\uDDEF\\uD83C\\uDDF5]", "u")`,
errors: [
{
-
orphaned high surrogate \uD83C (no matching low surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("[\\uD83C\\uDDEF\\uD83C\\uDDF5]", "u")`,
errors: [
{
-
orphaned low surrogate \uDDF5 (no preceding high surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("[\\uD83C\\uDDEF\\uD83C\\uDDF5]", "u")`,
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69\\u200D\\uD83D\\uDC66]", "u")`,
errors: [
{
-
orphaned low surrogate \uDC68 (no preceding high surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69\\u200D\\uD83D\\uDC66]", "u")`,
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69\\u200D\\uD83D\\uDC66]", "u")`,
errors: [
{
-
orphaned low surrogate \uDC69 (no preceding high surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69\\u200D\\uD83D\\uDC66]", "u")`,
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69\\u200D\\uD83D\\uDC66]", "u")`,
errors: [
{
-
orphaned low surrogate \uDC66 (no preceding high surrogate) (token pass, confidence 0.65)
{
code: String.raw`var r = new RegExp("[\\uD83D\\uDC68\\u200D\\uD83D\\uDC69\\u200D\\uD83D\\uDC66]", "u")`,
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: String.raw`/[\ud83d\u{dc4d}]/u`,
errors: [
{
-
orphaned low surrogate \uDC4D (no preceding high surrogate) (token pass, confidence 0.65)
{
code: String.raw`/[\u{d83d}\udc4d]/u`,
errors: [
{
-
orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
{
code: String.raw`/[\uD83D\u{DC4d}]/u`,
errors: [
{
-
file mixes tab and space indentation (43 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-new-object"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (83 tab-indented and 22 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-new-wrappers"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (272 tab-indented and 116 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-object-constructor"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (4625 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-restricted-imports"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (181 tab-indented and 22 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-return-assign"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (270 tab-indented and 168 space-indented lines) (raw pass, confidence 0.40)
function createErrorList({ suggestionOutput: output } = {}) {
return [
{
-
file mixes tab and space indentation (3479 tab-indented and 279 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-shadow"),
RuleTester = require("../../../lib/rule-tester/rule-tester"),
globals = require("globals");
-
file mixes tab and space indentation (280 tab-indented and 81 space-indented lines) (raw pass, confidence 0.40)
ruleTester.run("no-this-before-super", rule, {
valid: [
-
file mixes tab and space indentation (350 tab-indented and 65 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-unexpected-multiline"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (465 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-unneeded-ternary"),
RuleTester = require("../../../lib/rule-tester/rule-tester"),
parser = require("../../fixtures/fixture-parser");
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser("typescript-parsers/unneeded-ternary-1"),
),
likely benign
LLM, confidence 0.95
Test case requiring an unneeded-ternary parser fixture.
Reasoning
The require loads a named parser fixture for a ternary test case. The dynamic path is a fixture lookup in a test file.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser("typescript-parsers/unneeded-ternary-2"),
),
likely benign
LLM, confidence 0.95
Second unneeded-ternary test case requiring a parser fixture.
Reasoning
Same pattern as the other unneeded-ternary finding: a test-fixture parser is loaded via a helper, with no runtime or network behaviour.
-
file mixes tab and space indentation (613 tab-indented and 63 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-unreachable"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (302 tab-indented and 60 space-indented lines) (raw pass, confidence 0.40)
const languageOptions = {
ecmaVersion: 2021,
sourceType: "module",
};
-
file mixes tab and space indentation (831 tab-indented and 28 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-unused-expressions"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (957 tab-indented and 303 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-unused-private-class-members"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (4916 tab-indented and 32 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-unused-vars"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (3336 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-use-before-define"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (1045 tab-indented and 617 space-indented lines) (raw pass, confidence 0.40)
const ruleTester = new RuleTester({
plugins: {
test: {
rules: {
-
file mixes tab and space indentation (89 tab-indented and 108 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-useless-catch"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (459 tab-indented and 196 space-indented lines) (raw pass, confidence 0.40)
const error = {
messageId: "noUselessConstructor",
};
-
file mixes tab and space indentation (184 tab-indented and 390 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/no-useless-return"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (212 tab-indented and 106 space-indented lines) (raw pass, confidence 0.40)
ruleTester.run("nonblock-statement-body-position", rule, {
valid: [
"if (foo) bar;",
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.94
Test case requiring a parser resolved relative to __dirname.
Reasoning
The require wraps resolvePath(__dirname, ...) to locate a parser inside the repository. Resolving relative to __dirname confines the lookup to the project tree, which is standard test setup.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.94
Test case requiring a repo-local parser via resolvePath.
Reasoning
A repo-local parser is resolved via resolvePath(__dirname, ...) inside a test case. This is ordinary test configuration.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.94
Test case requiring a local parser via resolvePath.
Reasoning
Parser loaded through resolvePath relative to __dirname in a rule test. No dynamic execution beyond module loading of a local fixture.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.94
Test case requiring a local parser via resolvePath.
Reasoning
Repo-local parser resolved via __dirname in an ESLint rule test. Same benign scaffolding.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.94
Test case requiring a local parser via resolvePath.
Reasoning
Parser module resolved relative to __dirname inside a test's languageOptions. Expected for ESLint tests.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.94
Test case requiring a local parser via resolvePath.
Reasoning
Local parser fixture loaded through resolvePath in a rule test. No suspicious behaviour is visible.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.94
Test case requiring a local parser via resolvePath.
Reasoning
Resolves a repo-local parser via __dirname inside a test case. This is ordinary test configuration.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.94
Test case requiring a local parser via resolvePath.
Reasoning
Repo-local parser resolved through __dirname within a test. Expected scaffolding for ESLint rule tests.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.94
Test case requiring a local parser via resolvePath.
Reasoning
Parser resolved with resolvePath(__dirname, ...) in a test file. The lookup stays inside the repository.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.94
Test case requiring a local parser via resolvePath.
Reasoning
Local parser fixture loaded through __dirname-relative resolution in a test. No payload or network activity.
-
file mixes tab and space indentation (1310 tab-indented and 169 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/object-shorthand"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
const { unIndent } = require("../../_utils");
-
identifier `𐐀Foo` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
{
code: "var x = {𐐀Foo: function() {}}",
options: ["always", { ignoreConstructors: true }],
},
-
file mixes tab and space indentation (5536 tab-indented and 26 space-indented lines) (raw pass, confidence 0.40)
const ruleTester = new RuleTester({
languageOptions: { ecmaVersion: 2017, sourceType: "script" },
});
-
file mixes tab and space indentation (445 tab-indented and 56 space-indented lines) (raw pass, confidence 0.40)
const errors = [
{
messageId: "preferArrowCallback",
},
-
file mixes tab and space indentation (1049 tab-indented and 37 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/prefer-const"),
fixtureParser = require("../../fixtures/fixture-parser"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
fixtureParser("babel-eslint5/destructuring-object-spread"),
),
likely benign
LLM, confidence 0.95
Test case requiring a babel-eslint fixture parser via fixtureParser.
Reasoning
fixtureParser(...) resolves a babel-eslint fixture name for a destructuring test. This is a legitimate parser-fixture lookup in a test suite.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
fixtureParser("babel-eslint5/destructuring-object-spread"),
),
likely benign
LLM, confidence 0.93
Test config requires a parser fixture chosen by a helper function.
Reasoning
Test fixture loading a parser module via a helper that builds a path from a fixture name; this is the standard ESLint test pattern for parser fixtures, not malicious.
-
file mixes tab and space indentation (472 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)
function invalid(code, output) {
return {
code,
output,
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"typescript-parsers/exponentiation-with-assertion-1",
likely benign
LLM, confidence 0.93
Test requires a typescript parser fixture via a path helper.
Reasoning
Dynamic require of a parser fixture inside a unit test's languageOptions; the specifier is a fixed test name, consistent with ESLint test conventions.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"typescript-parsers/exponentiation-with-assertion-2",
likely benign
LLM, confidence 0.93
Test requires a typescript parser fixture via a path helper.
Reasoning
Same pattern as the other finding in this file: test fixture parser loaded with a computed fixture name.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"typescript-parsers/exponentiation-with-assertion-3",
likely benign
LLM, confidence 0.93
Test requires a typescript parser fixture via a path helper.
Reasoning
Same ESLint test-fixture parser loading pattern; no sign of attacker-controlled input.
-
file mixes tab and space indentation (603 tab-indented and 17 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/prefer-named-capture-group"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (505 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)
const languageOptions = {
ecmaVersion: 2022,
};
-
file mixes tab and space indentation (855 tab-indented and 196 space-indented lines) (raw pass, confidence 0.40)
const languageOptions = {
ecmaVersion: 2018,
sourceType: "module",
};
-
file mixes tab and space indentation (120 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)
const ruleTester = new RuleTester({
languageOptions: { ecmaVersion: 2022, sourceType: "script" },
});
-
compression ratio 0.862 is >2σ above file mean 0.643 (raw pass, confidence 0.50)
{
code: "RegExp(\"foo\") instanceof RegExp(String.raw`blahblah`, 'g') ? typeof new RegExp('(\\\\p{Emoji_Presentation})\\\\1', `ug`) : false",
errors: [
{
-
file mixes tab and space indentation (433 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)
const errors = [
{
messageId: "unexpectedStringConcatenation",
},
-
file mixes tab and space indentation (1210 tab-indented and 234 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/preserve-caught-error"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (218 tab-indented and 199 space-indented lines) (raw pass, confidence 0.40)
const ruleTester = new RuleTester({
languageOptions: { ecmaVersion: 2022, sourceType: "script" },
});
-
file mixes tab and space indentation (443 tab-indented and 43 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/require-await"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (561 tab-indented and 151 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/semi-style"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (2638 tab-indented and 328 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/semi"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (431 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/sort-imports"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
file mixes tab and space indentation (2265 tab-indented and 190 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/sort-keys"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
fixtureParser(
"space-before-blocks",
likely benign
LLM, confidence 0.92
Test requires a parser fixture for space-before-blocks rule tests.
Reasoning
Test config loads a parser via a fixture helper with a static fixture name; typical ESLint test code.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
fixtureParser(
"space-before-blocks",
likely benign
LLM, confidence 0.92
Test requires a parser fixture for space-before-blocks rule tests.
Reasoning
Same fixture-parser loading pattern in the same test file.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
baseParser("babel-eslint7", "function-type-annotation"),
),
likely benign
LLM, confidence 0.92
Test requires a babel parser fixture for function-paren spacing tests.
Reasoning
Test helper loads a babel-eslint parser fixture by name; benign test scaffolding.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
ecmaVersion: 6,
parser: require(
parser(
"type-annotations/function-parameter-type-annotation",
likely benign
LLM, confidence 0.92
Test requires a type-annotation parser fixture.
Reasoning
Parser fixture loaded through a helper in a rule test; consistent with ESLint's test suite layout.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
ecmaVersion: 6,
parser: require(
parser("type-annotations/function-return-type-annotation"),
),
likely benign
LLM, confidence 0.92
Test requires a return-type-annotation parser fixture.
Reasoning
Parser fixture loaded via helper with static name; benign test code.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
ecmaVersion: 6,
parser: require(
parser(
"type-annotations/variable-declaration-init-type-annotation",
likely benign
LLM, confidence 0.92
Test requires a variable-declaration type-annotation parser fixture.
Reasoning
Same fixture-based parser loading in rule tests; no malicious indicators.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
ecmaVersion: 6,
parser: require(
parser(
"type-annotations/function-expression-type-annotation",
likely benign
LLM, confidence 0.92
Test requires a function-expression type-annotation parser fixture.
Reasoning
Parser fixture loaded for a test case; benign test scaffolding.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
ecmaVersion: 6,
parser: require(parser("typescript-parsers/type-alias")),
},
},
likely benign
LLM, confidence 0.93
Test requires a typescript type-alias parser fixture.
Reasoning
Static fixture parser require in a test config; benign.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
parser(
"type-annotations/variable-declaration-init-type-annotation-no-space",
likely benign
LLM, confidence 0.92
Test requires a no-space type-annotation parser fixture.
Reasoning
Parser fixture loaded through a test helper; benign ESLint test pattern.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
ecmaVersion: 6,
parser: require(
parser(
"type-annotations/function-declaration-type-annotation-no-space",
likely benign
LLM, confidence 0.92
Test requires a function-declaration type-annotation parser fixture.
Reasoning
Parser fixture loaded for a declaration type-annotation test; benign.
-
file mixes tab and space indentation (1736 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)
const rule = require("../../../lib/rules/use-isnan"),
RuleTester = require("../../../lib/rule-tester/rule-tester");
-
orphaned high surrogate \uD834 (no matching low surrogate) (token pass, confidence 0.65)
{ start: 1, source: "a" },
{ start: 2, source: "\ud834" },
{ start: 3, source: "\udd1e" },
{ start: 4, source: "z" },
-
orphaned low surrogate \uDD1E (no preceding high surrogate) (token pass, confidence 0.65)
{ start: 2, source: "\ud834" },
{ start: 3, source: "\udd1e" },
{ start: 4, source: "z" },
],
-
orphaned high surrogate \uD834 (no matching low surrogate) (token pass, confidence 0.65)
{ start: 1, source: "A" },
{ start: 2, source: "\ud834" },
{ start: 3, source: "\udd1e" },
{ start: 4, source: "Z" },
-
orphaned low surrogate \uDD1E (no preceding high surrogate) (token pass, confidence 0.65)
{ start: 2, source: "\ud834" },
{ start: 3, source: "\udd1e" },
{ start: 4, source: "Z" },
],
-
file mixes tab and space indentation (132 tab-indented and 53 space-indented lines) (raw pass, confidence 0.40)
function setupSpawnSyncStubReturnVals(stub, returnVals) {
let stubChain = stub;
for (const [i, val] of returnVals.entries()) {
-
file mixes tab and space indentation (497 tab-indented and 21 space-indented lines) (raw pass, confidence 0.40)
function getMessage(templateName, messageData = {}) {
const template = require(`../../messages/${templateName}.js`);
return template(messageData);
}
-
`require` called with a non-literal specifier (ast pass, confidence 0.80)
function getMessage(templateName, messageData = {}) {
const template = require(`../../messages/${templateName}.js`);
return template(messageData);
}
likely benign
LLM, confidence 0.90
Helper requires a message template file by name from the messages directory.
Reasoning
Loads message templates by name from the repo's messages directory; the name comes from internal test/code callers, not untrusted input, so this is a normal dynamic require.
-
file mixes tab and space indentation (13487 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)
(function () {
var require;
require = (function (e, t, n) {
function i(n, s) {
-
`Function(...)` called with a non-literal body (ast pass, confidence 0.75)
try {
render = new Function(
settings.variable || "obj",
"_",
likely benign
LLM, confidence 0.80
Vendored template compiler builds a function from a template body via the Function constructor.
Reasoning
This is a vendored copy of the jshint/lodash template engine, which uses new Function to compile templates; it is a known library pattern and the body comes from the library's own template code, not an attacker. Still a dynamic execution sink in a test performance fixture, so not fully certain.
-
file mixes tab and space indentation (49 tab-indented and 30 space-indented lines) (raw pass, confidence 0.40)
describe("reduceBadExampleSize()", () => {
it("extracts relevant part of deeply nested code", () => {
const initialCode = `
if (true) {
-
file mixes tab and space indentation (17 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)
ruleTester.run("internal-rules/multiline-comment-style", rule, {
valid: [
`
//----------------
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
.map(filename => ({
[filename.replace(/\.js$/u, "")]: require(
path.resolve(__dirname, filename),
),
likely benign
LLM, confidence 0.85
Internal rules loader requires each rule file found in its directory.
Reasoning
Build tool loads internal rule files from a directory listing with path.resolve against __dirname; the filenames come from the repo's own directory, so this is a normal dynamic require with no external input.
-
dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
const { plugin: pluginRequested = "all" } = values;
const { default: pluginsData } = await import(pluginDataFilePath, {
with: { type: "json" },
});
likely benign
LLM, confidence 0.85
A test tooling script dynamically imports a JSON plugin data file whose path is computed locally.
Reasoning
The dynamic import uses a variable path (pluginDataFilePath) with a JSON import attribute, which is a common pattern for loading a local data file in a test-ecosystem tooling script. The surrounding code parses CLI values and loads plugin metadata for tests. Nothing in the snippet suggests remote code execution; the import is of a JSON file, which does not execute code. Residual doubt because the path origin is not shown.
-
file mixes tab and space indentation (6 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)
for (const [ruleId, rule] of builtInRules) {
if (!rule.meta.deprecated) {
allRules[ruleId] = "error";
}
-
file mixes tab and space indentation (11 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)
for (const [ruleId, rule] of builtInRules) {
if (!rule.meta.deprecated) {
if (rule.meta.docs.recommended === true) {
recommendedRule[ruleId] = "error";
-
file mixes tab and space indentation (31 tab-indented and 26 space-indented lines) (raw pass, confidence 0.40)
const SPONSORS_URL =
"https://raw.githubusercontent.com/eslint/eslint.org/main/includes/sponsors.md";
const TEAM_URL =
"https://raw.githubusercontent.com/eslint/eslint.org/main/src/_data/team.json";
Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.
disclude.io