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
Build script dynamically requires a rule module by resolved path.
Reasoning
Build script requiring a rule file from a path resolved from a filename argument; a normal Node build-tool pattern with no obfuscation or hidden execution.
-
`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 loads a data file via a computed path.
Reasoning
Build script loads a JSON/data file from a computed path; ordinary tooling behavior in the ESLint repository's Makefile.
-
`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 using a computed path.
Reasoning
Requires docs package.json at a path built from __dirname; benign release-script logic.
-
`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 error message template module by name.
Reasoning
Loads a message template by name from the messages directory; the template name is internal error metadata, a legitimate plugin-style pattern.
-
line length 789 characters (raw pass, confidence 0.50)
<path d="M10.4998 6.66666V9.99999M10.4998 13.3333H10.5081M9.0748 2.38333L2.01647 14.1667C1.87094 14.4187 1.79394 14.7044 1.79313 14.9954C1.79231 15.2864 1.86771 15.5726 2.01183 15.8254C2.15594 16.0783 2.36374 16.2889 2.61456 16.4365C2.86538 16.5841 3.15047 16.6635 3.44147 16.6667H17.5581C17.8491 16.6635 18.1342
-
line length 558 characters (raw pass, confidence 0.50)
<path d="M17.8333 9.23333V10C17.8323 11.797 17.2504 13.5456 16.1744 14.9849C15.0985 16.4241 13.5861 17.4771 11.8628 17.9866C10.1395 18.4961 8.29771 18.4349 6.61205 17.8122C4.92639 17.1894 3.4872 16.0384 2.50912 14.5309C1.53105 13.0234 1.06648 11.2401 1.18472 9.44693C1.30296 7.6538 1.99766 5.94694 3.16522 4.5808
-
line length 1729 characters (raw pass, confidence 0.50)
<path d="M118.919 44.2986C116.678 44.2986 114.688 43.9063 112.951 43.1218C111.242 42.3092 109.897 41.1464 108.916 39.6334C107.936 38.1203 107.445 36.271 107.445 34.0855V32.9928H112.447V34.0855C112.447 36.0189 113.035 37.4619 114.212 38.4145C115.389 39.3672 116.958 39.8435 118.919 39.8435C120.909 39.8435 122.408
-
line length 502 characters (raw pass, confidence 0.50)
yarn {% if params.args.includes("--global") %}{{ conversions.toYarnArgs["--global"] | safe }} {% endif -%} {% if conversions.toYarnCommands[params.command] %}{{ conversions.toYarnCommands[params.command] | safe }}{% else %}{{ params.command | safe }}{% endif -%}{% for arg in params.args %}{% if arg !== "--global" %} {{
-
compression ratio 0.771 is >2σ above file mean 0.557 (raw pass, confidence 0.50)
<a class="search_powered-by-wrapper"
href="https://www.algolia.com/developers/?utm_source=eslint&utm_medium=referral&utm_content=powered_by&utm_campaign=docsearch" target="_blank"
rel="noopener noreferrer">
<div class="search__powered-by">
-
compression ratio 0.647 is >2σ above file mean 0.463 (raw pass, confidence 0.50)
<path fill="none" d="M0 0h24v24H0z"></path><path d="M389.2 48h70.6L305.6 224.2 487 464H345L233.7 318.6 106.5 464H35.8L200.7 275.5 26.8 48H172.4L272.9 180.9 389.2 48zM364.4 421.8h39.1L151.1 88h-42L364.4 421.8z"></path>
</svg>
</a>
-
line length 1989 characters (raw pass, confidence 0.50)
d="m 50,955.36218 c 1.6568,0 3,1.3431 3,3 l 0,16 c 0,1.6569 -1.3432,3 -3,3 -1.6569,0 -3,-1.3431 -3,-3 l 0,-16 c 0,-1.6569 1.3431,-3 3,-3 z m 31.125,12.875 c 0.76777,0 1.50798,0.3205 2.09375,0.9062 1.17159,1.1717 1.17157,3.0472 0,4.2188 l -11.3125,11.3125 c -1.17157,1.1716 -3.04714,1.1716 -4.2187
-
line length 731 characters (raw pass, confidence 0.50)
d="m 35.377874,961.36325 a 3.0003,3.0003 0 0 0 -0.9063,0.1875 c -16.1759,5.9947 -25.4686997,21.7109 -25.4686997,39.59375 0,23.2769 18.9104997,42.2187 42.1873997,42.2187 17.8829,0 33.6304,-9.324 39.625,-25.5 a 3.0003,3.0003 0 0 0 -3.9374,-3.8125 c -4.0936,1.6462 -8.5949,2.5 -13.3438,2.5 -19.5969,
-
line length 1134 characters (raw pass, confidence 0.50)
d="M966.479,980.01h-5.077v-9.202c0-27.228-13.174-53.007-35.243-68.963l-8.084-5.843l8.084-5.847 c22.067-15.952,35.243-41.732,35.243-68.961v-9.203h5.077c4.415,0,7.995-3.58,7.995-7.996c0-4.415-3.58-7.995-7.995-7.995H825.522 c-4.416,0-7.996,3.58-7.996,7.995c0,4.416,3.58,7.996,7.996,7.996h5.074v11.397c0,
-
line length 749 characters (raw pass, confidence 0.50)
<p>Copyright <a href="https://openjsf.org">OpenJS Foundation</a> and ESLint contributors. All rights reserved. The <a href="https://openjsf.org">OpenJS Foundation</a> has registered trademarks and uses trademarks. For a list of trademarks of the <a href="https://openjsf.org">OpenJS Foundation</a>, please s
-
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 require with a variable name inside a function.
Reasoning
Documentation example illustrating the global-require rule; the require is shown as an anti-pattern in prose, 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 snippet demonstrating non-literal require inside a function.
Reasoning
Rule documentation example of disallowed require usage; 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 snippet demonstrating a dynamic require in try/catch.
Reasoning
Rule documentation example in a try block; illustrative content for a lint rule.
-
[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 of eval with a concatenated key.
Reasoning
Markdown documentation for the no-eval lint rule showing eval as a bad example; 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 usage.
Reasoning
Documentation example for no-eval rule; illustrative code in prose.
-
[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 snippet showing eval with a computed expression.
Reasoning
Same eval documentation example for the no-eval rule; 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
Documentation for the no-implied-eval rule showing a bad example; not executed.
-
[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 string code.
Reasoning
Rule documentation illustrating string timer calls as incorrect usage.
-
[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 string code.
Reasoning
Rule documentation illustrating setInterval string form as incorrect usage.
-
[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
Documentation example of dynamic import with a webpack chunk comment; a literal-style illustrative snippet in a lint rule doc.
-
[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 of require with computed argument in a declaration list.
Reasoning
Rule documentation example showing mixed require declarations; illustrative only.
-
[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 snippet of mixed require declarations.
Reasoning
Documentation example for no-mixed-requires rule; not executed code.
-
[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 snippet of var declarations with require calls.
Reasoning
Documentation example for no-mixed-requires rule; not executed 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();
dismissed
LLM, confidence 0.90
Documentation example showing require calls with computed specifiers.
Reasoning
Illustrative require calls inside a markdown lint-rule example. The non-literal specifiers are teaching examples, not executed code.
-
[embedded javascript] `require` called with a non-literal specifier (ast pass, confidence 0.60)
var foo = require('foo'),
bar = require(getBarModuleName());
dismissed
LLM, confidence 0.90
Documentation example of a non-literal require call.
Reasoning
Same documentation example pattern; the dynamic require is part of an illustrative snippet in prose.
-
[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
dismissed
LLM, confidence 0.85
Base64-like compressed code in a playground link in documentation.
Reasoning
The blob is a compressed code fragment inside a TypeScript playground URL fragment. It is a shared-code link, not a payload.
-
base64-like blob (89 bytes, compression ratio 1.03) (raw pass, confidence 0.60)
piKXJ2Ry+ubFTtL-PuKtez0uycbZ830i1GrNx3JdFdPB73982-HH2djb6Td6nGaIOaTe7ZRTQdCwbavGFww6I2Gwc5pOhI9F3LIdOEvejYlEQolojGkrHkryU+jQAAeAAdiJApIJAkA) for reference.
dismissed
LLM, confidence 0.85
Base64-like fragment of a playground link in documentation.
Reasoning
Trailing portion of the same playground URL in a documentation link; no executable 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
Documentation example illustrating a byte order mark in JavaScript source.
Reasoning
The BOM is deliberately placed in an example that demonstrates the unicode-bom lint rule. It is documentation of the BOM itself.
-
[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
Second documentation example with a BOM for the unicode-bom rule.
Reasoning
Same deliberate BOM in a second rule-demonstration example.
-
line length 1684 characters (raw pass, confidence 0.50)
<link rel="icon" type="image/png" sizes="any" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAACXBIWXMAAAHaAAAB2gGFomX7AAAAGXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAABD1JREFUWMPFl11sk2UUx3/nbYtjxS1MF7MLMTECMgSTtSSyrQkLhAj7UBPnDSEGoxegGzMwojhXVpmTAA5iYpSoMQa8GBhFOrMFk03buei6yRAlcm
-
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/
-
line length 1444 characters (raw pass, confidence 0.50)
<link rel="icon" type="image/svg+xml" href="data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PScwIDAgMjk0LjgyNSAyNTguOTgyJyB4bWxucz0naHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmcnPg0KPHBhdGggZmlsbD0nIzgwODBGMicgZD0nTTk3LjAyMSw5OS4wMTZsNDguNDMyLTI3Ljk2MmMxLjIxMi0wLjcsMi43MDYtMC43LDMuOTE4LDBsNDguNDMzLDI3Ljk2MiBjMS4yMTEsMC43LDEuOT
-
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
Stray zero-width spaces around prose words in a markdown changelog. Likely a copy-paste artifact. Low-impact, though it is a hidden-character pattern.
-
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, consistent with formatting or copy artifacts in documentation.
-
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 heading text.
Reasoning
Zero-width space adjacent to a heading word in documentation; no code is affected since it is in prose.
-
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 documentation prose before an example.
Reasoning
Zero-width space in prose just before a code fence. Consistent with a copy artifact, not an attack.
-
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.95
Base64-encoded PNG image inlined in the HTML formatter output.
Reasoning
A small embedded PNG favicon/image encoded as a data URI in an HTML formatter template. This is a standard way to inline images.
-
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.80
Dynamic import of a user config file URL in the config loader.
Reasoning
ESLint's config loader imports a config file by its file URL, which is the expected way to load user-supplied config modules. The specifier comes from the config path, not untrusted input.
-
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.80
Dynamic import of an options module from a URL.
Reasoning
Loads an options module by URL for CLI configuration. This is a legitimate dynamic import pattern for user-specified modules.
-
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 its resolved path.
Reasoning
Loads a formatter module from a resolved path via pathToFileURL, with a fallback path for removed formatters. This is normal plugin/formatter loading in ESLint.
-
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
Template compilation via Function constructor in a benchmark fixture.
Reasoning
Compiles a template with new Function in a benchmark file, matching the usage of template engines like lodash. The template source is test/benchmark data, not attacker input.
-
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 code requiring a plugin module by joined path.
Reasoning
Test fixture requiring a plugin via path.join from a test working directory. This is ordinary test setup code.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(filePath),
},
},
likely benign
LLM, confidence 0.93
Test code requires a custom parser module from a file path.
Reasoning
A parser module is loaded from a file path inside an ESLint test fixture. This is a standard way to test custom parsers and carries no sign of malicious intent.
-
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.92
Test code dynamically imports an options module by URL.
Reasoning
The dynamic import loads an options module path in a test of ESLint.fromOptionsModule. The path is test-controlled and this is the expected behavior under test.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
plugins: {
test: require(
path.join(
cwd,
likely benign
LLM, confidence 0.92
Test code requires a plugin from a test fixture path.
Reasoning
A plugin is required from a path built with path.join from the test's working directory. This is ordinary test fixture loading.
-
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.90
Rule tester intentionally evals code to assert that a syntax error is thrown.
Reasoning
The eval is preceded by an eslint-disable comment marking it as intentional. It runs test code to check that an error is thrown, which is expected in a rule tester.
-
`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 loads a rule-tester module through a data: URI built from local content.
Reasoning
A data: URI import looks alarming, but the content is most likely the repository's own rule source read from disk and loaded in memory to test the no-var rule. No external or attacker-controlled input is visible in the snippet, though the content variable's origin is not shown.
-
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.93
Rule test helper requires a parser by resolved local path.
Reasoning
The parser helper resolves a parser by name relative to __dirname within a rule test file. This is a standard test pattern.
-
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.93
Rule test helper requires a parser selected by test name.
Reasoning
The parser helper requires a parser from a base parser helper using the rule name. This is a standard test pattern.
-
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.93
Rule test helper requires a parser by resolved local path.
Reasoning
The parser helper resolves a parser by name relative to __dirname within a rule test file. This is a standard test pattern.
-
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.93
Test case requires a fixture parser by name.
Reasoning
A fixture parser is required by name inside a test case configuration. This is ordinary test setup.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
fixtureParser(
"function-paren-newline",
likely benign
LLM, confidence 0.93
Test case requires a fixture parser by name.
Reasoning
A fixture parser is required by name inside a test case configuration. This is ordinary test setup.
-
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.94
Indent rule test requires a parser fixture by name.
Reasoning
A parser fixture is required with a name-based helper in a test case. This is standard test configuration.
-
`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.94
Indent rule test requires a parser fixture by name.
Reasoning
A parser fixture is required with a name-based helper in a test case. This is standard test configuration.
-
`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.94
Indent rule test requires a parser fixture by name.
Reasoning
A parser fixture is required with a name-based helper in a test case. This is standard test configuration.
-
`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.94
Indent rule test requires a parser fixture by name.
Reasoning
A parser fixture is required with a name-based helper in a test case. This is standard test configuration.
-
`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.94
Indent rule test requires a parser fixture by name.
Reasoning
A parser fixture is required with a name-based helper in a test case. This is standard test configuration.
-
`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.94
Indent rule test requires a parser fixture by name.
Reasoning
A parser fixture is required with a name-based helper in a test case. This is standard test configuration.
-
`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.94
Indent rule test requires a parser fixture by name.
Reasoning
A parser fixture is required with a name-based helper in a test case. This is standard test configuration.
-
`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 an ESLint parser fixture through a helper function.
Reasoning
ESLint test file loading a parser via require() around a local fixture helper with a string path. The non-literal specifier is a test-fixture pattern, not dynamic code execution from untrusted input.
-
`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 requiring an abstract-class parser fixture via a helper.
Reasoning
Same ESLint test-fixture pattern: require() of a parser chosen by a local helper with a fixed fixture name. Benign.
-
`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 for functions with abstract classes.
Reasoning
Multi-line require(parser(...)) in an ESLint rule test with a hardcoded fixture path. No untrusted input reaches the specifier.
-
`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 parser fixture for namespaces with functions and abstract classes.
Reasoning
ESLint test fixture loading a parser by name through a local helper. The specifier is a constant test path, so this is ordinary test scaffolding.
-
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.93
Test case loading a keyword-spacing fixture parser.
Reasoning
ESLint keyword-spacing test that loads a parser through fixtureParser with a fixed directory name. Standard 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.93
Test case loading a keyword-spacing fixture parser.
Reasoning
Same fixtureParser pattern in an ESLint rule test with hardcoded fixture names. Benign.
-
`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.93
Test case requiring a TypeScript decorator-with-class parser fixture.
Reasoning
Requires a TypeScript parser fixture by a fixed string path in an ESLint test. No dynamic execution of external input.
-
`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.93
Test case requiring a TypeScript decorator class-methods parser fixture.
Reasoning
Requires a TypeScript parser fixture by a constant path inside an ESLint rule test. Benign test scaffolding.
-
`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.93
Test case requiring a static-class-methods decorator parser fixture.
Reasoning
Multi-line require(parser(...)) with a fixed fixture name in an ESLint test. Benign.
-
`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.93
Test case requiring a keyword-with-arrow-function parser fixture.
Reasoning
Parser fixture loaded by constant name in an ESLint keyword-spacing test. No untrusted input involved.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
fixtureParser(
"keyword-spacing",
likely benign
LLM, confidence 0.93
Test case loading a keyword-spacing fixture parser.
Reasoning
fixtureParser-based parser load in an ESLint test with fixed arguments. Standard test harness pattern.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
fixtureParser(
"keyword-spacing",
likely benign
LLM, confidence 0.93
Test case loading a keyword-spacing fixture parser.
Reasoning
Same fixtureParser pattern in an ESLint test with constant fixture names. Benign.
-
`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.93
Test case requiring a decorator keyword class-method parser fixture.
Reasoning
Parser fixture for a decorator keyword class method, loaded by a fixed string in an ESLint test. Benign.
-
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.93
Test case requiring a logical-assignment-with-assertion parser fixture.
Reasoning
Requires a TypeScript assertion parser fixture by constant name in an ESLint test. No dynamic execution of untrusted data.
-
`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.93
Test case requiring a logical-with-assignment assertion parser fixture.
Reasoning
Same parser-fixture loading pattern in an ESLint test with a fixed path. Benign.
-
`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.93
Test case requiring a logical-with-assignment assertion parser fixture (variant 2).
Reasoning
Fixed-name parser fixture require in an ESLint test file. Ordinary test scaffolding.
-
`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.93
Test case requiring a logical-with-assignment assertion parser fixture (variant 3).
Reasoning
Parser fixture loaded via helper with a constant string in an ESLint rule test. 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.90
Test config loads a fixture parser via require(parser(...)) in an ESLint rule test.
Reasoning
The require call wraps a local parser helper that resolves fixture parser names in an ESLint rule test. This is the standard way ESLint tests load custom parsers, and the file is a test fixture, not shipped code.
-
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.90
Test config requires a TypeScript parser fixture chosen by a helper in an ESLint rule test.
Reasoning
The non-literal require resolves a named TypeScript parser fixture through a test helper. This is normal ESLint test scaffolding for parser-specific cases.
-
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.90
Test config dynamically requires a parser fixture in an ESLint no-extra-parens test.
Reasoning
The dynamic require picks a parser fixture path through a helper function, consistent with ESLint's test layout for parser-specific rule cases.
-
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.90
Test config requires a parser fixture for a using-declaration case in an ESLint test.
Reasoning
The require loads a named parser fixture for a 'using' declaration case through the test parser helper. This is ordinary test setup in the ESLint codebase.
-
`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.90
Test config requires a parser fixture for an await-using case in an ESLint test.
Reasoning
The require loads a parser fixture for an await-using case via a test helper, matching ESLint's test conventions.
-
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.90
Test config requires a parser fixture for a ternary test case in ESLint.
Reasoning
The dynamic require resolves a named parser fixture through a helper inside a rule test case, which is routine for ESLint test files.
-
`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.90
Second ternary test case loads a parser fixture via a helper in ESLint.
Reasoning
Same pattern as the other ternary case: a parser fixture is loaded through a test helper in an ESLint rule test.
-
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.87
Test config requires a parser resolved relative to __dirname in an ESLint test.
Reasoning
The require wraps resolvePath(__dirname, ...), a path relative to the test directory, so the parser module comes from the repository's own fixtures.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.87
Test config requires a local parser fixture resolved from __dirname.
Reasoning
The require resolves a parser path relative to __dirname, which points at local test fixtures rather than an external or attacker-controlled source.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.87
Test config requires a local parser fixture via resolvePath(__dirname, ...).
Reasoning
The dynamic require uses resolvePath with __dirname, a routine pattern for loading local parsers in ESLint's test suite.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.87
Test config loads a local parser fixture relative to __dirname.
Reasoning
Same resolvePath(__dirname, ...) parser loading in a test case, with no sign of obfuscation or external fetching.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.87
Test config loads a local parser fixture from __dirname in an ESLint test.
Reasoning
The require resolves a local parser path from __dirname within an ESLint test case, consistent with the rest of the file.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.87
Test config loads a local fixture parser relative to __dirname.
Reasoning
The resolvePath(__dirname, ...) require points to a local fixture parser, the normal form for ESLint parser tests.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.87
Test config loads a local parser fixture from __dirname in an ESLint test.
Reasoning
The dynamic require loads a local parser fixture resolved from __dirname, matching the file's other test cases.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.87
Test config loads a local parser fixture from __dirname in an ESLint test.
Reasoning
The require resolves a local parser fixture path from __dirname, the same repeated test scaffolding seen throughout the file.
-
`require` called with a non-literal specifier (ast pass, confidence 0.60)
languageOptions: {
parser: require(
resolvePath(
__dirname,
likely benign
LLM, confidence 0.87
Test config loads a local parser fixture via resolvePath in an ESLint test.
Reasoning
The require resolves a local parser fixture through resolvePath(__dirname, ...), standard 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.87
Test config loads a local parser fixture relative to __dirname in an ESLint test.
Reasoning
The dynamic require resolves a local parser fixture from __dirname, consistent with the file's other test setup.
-
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.90
Test config requires a babel-eslint fixture parser for a destructuring case.
Reasoning
The require loads a babel-eslint fixture parser for a destructuring case through a test helper. This is ordinary parser-fixture loading in ESLint's tests.
-
`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 case loads a parser fixture via require with a computed path.
Reasoning
Test fixture requiring a parser module via a helper that builds a path from a fixture name; this is standard ESLint test scaffolding loading local parsers, 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 config requires a parser module chosen by a helper function.
Reasoning
Test file requiring a local typescript parser fixture through a helper; benign linter test setup.
-
`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 config requires a parser module chosen by a helper function.
Reasoning
Same benign ESLint test pattern loading parser fixtures by 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 config requires a parser module chosen by a helper function.
Reasoning
Same benign ESLint test pattern loading parser fixtures by name.
-
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.93
Test config requires a parser fixture by computed name.
Reasoning
Test fixture loading a parser via a helper with a fixture name; standard 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.93
Test config requires a parser fixture by computed name.
Reasoning
Same benign ESLint test pattern.
-
`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.93
Test config requires a parser fixture via helper.
Reasoning
Test config requiring a local babel-eslint parser fixture via helper; benign.
-
`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.93
Test config requires a parser fixture via helper.
Reasoning
Standard ESLint test parser loading with computed fixture path; benign.
-
`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.93
Test config requires a parser fixture via helper.
Reasoning
Standard ESLint test parser loading; benign.
-
`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.93
Test config requires a parser fixture via helper.
Reasoning
Standard ESLint test parser loading; benign.
-
`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.93
Test config requires a parser fixture via helper.
Reasoning
Standard ESLint test parser loading; benign.
-
`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 config requires a typescript parser fixture.
Reasoning
Requires a parser by literal-like helper argument in 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.93
Test config requires a parser fixture via helper.
Reasoning
Standard ESLint test parser loading; benign.
-
`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.93
Test config requires a parser fixture via helper.
Reasoning
Standard ESLint test parser loading; 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 by templateName from the local messages folder.
Reasoning
Loads message template files by name from the repo's messages directory in a test helper; a local, non-malicious template 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 library builds a template render function with new Function from settings.
Reasoning
This is bundled jshint/lodash template compilation using new Function for templates, a known library pattern in a vendored performance benchmark file; dynamic code generation but not evidently malicious.
-
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 tooling loads rule modules from a local directory by filename.
Reasoning
Build tooling dynamically requires rule files from a directory listing using path.resolve with __dirname; ordinary internal plugin loading.
-
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-ecosystem tooling script dynamically imports a local JSON data file whose path is computed at runtime.
Reasoning
The dynamic import uses a variable path (pluginDataFilePath) with a JSON import attribute, which is a common pattern for loading a local JSON data file in a test tooling script. The snippet shows no network fetch, decoding, or code execution beyond loading JSON. The file is under tools/test-ecosystem, consistent with developer test scaffolding. The non-literal specifier is the only concern and is typical for computed local paths.
-
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