npm / typescript / 7.1.0-dev.20261020.3

typescript 7.1.0-dev.20261020.3

Source
https://github.com/microsoft/TypeScript
Commit scanned
28534d760906 (recorded by npm)
Compared with
5237fd468909 (0 signals introduced since)
Files
34516 scanned, 33363 skipped (binary, oversized, or unrecognised)
Signals
1 critical · 428 warn · 2232 info
Scan time
114.9 s
LLM review
Reviewed by claude-haiku-5-5 (Anthropic): the 114 most severe of 542 warn and critical signals (114 with a verdict); 113 demoted to info. The rest are unreviewed.
Disclude version
4.0.0
Scanned (UTC)
2026-10-21 08:29

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

  1. `import(...)` specifier is a `data:` URI — executes arbitrary code without touching disk (ast pass, confidence 0.95)

    async function evaluateEnumMembers(enumSource: string, enumName: string): Promise<Record<string, number | string>> {⟨U+000D⟩
        const enumModule = await import(`data:text/javascript;charset=utf-8,${encodeURIComponent(enumSource)}`);⟨U+000D⟩
        const enumObj = enumModule[enumName] as Record<string, number | string>;
    likely benign LLM, confidence 0.60 Code generator that evaluates enum declarations by dynamically importing them as a data: URI.
    Reasoning

    The build script evaluates enum source text by importing it as a data: URI, which runs code without writing to disk. This is an unusual technique and is flagged critical, but the enumSource appears to come from the repository's own TypeScript sources in a code-generation tool. Malicious intent is unlikely, though the pattern is worth a human glance to confirm the input is trusted.

  2. line length 3962 characters (raw pass, confidence 0.65)

    export declare function f2<T extends Record<string, Iterable<unknown>>>(a: T): IteratorObject<T extends Partial<Record<keyof T, undefined>> ? keyof T extends never ? Record<PropertyKey, unknown> : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 
  3. line length 2253 characters (raw pass, confidence 0.65)

        }): IteratorObject<T extends Partial<Record<keyof T, undefined>> ? keyof T extends never ? Record<PropertyKey, unknown> : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) & object ? U 
  4. line length 2424 characters (raw pass, confidence 0.65)

        }) | undefined): IteratorObject<T extends Partial<Record<keyof T, undefined>> ? keyof T extends never ? Record<PropertyKey, unknown> : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) 
  5. line length 3948 characters (raw pass, confidence 0.65)

    export declare function f2<T extends Record<string, Iterable<unknown>>>(a: T): IteratorObject<T extends Partial<Record<keyof T, undefined>> ? keyof T extends never ? Record<PropertyKey, unknown> : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 
  6. line length 2239 characters (raw pass, confidence 0.65)

        }): IteratorObject<T extends Partial<Record<keyof T, undefined>> ? keyof T extends never ? Record<PropertyKey, unknown> : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) & object ? U 
  7. line length 2410 characters (raw pass, confidence 0.65)

        }) | undefined): IteratorObject<T extends Partial<Record<keyof T, undefined>> ? keyof T extends never ? Record<PropertyKey, unknown> : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) 
  8. base64-like blob (124 bytes, compression ratio 1.00) (raw pass, confidence 0.60)

    JsFile: a.js⟨U+000D⟩
    mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZXMiOlsiYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsTUFBTSxDQUFDO0NBQ04ifQ==⟨U+000D⟩
    sourceRoot: ⟨U+000D⟩
    sources: a.ts
  9. base64-like blob (124 bytes, compression ratio 1.00) (raw pass, confidence 0.60)

    ---⟨U+000D⟩
    >>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZXMiOlsiYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsTUFBTSxDQUFDO0NBQ04ifQ==
  10. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    /** @type {import("should-not-be-resolved").Type} */
    var v = import(String());
  11. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    /** @type {import("should-not-be-resolved").Type} */⟨U+000D⟩
    var v = Promise.resolve(`${String()}`).then(s => __importStar(require(s)));
  12. line length 10419 characters (raw pass, confidence 0.65)

    mappedTypeRecursiveInference.ts(19,18): error TS2345: Argument of type 'XMLHttpRequest' is not assignable to parameter of type 'Deep<{ dispatchEvent: unknown; onreadystatechange: unknown; readonly readyState: { toString: any; toFixed: any; toExponential: any; toPrecision: any; valueOf: any; toLocaleString: any; }; read
  13. line length 10383 characters (raw pass, confidence 0.65)

    !!! error TS2345: Argument of type 'XMLHttpRequest' is not assignable to parameter of type 'Deep<{ dispatchEvent: unknown; onreadystatechange: unknown; readonly readyState: { toString: any; toFixed: any; toExponential: any; toPrecision: any; valueOf: any; toLocaleString: any; }; readonly response: unknown; readonly res
  14. line length 4809 characters (raw pass, confidence 0.65)

    mappedTypeWithAsClauseAndLateBoundProperty.ts(3,1): error TS2741: Property 'length' is missing in type '{ [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: (NumberFormatOptions & DateTimeFormatOptions) | undefined): string; }; pop: () => number | undefined
  15. line length 4761 characters (raw pass, confidence 0.65)

    !!! error TS2741: Property 'length' is missing in type '{ [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: (NumberFormatOptions & DateTimeFormatOptions) | undefined): string; }; pop: () => number | undefined; push: (...items: number[]) => number; concat: 
  16. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    
    import(getSpecifier());
    ⟨U+000D⟩
    //// [specifier.cts]
  17. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const specifier_cjs_1 = require("./specifier.cjs");⟨U+000D⟩
    import(__rewriteRelativeImportExtension((0, specifier_cjs_1.getSpecifier)()));⟨U+000D⟩
    //// [target.js]⟨U+000D⟩
    "use strict";
  18. identifier `啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ` mixes scripts: Han + Other (raw pass, confidence 0.80)

    ===================================================================⟨U+000D⟩
    JsFile: ①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].js
  19. identifier `〇㐀㐁䶴䶵U1` mixes scripts: Other + Han + Latin (raw pass, confidence 0.80)

    ===================================================================⟨U+000D⟩
    JsFile: ①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].js
  20. identifier `啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ` mixes scripts: Han + Other (raw pass, confidence 0.80)

    sourceRoot: ⟨U+000D⟩
    sources: ①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].ts⟨U+000D⟩
    ===================================================================⟨U+000D⟩
    -------------------------------------------------------------------
  21. identifier `〇㐀㐁䶴䶵U1` mixes scripts: Other + Han + Latin (raw pass, confidence 0.80)

    sourceRoot: ⟨U+000D⟩
    sources: ①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].ts⟨U+000D⟩
    ===================================================================⟨U+000D⟩
    -------------------------------------------------------------------
  22. identifier `啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ` mixes scripts: Han + Other (raw pass, confidence 0.80)

    emittedFile:①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].js⟨U+000D⟩
    sourceFile:①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].ts
  23. identifier `〇㐀㐁䶴䶵U1` mixes scripts: Other + Han + Latin (raw pass, confidence 0.80)

    emittedFile:①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].js⟨U+000D⟩
    sourceFile:①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].ts
  24. identifier `啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ` mixes scripts: Han + Other (raw pass, confidence 0.80)

    sourceFile:①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].ts⟨U+000D⟩
    -------------------------------------------------------------------⟨U+000D⟩
    >>>"use strict";
  25. identifier `〇㐀㐁䶴䶵U1` mixes scripts: Other + Han + Latin (raw pass, confidence 0.80)

    sourceFile:①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].ts⟨U+000D⟩
    -------------------------------------------------------------------⟨U+000D⟩
    >>>"use strict";
  26. [markup prose] `eval` called on a string literal (ast pass, confidence 0.85)

            eval("y");
  27. base64-like blob (82 bytes, compression ratio 1.01) (raw pass, confidence 0.60)

    superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts(7,17): error TS2314: Generic type 'A<T1, T2>' requires 2 type argument(s).
  28. base64-like blob (82 bytes, compression ratio 1.01) (raw pass, confidence 0.60)

    ⟨U+000D⟩
    ==== superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts (1 errors) ====⟨U+000D⟩
        class A<T1, T2> {⟨U+000D⟩
            constructor(private map: (value: T1) => T2) {
  29. base64-like blob (67 bytes, compression ratio 1.07) (raw pass, confidence 0.60)

    superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts(7,17): error TS2314: Generic type 'A<T1, T2>' requires 2 type argument(s).
  30. base64-like blob (67 bytes, compression ratio 1.07) (raw pass, confidence 0.60)

    ⟨U+000D⟩
    ==== superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts (1 errors) ====⟨U+000D⟩
        class A<T1, T2> {⟨U+000D⟩
            constructor(private map: (value: T1) => T2) {
  31. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

    superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts(7,17): error TS2315: Type 'A' is not generic.
  32. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

    ⟨U+000D⟩
    ==== superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts (1 errors) ====⟨U+000D⟩
        class A {⟨U+000D⟩
            constructor(private map: (value: number) => string) {
  33. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    // impossible to use a single baseline file to match the result of both. this test should be enabled once this issue is resolved.
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;
  34. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    // impossible to use a single baseline file to match the result of both. this test should be enabled once this issue is resolved.
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;
  35. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    // impossible to use a single baseline file to match the result of both. this test should be enabled once this issue is resolved.
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;
  36. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    // impossible to use a single baseline file to match the result of both. this test should be enabled once this issue is resolved.⟨U+000D⟩
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;
  37. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    // impossible to use a single baseline file to match the result of both. this test should be enabled once this issue is resolved.⟨U+000D⟩
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;
  38. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    // impossible to use a single baseline file to match the result of both. this test should be enabled once this issue is resolved.⟨U+000D⟩
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;
  39. line length 4039 characters (raw pass, confidence 0.65)

        var bin4 = 0B111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  40. line length 4038 characters (raw pass, confidence 0.65)

            0B1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  41. line length 4034 characters (raw pass, confidence 0.65)

    var bin4 = 0B1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  42. line length 4033 characters (raw pass, confidence 0.65)

        0B11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  43. line length 4035 characters (raw pass, confidence 0.65)

    var bin4 = 0B1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  44. line length 4034 characters (raw pass, confidence 0.65)

        0B11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  45. line length 4039 characters (raw pass, confidence 0.65)

        var bin4 = 0B111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  46. line length 4038 characters (raw pass, confidence 0.65)

            0B1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  47. line length 4034 characters (raw pass, confidence 0.65)

    var bin4 = 0B1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  48. line length 4033 characters (raw pass, confidence 0.65)

        0B11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  49. line length 4035 characters (raw pass, confidence 0.65)

    var bin4 = 0B1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  50. line length 4034 characters (raw pass, confidence 0.65)

        0B11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  51. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    //// [b.ts]⟨U+000D⟩
    import.defer;
    
    (import.defer)("a");
  52. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    "use strict";⟨U+000D⟩
    import.defer;⟨U+000D⟩
    (import.defer)("a");⟨U+000D⟩
    Function(import.defer);
  53. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    import("./foo.ts", { with: { attr: "value" } });
    import("" + "./foo.ts");⟨U+000D⟩
    //// [js.js]⟨U+000D⟩
    // Rewrite
  54. `require` called with a non-literal specifier (ast pass, confidence 0.60)

      require("./foo.ts");
      require(getPath());
    }
  55. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import("./foo.js", { with: { attr: "value" } });⟨U+000D⟩
    import(__rewriteRelativeImportExtension("" + "./foo.ts", true));⟨U+000D⟩
    //// [js.js]⟨U+000D⟩
    var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx, extraExtensions, ignoreCase) {
  56. `require` called with a non-literal specifier (ast pass, confidence 0.60)

        require("./foo.js");⟨U+000D⟩
        require(__rewriteRelativeImportExtension(getPath(), true));⟨U+000D⟩
    }⟨U+000D⟩
    // No rewrite or shim
  57. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    import("./foo.ts", { with: { attr: "value" } });
    import("" + "./foo.ts");⟨U+000D⟩
    //// [js.js]⟨U+000D⟩
    // Rewrite
  58. `require` called with a non-literal specifier (ast pass, confidence 0.60)

      require("./foo.ts");
      require(getPath());
    }
  59. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import("./foo.js", { with: { attr: "value" } });⟨U+000D⟩
    import(__rewriteRelativeImportExtension("" + "./foo.ts"));⟨U+000D⟩
    //// [js.js]⟨U+000D⟩
    var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx, extraExtensions, ignoreCase) {
  60. `require` called with a non-literal specifier (ast pass, confidence 0.60)

        require("./foo.js");⟨U+000D⟩
        require(__rewriteRelativeImportExtension(getPath()));⟨U+000D⟩
    }⟨U+000D⟩
    // No rewrite or shim
  61. `require` called with a non-literal specifier (ast pass, confidence 0.80)

    {
      require("" + "./foo.ts");
      import("" + "./foo.ts");
      require("./foo.ts");
  62. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

      require("" + "./foo.ts");
      import("" + "./foo.ts");
      require("./foo.ts");
      import("./foo.ts");
  63. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    {
      import("" + "./foo.ts");
      import("./foo.ts");
    }
  64. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    {⟨U+000D⟩
        require(__rewriteRelativeImportExtension("" + "./foo.ts"));⟨U+000D⟩
        Promise.resolve(`${__rewriteRelativeImportExtension("" + "./foo.ts")}`).then(s => __importStar(require(s)));⟨U+000D⟩
        require("./foo.js");
  65. `require` called with a non-literal specifier (ast pass, confidence 0.60)

        require(__rewriteRelativeImportExtension("" + "./foo.ts"));⟨U+000D⟩
        Promise.resolve(`${__rewriteRelativeImportExtension("" + "./foo.ts")}`).then(s => __importStar(require(s)));⟨U+000D⟩
        require("./foo.js");⟨U+000D⟩
        Promise.resolve().then(() => __importStar(require("./foo.js")));
  66. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    {⟨U+000D⟩
        Promise.resolve(`${__rewriteRelativeImportExtension("" + "./foo.ts")}`).then(s => __importStar(require(s)));⟨U+000D⟩
        Promise.resolve().then(() => __importStar(require("./foo.js")));⟨U+000D⟩
    }
  67. `require` called with a non-literal specifier (ast pass, confidence 0.80)

    {
      require("" + "./foo.ts");
      import("" + "./foo.ts");
      require("./foo.ts");
  68. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

      require("" + "./foo.ts");
      import("" + "./foo.ts");
      require("./foo.ts");
      import("./foo.ts");
  69. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    {
      import("" + "./foo.ts");
      import("./foo.ts");
    }
  70. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    {⟨U+000D⟩
        require(__rewriteRelativeImportExtension("" + "./foo.ts"));⟨U+000D⟩
        import(__rewriteRelativeImportExtension("" + "./foo.ts"));⟨U+000D⟩
        require("./foo.js");
  71. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

        require(__rewriteRelativeImportExtension("" + "./foo.ts"));⟨U+000D⟩
        import(__rewriteRelativeImportExtension("" + "./foo.ts"));⟨U+000D⟩
        require("./foo.js");⟨U+000D⟩
        import("./foo.js");
  72. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    {⟨U+000D⟩
        import(__rewriteRelativeImportExtension("" + "./foo.ts"));⟨U+000D⟩
        import("./foo.js");⟨U+000D⟩
    }
  73. line length 5341 characters (raw pass, confidence 0.65)

                "Samsung": "Samsung|SM-G9250|GT-19300|SGH-I337|BGT-S5230|GT-B2100|GT-B2700|GT-B2710|GT-B3210|GT-B3310|GT-B3410|GT-B3730|GT-B3740|GT-B5510|GT-B5512|GT-B5722|GT-B6520|GT-B7300|GT-B7320|GT-B7330|GT-B7350|GT-B7510|GT-B7722|GT-B7800|GT-C3010|GT-C3011|GT-C3060|GT-C3200|GT-C3212|GT-C3212I|GT-C3262|GT-C3222|GT-C330
  74. [markup prose] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)

    18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i,⟨U+000D⟩
  75. generator `g` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

    function* g(): IterableIterator<(x: string) => number, (x: string) => number> {
        yield x => x.length;
        yield *[x => x.length];
        return x => x.length;
  76. generator `g` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

    function* g() {⟨U+000D⟩
        yield x => x.length;⟨U+000D⟩
        yield* [x => x.length];⟨U+000D⟩
        return x => x.length;
  77. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

        yield * function* () {
            yield x => x.length;
        } ();
    }
  78. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

        yield* function* () {⟨U+000D⟩
            yield x => x.length;⟨U+000D⟩
        }();⟨U+000D⟩
    }
  79. generator `g` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

            *[Symbol.iterator]() {
                yield x => x.length;
            }
        };
  80. generator `g` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

            *[Symbol.iterator]() {⟨U+000D⟩
                yield x => x.length;⟨U+000D⟩
            }⟨U+000D⟩
        };
  81. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

        yield function* () {
            yield x => x.length;
        } ()
    }
  82. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

        yield function* () {⟨U+000D⟩
            yield x => x.length;⟨U+000D⟩
        }();⟨U+000D⟩
    }
  83. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

        yield function* () {
            yield x => x.length;
        } ()
    }
  84. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

        yield function* () {⟨U+000D⟩
            yield x => x.length;⟨U+000D⟩
        }();⟨U+000D⟩
    }
  85. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

        yield function* () {
            yield x => x.length;
        } ()
    }
  86. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

        yield function* () {⟨U+000D⟩
            yield x => x.length;⟨U+000D⟩
        }();⟨U+000D⟩
    }
  87. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

    
    foo("", function* () { yield x => x.length }, p => undefined); // T is fixed, should be string⟨U+000D⟩
    ⟨U+000D⟩
    //// [generatorTypeCheck45.js]
  88. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

    "use strict";⟨U+000D⟩
    foo("", function* () { yield x => x.length; }, p => undefined); // T is fixed, should be string
  89. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

            *[Symbol.iterator]() {
                yield x => x.length
            }
        }
  90. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

            *[Symbol.iterator]() {⟨U+000D⟩
                yield x => x.length;⟨U+000D⟩
            }⟨U+000D⟩
        };
  91. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const specify = bar() ? "./0" : undefined;
    let myModule = import(specify);
    let myModule1 = import(undefined);
    let myModule2 = import(bar() ? "./1" : null);
  92. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    let myModule1 = import(undefined);
    let myModule2 = import(bar() ? "./1" : null);
    let myModule3 = import(null);
  93. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const specify = bar() ? "./0" : undefined;⟨U+000D⟩
    let myModule = import(specify);⟨U+000D⟩
    let myModule1 = import(undefined);⟨U+000D⟩
    let myModule2 = import(bar() ? "./1" : null);
  94. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    let myModule1 = import(undefined);⟨U+000D⟩
    let myModule2 = import(bar() ? "./1" : null);⟨U+000D⟩
    let myModule3 = import(null);
  95. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const specify = bar() ? "./0" : undefined;
    let myModule = import(specify);
    let myModule1 = import(undefined);
    let myModule2 = import(bar() ? "./1" : null);
  96. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    let myModule1 = import(undefined);
    let myModule2 = import(bar() ? "./1" : null);
    let myModule3 = import(null);
  97. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const specify = bar() ? "./0" : undefined;⟨U+000D⟩
    let myModule = import(specify);⟨U+000D⟩
    let myModule1 = import(undefined);⟨U+000D⟩
    let myModule2 = import(bar() ? "./1" : null);
  98. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    let myModule1 = import(undefined);⟨U+000D⟩
    let myModule2 = import(bar() ? "./1" : null);⟨U+000D⟩
    let myModule3 = import(null);
  99. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    
    import(getSpecifier());
    
    var p0 = import(`${directory}\\${moduleFile}`);
  100. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    
    var p0 = import(`${directory}\\${moduleFile}`);
    var p1 = import(getSpecifier());
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
  101. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var p0 = import(`${directory}\\${moduleFile}`);
    var p1 = import(getSpecifier());
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
  102. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var p1 = import(getSpecifier());
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
    
    function returnDynamicLoad(path: string) {
  103. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    function returnDynamicLoad(path: string) {
        return import(path);
    }
  104. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    })();⟨U+000D⟩
    Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p0 = Promise.resolve(`${`${directory}\\${moduleFile}`}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p1 = Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));
  105. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p0 = Promise.resolve(`${`${directory}\\${moduleFile}`}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p1 = Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));
  106. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    var p0 = Promise.resolve(`${`${directory}\\${moduleFile}`}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p1 = Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    const p2 = Promise.resolve(`${whatToLoad ? getSpecifier() : "defaulPath"}`).then(s => __importStar(require(s)));
  107. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    var p1 = Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    const p2 = Promise.resolve(`${whatToLoad ? getSpecifier() : "defaulPath"}`).then(s => __importStar(require(s)));⟨U+000D⟩
    function returnDynamicLoad(path) {⟨U+000D⟩
        return Promise.resolve(`${path}`).then(s => __importStar(require(s)));
  108. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    function returnDynamicLoad(path) {⟨U+000D⟩
        return Promise.resolve(`${path}`).then(s => __importStar(require(s)));⟨U+000D⟩
    }
  109. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    
    export var p0: Promise<typeof Zero> = import(getPath());
    export var p1: Promise<typeof Zero> = import("./0");
    export var p2: Promise<any> = import("./0");
  110. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import("./0");⟨U+000D⟩
    export var p0 = import(getPath());⟨U+000D⟩
    export var p1 = import("./0");⟨U+000D⟩
    export var p2 = import("./0");
  111. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var a = ["./0"];
    import(...["PathModule"]);
    
    var p1 = import(...a);
  112. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    
    var p1 = import(...a);
    const p2 = import();
    const p4 = import("pathToModule", "secondModule");
  113. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    var a = ["./0"];⟨U+000D⟩
    Promise.resolve(`${...["PathModule"]}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p1 = Promise.resolve(`${...a}`).then(s => __importStar(require(s)));⟨U+000D⟩
    const p2 = Promise.resolve().then(() => __importStar(require()));
  114. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    Promise.resolve(`${...["PathModule"]}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p1 = Promise.resolve(`${...a}`).then(s => __importStar(require(s)));⟨U+000D⟩
    const p2 = Promise.resolve().then(() => __importStar(require()));⟨U+000D⟩
    const p4 = Promise.resolve().then(() => __importStar(require("pathToModule")));
  115. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {
        return await import((await import("./foo")).default);
    }
  116. `require` called with a non-literal specifier (ast pass, confidence 0.60)

        return __awaiter(this, void 0, void 0, function* () {⟨U+000D⟩
            return yield Promise.resolve(`${(yield Promise.resolve().then(() => __importStar(require("./foo")))).default}`).then(s => __importStar(require(s)));⟨U+000D⟩
        });⟨U+000D⟩
    }
  117. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {
        return await import((await import("./foo")).default);
    }
  118. `require` called with a non-literal specifier (ast pass, confidence 0.60)

        return __awaiter(this, void 0, void 0, function* () {⟨U+000D⟩
            return yield Promise.resolve(`${(yield Promise.resolve().then(() => __importStar(require("./foo")))).default}`).then(s => __importStar(require(s)));⟨U+000D⟩
        });⟨U+000D⟩
    }
  119. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {
        return await import((await import("./foo")).default);
    }
  120. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

        return __awaiter(this, void 0, void 0, function* () {⟨U+000D⟩
            return yield import((yield import("./foo")).default);⟨U+000D⟩
        });⟨U+000D⟩
    }
  121. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {
        return await import((await import("./foo")).default);
    }
  122. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

        return __awaiter(this, void 0, void 0, function* () {⟨U+000D⟩
            return yield import((yield import("./foo")).default);⟨U+000D⟩
        });⟨U+000D⟩
    }
  123. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {
        return await import((await import("./foo")).default);
    }
  124. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

        return __awaiter(this, void 0, void 0, function* () {⟨U+000D⟩
            return yield import((yield import("./foo")).default);⟨U+000D⟩
        });⟨U+000D⟩
    }
  125. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {
        return await import((await import("./foo")).default);
    }
  126. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

        return __awaiter(this, void 0, void 0, function* () {⟨U+000D⟩
            return yield import((yield import("./foo")).default);⟨U+000D⟩
        });⟨U+000D⟩
    }
  127. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    
    import(`${directory}\\${moduleFile}`);
    import(getSpecifier());
  128. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import(`${directory}\\${moduleFile}`);
    import(getSpecifier());
    
    var p1 = import(ValidSomeCondition() ? "./0" : "externalModule");
  129. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    
    var p1 = import(ValidSomeCondition() ? "./0" : "externalModule");
    var p1: Promise<any> = import(getSpecifier());
    var p11: Promise<typeof defaultModule> = import(getSpecifier());
  130. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var p1 = import(ValidSomeCondition() ? "./0" : "externalModule");
    var p1: Promise<any> = import(getSpecifier());
    var p11: Promise<typeof defaultModule> = import(getSpecifier());
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise<typeof defaultModule>;
  131. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var p1: Promise<any> = import(getSpecifier());
    var p11: Promise<typeof defaultModule> = import(getSpecifier());
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise<typeof defaultModule>;
    p1.then(zero => {
  132. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var p11: Promise<typeof defaultModule> = import(getSpecifier());
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise<typeof defaultModule>;
    p1.then(zero => {
        return zero.foo();  // ok, zero is any
  133. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    let j: string;
    var p3: Promise<typeof defaultModule> = import(j=getSpecifier());
    
    function * loadModule(directories: string[]) {
  134. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

            const path = `${directory}\\moduleFile`;
            import(yield path);
        }
    }
  135. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    Object.defineProperty(exports, "__esModule", { value: true });⟨U+000D⟩
    Promise.resolve(`${`${directory}\\${moduleFile}`}`).then(s => __importStar(require(s)));⟨U+000D⟩
    Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));
  136. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    Promise.resolve(`${`${directory}\\${moduleFile}`}`).then(s => __importStar(require(s)));⟨U+000D⟩
    Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p1 = Promise.resolve(`${ValidSomeCondition() ? "./0" : "externalModule"}`).then(s => __importStar(require(s)));
  137. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p1 = Promise.resolve(`${ValidSomeCondition() ? "./0" : "externalModule"}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p1 = Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));
  138. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    var p1 = Promise.resolve(`${ValidSomeCondition() ? "./0" : "externalModule"}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p1 = Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p11 = Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));
  139. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    var p1 = Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p11 = Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    const p2 = Promise.resolve(`${whatToLoad ? getSpecifier() : "defaulPath"}`).then(s => __importStar(require(s)));⟨U+000D⟩
    p1.then(zero => {
  140. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    var p11 = Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    const p2 = Promise.resolve(`${whatToLoad ? getSpecifier() : "defaulPath"}`).then(s => __importStar(require(s)));⟨U+000D⟩
    p1.then(zero => {⟨U+000D⟩
        return zero.foo(); // ok, zero is any
  141. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    let j;⟨U+000D⟩
    var p3 = Promise.resolve(`${j = getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    function* loadModule(directories) {⟨U+000D⟩
        for (const directory of directories) {
  142. `require` called with a non-literal specifier (ast pass, confidence 0.60)

            const path = `${directory}\\moduleFile`;⟨U+000D⟩
            Promise.resolve(`${yield path}`).then(s => __importStar(require(s)));⟨U+000D⟩
        }⟨U+000D⟩
    }
  143. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    const localeName = "zh-CN";
    import(`./locales/${localeName}.js`).then(bar => {
        let x = bar;
    });
  144. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    
    import("./locales/" + localeName + ".js").then(bar => {
        let x = bar;
    });
  145. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    const localeName = "zh-CN";⟨U+000D⟩
    import(`./locales/${localeName}.js`).then(bar => {⟨U+000D⟩
        let x = bar;⟨U+000D⟩
    });
  146. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    });⟨U+000D⟩
    import("./locales/" + localeName + ".js").then(bar => {⟨U+000D⟩
        let x = bar;⟨U+000D⟩
    });
  147. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    // Error specifier is not assignable to string
    import(getSpecifier());
    var p1 = import(getSpecifier());
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
  148. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import(getSpecifier());
    var p1 = import(getSpecifier());
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
    p1.then(zero => {
  149. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var p1 = import(getSpecifier());
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
    p1.then(zero => {
        return zero.foo();  // ok, zero is any
  150. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    
    var p3 = import(["path1", "path2"]);
    var p4 = import(()=>"PathToModule");
  151. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var p3 = import(["path1", "path2"]);
    var p4 = import(()=>"PathToModule");⟨U+000D⟩
    ⟨U+000D⟩
    //// [importCallExpressionSpecifierNotStringTypeError.js]
  152. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    // Error specifier is not assignable to string⟨U+000D⟩
    Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p1 = Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    const p2 = Promise.resolve(`${whatToLoad ? getSpecifier() : "defaulPath"}`).then(s => __importStar(require(s)));
  153. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p1 = Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    const p2 = Promise.resolve(`${whatToLoad ? getSpecifier() : "defaulPath"}`).then(s => __importStar(require(s)));⟨U+000D⟩
    p1.then(zero => {
  154. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    var p1 = Promise.resolve(`${getSpecifier()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    const p2 = Promise.resolve(`${whatToLoad ? getSpecifier() : "defaulPath"}`).then(s => __importStar(require(s)));⟨U+000D⟩
    p1.then(zero => {⟨U+000D⟩
        return zero.foo(); // ok, zero is any
  155. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    });⟨U+000D⟩
    var p3 = Promise.resolve(`${["path1", "path2"]}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p4 = Promise.resolve(`${() => "PathToModule"}`).then(s => __importStar(require(s)));
  156. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    var p3 = Promise.resolve(`${["path1", "path2"]}`).then(s => __importStar(require(s)));⟨U+000D⟩
    var p4 = Promise.resolve(`${() => "PathToModule"}`).then(s => __importStar(require(s)));
  157. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    a.value;
    import(a);
    import.source(a);
    import.source(1);
  158. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import(a);
    import.source(a);
    import.source(1);
    import.source(undefined);
  159. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    a.value;⟨U+000D⟩
    import(a);⟨U+000D⟩
    import.source(a);⟨U+000D⟩
    import.source(1);
  160. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import(a);⟨U+000D⟩
    import.source(a);⟨U+000D⟩
    import.source(1);⟨U+000D⟩
    import.source(undefined);
  161. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    //// [b.ts]⟨U+000D⟩
    import.source;
    (import.source)("./a.js");
    Function(import.source);
  162. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import.source<string>("./a.js");
    import.source(...["./a.js"]);
    ⟨U+000D⟩
    //// [c.ts]
  163. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    "use strict";⟨U+000D⟩
    import.source;⟨U+000D⟩
    (import.source)("./a.js");⟨U+000D⟩
    Function(import.source);
  164. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import.source("./a.js");⟨U+000D⟩
    import.source(...["./a.js"]);⟨U+000D⟩
    //// [c.js]⟨U+000D⟩
    "use strict";
  165. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    ⟨U+000D⟩
    b.d.ts(2,8): error TS1363: A type-only import can specify a default import or named bindings, but not both.
  166. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    //// [usage.ts]⟨U+000D⟩
    export function getFooFrom<T extends "./a" | "./b">(v: T): import(T).Foo {
        return undefined as any;
    }
  167. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    
    export function getFooValueFrom<T extends "./a" | "./b">(v: T): import(T).Foo["a"] {
        return undefined as any;
    }
  168. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    //// [usage.d.ts]⟨U+000D⟩
    export declare function getFooFrom<T extends "./a" | "./b">(v: T): import(T).Foo;⟨U+000D⟩
    export declare function getFooValueFrom<T extends "./a" | "./b">(v: T): import(T).Foo["a"];
  169. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    export declare function getFooFrom<T extends "./a" | "./b">(v: T): import(T).Foo;⟨U+000D⟩
    export declare function getFooValueFrom<T extends "./a" | "./b">(v: T): import(T).Foo["a"];
  170. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    //// [chainer.ts]⟨U+000D⟩
    export const x: import(import("./a").LookAt).Value = "yes";
  171. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    //// [chainer.d.ts]⟨U+000D⟩
    export declare const x: import(import("./a").LookAt).Value;
  172. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    //// [chainer.ts]⟨U+000D⟩
    export const x: import(import("./a").LookAt).Value = "yes"; // expect outter import to fail, since b.d.ts isn't in the build
  173. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    //// [chainer.d.ts]⟨U+000D⟩
    export declare const x: import(import("./a").LookAt).Value;
  174. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    //// [importTypeNonString.ts]⟨U+000D⟩
    export const x: import({x: 12}) = undefined as any;
  175. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    //// [importTypeNonString.d.ts]⟨U+000D⟩
    export declare const x: import({⟨U+000D⟩
        x: 12;⟨U+000D⟩
    });
  176. identifier `С1` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    ==== index.js (2 errors) ====⟨U+000D⟩
        class С1 {⟨U+000D⟩
            /** @type {string=} */⟨U+000D⟩
            p1 = undefined;
  177. identifier `С2` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

        ⟨U+000D⟩
        class С2 {⟨U+000D⟩
            /** @type {string=} */⟨U+000D⟩
            get p1() {
  178. identifier `С3` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

        ⟨U+000D⟩
        class С3 {⟨U+000D⟩
            /** @type {string=} */⟨U+000D⟩
            get p1() {
  179. identifier `С4` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

        ⟨U+000D⟩
        class С4 {⟨U+000D⟩
            /** @param {string=} value */⟨U+000D⟩
                ~~~~~~~~~~~~~~~~~~~~~~~
  180. identifier `С1` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    //// [index.js]⟨U+000D⟩
    class С1 {
        /** @type {string=} */
        p1 = undefined;
  181. identifier `С2` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    
    class С2 {
        /** @type {string=} */
        get p1() {
  182. identifier `С3` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    
    class С3 {
        /** @type {string=} */
        get p1() {
  183. identifier `С4` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    
    class С4 {
        /** @param {string=} value */
        set p1(value) {
  184. identifier `С1` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    "use strict";⟨U+000D⟩
    class С1 {⟨U+000D⟩
        /** @type {string=} */⟨U+000D⟩
        p1 = undefined;
  185. identifier `С2` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    }⟨U+000D⟩
    class С2 {⟨U+000D⟩
        /** @type {string=} */⟨U+000D⟩
        get p1() {
  186. identifier `С3` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    }⟨U+000D⟩
    class С3 {⟨U+000D⟩
        /** @type {string=} */⟨U+000D⟩
        get p1() {
  187. identifier `С4` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    }⟨U+000D⟩
    class С4 {⟨U+000D⟩
        /** @param {string=} value */⟨U+000D⟩
        set p1(value) {
  188. identifier `С1` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    //// [index.d.ts]⟨U+000D⟩
    declare class С1 {⟨U+000D⟩
        /** @type {string=} */⟨U+000D⟩
        p1: string | undefined;
  189. identifier `С2` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    }⟨U+000D⟩
    declare class С2 {⟨U+000D⟩
        /** @type {string=} */⟨U+000D⟩
        get p1(): string | undefined;
  190. identifier `С3` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    }⟨U+000D⟩
    declare class С3 {⟨U+000D⟩
        /** @type {string=} */⟨U+000D⟩
        get p1(): string | undefined;
  191. identifier `С4` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    }⟨U+000D⟩
    declare class С4 {⟨U+000D⟩
        /** @param {string=} value */⟨U+000D⟩
        set p1(value?: string | undefined);
  192. [markup prose] `eval` called on a string literal (ast pass, confidence 0.85)

        eval("\u00A0var x\u00A0= 1\u00A0");
  193. invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

    //CHECK#2
    ⟨U+00A0⟩var x⟨U+00A0⟩= 1⟨U+00A0⟩;
    if (x !== 1) {
      $ERROR('#2: ⟨U+00A0⟩var x⟨U+00A0⟩= 1⟨U+00A0⟩; x === 1. Actual: ' + (x));
  194. identifier `А` contains homoglyph candidates: А (0410)→A (raw pass, confidence 0.70)

        ⟨U+000D⟩
        //CHECK#А-Я⟨U+000D⟩
        var \u0410 = 1;⟨U+000D⟩
        if (А !== 1) {
  195. identifier `А` contains homoglyph candidates: А (0410)→A (raw pass, confidence 0.70)

        var \u0410 = 1;⟨U+000D⟩
        if (А !== 1) {⟨U+000D⟩
          $ERROR('#А');⟨U+000D⟩
          ~~~~~~
  196. identifier `А` contains homoglyph candidates: А (0410)→A (raw pass, confidence 0.70)

        if (А !== 1) {⟨U+000D⟩
          $ERROR('#А');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  197. identifier `В` contains homoglyph candidates: В (0412)→B (raw pass, confidence 0.70)

        var \u0412 = 1;⟨U+000D⟩
        if (В !== 1) {⟨U+000D⟩
          $ERROR('#В');⟨U+000D⟩
          ~~~~~~
  198. identifier `В` contains homoglyph candidates: В (0412)→B (raw pass, confidence 0.70)

        if (В !== 1) {⟨U+000D⟩
          $ERROR('#В');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  199. identifier `Е` contains homoglyph candidates: Е (0415)→E (raw pass, confidence 0.70)

        var \u0415 = 1;⟨U+000D⟩
        if (Е !== 1) {⟨U+000D⟩
          $ERROR('#Е');⟨U+000D⟩
          ~~~~~~
  200. identifier `Е` contains homoglyph candidates: Е (0415)→E (raw pass, confidence 0.70)

        if (Е !== 1) {⟨U+000D⟩
          $ERROR('#Е');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  201. identifier `К` contains homoglyph candidates: К (041A)→K (raw pass, confidence 0.70)

        var \u041A = 1;⟨U+000D⟩
        if (К !== 1) {⟨U+000D⟩
          $ERROR('#К');⟨U+000D⟩
          ~~~~~~
  202. identifier `К` contains homoglyph candidates: К (041A)→K (raw pass, confidence 0.70)

        if (К !== 1) {⟨U+000D⟩
          $ERROR('#К');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  203. identifier `М` contains homoglyph candidates: М (041C)→M (raw pass, confidence 0.70)

        var \u041C = 1;⟨U+000D⟩
        if (М !== 1) {⟨U+000D⟩
          $ERROR('#М');⟨U+000D⟩
          ~~~~~~
  204. identifier `М` contains homoglyph candidates: М (041C)→M (raw pass, confidence 0.70)

        if (М !== 1) {⟨U+000D⟩
          $ERROR('#М');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  205. identifier `Н` contains homoglyph candidates: Н (041D)→H (raw pass, confidence 0.70)

        var \u041D = 1;⟨U+000D⟩
        if (Н !== 1) {⟨U+000D⟩
          $ERROR('#Н');⟨U+000D⟩
          ~~~~~~
  206. identifier `Н` contains homoglyph candidates: Н (041D)→H (raw pass, confidence 0.70)

        if (Н !== 1) {⟨U+000D⟩
          $ERROR('#Н');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  207. identifier `О` contains homoglyph candidates: О (041E)→O (raw pass, confidence 0.70)

        var \u041E = 1;⟨U+000D⟩
        if (О !== 1) {⟨U+000D⟩
          $ERROR('#О');⟨U+000D⟩
          ~~~~~~
  208. identifier `О` contains homoglyph candidates: О (041E)→O (raw pass, confidence 0.70)

        if (О !== 1) {⟨U+000D⟩
          $ERROR('#О');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  209. identifier `Р` contains homoglyph candidates: Р (0420)→P (raw pass, confidence 0.70)

        var \u0420 = 1;⟨U+000D⟩
        if (Р !== 1) {⟨U+000D⟩
          $ERROR('#Р');⟨U+000D⟩
          ~~~~~~
  210. identifier `Р` contains homoglyph candidates: Р (0420)→P (raw pass, confidence 0.70)

        if (Р !== 1) {⟨U+000D⟩
          $ERROR('#Р');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  211. identifier `С` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

        var \u0421 = 1;⟨U+000D⟩
        if (С !== 1) {⟨U+000D⟩
          $ERROR('#С');⟨U+000D⟩
          ~~~~~~
  212. identifier `С` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

        if (С !== 1) {⟨U+000D⟩
          $ERROR('#С');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  213. identifier `Т` contains homoglyph candidates: Т (0422)→T (raw pass, confidence 0.70)

        var \u0422 = 1;⟨U+000D⟩
        if (Т !== 1) {⟨U+000D⟩
          $ERROR('#Т');⟨U+000D⟩
          ~~~~~~
  214. identifier `Т` contains homoglyph candidates: Т (0422)→T (raw pass, confidence 0.70)

        if (Т !== 1) {⟨U+000D⟩
          $ERROR('#Т');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  215. identifier `Х` contains homoglyph candidates: Х (0425)→X (raw pass, confidence 0.70)

        var \u0425 = 1;⟨U+000D⟩
        if (Х !== 1) {⟨U+000D⟩
          $ERROR('#Х');⟨U+000D⟩
          ~~~~~~
  216. identifier `Х` contains homoglyph candidates: Х (0425)→X (raw pass, confidence 0.70)

        if (Х !== 1) {⟨U+000D⟩
          $ERROR('#Х');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  217. identifier `А` contains homoglyph candidates: А (0410)→A (raw pass, confidence 0.70)

    var \u0410 = 1;
    if (А !== 1) {
      $ERROR('#А');
    }
  218. identifier `В` contains homoglyph candidates: В (0412)→B (raw pass, confidence 0.70)

    var \u0412 = 1;
    if (В !== 1) {
      $ERROR('#В');
    }
  219. identifier `Е` contains homoglyph candidates: Е (0415)→E (raw pass, confidence 0.70)

    var \u0415 = 1;
    if (Е !== 1) {
      $ERROR('#Е');
    }
  220. identifier `К` contains homoglyph candidates: К (041A)→K (raw pass, confidence 0.70)

    var \u041A = 1;
    if (К !== 1) {
      $ERROR('#К');
    }
  221. identifier `М` contains homoglyph candidates: М (041C)→M (raw pass, confidence 0.70)

    var \u041C = 1;
    if (М !== 1) {
      $ERROR('#М');
    }
  222. identifier `Н` contains homoglyph candidates: Н (041D)→H (raw pass, confidence 0.70)

    var \u041D = 1;
    if (Н !== 1) {
      $ERROR('#Н');
    }
  223. identifier `О` contains homoglyph candidates: О (041E)→O (raw pass, confidence 0.70)

    var \u041E = 1;
    if (О !== 1) {
      $ERROR('#О');
    }
  224. identifier `Р` contains homoglyph candidates: Р (0420)→P (raw pass, confidence 0.70)

    var \u0420 = 1;
    if (Р !== 1) {
      $ERROR('#Р');
    }
  225. identifier `С` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    var \u0421 = 1;
    if (С !== 1) {
      $ERROR('#С');
    }
  226. identifier `Т` contains homoglyph candidates: Т (0422)→T (raw pass, confidence 0.70)

    var \u0422 = 1;
    if (Т !== 1) {
      $ERROR('#Т');
    }
  227. identifier `Х` contains homoglyph candidates: Х (0425)→X (raw pass, confidence 0.70)

    var \u0425 = 1;
    if (Х !== 1) {
      $ERROR('#Х');
    }
  228. identifier `А` contains homoglyph candidates: А (0410)→A (raw pass, confidence 0.70)

    var \u0410 = 1;⟨U+000D⟩
    if (А !== 1) {⟨U+000D⟩
        $ERROR('#А');⟨U+000D⟩
    }
  229. identifier `В` contains homoglyph candidates: В (0412)→B (raw pass, confidence 0.70)

    var \u0412 = 1;⟨U+000D⟩
    if (В !== 1) {⟨U+000D⟩
        $ERROR('#В');⟨U+000D⟩
    }
  230. identifier `Е` contains homoglyph candidates: Е (0415)→E (raw pass, confidence 0.70)

    var \u0415 = 1;⟨U+000D⟩
    if (Е !== 1) {⟨U+000D⟩
        $ERROR('#Е');⟨U+000D⟩
    }
  231. identifier `К` contains homoglyph candidates: К (041A)→K (raw pass, confidence 0.70)

    var \u041A = 1;⟨U+000D⟩
    if (К !== 1) {⟨U+000D⟩
        $ERROR('#К');⟨U+000D⟩
    }
  232. identifier `М` contains homoglyph candidates: М (041C)→M (raw pass, confidence 0.70)

    var \u041C = 1;⟨U+000D⟩
    if (М !== 1) {⟨U+000D⟩
        $ERROR('#М');⟨U+000D⟩
    }
  233. identifier `Н` contains homoglyph candidates: Н (041D)→H (raw pass, confidence 0.70)

    var \u041D = 1;⟨U+000D⟩
    if (Н !== 1) {⟨U+000D⟩
        $ERROR('#Н');⟨U+000D⟩
    }
  234. identifier `О` contains homoglyph candidates: О (041E)→O (raw pass, confidence 0.70)

    var \u041E = 1;⟨U+000D⟩
    if (О !== 1) {⟨U+000D⟩
        $ERROR('#О');⟨U+000D⟩
    }
  235. identifier `Р` contains homoglyph candidates: Р (0420)→P (raw pass, confidence 0.70)

    var \u0420 = 1;⟨U+000D⟩
    if (Р !== 1) {⟨U+000D⟩
        $ERROR('#Р');⟨U+000D⟩
    }
  236. identifier `С` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    var \u0421 = 1;⟨U+000D⟩
    if (С !== 1) {⟨U+000D⟩
        $ERROR('#С');⟨U+000D⟩
    }
  237. identifier `Т` contains homoglyph candidates: Т (0422)→T (raw pass, confidence 0.70)

    var \u0422 = 1;⟨U+000D⟩
    if (Т !== 1) {⟨U+000D⟩
        $ERROR('#Т');⟨U+000D⟩
    }
  238. identifier `Х` contains homoglyph candidates: Х (0425)→X (raw pass, confidence 0.70)

    var \u0425 = 1;⟨U+000D⟩
    if (Х !== 1) {⟨U+000D⟩
        $ERROR('#Х');⟨U+000D⟩
    }
  239. [markup prose] `eval` called on a string literal (ast pass, confidence 0.85)

        eval = 1;
  240. [markup prose] `eval` called on a string literal (ast pass, confidence 0.85)

        eval = 1;
  241. [markup prose] `eval` called on a string literal (ast pass, confidence 0.85)

        eval += 1;
  242. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    //// [parserUnicode2.ts]⟨U+000D⟩
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;⟨U+000D⟩
    ⟨U+000D⟩
    //// [parserUnicode2.js]
  243. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    //// [parserUnicode2.ts]⟨U+000D⟩
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;⟨U+000D⟩
    ⟨U+000D⟩
    //// [parserUnicode2.js]
  244. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    //// [parserUnicode2.ts]⟨U+000D⟩
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;⟨U+000D⟩
    ⟨U+000D⟩
    //// [parserUnicode2.js]
  245. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    "use strict";⟨U+000D⟩
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;
  246. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    "use strict";⟨U+000D⟩
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;
  247. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    "use strict";⟨U+000D⟩
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;
  248. U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (raw pass, confidence 0.75)

    ==== parserharness.ts (193 errors) ====⟨U+000D⟩
        //⟨U+FEFF⟩⟨U+000D⟩
        // Copyright (c) Microsoft Corporation.  All rights reserved.⟨U+000D⟩
        // 
  249. [markup prose] `eval` called on a string literal (ast pass, confidence 0.85)

            eval(typescriptServiceFile);
  250. U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (raw pass, confidence 0.75)

    ==== parserindenter.ts (136 errors) ====⟨U+000D⟩
        //⟨U+FEFF⟩⟨U+000D⟩
        // Copyright (c) Microsoft Corporation.  All rights reserved.⟨U+000D⟩
        // 
  251. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const trinaryDynamicImport = import('1', '2', '3');⟨U+000D⟩
    const spreadDynamicImport = import(...[]);⟨U+000D⟩
    return;
  252. [markup prose] `eval` called on a string literal (ast pass, confidence 0.85)

        eval("\u00A0var x\u00A0= 1\u00A0");
  253. invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

    //CHECK#2
    ⟨U+00A0⟩var x⟨U+00A0⟩= 1⟨U+00A0⟩;
    if (x !== 1) {
      $ERROR('#2: ⟨U+00A0⟩var x⟨U+00A0⟩= 1⟨U+00A0⟩; x === 1. Actual: ' + (x));
  254. identifier `А` contains homoglyph candidates: А (0410)→A (raw pass, confidence 0.70)

        ⟨U+000D⟩
        //CHECK#А-Я⟨U+000D⟩
        var \u0410 = 1;⟨U+000D⟩
        if (А !== 1) {
  255. identifier `А` contains homoglyph candidates: А (0410)→A (raw pass, confidence 0.70)

        var \u0410 = 1;⟨U+000D⟩
        if (А !== 1) {⟨U+000D⟩
          $ERROR('#А');⟨U+000D⟩
          ~~~~~~
  256. identifier `А` contains homoglyph candidates: А (0410)→A (raw pass, confidence 0.70)

        if (А !== 1) {⟨U+000D⟩
          $ERROR('#А');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  257. identifier `В` contains homoglyph candidates: В (0412)→B (raw pass, confidence 0.70)

        var \u0412 = 1;⟨U+000D⟩
        if (В !== 1) {⟨U+000D⟩
          $ERROR('#В');⟨U+000D⟩
          ~~~~~~
  258. identifier `В` contains homoglyph candidates: В (0412)→B (raw pass, confidence 0.70)

        if (В !== 1) {⟨U+000D⟩
          $ERROR('#В');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  259. identifier `Е` contains homoglyph candidates: Е (0415)→E (raw pass, confidence 0.70)

        var \u0415 = 1;⟨U+000D⟩
        if (Е !== 1) {⟨U+000D⟩
          $ERROR('#Е');⟨U+000D⟩
          ~~~~~~
  260. identifier `Е` contains homoglyph candidates: Е (0415)→E (raw pass, confidence 0.70)

        if (Е !== 1) {⟨U+000D⟩
          $ERROR('#Е');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  261. identifier `К` contains homoglyph candidates: К (041A)→K (raw pass, confidence 0.70)

        var \u041A = 1;⟨U+000D⟩
        if (К !== 1) {⟨U+000D⟩
          $ERROR('#К');⟨U+000D⟩
          ~~~~~~
  262. identifier `К` contains homoglyph candidates: К (041A)→K (raw pass, confidence 0.70)

        if (К !== 1) {⟨U+000D⟩
          $ERROR('#К');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  263. identifier `М` contains homoglyph candidates: М (041C)→M (raw pass, confidence 0.70)

        var \u041C = 1;⟨U+000D⟩
        if (М !== 1) {⟨U+000D⟩
          $ERROR('#М');⟨U+000D⟩
          ~~~~~~
  264. identifier `М` contains homoglyph candidates: М (041C)→M (raw pass, confidence 0.70)

        if (М !== 1) {⟨U+000D⟩
          $ERROR('#М');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  265. identifier `Н` contains homoglyph candidates: Н (041D)→H (raw pass, confidence 0.70)

        var \u041D = 1;⟨U+000D⟩
        if (Н !== 1) {⟨U+000D⟩
          $ERROR('#Н');⟨U+000D⟩
          ~~~~~~
  266. identifier `Н` contains homoglyph candidates: Н (041D)→H (raw pass, confidence 0.70)

        if (Н !== 1) {⟨U+000D⟩
          $ERROR('#Н');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  267. identifier `О` contains homoglyph candidates: О (041E)→O (raw pass, confidence 0.70)

        var \u041E = 1;⟨U+000D⟩
        if (О !== 1) {⟨U+000D⟩
          $ERROR('#О');⟨U+000D⟩
          ~~~~~~
  268. identifier `О` contains homoglyph candidates: О (041E)→O (raw pass, confidence 0.70)

        if (О !== 1) {⟨U+000D⟩
          $ERROR('#О');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  269. identifier `Р` contains homoglyph candidates: Р (0420)→P (raw pass, confidence 0.70)

        var \u0420 = 1;⟨U+000D⟩
        if (Р !== 1) {⟨U+000D⟩
          $ERROR('#Р');⟨U+000D⟩
          ~~~~~~
  270. identifier `Р` contains homoglyph candidates: Р (0420)→P (raw pass, confidence 0.70)

        if (Р !== 1) {⟨U+000D⟩
          $ERROR('#Р');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  271. identifier `С` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

        var \u0421 = 1;⟨U+000D⟩
        if (С !== 1) {⟨U+000D⟩
          $ERROR('#С');⟨U+000D⟩
          ~~~~~~
  272. identifier `С` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

        if (С !== 1) {⟨U+000D⟩
          $ERROR('#С');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  273. identifier `Т` contains homoglyph candidates: Т (0422)→T (raw pass, confidence 0.70)

        var \u0422 = 1;⟨U+000D⟩
        if (Т !== 1) {⟨U+000D⟩
          $ERROR('#Т');⟨U+000D⟩
          ~~~~~~
  274. identifier `Т` contains homoglyph candidates: Т (0422)→T (raw pass, confidence 0.70)

        if (Т !== 1) {⟨U+000D⟩
          $ERROR('#Т');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  275. identifier `Х` contains homoglyph candidates: Х (0425)→X (raw pass, confidence 0.70)

        var \u0425 = 1;⟨U+000D⟩
        if (Х !== 1) {⟨U+000D⟩
          $ERROR('#Х');⟨U+000D⟩
          ~~~~~~
  276. identifier `Х` contains homoglyph candidates: Х (0425)→X (raw pass, confidence 0.70)

        if (Х !== 1) {⟨U+000D⟩
          $ERROR('#Х');⟨U+000D⟩
          ~~~~~~⟨U+000D⟩
    !!! error TS2552: Cannot find name '$ERROR'. Did you mean 'Error'?
  277. identifier `А` contains homoglyph candidates: А (0410)→A (raw pass, confidence 0.70)

    var \u0410 = 1;
    if (А !== 1) {
      $ERROR('#А');
    }
  278. identifier `В` contains homoglyph candidates: В (0412)→B (raw pass, confidence 0.70)

    var \u0412 = 1;
    if (В !== 1) {
      $ERROR('#В');
    }
  279. identifier `Е` contains homoglyph candidates: Е (0415)→E (raw pass, confidence 0.70)

    var \u0415 = 1;
    if (Е !== 1) {
      $ERROR('#Е');
    }
  280. identifier `К` contains homoglyph candidates: К (041A)→K (raw pass, confidence 0.70)

    var \u041A = 1;
    if (К !== 1) {
      $ERROR('#К');
    }
  281. identifier `М` contains homoglyph candidates: М (041C)→M (raw pass, confidence 0.70)

    var \u041C = 1;
    if (М !== 1) {
      $ERROR('#М');
    }
  282. identifier `Н` contains homoglyph candidates: Н (041D)→H (raw pass, confidence 0.70)

    var \u041D = 1;
    if (Н !== 1) {
      $ERROR('#Н');
    }
  283. identifier `О` contains homoglyph candidates: О (041E)→O (raw pass, confidence 0.70)

    var \u041E = 1;
    if (О !== 1) {
      $ERROR('#О');
    }
  284. identifier `Р` contains homoglyph candidates: Р (0420)→P (raw pass, confidence 0.70)

    var \u0420 = 1;
    if (Р !== 1) {
      $ERROR('#Р');
    }
  285. identifier `С` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    var \u0421 = 1;
    if (С !== 1) {
      $ERROR('#С');
    }
  286. identifier `Т` contains homoglyph candidates: Т (0422)→T (raw pass, confidence 0.70)

    var \u0422 = 1;
    if (Т !== 1) {
      $ERROR('#Т');
    }
  287. identifier `Х` contains homoglyph candidates: Х (0425)→X (raw pass, confidence 0.70)

    var \u0425 = 1;
    if (Х !== 1) {
      $ERROR('#Х');
    }
  288. identifier `А` contains homoglyph candidates: А (0410)→A (raw pass, confidence 0.70)

    var \u0410 = 1;⟨U+000D⟩
    if (А !== 1) {⟨U+000D⟩
        $ERROR('#А');⟨U+000D⟩
    }
  289. identifier `В` contains homoglyph candidates: В (0412)→B (raw pass, confidence 0.70)

    var \u0412 = 1;⟨U+000D⟩
    if (В !== 1) {⟨U+000D⟩
        $ERROR('#В');⟨U+000D⟩
    }
  290. identifier `Е` contains homoglyph candidates: Е (0415)→E (raw pass, confidence 0.70)

    var \u0415 = 1;⟨U+000D⟩
    if (Е !== 1) {⟨U+000D⟩
        $ERROR('#Е');⟨U+000D⟩
    }
  291. identifier `К` contains homoglyph candidates: К (041A)→K (raw pass, confidence 0.70)

    var \u041A = 1;⟨U+000D⟩
    if (К !== 1) {⟨U+000D⟩
        $ERROR('#К');⟨U+000D⟩
    }
  292. identifier `М` contains homoglyph candidates: М (041C)→M (raw pass, confidence 0.70)

    var \u041C = 1;⟨U+000D⟩
    if (М !== 1) {⟨U+000D⟩
        $ERROR('#М');⟨U+000D⟩
    }
  293. identifier `Н` contains homoglyph candidates: Н (041D)→H (raw pass, confidence 0.70)

    var \u041D = 1;⟨U+000D⟩
    if (Н !== 1) {⟨U+000D⟩
        $ERROR('#Н');⟨U+000D⟩
    }
  294. identifier `О` contains homoglyph candidates: О (041E)→O (raw pass, confidence 0.70)

    var \u041E = 1;⟨U+000D⟩
    if (О !== 1) {⟨U+000D⟩
        $ERROR('#О');⟨U+000D⟩
    }
  295. identifier `Р` contains homoglyph candidates: Р (0420)→P (raw pass, confidence 0.70)

    var \u0420 = 1;⟨U+000D⟩
    if (Р !== 1) {⟨U+000D⟩
        $ERROR('#Р');⟨U+000D⟩
    }
  296. identifier `С` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    var \u0421 = 1;⟨U+000D⟩
    if (С !== 1) {⟨U+000D⟩
        $ERROR('#С');⟨U+000D⟩
    }
  297. identifier `Т` contains homoglyph candidates: Т (0422)→T (raw pass, confidence 0.70)

    var \u0422 = 1;⟨U+000D⟩
    if (Т !== 1) {⟨U+000D⟩
        $ERROR('#Т');⟨U+000D⟩
    }
  298. identifier `Х` contains homoglyph candidates: Х (0425)→X (raw pass, confidence 0.70)

    var \u0425 = 1;⟨U+000D⟩
    if (Х !== 1) {⟨U+000D⟩
        $ERROR('#Х');⟨U+000D⟩
    }
  299. line length 4658 characters (raw pass, confidence 0.65)

    const unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 16
  300. line length 5355 characters (raw pass, confidence 0.65)

    const unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 147
  301. line length 8908 characters (raw pass, confidence 0.65)

    const unicodeESNextIdentifierStart = [65, 90, 97, 122, 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 895, 895, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1488, 1514, 15
  302. line length 10367 characters (raw pass, confidence 0.65)

    const unicodeESNextIdentifierPart = [48, 57, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 183, 183, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 895, 895, 902, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1327, 1329, 1366, 1369, 1369,
  303. `require` called with a non-literal specifier (ast pass, confidence 0.60)

                        const modulePath = resolveJSModule(moduleName, baseDir, nodeSystem);⟨U+000D⟩
                        return { module: require(modulePath), modulePath, error: undefined };⟨U+000D⟩
                    }⟨U+000D⟩
                    catch (error) {
  304. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

    compiler/declFileModuleContinuation.types.diff
    compiler/declFileWithInternalModuleNameConflictsInExtendsClause1.types.diff
    compiler/declFileWithInternalModuleNameConflictsInExtendsClause2.types.diff
    compiler/declFileWithInternalModuleNameConflictsInExtendsClause3.types.diff
  305. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

    compiler/declFileWithInternalModuleNameConflictsInExtendsClause1.types.diff
    compiler/declFileWithInternalModuleNameConflictsInExtendsClause2.types.diff
    compiler/declFileWithInternalModuleNameConflictsInExtendsClause3.types.diff
    compiler/declarationEmitNameConflicts.types.diff
  306. base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)

    compiler/declFileWithInternalModuleNameConflictsInExtendsClause2.types.diff
    compiler/declFileWithInternalModuleNameConflictsInExtendsClause3.types.diff
    compiler/declarationEmitNameConflicts.types.diff
    compiler/genericConstraintOnExtendedBuiltinTypes.types.diff
  307. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function* foo() {⟨U+000D⟩
        import((await import(yield "foo")).default);⟨U+000D⟩
    }
  308. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function* foo() {⟨U+000D⟩
        import((await import(yield "foo")).default);⟨U+000D⟩
    }
  309. line length 9389 characters (raw pass, confidence 0.65)

    0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 
  310. line length 9389 characters (raw pass, confidence 0.65)

    0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 
  311. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const path = "./Card.astro";
    void import(path);
    
    export async function load() { return import("./Card.astro"); }
  312. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    // @Filename: /main.ts
    export function dynamic(path: string) { return import(path); }
    export function literal() { return import("./Card.astro"); }
  313. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    /** @param {string} path */
    export function dynamicRequire(path) { return require(path); }
    
    // @Filename: /globals.d.ts
  314. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    // @Filename: /main.ts
    export function dynamic(path: string) { return import(path); }
    export function literal() { return import("./Card.astro"); }
  315. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    /** @param {string} path */
    export function dynamicRequire(path) { return require(path); }
    
    // @Filename: /globals.d.ts
  316. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    export function literal() { return import("./Widget.y.z"); }
    export function dynamic(path: string) { return import(path); }
    export const inferred = import("./Widget.y.z");
  317. generator `f` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

    const f: FuncOrGeneratorFunc = function*() {⟨U+000D⟩
      yield (num) => console.log(num); // `num` should be inferred to have type `number`.⟨U+000D⟩
    }
  318. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    
    import(String(i++));
    import(String(i++));
  319. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import(String(i++));
    import(String(i++));
    
    const getPath = async () => {
  320. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const someFunction = async () => {
    	const result = await import(await getPath());
    };
  321. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const path = './foo';
    import(path,);
  322. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    	dynamic() {⟨U+000D⟩
    		return import(this._path);⟨U+000D⟩
    	}⟨U+000D⟩
    }
  323. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    	dynamic() {⟨U+000D⟩
    		return import(this._path);⟨U+000D⟩
    	}⟨U+000D⟩
    }
  324. `require` called with a non-literal specifier (ast pass, confidence 0.80)

    function foo(name) {⟨U+000D⟩
        var s = require("t/" + name)⟨U+000D⟩
    }
  325. invisible whitespace U+3000 in indentation (raw pass, confidence 0.80)

      }⟨U+000D⟩
    ⟨U+3000⟩⟨U+000D⟩
      export class PullSymbol {⟨U+000D⟩
        constructor (name: string, declKind: DeclKind) {
  326. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    /** @type {import("should-not-be-resolved").Type} */
    var v = import(String());
  327. line length 7997 characters (raw pass, confidence 0.65)

                                }(T, A, 64), E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = (E = E + ((((w = (w = (w = w + (606105819 + (
  328. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    
    import(getSpecifier());
    
    // @filename: specifier.cts
  329. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const specify = bar() ? "./0" : undefined;⟨U+000D⟩
    let myModule = import(specify);⟨U+000D⟩
    let myModule1 = import(undefined);⟨U+000D⟩
    let myModule2 = import(bar() ? "./1" : null);
  330. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    let myModule1 = import(undefined);⟨U+000D⟩
    let myModule2 = import(bar() ? "./1" : null);⟨U+000D⟩
    let myModule3 = import(null);
  331. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const specify = bar() ? "./0" : undefined;⟨U+000D⟩
    let myModule = import(specify);⟨U+000D⟩
    let myModule1 = import(undefined);⟨U+000D⟩
    let myModule2 = import(bar() ? "./1" : null);
  332. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    let myModule1 = import(undefined);⟨U+000D⟩
    let myModule2 = import(bar() ? "./1" : null);⟨U+000D⟩
    let myModule3 = import(null);
  333. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    ⟨U+000D⟩
    import(getSpecifier());⟨U+000D⟩
    ⟨U+000D⟩
    var p0 = import(`${directory}\\${moduleFile}`);
  334. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    ⟨U+000D⟩
    var p0 = import(`${directory}\\${moduleFile}`);⟨U+000D⟩
    var p1 = import(getSpecifier());⟨U+000D⟩
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
  335. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var p0 = import(`${directory}\\${moduleFile}`);⟨U+000D⟩
    var p1 = import(getSpecifier());⟨U+000D⟩
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
  336. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var p1 = import(getSpecifier());⟨U+000D⟩
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")⟨U+000D⟩
    ⟨U+000D⟩
    function returnDynamicLoad(path: string) {
  337. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    function returnDynamicLoad(path: string) {⟨U+000D⟩
        return import(path);⟨U+000D⟩
    }
  338. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    ⟨U+000D⟩
    export var p0: Promise<typeof Zero> = import(getPath());⟨U+000D⟩
    export var p1: Promise<typeof Zero> = import("./0");⟨U+000D⟩
    export var p2: Promise<any> = import("./0");
  339. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var a = ["./0"];⟨U+000D⟩
    import(...["PathModule"]);⟨U+000D⟩
    ⟨U+000D⟩
    var p1 = import(...a);
  340. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    ⟨U+000D⟩
    var p1 = import(...a);⟨U+000D⟩
    const p2 = import();⟨U+000D⟩
    const p4 = import("pathToModule", "secondModule");
  341. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

        const packageName = '.';⟨U+000D⟩
        const packageJson = await import(packageName + '/package.json');⟨U+000D⟩
    }
  342. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {⟨U+000D⟩
        return await import((await import("./foo")).default);⟨U+000D⟩
    }
  343. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {⟨U+000D⟩
        return await import((await import("./foo")).default);⟨U+000D⟩
    }
  344. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {⟨U+000D⟩
        return await import((await import("./foo")).default);⟨U+000D⟩
    }
  345. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {⟨U+000D⟩
        return await import((await import("./foo")).default);⟨U+000D⟩
    }
  346. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {⟨U+000D⟩
        return await import((await import("./foo")).default);⟨U+000D⟩
    }
  347. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {⟨U+000D⟩
        return await import((await import("./foo")).default);⟨U+000D⟩
    }
  348. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {⟨U+000D⟩
        return await import((await import("./foo")).default);⟨U+000D⟩
    }
  349. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {⟨U+000D⟩
        return await import((await import("./foo")).default);⟨U+000D⟩
    }
  350. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {⟨U+000D⟩
        return await import((await import("./foo")).default);⟨U+000D⟩
    }
  351. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function foo() {⟨U+000D⟩
        return await import((await import("./foo")).default);⟨U+000D⟩
    }
  352. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    ⟨U+000D⟩
    import(`${directory}\\${moduleFile}`);⟨U+000D⟩
    import(getSpecifier());
  353. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import(`${directory}\\${moduleFile}`);⟨U+000D⟩
    import(getSpecifier());⟨U+000D⟩
    ⟨U+000D⟩
    var p1 = import(ValidSomeCondition() ? "./0" : "externalModule");
  354. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    ⟨U+000D⟩
    var p1 = import(ValidSomeCondition() ? "./0" : "externalModule");⟨U+000D⟩
    var p1: Promise<any> = import(getSpecifier());⟨U+000D⟩
    var p11: Promise<typeof defaultModule> = import(getSpecifier());
  355. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var p1 = import(ValidSomeCondition() ? "./0" : "externalModule");⟨U+000D⟩
    var p1: Promise<any> = import(getSpecifier());⟨U+000D⟩
    var p11: Promise<typeof defaultModule> = import(getSpecifier());⟨U+000D⟩
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise<typeof defaultModule>;
  356. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var p1: Promise<any> = import(getSpecifier());⟨U+000D⟩
    var p11: Promise<typeof defaultModule> = import(getSpecifier());⟨U+000D⟩
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise<typeof defaultModule>;⟨U+000D⟩
    p1.then(zero => {
  357. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var p11: Promise<typeof defaultModule> = import(getSpecifier());⟨U+000D⟩
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise<typeof defaultModule>;⟨U+000D⟩
    p1.then(zero => {⟨U+000D⟩
        return zero.foo();  // ok, zero is any
  358. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    let j: string;⟨U+000D⟩
    var p3: Promise<typeof defaultModule> = import(j=getSpecifier());⟨U+000D⟩
    ⟨U+000D⟩
    function * loadModule(directories: string[]) {
  359. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

            const path = `${directory}\\moduleFile`;⟨U+000D⟩
            import(yield path);⟨U+000D⟩
        }⟨U+000D⟩
    }
  360. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    const localeName = "zh-CN";⟨U+000D⟩
    import(`./locales/${localeName}.js`).then(bar => {⟨U+000D⟩
        let x = bar;⟨U+000D⟩
    });
  361. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    ⟨U+000D⟩
    import("./locales/" + localeName + ".js").then(bar => {⟨U+000D⟩
        let x = bar;⟨U+000D⟩
    });
  362. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    // Error specifier is not assignable to string⟨U+000D⟩
    import(getSpecifier());⟨U+000D⟩
    var p1 = import(getSpecifier());⟨U+000D⟩
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")
  363. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import(getSpecifier());⟨U+000D⟩
    var p1 = import(getSpecifier());⟨U+000D⟩
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")⟨U+000D⟩
    p1.then(zero => {
  364. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var p1 = import(getSpecifier());⟨U+000D⟩
    const p2 = import(whatToLoad ? getSpecifier() : "defaulPath")⟨U+000D⟩
    p1.then(zero => {⟨U+000D⟩
        return zero.foo();  // ok, zero is any
  365. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    ⟨U+000D⟩
    var p3 = import(["path1", "path2"]);⟨U+000D⟩
    var p4 = import(()=>"PathToModule");
  366. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    var p3 = import(["path1", "path2"]);⟨U+000D⟩
    var p4 = import(()=>"PathToModule");
  367. line length 4035 characters (raw pass, confidence 0.65)

    var bin4 = 0B1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  368. line length 4034 characters (raw pass, confidence 0.65)

        0B11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  369. line length 4035 characters (raw pass, confidence 0.65)

    var bin4 = 0B1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  370. line length 4034 characters (raw pass, confidence 0.65)

        0B11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  371. generator `g` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

    function* g(): IterableIterator<(x: string) => number, (x: string) => number> {⟨U+000D⟩
        yield x => x.length;⟨U+000D⟩
        yield *[x => x.length];⟨U+000D⟩
        return x => x.length;
  372. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

        yield * function* () {⟨U+000D⟩
            yield x => x.length;⟨U+000D⟩
        } ();⟨U+000D⟩
    }
  373. generator `g` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

            *[Symbol.iterator]() {⟨U+000D⟩
                yield x => x.length;⟨U+000D⟩
            }⟨U+000D⟩
        };
  374. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

        yield function* () {⟨U+000D⟩
            yield x => x.length;⟨U+000D⟩
        } ()⟨U+000D⟩
    }
  375. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

        yield function* () {⟨U+000D⟩
            yield x => x.length;⟨U+000D⟩
        } ()⟨U+000D⟩
    }
  376. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

        yield function* () {⟨U+000D⟩
            yield x => x.length;⟨U+000D⟩
        } ()⟨U+000D⟩
    }
  377. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

    ⟨U+000D⟩
    foo("", function* () { yield x => x.length }, p => undefined); // T is fixed, should be string
  378. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

            *[Symbol.iterator]() {⟨U+000D⟩
                yield x => x.length⟨U+000D⟩
            }⟨U+000D⟩
        }
  379. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

        yield function* () {
            yield x => x.length;
        } ()
    }
  380. generator `<anonymous>` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

      yield (function* () {
        yield (x) => x.length;
      })();
    }
  381. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    import("./foo.ts", { with: { attr: "value" } });
    import("" + "./foo.ts");
    // @Filename: js.js
    // Rewrite
  382. `require` called with a non-literal specifier (ast pass, confidence 0.60)

      require("./foo.ts");
      require(getPath());
    }
  383. `require` called with a non-literal specifier (ast pass, confidence 0.80)

    {
      require("" + "./foo.ts");
      import("" + "./foo.ts");
      require("./foo.ts");
  384. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

      require("" + "./foo.ts");
      import("" + "./foo.ts");
      require("./foo.ts");
      import("./foo.ts");
  385. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    {
      import("" + "./foo.ts");
      import("./foo.ts");
    }
  386. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    // @filename: b.ts
    import.defer;
    
    (import.defer)("a");
  387. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    // @filename: f.js
    import.source;
    (import.source)("./a.js");
    Function(import.source);
  388. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import.source<string>("./a.js");
    import.source(...["./a.js"]);
    
    // @filename: g.js
  389. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    a.value;
    import(a);
    import.source(a);
    import.source(1);
  390. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import(a);
    import.source(a);
    import.source(1);
    import.source(undefined);
  391. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    // @filename: b.ts
    import.source;
    (import.source)("./a.js");
    Function(import.source);
  392. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import.source<string>("./a.js");
    import.source(...["./a.js"]);
    
    // @filename: c.ts
  393. identifier `С1` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    ⟨U+000D⟩
    class С1 {⟨U+000D⟩
        /** @type {string=} */⟨U+000D⟩
        p1 = undefined;
  394. identifier `С2` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    ⟨U+000D⟩
    class С2 {⟨U+000D⟩
        /** @type {string=} */⟨U+000D⟩
        get p1() {
  395. identifier `С3` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    ⟨U+000D⟩
    class С3 {⟨U+000D⟩
        /** @type {string=} */⟨U+000D⟩
        get p1() {
  396. identifier `С4` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    ⟨U+000D⟩
    class С4 {⟨U+000D⟩
        /** @param {string=} value */⟨U+000D⟩
        set p1(value) {
  397. invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

    //CHECK#2
    ⟨U+00A0⟩var x⟨U+00A0⟩= 1⟨U+00A0⟩;
    if (x !== 1) {
      $ERROR('#2: ⟨U+00A0⟩var x⟨U+00A0⟩= 1⟨U+00A0⟩; x === 1. Actual: ' + (x));
  398. identifier `А` contains homoglyph candidates: А (0410)→A (raw pass, confidence 0.70)

    var \u0410 = 1;
    if (А !== 1) {
      $ERROR('#А');
    }
  399. identifier `В` contains homoglyph candidates: В (0412)→B (raw pass, confidence 0.70)

    var \u0412 = 1;
    if (В !== 1) {
      $ERROR('#В');
    }
  400. identifier `Е` contains homoglyph candidates: Е (0415)→E (raw pass, confidence 0.70)

    var \u0415 = 1;
    if (Е !== 1) {
      $ERROR('#Е');
    }
  401. identifier `К` contains homoglyph candidates: К (041A)→K (raw pass, confidence 0.70)

    var \u041A = 1;
    if (К !== 1) {
      $ERROR('#К');
    }
  402. identifier `М` contains homoglyph candidates: М (041C)→M (raw pass, confidence 0.70)

    var \u041C = 1;
    if (М !== 1) {
      $ERROR('#М');
    }
  403. identifier `Н` contains homoglyph candidates: Н (041D)→H (raw pass, confidence 0.70)

    var \u041D = 1;
    if (Н !== 1) {
      $ERROR('#Н');
    }
  404. identifier `О` contains homoglyph candidates: О (041E)→O (raw pass, confidence 0.70)

    var \u041E = 1;
    if (О !== 1) {
      $ERROR('#О');
    }
  405. identifier `Р` contains homoglyph candidates: Р (0420)→P (raw pass, confidence 0.70)

    var \u0420 = 1;
    if (Р !== 1) {
      $ERROR('#Р');
    }
  406. identifier `С` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    var \u0421 = 1;
    if (С !== 1) {
      $ERROR('#С');
    }
  407. identifier `Т` contains homoglyph candidates: Т (0422)→T (raw pass, confidence 0.70)

    var \u0422 = 1;
    if (Т !== 1) {
      $ERROR('#Т');
    }
  408. identifier `Х` contains homoglyph candidates: Х (0425)→X (raw pass, confidence 0.70)

    var \u0425 = 1;
    if (Х !== 1) {
      $ERROR('#Х');
    }
  409. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    ⟨U+FEFF⟩// @target: es2015
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;
  410. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    ⟨U+FEFF⟩// @target: es2015
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;
  411. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    ⟨U+FEFF⟩// @target: es2015
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 1;
  412. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const trinaryDynamicImport = import('1', '2', '3')
    const spreadDynamicImport = import(...[])
    
    return
  413. invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)

    //CHECK#2
    ⟨U+00A0⟩var x⟨U+00A0⟩= 1⟨U+00A0⟩;
    if (x !== 1) {
      $ERROR('#2: ⟨U+00A0⟩var x⟨U+00A0⟩= 1⟨U+00A0⟩; x === 1. Actual: ' + (x));
  414. identifier `А` contains homoglyph candidates: А (0410)→A (raw pass, confidence 0.70)

    var \u0410 = 1;
    if (А !== 1) {
      $ERROR('#А');
    }
  415. identifier `В` contains homoglyph candidates: В (0412)→B (raw pass, confidence 0.70)

    var \u0412 = 1;
    if (В !== 1) {
      $ERROR('#В');
    }
  416. identifier `Е` contains homoglyph candidates: Е (0415)→E (raw pass, confidence 0.70)

    var \u0415 = 1;
    if (Е !== 1) {
      $ERROR('#Е');
    }
  417. identifier `К` contains homoglyph candidates: К (041A)→K (raw pass, confidence 0.70)

    var \u041A = 1;
    if (К !== 1) {
      $ERROR('#К');
    }
  418. identifier `М` contains homoglyph candidates: М (041C)→M (raw pass, confidence 0.70)

    var \u041C = 1;
    if (М !== 1) {
      $ERROR('#М');
    }
  419. identifier `Н` contains homoglyph candidates: Н (041D)→H (raw pass, confidence 0.70)

    var \u041D = 1;
    if (Н !== 1) {
      $ERROR('#Н');
    }
  420. identifier `О` contains homoglyph candidates: О (041E)→O (raw pass, confidence 0.70)

    var \u041E = 1;
    if (О !== 1) {
      $ERROR('#О');
    }
  421. identifier `Р` contains homoglyph candidates: Р (0420)→P (raw pass, confidence 0.70)

    var \u0420 = 1;
    if (Р !== 1) {
      $ERROR('#Р');
    }
  422. identifier `С` contains homoglyph candidates: С (0421)→C (raw pass, confidence 0.70)

    var \u0421 = 1;
    if (С !== 1) {
      $ERROR('#С');
    }
  423. identifier `Т` contains homoglyph candidates: Т (0422)→T (raw pass, confidence 0.70)

    var \u0422 = 1;
    if (Т !== 1) {
      $ERROR('#Т');
    }
  424. identifier `Х` contains homoglyph candidates: Х (0425)→X (raw pass, confidence 0.70)

    var \u0425 = 1;
    if (Х !== 1) {
      $ERROR('#Х');
    }
  425. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    // @filename: usage.ts⟨U+000D⟩
    export function getFooFrom<T extends "./a" | "./b">(v: T): import(T).Foo {⟨U+000D⟩
        return undefined as any;⟨U+000D⟩
    }
  426. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    ⟨U+000D⟩
    export function getFooValueFrom<T extends "./a" | "./b">(v: T): import(T).Foo["a"] {⟨U+000D⟩
        return undefined as any;⟨U+000D⟩
    }
  427. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    // @filename: chainer.ts⟨U+000D⟩
    export const x: import(import("./a").LookAt).Value = "yes";
  428. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    // @filename: chainer.ts⟨U+000D⟩
    export const x: import(import("./a").LookAt).Value = "yes"; // expect outter import to fail, since b.d.ts isn't in the build
  429. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    // @target: es6⟨U+000D⟩
    export const x: import({x: 12}) = undefined as any;
  430. info warn → info by review long-line NOTICE.txt:119:1

    line length 13885 characters (raw pass, confidence 0.65)

    Creative Commons Attribution 4.0 International Public License By exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution 4.0 International Public License ("Public License"). To the extent this Public License may be interpreted as 
    dismissed LLM, confidence 0.97 Long line of Creative Commons license text in NOTICE.txt.
    Reasoning

    A long line in a Creative Commons license text file is ordinary prose wrapping in a legal notice, with no code or encoding involved.

  431. line length 805 characters (raw pass, confidence 0.50)

    export const popcount8: number[] = [0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5,
  432. line length 588 characters (raw pass, confidence 0.50)

    export type CompoundAssignmentOperator = SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEquals
  433. line length 602 characters (raw pass, confidence 0.50)

        return kind === SyntaxKind.AbstractKeyword || kind === SyntaxKind.AccessorKeyword || kind === SyntaxKind.AsyncKeyword || kind === SyntaxKind.ConstKeyword || kind === SyntaxKind.DeclareKeyword || kind === SyntaxKind.DefaultKeyword || kind === SyntaxKind.ExportKeyword || kind === SyntaxKind.InKeyword || kind === Synt
  434. line length 508 characters (raw pass, confidence 0.50)

        return kind === SyntaxKind.CallSignature || kind === SyntaxKind.ConstructSignature || kind === SyntaxKind.MethodSignature || kind === SyntaxKind.IndexSignature || kind === SyntaxKind.FunctionType || kind === SyntaxKind.ConstructorType || kind === SyntaxKind.FunctionDeclaration || kind === SyntaxKind.MethodDeclarati
  435. line length 574 characters (raw pass, confidence 0.50)

    export type JSDocTokenKind = SyntaxKind.EndOfFile | SyntaxKind.WhitespaceTrivia | SyntaxKind.AtToken | SyntaxKind.NewLineTrivia | SyntaxKind.AsteriskToken | SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.LessThanToken | SyntaxKind.GreaterThanToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBra
  436. info warn → info by review long-line packages/typescript/src/ast/scanner.ts:263:1

    line length 8908 characters (raw pass, confidence 0.65)

    const unicodeESNextIdentifierStart = [65, 90, 97, 122, 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 895, 895, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1488, 1514, 15
    dismissed LLM, confidence 0.95 Large Unicode identifier-start code-point table in the TypeScript scanner.
    Reasoning

    This is a long array literal of Unicode identifier code-point ranges, a standard data table in a TypeScript scanner. Raw long-line findings on data tables are expected false positives.

  437. info warn → info by review long-line packages/typescript/src/ast/scanner.ts:265:1

    line length 10367 characters (raw pass, confidence 0.65)

    const unicodeESNextIdentifierPart = [48, 57, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 183, 183, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 895, 895, 902, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1327, 1329, 1366, 1369, 1369,
    dismissed LLM, confidence 0.95 Large Unicode identifier-part code-point table in the TypeScript scanner.
    Reasoning

    Same pattern as the adjacent line: a Unicode identifier-part code-point table, which is legitimate lookup data.

  438. info warn → info by review dynamic-import packages/typescript/src/vscode/moduleLoader.ts:37:16

    dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

            const modulePath = require.resolve(`${manifest.name}/${exportPath.slice("typescript/".length)}`);⟨U+000D⟩
            return import(pathToFileURL(modulePath).href);⟨U+000D⟩
        }
    likely benign LLM, confidence 0.85 Dynamic import of a resolved TypeScript plugin module path in the VS Code extension loader.
    Reasoning

    The import specifier is built from the package manifest name and a export path that is sliced from a known prefix, then resolved with require.resolve. This is a plugin-loading helper inside an extension, so the non-literal specifier is expected and not evidence of an attack.

  439. identifier `a𐐀b` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

     * offset. Prior to 3.17 the offsets were always based on a UTF-16 string⟨U+000D⟩
     * representation. So a string of the form `a𐐀b` the character offset of the⟨U+000D⟩
     * character `a` is 0, the character offset of `𐐀` is 1 and the character⟨U+000D⟩
     * offset of b is 3 since `𐐀` is represented using two code units in UTF-16.
  440. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

                "/src/1.ts": `"😃"`,⟨U+000D⟩
                "/src/2.ts": `"\\ud83d\\ude03"`,⟨U+000D⟩
                "/src/3.ts": `"\\ud800a\\udc00"`,⟨U+000D⟩
            });
  441. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

                "/src/1.ts": `"😃"`,⟨U+000D⟩
                "/src/2.ts": `"\\ud83d\\ude03"`,⟨U+000D⟩
                "/src/3.ts": `"\\ud800a\\udc00"`,⟨U+000D⟩
            });
  442. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

                "/src/2.ts": `"\\ud83d\\ude03"`,⟨U+000D⟩
                "/src/3.ts": `"\\ud800a\\udc00"`,⟨U+000D⟩
            });
  443. orphaned low surrogate \uDC00 (no preceding high surrogate) (token pass, confidence 0.65)

                "/src/2.ts": `"\\ud83d\\ude03"`,⟨U+000D⟩
                "/src/3.ts": `"\\ud800a\\udc00"`,⟨U+000D⟩
            });
  444. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

                ["/src/2.ts", "😃"],⟨U+000D⟩
                ["/src/3.ts", "\ud800a\udc00"],⟨U+000D⟩
            ]);
  445. orphaned low surrogate \uDC00 (no preceding high surrogate) (token pass, confidence 0.65)

                ["/src/2.ts", "😃"],⟨U+000D⟩
                ["/src/3.ts", "\ud800a\udc00"],⟨U+000D⟩
            ]);
  446. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

                "/tsconfig.json": "{}",⟨U+000D⟩
                "/src/index.ts": "`\\ud800${0}\\udc00`",⟨U+000D⟩
            });
  447. orphaned low surrogate \uDC00 (no preceding high surrogate) (token pass, confidence 0.65)

                "/tsconfig.json": "{}",⟨U+000D⟩
                "/src/index.ts": "`\\ud800${0}\\udc00`",⟨U+000D⟩
            });
  448. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

                if (isTemplateHead(node)) {⟨U+000D⟩
                    assert.equal(node.text, "\ud800");⟨U+000D⟩
                    sawHead = true;⟨U+000D⟩
                }
  449. orphaned low surrogate \uDC00 (no preceding high surrogate) (token pass, confidence 0.65)

                else if (isTemplateTail(node)) {⟨U+000D⟩
                    assert.equal(node.text, "\udc00");⟨U+000D⟩
                    sawTail = true;⟨U+000D⟩
                }
  450. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

                "/src/1.ts": `"😃"`,⟨U+000D⟩
                "/src/2.ts": `"\\ud83d\\ude03"`,⟨U+000D⟩
                "/src/3.ts": `"\\ud800a\\udc00"`,⟨U+000D⟩
            });
  451. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

                "/src/1.ts": `"😃"`,⟨U+000D⟩
                "/src/2.ts": `"\\ud83d\\ude03"`,⟨U+000D⟩
                "/src/3.ts": `"\\ud800a\\udc00"`,⟨U+000D⟩
            });
  452. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

                "/src/2.ts": `"\\ud83d\\ude03"`,⟨U+000D⟩
                "/src/3.ts": `"\\ud800a\\udc00"`,⟨U+000D⟩
            });
  453. orphaned low surrogate \uDC00 (no preceding high surrogate) (token pass, confidence 0.65)

                "/src/2.ts": `"\\ud83d\\ude03"`,⟨U+000D⟩
                "/src/3.ts": `"\\ud800a\\udc00"`,⟨U+000D⟩
            });
  454. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

                ["/src/2.ts", "😃"],⟨U+000D⟩
                ["/src/3.ts", "\ud800a\udc00"],⟨U+000D⟩
            ]);
  455. orphaned low surrogate \uDC00 (no preceding high surrogate) (token pass, confidence 0.65)

                ["/src/2.ts", "😃"],⟨U+000D⟩
                ["/src/3.ts", "\ud800a\udc00"],⟨U+000D⟩
            ]);
  456. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

                "/tsconfig.json": "{}",⟨U+000D⟩
                "/src/index.ts": "`\\ud800${0}\\udc00`",⟨U+000D⟩
            });
  457. orphaned low surrogate \uDC00 (no preceding high surrogate) (token pass, confidence 0.65)

                "/tsconfig.json": "{}",⟨U+000D⟩
                "/src/index.ts": "`\\ud800${0}\\udc00`",⟨U+000D⟩
            });
  458. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

                if (isTemplateHead(node)) {⟨U+000D⟩
                    assert.equal(node.text, "\ud800");⟨U+000D⟩
                    sawHead = true;⟨U+000D⟩
                }
  459. orphaned low surrogate \uDC00 (no preceding high surrogate) (token pass, confidence 0.65)

                else if (isTemplateTail(node)) {⟨U+000D⟩
                    assert.equal(node.text, "\udc00");⟨U+000D⟩
                    sawTail = true;⟨U+000D⟩
                }
  460. line length 523 characters (raw pass, confidence 0.50)

    import { Message, MessageSignature, RequestMessage, RequestType, RequestType0, RequestType1, RequestType2, RequestType3, RequestType4, RequestType5, RequestType6, RequestType7, RequestType8, RequestType9, ResponseError, ErrorCodes, NotificationMessage, NotificationType, NotificationType0, NotificationType1, Notificatio
  461. line length 1074 characters (raw pass, confidence 0.50)

    import { Logger, ConnectionStrategy, ConnectionOptions, MessageConnection, NullLogger, createMessageConnection, ProgressToken, ProgressType, RequestParam, HandlerResult, StarRequestHandler, GenericRequestHandler, RequestHandler0, RequestHandler, RequestHandler1, RequestHandler2, RequestHandler3, RequestHandler4, Reques
  462. line length 2105 characters (raw pass, confidence 0.65)

    export { RAL, Message, MessageSignature, RequestMessage, RequestType, RequestType0, RequestType1, RequestType2, RequestType3, RequestType4, RequestType5, RequestType6, RequestType7, RequestType8, RequestType9, ResponseError, ErrorCodes, NotificationMessage, NotificationType, NotificationType0, NotificationType1, Notifi
    dismissed LLM, confidence 0.93 Long re-export statement in a vendored vscode-jsonrpc declaration file.
    Reasoning

    This is a vendored TypeScript declaration file whose long line is a re-export list of JSON-RPC types. Declaration files commonly contain long export lines.

  463. line length 1299 characters (raw pass, confidence 0.50)

    exports.ProgressType = exports.ProgressToken = exports.createMessageConnection = exports.NullLogger = exports.ConnectionOptions = exports.ConnectionStrategy = exports.AbstractMessageBuffer = exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = exports.ReadableStreamMessageReade
  464. line length 548 characters (raw pass, confidence 0.50)

    exports.ConnectionOptions = exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.RequestCancellationReceiverStrategy = exports.IdCancellationReceiverStrategy = exports.ConnectionStrategy = exports.ConnectionError = exports.Connectio
  465. line length 694 characters (raw pass, confidence 0.50)

    exports.Message = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationTy
  466. compression ratio 0.807 is >2σ above file mean 0.697 (in comment) (raw pass, confidence 0.30)

    /**
     * The **`CharacterData`** abstract interface represents a Node object that contains characters. This is an abstract interface, meaning there aren't any objects of type CharacterData: it is implemented by other interfaces like Text, Comment, CDATASection, or ProcessingInstruction, which aren't abstract.
     *
  467. line length 627 characters (raw pass, confidence 0.50)

    type AutoFillNormalField = "additional-name" | "address-level1" | "address-level2" | "address-level3" | "address-level4" | "address-line1" | "address-line2" | "address-line3" | "bday-day" | "bday-month" | "bday-year" | "cc-csc" | "cc-exp" | "cc-exp-month" | "cc-exp-year" | "cc-family-name" | "cc-given-name" | "cc-name"
  468. line length 569 characters (raw pass, confidence 0.50)

    type GPUVertexFormat = "float16" | "float16x2" | "float16x4" | "float32" | "float32x2" | "float32x3" | "float32x4" | "sint16" | "sint16x2" | "sint16x4" | "sint32" | "sint32x2" | "sint32x3" | "sint32x4" | "sint8" | "sint8x2" | "sint8x4" | "snorm10-10-10-2" | "snorm16" | "snorm16x2" | "snorm16x4" | "snorm8" | "snorm8x2" 
  469. U+200D ZERO WIDTH JOINER in source (in string/comment) (raw pass, confidence 0.45)

         * that is representable as a Number value, which is approximately:
         * 2.2204460492503130808472633361816 x 10⟨U+200D⟩−⟨U+200D⟩16.
         */
        readonly EPSILON: number;
  470. U+200D ZERO WIDTH JOINER in source (in string/comment) (raw pass, confidence 0.45)

         * that is representable as a Number value, which is approximately:
         * 2.2204460492503130808472633361816 x 10⟨U+200D⟩−⟨U+200D⟩16.
         */
        readonly EPSILON: number;
  471. 21 of 41 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  472. 18 of 38 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  473. line length 569 characters (raw pass, confidence 0.50)

    type GPUVertexFormat = "float16" | "float16x2" | "float16x4" | "float32" | "float32x2" | "float32x3" | "float32x4" | "sint16" | "sint16x2" | "sint16x4" | "sint32" | "sint32x2" | "sint32x3" | "sint32x4" | "sint8" | "sint8x2" | "sint8x4" | "snorm10-10-10-2" | "snorm16" | "snorm16x2" | "snorm16x4" | "snorm8" | "snorm8x2" 
  474. info warn → info by review dynamic-import tsc/internal/stringutil/_scripts/generate-unicode-data.mts:45:26

    dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    async function loadCodePoints(property: string): Promise<number[]> {⟨U+000D⟩
        const module = await import(`${PACKAGE}/${property}/code-points.js`);⟨U+000D⟩
        return module.default as number[];⟨U+000D⟩
    }
    likely benign LLM, confidence 0.90 Dynamic import of Unicode code-point data in a generator script.
    Reasoning

    This is a build script that imports Unicode code-point data from a fixed package with a property name interpolated into the path. The specifier is constrained to a known package and is normal for a generator script.

  475. info warn → info by review dynamic-import tsc/internal/stringutil/_scripts/generate-unicode-data.mts:50:26

    dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    async function loadMapping(property: string): Promise<Map<number, number[]>> {⟨U+000D⟩
        const module = await import(`${PACKAGE}/${property}/code-points.js`);⟨U+000D⟩
        return module.default as Map<number, number[]>;⟨U+000D⟩
    }
    likely benign LLM, confidence 0.90 Dynamic import of Unicode mapping data in a generator script.
    Reasoning

    Same generator pattern as the previous finding: the import path is a fixed package plus a property name, used to load mapping data at build time.

  476. info warn → info by review dynamic-import tsc/internal/stringutil/_scripts/generate-unicode-data.mts:55:26

    dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.80)

    async function loadSimpleMapping(property: string): Promise<Map<number, number>> {⟨U+000D⟩
        const module = await import(`${PACKAGE}/${property}/code-points.js`);⟨U+000D⟩
        return module.default as Map<number, number>;⟨U+000D⟩
    }
    likely benign LLM, confidence 0.90 Dynamic import of simple Unicode mapping data in a generator script.
    Reasoning

    Same generator pattern: a fixed package and property name are used to load simple mapping data during code generation.

  477. line length 569 characters (raw pass, confidence 0.50)

        G@⟨U+0004⟩�⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩G@⟨U+0005⟩�⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩
  478. line length 569 characters (raw pass, confidence 0.50)

           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  479. line length 565 characters (raw pass, confidence 0.50)

    G@⟨U+0004⟩�⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩G@⟨U+0005⟩�⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩
  480. 15 of 36 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  481. 27 of 46 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  482. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    export class Foo {
    	member: string;
    }
  483. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    declare class Foo {
    	member: string;
    }
    export = Foo;
  484. 29 of 66 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  485. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    declare namespace Foo {
    	function a():void;
    	var b:number;
    	class C {}
  486. 19 of 47 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  487. 22 of 38 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  488. 21 of 39 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  489. 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  490. file mixes tab and space indentation (8 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    module {
    	export var foo = 1;
    
    	module {
  491. file mixes tab and space indentation (5 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	/**
    	 * Constructor
    	 *
  492. file mixes tab and space indentation (5 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	/**
    	 * Constructor
    	 *
  493. file mixes tab and space indentation (11 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	get arguments() {
    		return { bar: {} };
    	}
  494. file mixes tab and space indentation (17 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	/**
    	 * Constructor
    	 *
  495. file mixes tab and space indentation (8 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    const bar = {
    	arguments: {}
    }
  496. file mixes tab and space indentation (4 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	constructor() {
    		/**
    		 * @type object
  497. file mixes tab and space indentation (4 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	constructor() {
    		/**
    		 * @type Function
  498. file mixes tab and space indentation (5 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	/**
    	 * @param {object} [foo={}]
    	 */
  499. file mixes tab and space indentation (5 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	/**
    	 * @param {object} [foo={}]
    	 */
  500. file mixes tab and space indentation (10 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	get arguments() {
    		return { bar: {} };
    	}
  501. file mixes tab and space indentation (17 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	/**
    	 * @param {object} [foo={}]
    	 */
  502. file mixes tab and space indentation (8 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    const bar = {
    	arguments: {}
    }
  503. file mixes tab and space indentation (4 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	m() {
    		/**
    		 * @type object
  504. file mixes tab and space indentation (4 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	m() {
    		/**
    		 * @type Function
  505. mean non-conventional identifier length 1.29 over 28 names (token pass, confidence 0.50)

  506. 27 of 51 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  507. file mixes tab and space indentation (3 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    interface I1 {
    	IM1():void[];
    }
  508. file mixes tab and space indentation (5 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    interface I1 {
    	IM1():void[];
    }
  509. 24 of 39 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  510. 16 of 37 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  511. file mixes tab and space indentation (4 tab-indented and 32 space-indented lines) (raw pass, confidence 0.40)

    interface IOptions {
        name?: string;
        flag?: boolean;
        short?: string;
  512. mean non-conventional identifier length 1.54 over 35 names (token pass, confidence 0.50)

  513. 21 of 36 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  514. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    namespace M {
        interface I {
    	f(n:number):boolean;
        }
  515. 43 of 100 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  516. file mixes tab and space indentation (3 tab-indented and 21 space-indented lines) (raw pass, confidence 0.40)

    function makePoint(x: number, y: number) {
        return {
            get x() { return x;}, // shouldn't be "void"
            get y() { return y;}, // shouldn't be "void"
  517. 20 of 42 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  518. 24 of 58 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  519. 19 of 30 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  520. 26 of 48 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  521. 20 of 44 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  522. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function* foo() {
        import((await import(yield "foo")).default);
    }
    dismissed LLM, confidence 0.90 Compiler test fixture using a dynamic import with a yield-based specifier.
    Reasoning

    This is a TypeScript compiler test baseline exercising yield inside a dynamic import expression. The construct is deliberate test input, not a payload.

  523. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    async function* foo() {
        import((await import(yield "foo")).default);
    }
    dismissed LLM, confidence 0.90 Nested dynamic import expression within the same compiler test fixture.
    Reasoning

    Second flag on the same test fixture line; the nested import with yield is intentional compiler test coverage for async generator semantics.

  524. `require` called with a non-literal specifier (ast pass, confidence 0.60)

        return __asyncGenerator(this, arguments, function* foo_1() {⟨U+000D⟩
            Promise.resolve(`${(yield __await(Promise.resolve(`${yield yield __await("foo")}`).then(s => __importStar(require(s))))).default}`).then(s => __importStar(require(s)));⟨U+000D⟩
        });⟨U+000D⟩
    }
    dismissed LLM, confidence 0.90 Transpiled require call in a compiler test baseline for dynamic import.
    Reasoning

    This is compiler-emitted output for the same test, where require is called with a runtime-computed specifier as the transpiled form of dynamic import. It mirrors the source fixture and is not malicious.

  525. `require` called with a non-literal specifier (ast pass, confidence 0.60)

        return __asyncGenerator(this, arguments, function* foo_1() {⟨U+000D⟩
            Promise.resolve(`${(yield __await(Promise.resolve(`${yield yield __await("foo")}`).then(s => __importStar(require(s))))).default}`).then(s => __importStar(require(s)));⟨U+000D⟩
        });⟨U+000D⟩
    }
    likely benign LLM, confidence 0.90 Compiled TypeScript test baseline showing a dynamic import transformed to require with a computed specifier.
    Reasoning

    This is TypeScript compiler test baseline output for async import with yield. The require(s) with a dynamic specifier is an artifact of the compiled test of dynamic import semantics, not a dropper. No shell or exec pattern; it is inside a test fixture.

  526. 49 of 76 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  527. 24 of 48 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  528. file mixes tab and space indentation (6 tab-indented and 26 space-indented lines) (raw pass, confidence 0.40)

    async function main() {
        let aaa: number;
        let bbb: string;
        [
  529. file mixes tab and space indentation (4 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    class Greeter {
        constructor() {
    		foo(() => {
                bar(() => {
  530. mean non-conventional identifier length 1.69 over 9848 names (token pass, confidence 0.50)

  531. line length 9388 characters (raw pass, confidence 0.65)

    0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 
    dismissed LLM, confidence 0.97 Generated stress-test line of chained numeric additions in a compiler test baseline.
    Reasoning

    A very long line of literal additions is a stress test for the TypeScript binder, a known test fixture. Length alone is not obfuscation.

  532. line length 9389 characters (raw pass, confidence 0.65)

    0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 
    dismissed LLM, confidence 0.97 Another generated stress-test line of chained numeric additions in the same baseline.
    Reasoning

    Same generated binder stress-test line of numeric additions in a TypeScript compiler fixture; harmless.

  533. 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  534. mean non-conventional identifier length 1.76 over 110 names (token pass, confidence 0.50)

  535. 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  536. 20 of 45 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  537. 29 of 65 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  538. 26 of 61 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  539. 29 of 65 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  540. file mixes tab and space indentation (10 tab-indented and 78 space-indented lines) (raw pass, confidence 0.40)

    export declare class Promise<R> implements Promise.Thenable<R> {
    	constructor(callback: (resolve: (thenableOrResult: R | Promise.Thenable<R>) => void, reject: (error: any) => void) => void);
        static try<R>(dit: typeof Promise, fn: () => Promise.Thenable<R>, args?: any[], ctx?: any): Promise<R>;
  541. 18 of 34 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  542. file mixes tab and space indentation (2 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    class Foo { // error
    	bar1(s:string);
    	bar1(n:number);
        bar1(a:any) { /*WScript.Echo(a);*/ }
  543. file mixes tab and space indentation (6 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	constructor(f: () => string) {
    	}
    	public blah(): string { return ""; }
  544. mean non-conventional identifier length 1.91 over 76 names (token pass, confidence 0.50)

  545. 20 of 37 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  546. 44 of 71 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  547. 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  548. 33 of 51 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  549. 22 of 40 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  550. 20 of 40 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  551. 16 of 32 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  552. 14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  553. 14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  554. 32 of 76 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  555. file mixes tab and space indentation (3 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    namespace M {
      export interface I1 {}
      export interface I2<T> {}
    }
  556. 18 of 41 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  557. 21 of 43 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  558. file mixes tab and space indentation (45 tab-indented and 58 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	public p1 = 0;
    	private p2 = 0;
    	p3;
  559. 14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  560. 27 of 49 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  561. 22 of 35 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  562. 50 of 107 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  563. 28 of 64 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  564. 36 of 74 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  565. 56 of 108 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  566. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    //// [collisionCodeGenModuleWithUnicodeNames.ts]⟨U+000D⟩
    namespace 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 {
    likely benign LLM, confidence 0.95 Namespace identifier using mixed Unicode scripts in a TypeScript compiler collision test.
    Reasoning

    The identifier is a deliberately constructed unicode-name test from the TypeScript compiler suite, testing identifier handling across scripts. Mixed scripts here are test content, not a homoglyph attack in shipped code.

  567. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    //// [collisionCodeGenModuleWithUnicodeNames.ts]⟨U+000D⟩
    namespace 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 {
    likely benign LLM, confidence 0.95 Mixed-script identifier within the same Unicode collision test namespace.
    Reasoning

    Same deliberate unicode identifier test fixture from the TypeScript compiler; the mixed scripts reflect test intent.

  568. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    //// [collisionCodeGenModuleWithUnicodeNames.ts]⟨U+000D⟩
    namespace 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 {
    likely benign LLM, confidence 0.95 Mixed-script identifier fragment in the Unicode collision compiler test.
    Reasoning

    Same unicode-name compiler test; the identifier tests script handling rather than hiding malicious logic.

  569. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

        export class 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 {
        }
    }
    likely benign LLM, confidence 0.95 Exported class declared with a mixed-script unicode name in a compiler test.
    Reasoning

    Exported class with mixed-script name in a TypeScript compiler fixture designed to exercise unicode identifiers.

  570. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

        export class 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 {
        }
    }
    likely benign LLM, confidence 0.95 Mixed-script class identifier fragment in the Unicode collision compiler test.
    Reasoning

    Same deliberate unicode identifier test; no execution or concealment of payload.

  571. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

        export class 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 {
        }
    }
    likely benign LLM, confidence 0.95 Mixed-script identifier tail in the Unicode collision compiler test class.
    Reasoning

    Same compiler test fixture with a deliberately mixed-script identifier; benign.

  572. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    var x = new 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيك
    likely benign LLM, confidence 0.95 Constructor call with a mixed-script unicode identifier in a compiler test baseline.
    Reasoning

    Instantiation using a mixed-script identifier within the TypeScript compiler's unicode name test; no malicious behavior.

  573. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    w 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄü
    likely benign LLM, confidence 0.90 Unicode identifier with mixed scripts in a tsc test baseline.
    Reasoning

    This is a TypeScript compiler baseline test file exercising Unicode identifiers in code generation; the mixed scripts are deliberate test content, not obfuscation.

  574. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    ß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123();
    likely benign LLM, confidence 0.95 A deliberately odd, mixed-script identifier call inside a TypeScript compiler test baseline.
    Reasoning

    The file is a TypeScript compiler baseline (reference output) for a test named collisionCodeGenModuleWithUnicodeNames. The mixed-script identifier is a deliberate Unicode identifier used to test code generation for module name collisions. Raw-pass unicode findings have a high false-positive rate, and nothing here indicates an attack.

  575. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    ışğİliيونيكودöÄüßAbcd123.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123();
    likely benign LLM, confidence 0.95 Mixed-script property access in a TypeScript compiler Unicode-identifier test baseline.
    Reasoning

    Same compiler test baseline. The identifier mixes Han, Katakana, Cyrillic and other scripts as a Unicode-identifier test case. It is a property access on a function-call target with no execution or exfiltration behavior.

  576. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    3.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123();
    likely benign LLM, confidence 0.95 Long mixed-script identifier in a compiler test baseline.
    Reasoning

    This is a continuation of the same generated test fixture. The long mixed-script identifier is a stress case for Unicode identifier handling in the compiler and is not obfuscation.

  577. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    ß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123();
    likely benign LLM, confidence 0.95 Mixed-script identifier call in a compiler conformance test baseline.
    Reasoning

    Same compiler baseline file. The flagged identifier is a Unicode test name exercised by a call expression, which is typical of compiler conformance tests.

  578. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    "use strict";⟨U+000D⟩
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123;
    likely benign LLM, confidence 0.95 Var declaration with a mixed-script Unicode identifier in a compiler test baseline.
    Reasoning

    The file is a TypeScript baseline containing a 'use strict' header and a var declaration of a Unicode identifier. This is the expected emitted output for a Unicode-name test, not malicious code.

  579. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    "use strict";⟨U+000D⟩
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123;
    likely benign LLM, confidence 0.95 Mixed-script var declaration in a compiler test baseline.
    Reasoning

    Same var declaration in the compiler test baseline. The mixed-script name is the subject of the test and carries no execution or network behavior.

  580. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    "use strict";⟨U+000D⟩
    var 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123;
    likely benign LLM, confidence 0.95 Mixed-script var declaration in a compiler test baseline.
    Reasoning

    The identifier appears in a standard emitted-JavaScript baseline for a compiler test. The Unicode mix is intentional test input.

  581. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    (function (才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123_1) {
    likely benign LLM, confidence 0.95 Mixed-script function parameter in an emitted module wrapper inside a compiler test baseline.
    Reasoning

    This is a function parameter in the compiler's emitted module wrapper, which is standard IIFE output. The Unicode name is the test subject, so this is not obfuscation.

  582. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    (function (才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123_1) {
    likely benign LLM, confidence 0.95 Mixed-script parameter name in a compiler test baseline IIFE.
    Reasoning

    Same IIFE parameter list in the compiler baseline. The mixed-script identifier is the intended test input for module name collision codegen.

  583. identifier `राüışğİliيونيكودöÄüßAbcd123_1` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    (function (才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123_1) {
    likely benign LLM, confidence 0.95 Mixed-script parameter with a collision-suffix _1 in a compiler test baseline.
    Reasoning

    The identifier ends in _1, a collision-avoidance suffix that the TypeScript emitter generates. This confirms the file is compiler output for a naming-collision test and not an attack.

  584. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

        class 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 {⟨U+000D⟩
        }
    likely benign LLM, confidence 0.93 A class declaration with a long unicode identifier mixing Han, Katakana, Cyrillic and other scripts, in a TypeScript test baseline.
    Reasoning

    This is a compiler test baseline from the TypeScript repo. The identifier is a deliberately long, multi-script name used to test unicode identifier handling and name collision in code generation. Raw-pass unicode-mixed-script findings have a high false-positive rate, and nothing here is executed or hidden.

  585. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

        class 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 {⟨U+000D⟩
        }
    likely benign LLM, confidence 0.93 Part of the same mixed-script unicode class identifier used in a TypeScript compiler test.
    Reasoning

    Same test baseline and the same deliberate unicode identifier stress case. The mixed scripts reflect a compiler conformance test for unicode names, not concealment of malicious behaviour.

  586. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

        class 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 {⟨U+000D⟩
        }
    likely benign LLM, confidence 0.93 A trailing segment of the mixed-script unicode class name in a compiler test fixture.
    Reasoning

    The identifier suffix shares the same test-fixture origin. Mixed-script identifiers are legal in JavaScript, and this one exists to exercise the compiler's identifier handling.

  587. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

        才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123_1.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودö
    likely benign LLM, confidence 0.93 A reference to the mixed-script unicode identifier in a generated expected-output baseline for a TypeScript test.
    Reasoning

    Line 20 is generated expected output from the same conformance test, using the same unicode identifiers in a module-qualified assignment. It is test data, not an attack payload.

  588. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

      才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123_1.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄ
    likely benign LLM, confidence 0.93 Another occurrence of the mixed-script identifier in the compiler test baseline output.
    Reasoning

    The same deliberate unicode identifier appears in the generated test output. The pattern is consistent with a collision test for names that look alike across scripts.

  589. identifier `राüışğİliيونيكودöÄüßAbcd123_1` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    ß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123_1.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيوني
    likely benign LLM, confidence 0.93 A mixed-script identifier used in a member assignment inside a TypeScript conformance baseline.
    Reasoning

    Test baseline with a deliberate unicode identifier used in a property assignment. No execution, encoding, or concealed control flow is present.

  590. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    şğİliيونيكودöÄüßAbcd123_1.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड… (340 bytes total)
    likely benign LLM, confidence 0.93 A mixed-script identifier in an assignment within the compiler test's expected output.
    Reasoning

    Repeated occurrence of the same test identifier in generated expected output. The snippet is plain assignment, with no dynamic execution or obfuscated payload.

  591. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    1.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄ
    likely benign LLM, confidence 0.93 A mixed-script identifier in a plain assignment from a TypeScript compiler test baseline.
    Reasoning

    This is part of the same generated test baseline. The mixed-script identifiers are the subject of the test, and the code only performs ordinary assignments.

  592. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    ß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123;⟨U+000D⟩
    likely benign LLM, confidence 0.93 A final mixed-script identifier assignment in the compiler test baseline output.
    Reasoning

    The line is ordinary assignment in a test fixture from the TypeScript repository. The unicode identifiers are intentional test inputs, with no sign of malicious intent.

  593. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    şğİliيونيكودöÄüßAbcd123 = 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123;⟨U+000D⟩
    dismissed LLM, confidence 0.94 A generated TypeScript compiler baseline containing a deliberately mixed-script Unicode identifier.
    Reasoning

    This is a TypeScript compiler baseline output file for a test about Unicode identifiers. The mixed-script identifier is deliberate test input for how the compiler handles unicode names, not an obfuscation attempt. The raw-pass unicode signal has a high false-positive rate and nothing here suggests malicious intent.

  594. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    = 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123;⟨U+000D⟩
    dismissed LLM, confidence 0.94 Another mixed-script Unicode identifier in the same compiler baseline file.
    Reasoning

    Same compiler test baseline. The identifier mixes scripts only because the test exercises unicode identifier handling. It is not executed payload or hidden logic.

  595. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    ß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123;⟨U+000D⟩
    dismissed LLM, confidence 0.94 A mixed-script identifier used as a test case for unicode name emission.
    Reasoning

    Compiler test fixture for unicode names. The raw-pass mixed-script flag is a predictable false positive on purposeful test identifiers.

  596. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    })(才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 || (才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكود… (340 bytes total)
    dismissed LLM, confidence 0.94 A mixed-script identifier in a compiled namespace IIFE within a compiler baseline.
    Reasoning

    Part of the TypeScript compiler's expected output for a module with unicode names, showing a namespace IIFE pattern. Nothing here is dynamic execution or an encoded dropper.

  597. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    )(才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 || (才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودö
    dismissed LLM, confidence 0.94 A mixed-script identifier in compiled namespace code from a test baseline.
    Reasoning

    Standard compiler-emitted namespace code in a baseline test file. The mixed-script identifier is intentional test content.

  598. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    ß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 || (才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = {}));⟨U+000D⟩
    dismissed LLM, confidence 0.94 A mixed-script identifier in compiler test output.
    Reasoning

    Compiler baseline output for a unicode-name test. The raw-pass finding flags a deliberate test identifier, which is a benign pattern.

  599. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    ğİliيونيكودöÄüßAbcd123 || (才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = {}));⟨U+000D⟩
    dismissed LLM, confidence 0.94 A mixed-script identifier in the compiled output of a unicode-name test case.
    Reasoning

    Expected compiler output for a unicode identifier test. The flagged identifier is test data and the surrounding code is ordinary module emission.

  600. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

     (才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = {}));⟨U+000D⟩
    dismissed LLM, confidence 0.94 A mixed-script identifier in a TypeScript compiler baseline for unicode names.
    Reasoning

    Compiler baseline file in the TypeScript repository. The mixed-script identifier is an intentional test input, and the raw-pass signal is a known false-positive class.

  601. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    ß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = {}));⟨U+000D⟩
    dismissed LLM, confidence 0.94 A mixed-script identifier in expected compiler output for a unicode test.
    Reasoning

    Compiler test baseline. The mixed-script identifier exists to test unicode name handling and is not obfuscation.

  602. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    var x = new 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيك
    dismissed LLM, confidence 0.93 A constructor call using a mixed-script identifier in a TypeScript compiler test baseline.
    Reasoning

    A new-expression using a mixed-script identifier in a compiler baseline file. This is a deliberate unicode naming test, and the raw-pass unicode flag is a false positive here.

  603. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    w 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄü
    likely benign LLM, confidence 0.93 Unicode identifier with mixed scripts in a TypeScript compiler baseline test file.
    Reasoning

    Raw-pass unicode mixed-script flag on identifiers inside a TypeScript compiler test baseline that deliberately exercises unicode identifier names. Mixed scripts in a test fixture for identifier handling is expected; no execution or payload behavior is present.

  604. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    ß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123();⟨U+000D⟩
    likely benign LLM, confidence 0.93 Mixed-script unicode identifier used in a call inside a compiler test baseline.
    Reasoning

    Same compiler test baseline; the identifier is a unicode test name used in a call. Raw-pass signal with high false-positive rate, consistent with a legitimate unicode-identifier test.

  605. identifier `才能ソЫⅨ蒤郳र` mixes scripts: Han + Katakana + Cyrillic + Other (raw pass, confidence 0.80)

    ışğİliيونيكودöÄüßAbcd123.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123();⟨U+000D⟩
    likely benign LLM, confidence 0.93 Unicode identifier in a compiler test baseline, flagged for mixed scripts.
    Reasoning

    Part of the same deliberate unicode-identifier test fixture; no obfuscation-driven behavior in the snippet.

  606. identifier `राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र` mixes scripts: Other + Latin + Arabic + Han + Katakana + Cyrillic (raw pass, confidence 0.80)

    3.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123();⟨U+000D⟩
    likely benign LLM, confidence 0.93 Mixed-script identifier in a compiler test baseline.
    Reasoning

    Same unicode-identifier compiler test fixture; the flag is a raw-pass false positive on intentionally exotic identifier names.

  607. identifier `राüışğİliيونيكودöÄüßAbcd123` mixes scripts: Other + Latin + Arabic (raw pass, confidence 0.80)

    ß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123();⟨U+000D⟩
    likely benign LLM, confidence 0.93 Mixed-script identifier call in a compiler test baseline.
    Reasoning

    Same compiler test fixture; the call is a plain invocation of a unicode-named function in a baseline output file.

  608. 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  609. 46 of 87 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  610. file mixes tab and space indentation (27 tab-indented and 774 space-indented lines) (raw pass, confidence 0.40)

     */
     /* tslint:disable */
    
    // import * as import0 from '@angular/core/src/linker/ng_module_factory';
  611. 17 of 41 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  612. file mixes tab and space indentation (2 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    interface Array<T> {
        concat(...items: T[][]): T[]; // Note: This overload needs to be picked for arrays of arrays, even though both are applicable
        concat(...items: T[]): T[];
    }
  613. mean non-conventional identifier length 1.52 over 122 names (token pass, confidence 0.50)

  614. 23 of 50 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  615. mean non-conventional identifier length 1.81 over 80 names (token pass, confidence 0.50)

  616. mean non-conventional identifier length 1.84 over 74 names (token pass, confidence 0.50)

  617. 122 of 288 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  618. 16 of 32 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  619. 15 of 30 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  620. 26 of 56 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  621. 14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  622. file mixes tab and space indentation (2 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    interface A {
    	a: number;
    }
  623. file mixes tab and space indentation (1 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    declare class FooBase {
        constructor(s: string);
        constructor(n: number);
        constructor(x: any) {
  624. 20 of 43 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  625. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const path = "./Card.astro";
    void import(path);
    
    export async function load() { return import("./Card.astro"); }
    likely benign LLM, confidence 0.88 Dynamic import of a local relative path in a compiler test baseline.
    Reasoning

    This is a TypeScript compiler baseline testing import extension rewriting. The dynamic import of a local path variable is a test of the emitted output, not a malicious loader. Local relative path, no network or payload.

  626. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const path = "./Card.astro";⟨U+000D⟩
    void import(__rewriteRelativeImportExtension(path, false, { ".astro": ".js", ".y.z": ".mjs" }));⟨U+000D⟩
    export async function load() { return import("./Card.js"); }⟨U+000D⟩
    export const inferred = import("./Widget.mjs");
    likely benign LLM, confidence 0.88 Dynamic import wrapped in an extension-rewrite helper in a compiler test baseline.
    Reasoning

    Compiler baseline for import-extension rewriting; the non-literal import is wrapped in a rewrite helper and targets relative module paths, consistent with test coverage of the feature.

  627. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    //// [main.ts]⟨U+000D⟩
    export function dynamic(path: string) { return import(path); }
    export function literal() { return import("./Card.astro"); }
    likely benign LLM, confidence 0.88 Generic dynamic import function in a compiler test baseline.
    Reasoning

    Compiler baseline for import helpers; a function taking a path and returning import(path) is a generic dynamic-import pattern in test source. No malicious indicators.

  628. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    /** @param {string} path */
    export function dynamicRequire(path) { return require(path); }
    ⟨U+000D⟩
    //// [globals.d.ts]
    likely benign LLM, confidence 0.88 Generic require with a variable path in a compiler test baseline.
    Reasoning

    Compiler test baseline demonstrating require with a parameter; standard for module-system tests, no encoded or network payload.

  629. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    const tslib_1 = require("tslib");⟨U+000D⟩
    function dynamic(path) { return Promise.resolve(`${tslib_1.__rewriteRelativeImportExtension(path, false, { ".astro": ".js" })}`).then(s => tslib_1.__importStar(require(s))); }⟨U+000D⟩
    function literal() { return Promise.resolve().then(() => tslib_1.__importStar(require("./Card.js"))); }
    likely benign LLM, confidence 0.88 Computed require in emitted helper code within a compiler test baseline.
    Reasoning

    Emitted CommonJS helper code from a compiler test baseline, rewriting relative import specifiers. The require of a computed relative path is expected for testing the rewrite feature.

  630. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    /** @param {string} path */⟨U+000D⟩
    function dynamicRequire(path) { return require(tslib_1.__rewriteRelativeImportExtension(path, false, { ".astro": ".js" })); }
    likely benign LLM, confidence 0.88 Require with a rewritten path in a compiler test baseline.
    Reasoning

    Compiler baseline with require of a rewritten path; consistent with test coverage of extension rewriting, no malicious behavior shown.

  631. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    //// [main.ts]⟨U+000D⟩
    export function dynamic(path: string) { return import(path); }
    export function literal() { return import("./Card.astro"); }
    dismissed LLM, confidence 0.93 Test baseline showing a dynamic import with a variable specifier in a TypeScript compiler fixture.
    Reasoning

    This is a TypeScript compiler baseline file, an expected-output fixture for a test of relative import extension rewriting. The dynamic import(path) is part of the test input and the file is not executed code shipped to users. Dynamic import with a variable specifier is a normal TypeScript pattern.

  632. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    /** @param {string} path */
    export function dynamicRequire(path) { return require(path); }
    ⟨U+000D⟩
    //// [globals.d.ts]
    dismissed LLM, confidence 0.93 Test baseline with require called on a non-literal path inside a TypeScript compiler fixture.
    Reasoning

    This is a compiler test baseline. The require(path) call comes from a fixture exercising JSDoc-typed CommonJS-style code. It is an expected-output artifact, not a dropper or runtime loader.

  633. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import { __rewriteRelativeImportExtension } from "tslib";⟨U+000D⟩
    export function dynamic(path) { return import(__rewriteRelativeImportExtension(path, false, { ".astro": ".js" })); }⟨U+000D⟩
    export function literal() { return import("./Card.js"); }⟨U+000D⟩
    //// [require.js]
    dismissed LLM, confidence 0.93 Generated test output where a dynamic import specifier is passed through the tslib extension-rewrite helper.
    Reasoning

    The non-literal import wraps a call to the tslib helper __rewriteRelativeImportExtension, which is the feature under test. This is a compiler baseline snapshot of generated output, so the flagged dynamic import is expected behavior.

  634. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    /** @param {string} path */⟨U+000D⟩
    export function dynamicRequire(path) { return require(__rewriteRelativeImportExtension(path, false, { ".astro": ".js" })); }
    dismissed LLM, confidence 0.93 Compiler baseline calling require on a helper-rewritten specifier, part of an import-rewrite test.
    Reasoning

    This is a compiler baseline that wraps require around the tslib rewrite helper. It exercises import extension rewriting and is not malicious. The non-literal require is intentional in the fixture.

  635. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    //// [main.ts]⟨U+000D⟩
    export function dynamic(path: string) { return import(path); }
    export function literal() { return import("./Card.astro"); }
    dismissed LLM, confidence 0.93 CommonJS-mode compiler baseline with a dynamic import on a variable path.
    Reasoning

    Compiler test baseline for the CommonJS-compatible variant of the import-helpers test. The dynamic import(path) is an intentional fixture input and the file is not shipped runtime code.

  636. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    /** @param {string} path */
    export function dynamicRequire(path) { return require(path); }
    ⟨U+000D⟩
    //// [globals.d.ts]
    dismissed LLM, confidence 0.93 CommonJS-mode compiler baseline calling require on a non-literal path.
    Reasoning

    Compiler baseline from the TypeScript test suite. The require(path) call is an intentional test case and the file is expected output, not a loader or dropper.

  637. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    const tslib_1 = require("tslib");⟨U+000D⟩
    function dynamic(path) { return Promise.resolve(`${tslib_1.__rewriteRelativeImportExtension(path, false, { ".astro": ".js" })}`).then(s => tslib_1.__importStar(require(s))); }⟨U+000D⟩
    function literal() { return Promise.resolve().then(() => tslib_1.__importStar(require("./Card.js"))); }
    dismissed LLM, confidence 0.94 Compiled CommonJS test output using tslib __importStar around a rewritten require specifier.
    Reasoning

    This is compiled output from a TypeScript test. The require is wrapped in tslib __importStar and applied to a path produced by the tslib rewrite helper, which is the behavior under test. The literal require alongside it shows ordinary module loading.

  638. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    /** @param {string} path */⟨U+000D⟩
    function dynamicRequire(path) { return require(tslib_1.__rewriteRelativeImportExtension(path, false, { ".astro": ".js" })); }
    dismissed LLM, confidence 0.93 Compiler baseline with require wrapped in the tslib extension-rewrite helper.
    Reasoning

    Compiler test baseline for the CommonJS-compatible import-rewrite feature. The non-literal require passes through the tslib helper as intended, and the file is an expected-output fixture.

  639. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    //// [main.ts]⟨U+000D⟩
    export function dynamic(path: string) { return import(path); }
    export function literal() { return import("./Card.astro"); }
    dismissed LLM, confidence 0.93 Preserve-mode compiler baseline with a dynamic import on a variable path.
    Reasoning

    Preserve-mode compiler baseline containing a dynamic import with a variable specifier. This is a test fixture showing expected TypeScript output and does not indicate malicious intent.

  640. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    /** @param {string} path */
    export function dynamicRequire(path) { return require(path); }
    ⟨U+000D⟩
    //// [globals.d.ts]
    dismissed LLM, confidence 0.93 Preserve-mode compiler baseline calling require on a non-literal path.
    Reasoning

    Compiler baseline from the TypeScript test suite. The require(path) on a non-literal argument is the intentional subject of the test and the file is not executed code.

  641. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import { __rewriteRelativeImportExtension } from "tslib";⟨U+000D⟩
    export function dynamic(path) { return import(__rewriteRelativeImportExtension(path, false, { ".astro": ".js" })); }⟨U+000D⟩
    export function literal() { return import("./Card.js"); }⟨U+000D⟩
    //// [require.js]
    dismissed LLM, confidence 0.93 Preserve-mode test baseline with a dynamic import whose specifier is rewritten by a tslib helper.
    Reasoning

    Compiler test output where a dynamic import specifier is passed through the tslib rewrite helper. This is the feature being verified, not obfuscation or a dropper.

  642. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    /** @param {string} path */⟨U+000D⟩
    export function dynamicRequire(path) { return require(__rewriteRelativeImportExtension(path, false, { ".astro": ".js" })); }
    dismissed LLM, confidence 0.93 Preserve-mode compiler baseline calling require on a rewritten specifier.
    Reasoning

    Compiler baseline showing require on a helper-rewritten specifier. It is an expected-output snapshot for an import-extension test, with no sign of malicious use.

  643. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    export function literal() { return import("./Widget.y.z"); }
    export function dynamic(path: string) { return import(path); }
    export const inferred = import("./Widget.y.z");
    likely benign LLM, confidence 0.90 Dynamic import with a variable specifier in a TypeScript compiler test baseline.
    Reasoning

    This is TypeScript compiler test baseline output. The dynamic import(path) is a plain parameterized module loader in a test fixture, with no obfuscation or malicious payload.

  644. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    export function literal() { return import("./Widget.mjs"); }⟨U+000D⟩
    export function dynamic(path) { return import(__rewriteRelativeImportExtension(path, false, { ".identity.y.z": ".identity.y.z", ".unmapped.y.z": ".unmapped.y.z", ".y.z": ".mjs", ".z": ".js" })); }⟨U+000D⟩
    export const inferred = import("./Widget.mjs");
    likely benign LLM, confidence 0.90 Dynamic import wrapped in a compiler-generated extension rewrite helper.
    Reasoning

    Compiler-generated test baseline; the non-literal import is wrapped in a path-rewriting helper for extension mapping, which is expected TypeScript output.

  645. 24 of 59 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  646. mean non-conventional identifier length 1.61 over 46 names (token pass, confidence 0.50)

  647. 27 of 44 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  648. 18 of 38 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  649. 19 of 42 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  650. info warn → info by review generator-yield-callable tsc/testdata/baselines/reference/compiler/contextualTypeOnYield1.js:7:3

    generator `f` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

    const f: FuncOrGeneratorFunc = function*() {
      yield (num) => console.log(num); // `num` should be inferred to have type `number`.
    }
    likely benign LLM, confidence 0.90 Generator yielding a lambda in a TypeScript contextual typing test.
    Reasoning

    A generator yielding an arrow function is a normal JavaScript/TypeScript pattern in a compiler test for contextual typing. The 'state-machine' message is an overreach; nothing invokes the value maliciously.

  651. info warn → info by review generator-yield-callable tsc/testdata/baselines/reference/compiler/contextualTypeOnYield1.js:13:5

    generator `f` yields a callable — `next().value()` invokes the yielded function (state-machine pattern) (ast pass, confidence 0.80)

    const f = function* () {⟨U+000D⟩
        yield (num) => console.log(num); // `num` should be inferred to have type `number`.⟨U+000D⟩
    };
    likely benign LLM, confidence 0.90 Generator yielding a lambda in a TypeScript contextual typing test.
    Reasoning

    Same benign generator-yields-arrow-function pattern in a compiler test fixture.

  652. file mixes tab and space indentation (4 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    interface I {
    	a(s: string): void;
    	b(): (n: number) => void;
    }
  653. 29 of 66 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  654. 19 of 45 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  655. 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  656. 33 of 74 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  657. 21 of 38 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  658. line length 1291 characters (raw pass, confidence 0.50)

        var o = this.opt, ta = this.chart.theme.axis, position = o.position, leftBottom = position !== "rightOrTop", rotation = o.rotation % 360, start, stop, titlePos, titleRotation = 0, titleOffset, axisVector, tickVector, anchorOffset, labelOffset, labelAlign, labelGap = this.chart.theme.axis.tick.labelGap, taFont = o.f
  659. 704 of 1246 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  660. 29 of 61 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  661. 21 of 31 non-conventional identifiers are single-character (68%) (token pass, confidence 0.50)

  662. 15 of 34 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  663. 222 of 446 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  664. 26 of 52 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  665. 42 of 63 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  666. 22 of 55 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  667. 48 of 103 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  668. 57 of 126 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  669. 63 of 141 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  670. 75 of 152 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  671. 49 of 100 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  672. 56 of 80 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)

  673. 62 of 89 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)

  674. 65 of 94 non-conventional identifiers are single-character (69%) (token pass, confidence 0.50)

  675. 17 of 36 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  676. file mixes tab and space indentation (28 tab-indented and 96 space-indented lines) (raw pass, confidence 0.40)

    function referencedInCode({ name: alias }: Named) {
        return alias;
    }
  677. 60 of 124 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  678. 27 of 51 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  679. 42 of 82 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  680. 23 of 50 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  681. file mixes tab and space indentation (1 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)

    export class ExportedClass<T> {
    	x: T;
    }
  682. file mixes tab and space indentation (13 tab-indented and 19 space-indented lines) (raw pass, confidence 0.40)

    {
    	export interface IFace
    	{
    	}
  683. 17 of 31 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  684. surrogate pair \uD83E\uDD2A (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

        (): void;⟨U+000D⟩
        "\uD83E\uDD2A": number;⟨U+000D⟩
    };⟨U+000D⟩
    export declare const arrow10: {
  685. surrogate pair \uD83E\uDD37 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

        (): void;⟨U+000D⟩
        "\uD83E\uDD37\u200D\u2642\uFE0F": number;⟨U+000D⟩
    };
  686. 256 of 442 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  687. 110 of 202 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  688. 137 of 216 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  689. 26 of 62 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  690. 29 of 65 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  691. line length 684 characters (raw pass, confidence 0.50)

    2 >^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  692. 41 of 101 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  693. 25 of 56 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  694. 163 of 404 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  695. 37 of 82 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  696. 20 of 46 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  697. file mixes tab and space indentation (1 tab-indented and 15 space-indented lines) (raw pass, confidence 0.40)

    {
      "name": "package-b",
      "type": "module",
      "exports": {
  698. 20 of 50 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  699. 45 of 99 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  700. file mixes tab and space indentation (2 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    export const foo = <T,>(x: T) => {
    	const inner = <T,>(y: T) => [x, y] as const;
    	return inner;
    }
  701. 19 of 37 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  702. 56 of 92 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  703. 44 of 82 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  704. 202 of 422 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  705. line length 2201 characters (raw pass, confidence 0.65)

    type Foo<T> = T extends 0 ? '0' : T extends 1 ? '1' : T extends 2 ? '2' : T extends 3 ? '3' : T extends 4 ? '4' : T extends 5 ? '5' : T extends 6 ? '6' : T extends 7 ? '7' : T extends 8 ? '8' : T extends 9 ? '9' : T extends 10 ? '10' : T extends 11 ? '11' : T extends 12 ? '12' : T extends 13 ? '13' : T extends 14 ? '14
    dismissed LLM, confidence 0.95 Very long line containing a deeply nested TypeScript conditional type.
    Reasoning

    A very long line of nested conditional type declarations is typical of a TypeScript stress test. Long lines in generated test baselines are not obfuscation.

  706. 60 of 132 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  707. file mixes tab and space indentation (6 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    class C {
    	fun(a: string);
    	fun(a = 3);
    	fun(a = null) { }
  708. 14 of 35 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  709. file mixes tab and space indentation (1 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    class Foo {
    	public v = "Yo";
    }
  710. file mixes tab and space indentation (1 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    class Foo {
    	public v = "Yo";
    }
  711. 19 of 39 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  712. 65 of 129 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  713. 65 of 129 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  714. 102 of 190 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  715. 102 of 190 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  716. 19 of 35 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  717. 20 of 50 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  718. 22 of 30 non-conventional identifiers are single-character (73%) (token pass, confidence 0.50)

  719. file mixes tab and space indentation (4 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    if (null as any) {
        ({ exportedFoo, nonexportedFoo } = null as any);
    }
    else if (null as any) {
  720. 28 of 58 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  721. base64-like blob (65 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [doYouNeedToChangeYourTargetLibraryES2016Plus.ts]
  722. 86 of 124 non-conventional identifiers are single-character (69%) (token pass, confidence 0.50)

  723. file mixes tab and space indentation (7 tab-indented and 31 space-indented lines) (raw pass, confidence 0.40)

    namespace M {
        export namespace N {
    	export function f(x:number)=>2*x;
    	export namespace X.Y.Z {
  724. 55 of 103 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  725. 52 of 88 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  726. 52 of 88 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  727. 32 of 68 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  728. 36 of 72 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  729. 91 of 164 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  730. mean non-conventional identifier length 1.95 over 21 names (token pass, confidence 0.50)

  731. 18 of 37 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  732. 69 of 167 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  733. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    
    import(String(i++));
    import(String(i++));
    likely benign LLM, confidence 0.90 Dynamic import with a side-effecting specifier in a compiler evaluation-order test.
    Reasoning

    Compiler test for evaluation order of dynamic import specifiers; the side-effecting counter is intentional test design, not malicious.

  734. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    import(String(i++));
    import(String(i++));
    
    const getPath = async () => {
    likely benign LLM, confidence 0.90 Dynamic import with a side-effecting specifier in a compiler evaluation-order test.
    Reasoning

    Same compiler evaluation-order test fixture; the non-literal import is deliberate.

  735. file mixes tab and space indentation (3 tab-indented and 28 space-indented lines) (raw pass, confidence 0.40)

    const getPath = async () => {
    	/* in reality this would do some async FS operation, or a web request */
    	return "/root/my/cool/path";
    };
  736. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const someFunction = async () => {
    	const result = await import(await getPath());
    };
    likely benign LLM, confidence 0.90 Dynamic import of an awaited computed path in a compiler test.
    Reasoning

    Awaiting a computed path before import is an ordinary test pattern for async specifier evaluation.

  737. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    let i = 0;⟨U+000D⟩
    Promise.resolve(`${String(i++)}`).then(s => __importStar(require(s)));⟨U+000D⟩
    Promise.resolve(`${String(i++)}`).then(s => __importStar(require(s)));⟨U+000D⟩
    const getPath = async () => {
    likely benign LLM, confidence 0.90 Non-literal require inside a compiler-emitted dynamic import test.
    Reasoning

    Compiler-emitted __importStar(require(s)) within a test fixture; the non-literal require is part of the test's purpose.

  738. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    Promise.resolve(`${String(i++)}`).then(s => __importStar(require(s)));⟨U+000D⟩
    Promise.resolve(`${String(i++)}`).then(s => __importStar(require(s)));⟨U+000D⟩
    const getPath = async () => {⟨U+000D⟩
        /* in reality this would do some async FS operation, or a web request */
    likely benign LLM, confidence 0.90 Non-literal require inside a compiler-emitted dynamic import test.
    Reasoning

    Same compiler-emitted require pattern in a test baseline.

  739. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    const someFunction = async () => {⟨U+000D⟩
        const result = await Promise.resolve(`${await getPath()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    };
    likely benign LLM, confidence 0.90 Non-literal require of an awaited path in a compiler test.
    Reasoning

    Compiler test baseline with the same benign require-of-computed-path pattern.

  740. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const path = './foo';
    import(path,);⟨U+000D⟩
    ⟨U+000D⟩
    //// [dynamicImportTrailingComma.js]
    likely benign LLM, confidence 0.90 Dynamic import with a trailing comma in a compiler test.
    Reasoning

    Test fixture checking trailing commas in import(); the variable specifier is intentional and harmless.

  741. `require` called with a non-literal specifier (ast pass, confidence 0.60)

    const path = './foo';⟨U+000D⟩
    Promise.resolve(`${path}`).then(s => __importStar(require(s)));
    likely benign LLM, confidence 0.90 Non-literal require in a compiler-emitted trailing comma test.
    Reasoning

    Compiler-emitted require of a template-derived path in a test baseline; benign.

  742. info warn → info by review dynamic-import tsc/testdata/baselines/reference/compiler/dynamicRequire.js:5:13

    `require` called with a non-literal specifier (ast pass, confidence 0.80)

    function foo(name) {
        var s = require("t/" + name)
    }
    likely benign LLM, confidence 0.85 Require with a concatenated variable path in a compiler test fixture.
    Reasoning

    Concatenated require path with a variable suffix is a generic dynamic-require pattern; in a compiler test it is benign, though the same shape could be a path traversal sink in real code.

  743. info warn → info by review dynamic-import tsc/testdata/baselines/reference/compiler/dynamicRequire.js:12:13

    `require` called with a non-literal specifier (ast pass, confidence 0.80)

    function foo(name) {⟨U+000D⟩
        var s = require("t/" + name);⟨U+000D⟩
    }
    likely benign LLM, confidence 0.85 Test fixture calling require with a path concatenated from a parameter.
    Reasoning

    A require with a concatenated path built from a function parameter is a common, legitimate dynamic module loading pattern; in a TypeScript compiler test baseline it is a fixture exercising dynamic require emit, not an attack.

  744. info warn → info by review unicode-zero-width tsc/testdata/baselines/reference/compiler/emitBOM.js:8:1

    U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (raw pass, confidence 0.75)

    //// [emitBOM.js]⟨U+000D⟩
    ⟨U+FEFF⟩"use strict";⟨U+000D⟩
    // JS and d.ts output should have a BOM but not the sourcemap⟨U+000D⟩
    var x;
    likely benign LLM, confidence 0.95 Intentional UTF-8 byte order mark in a compiler emit baseline.
    Reasoning

    The BOM is intentional, as the fixture's own comment says JS output should have a BOM. It is a test baseline for BOM emission, not hidden content.

  745. info warn → info by review unicode-zero-width tsc/testdata/baselines/reference/compiler/emitBOM.js:14:1

    U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (raw pass, confidence 0.75)

    //// [emitBOM.d.ts]⟨U+000D⟩
    ⟨U+FEFF⟩declare var x: any;
    likely benign LLM, confidence 0.95 Intentional BOM in a declaration emit baseline.
    Reasoning

    Same intentional BOM test fixture for the .d.ts emit output; no malicious use.

  746. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    function test(param) {
    	// Comment inside function
    	return param.length;
    	/** @typedef {number} B2 */
  747. 22 of 46 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  748. 92 of 138 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  749. 92 of 138 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  750. 39 of 71 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  751. 24 of 49 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  752. file mixes tab and space indentation (9 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    enum E {
    	A = 1,
    	B,
    	C
  753. 48 of 93 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  754. file mixes tab and space indentation (12 tab-indented and 24 space-indented lines) (raw pass, confidence 0.40)

    export enum MouseButton {
    	LEFT_BUTTON = 1,
    	RIGHT_BUTTON = 2,
    	MIDDLE_BUTTON = 4,
  755. file mixes tab and space indentation (1 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    {
    	private readonly items: T[] = [];
    }
  756. 4105 of 9235 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  757. 31 of 77 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  758. mean non-conventional identifier length 1.98 over 61 names (token pass, confidence 0.50)

  759. 93 of 153 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  760. mean non-conventional identifier length 1.38 over 32 names (token pass, confidence 0.50)

  761. 19 of 37 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  762. 36 of 69 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  763. 24 of 58 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  764. 24 of 58 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  765. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    export default function () {
    	return "test";
    }
  766. 44 of 106 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  767. file mixes tab and space indentation (6 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	constructor(str1:string, str2:string) {}
    }
    class B extends A {
  768. file mixes tab and space indentation (18 tab-indented and 23 space-indented lines) (raw pass, confidence 0.40)

    class Bar {
        public goo: number;
        public prop1(x) {
            return x;
  769. file mixes tab and space indentation (10 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    namespace M {	
    	class Visibility {
    	    public foo() { };
    	    private bar() { };
  770. file mixes tab and space indentation (3 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    class C1T5 {
        foo: (i: number, s: string) => number = 
    	   	(i) => {
    	        return i;
  771. 24 of 42 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  772. 22 of 47 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  773. 30 of 69 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  774. file mixes tab and space indentation (1 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    declare namespace http {
    	export interface Server { openPort: number; }
    }
  775. 13 of 31 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  776. 28 of 57 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  777. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    enum E {
    	A,
    	B,
    	C,
  778. 20 of 42 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  779. base64-like blob (72 bytes, compression ratio 1.04) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/exportDeclarationWithModuleSpecifierNameOnNextLine1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [t1.ts]
  780. file mixes tab and space indentation (1 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    //// [exportDeclareClass1.ts]⟨U+000D⟩
        export declare class eaC {
            static tF() { };
            static tsF(param:any) { };
  781. 17 of 39 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  782. 44 of 89 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  783. file mixes tab and space indentation (3 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    export interface ProgressCallback {
    	(progress:any):any;
    }	
  784. mean non-conventional identifier length 1.15 over 522 names (token pass, confidence 0.50)

  785. 35 of 72 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  786. file mixes tab and space indentation (1 tab-indented and 23 space-indented lines) (raw pass, confidence 0.40)

    namespace M {
        export class B {
    	    public x=10;
        }
  787. 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  788. 21 of 46 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  789. 18 of 32 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  790. identifier `_K_𝑚` mixes scripts: Latin + Other (raw pass, confidence 0.80)

    "use strict";⟨U+000D⟩
    var _K_𝑚, _K_𝑀;⟨U+000D⟩
    const 𝑚 = 4;⟨U+000D⟩
    const 𝑀 = 5;
    likely benign LLM, confidence 0.90 Identifier using a Unicode mathematical letter, deliberately tested by the compiler suite.
    Reasoning

    The file is a TypeScript test specifically exercising extended Unicode identifiers (mathematical letters); mixed-script identifiers are the intended subject of the test.

  791. identifier `_K_𝑀` mixes scripts: Latin + Other (raw pass, confidence 0.80)

    "use strict";⟨U+000D⟩
    var _K_𝑚, _K_𝑀;⟨U+000D⟩
    const 𝑚 = 4;⟨U+000D⟩
    const 𝑀 = 5;
    likely benign LLM, confidence 0.90 Second identifier using a Unicode mathematical letter in the test fixture.
    Reasoning

    Same deliberate extended-Unicode identifier test fixture; the mixed scripts are the point of the test.

  792. identifier `_K_𝑚` mixes scripts: Latin + Other (raw pass, confidence 0.80)

        constructor() {⟨U+000D⟩
            _K_𝑚.set(this, 4);⟨U+000D⟩
            _K_𝑀.set(this, 5);⟨U+000D⟩
        }
    likely benign LLM, confidence 0.90 Usage of the Unicode-identifier WeakMap in emitted private-field code.
    Reasoning

    Consistent with the rest of the compiler test; the identifiers are used as WeakMap private-field stand-ins in emitted output.

  793. identifier `_K_𝑀` mixes scripts: Latin + Other (raw pass, confidence 0.80)

            _K_𝑚.set(this, 4);⟨U+000D⟩
            _K_𝑀.set(this, 5);⟨U+000D⟩
        }⟨U+000D⟩
    }
    likely benign LLM, confidence 0.90 Second WeakMap identifier usage in the Unicode test fixture.
    Reasoning

    Same deliberate test of extended Unicode identifiers in emitted helper code.

  794. identifier `_K_𝑚` mixes scripts: Latin + Other (raw pass, confidence 0.80)

    }⟨U+000D⟩
    _K_𝑚 = new WeakMap(), _K_𝑀 = new WeakMap();⟨U+000D⟩
    // lower 8 bits look like 'a'⟨U+000D⟩
    const ၡ = 6;
    likely benign LLM, confidence 0.90 Test assignment using a mixed-script identifier with a documented purpose.
    Reasoning

    The comment explicitly describes the homoglyph-like identifier as a test case; it is a compiler test fixture, not a supply-chain payload.

  795. identifier `_K_𝑀` mixes scripts: Latin + Other (raw pass, confidence 0.80)

    }⟨U+000D⟩
    _K_𝑚 = new WeakMap(), _K_𝑀 = new WeakMap();⟨U+000D⟩
    // lower 8 bits look like 'a'⟨U+000D⟩
    const ၡ = 6;
    likely benign LLM, confidence 0.90 Second identifier in the documented Unicode test assignment.
    Reasoning

    Same test fixture; the comment indicates the identifier is intentionally chosen to test Unicode handling.

  796. 20 of 44 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  797. file mixes tab and space indentation (23 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    declare module {
        export class XDate {
    		public getDay():number;
    		public getXDate():number;
  798. 27 of 42 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  799. file mixes tab and space indentation (1 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    function foo(x:any) {
    	return x();
    }
  800. mean non-conventional identifier length 1.60 over 40 names (token pass, confidence 0.50)

  801. 38 of 76 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  802. 25 of 39 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  803. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    namespace Foo {
    	for (var i = 0; i < 1; i++) {
    		i+i;
    	}
  804. file mixes tab and space indentation (4 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    function foo(x: A) {
       var x: B = new B();
         x.bar(); // the property bar does not exist on a value of type A
    }
  805. 33 of 50 non-conventional identifiers are single-character (66%) (token pass, confidence 0.50)

  806. base64-like blob (72 bytes, compression ratio 1.03) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/functionDeclarationWithResolutionOfTypeOfSameName01.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [functionDeclarationWithResolutionOfTypeOfSameName01.ts]
  807. base64-like blob (71 bytes, compression ratio 1.06) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/functionExpressionWithResolutionOfTypeOfSameName01.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [functionExpressionWithResolutionOfTypeOfSameName01.ts]
  808. base64-like blob (71 bytes, compression ratio 1.06) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/functionExpressionWithResolutionOfTypeOfSameName02.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [functionExpressionWithResolutionOfTypeOfSameName02.ts]
  809. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function clone():number {
    	throw new Error("To be implemented");
    }
  810. 23 of 46 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  811. 19 of 31 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  812. 15 of 35 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  813. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    interface String{
    	length: number;
    }
    */
  814. 51 of 107 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  815. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    class C<T> {
    	public x: T;
    }
  816. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    class C<T> {
    	public x: T;
    }
  817. file mixes tab and space indentation (4 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    interface Foo<T> {
    	a: T;
    }
  818. 34 of 76 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  819. 25 of 47 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  820. 30 of 54 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  821. 1629 of 3122 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  822. 18 of 32 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  823. 28 of 43 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  824. 33 of 51 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  825. 13 of 32 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  826. 18 of 39 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  827. 34 of 63 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  828. 39 of 86 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  829. 21 of 37 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  830. 18 of 38 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  831. 58 of 125 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  832. 17 of 30 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  833. 33 of 73 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  834. 38 of 81 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  835. 44 of 72 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  836. 1 line of text indented with invisible whitespace (U+3000), first at line 13 (raw pass, confidence 0.40)

          }⟨U+000D⟩
        ⟨U+3000⟩⟨U+000D⟩
          export class PullSymbol {⟨U+000D⟩
            constructor (name: string, declKind: DeclKind) {
  837. invisible whitespace U+3000 in indentation (raw pass, confidence 0.80)

      }
    ⟨U+3000⟩
      export class PullSymbol {
        constructor (name: string, declKind: DeclKind) {
    likely benign LLM, confidence 0.85 Ideographic space used as indentation in a test baseline.
    Reasoning

    An ideographic space in indentation is a stray whitespace artifact in a compiler error-baseline fixture; it is harmless and has no executable effect beyond formatting.

  838. 37 of 72 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  839. 32 of 56 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  840. 45 of 95 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  841. 18 of 34 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  842. file mixes tab and space indentation (2 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    interface I {
    	f: (a: { a: number }) => void
    }
    class X<T extends { a: string }> implements I {
  843. 30 of 65 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  844. 31 of 73 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  845. 50 of 93 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  846. 32 of 78 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  847. 52 of 103 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  848. 32 of 54 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  849. 28 of 50 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  850. mean non-conventional identifier length 1.44 over 82 names (token pass, confidence 0.50)

  851. line length 501 characters (raw pass, confidence 0.50)

    function Foo(x1, y1, z1, a1, b1, c1, x2, y2, z2, a2, b2, c2, x3, y3, z3, a3, b3, c3, x4, y4, z4, a4, b4, c4, x5, y5, z5, a5, b5, c5, x6, y6, z6, a6, b6, c6, x7, y7, z7, a7, b7, c7, x8, y8, z8, a8, b8, c8, x9, y9, z9, a9, b9, c9, x10, y12, z10, a10, b10, c10, x11, y13, z11, a11, b11, c11, x12, y14, z12, a12, b12, c12, x
  852. 56 of 90 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  853. 46 of 104 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  854. 22 of 49 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  855. 20 of 49 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  856. file mixes tab and space indentation (2 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    class C99 {
    	private get Baz():number { return 0; }
    	public set Baz(n:number) {} // error - accessors do not agree in visibility
    }
  857. 38 of 54 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)

  858. 21 of 41 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  859. 27 of 49 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  860. 27 of 55 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  861. 79 of 115 non-conventional identifiers are single-character (69%) (token pass, confidence 0.50)

  862. 16 of 32 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  863. mean non-conventional identifier length 1.96 over 79 names (token pass, confidence 0.50)

  864. 34 of 56 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  865. 19 of 44 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  866. file mixes tab and space indentation (15 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    interface I {
        ({descendants, read}?: {
            descendants?: boolean;
            read?: any;
  867. 28 of 46 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  868. 24 of 48 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  869. file mixes tab and space indentation (14 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    interface Red {
    	[n:number]; // ok
    	[s:string]; // ok
    }
  870. 42 of 76 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  871. 22 of 36 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  872. 36 of 78 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  873. mean non-conventional identifier length 1.78 over 41 names (token pass, confidence 0.50)

  874. 33 of 62 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  875. 59 of 133 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  876. file mixes tab and space indentation (16 tab-indented and 118 space-indented lines) (raw pass, confidence 0.40)

    function truePromise(): Promise<true> {
        return Promise.resolve(true);
    }
  877. 28 of 56 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  878. file mixes tab and space indentation (2 tab-indented and 199 space-indented lines) (raw pass, confidence 0.40)

    const evenSquaresInline: number[] =  // should error
        [1, 2, 3, 4]
            .map(x => x % 2 === 0 ? x * x : null)
            .filter(x => !!x); // tests truthiness, not non-nullishness
  879. 95 of 199 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  880. 18 of 38 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  881. file mixes tab and space indentation (7 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    export type inferPipe<t, pipe> =
        pipe extends (In: t) => unknown ? (In: t) => ReturnType<pipe> : never
    
    interface Type<t> {
  882. 19 of 30 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  883. 16 of 39 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  884. 25 of 39 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  885. file mixes tab and space indentation (3 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    interface A {
      (key:string):void;
    }
  886. 20 of 33 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  887. 37 of 76 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  888. base64-like blob (288 bytes, compression ratio 0.74) (in comment) (raw pass, confidence 0.36)

    //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwMi5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHVCQUF1QjtBQUV2QixJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDVixPQUFPLENBQUMsR0FBRyxDQUFDLENBQU
  889. base64-like blob (288 bytes, compression ratio 0.74) (raw pass, confidence 0.60)

    mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwMi5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHVCQUF1QjtBQUV2QixJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDVixPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUF
    likely benign LLM, confidence 0.90 Base64-encoded inline source map in a test baseline.
    Reasoning

    This is a standard inline source map data URL in a sourcemap test baseline; the decoded content is ordinary JSON mappings.

  890. base64-like blob (288 bytes, compression ratio 0.74) (raw pass, confidence 0.60)

    //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwMi5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHVCQUF1QjtBQUV2QixJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDVixPQUFPLENBQUMsR0FBRyxDQUFDLENBQU
    likely benign LLM, confidence 0.90 Base64 inline sourcemap reference in a test baseline.
    Reasoning

    Same standard inline source map sourceMappingURL comment in the test baseline.

  891. 49 of 105 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  892. 20 of 43 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  893. file mixes tab and space indentation (2 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

     
    	function inner(n) {
                    // this line should raise an error
                    // otherwise, there's a bug in overload resolution / partial typechecking
  894. file mixes tab and space indentation (44 tab-indented and 38 space-indented lines) (raw pass, confidence 0.40)

    interface Base {
    	foo: string|number;
    	optional?: number;
    }
  895. 25 of 32 non-conventional identifiers are single-character (78%) (token pass, confidence 0.50)

  896. file mixes tab and space indentation (21 tab-indented and 67 space-indented lines) (raw pass, confidence 0.40)

    export interface A<a> {
        value: a;
    }
  897. 68 of 112 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  898. 22 of 50 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  899. 22 of 50 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  900. file mixes tab and space indentation (3 tab-indented and 16 space-indented lines) (raw pass, confidence 0.40)

    interface I1 {
        item:number;
        item:number;
    }
  901. file mixes tab and space indentation (2 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    namespace Foo {
        export interface I1 { item: string; }
        export class C1 { }
    }
  902. 31 of 71 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  903. file mixes tab and space indentation (2 tab-indented and 19 space-indented lines) (raw pass, confidence 0.40)

    interface I1 {
        iObj:{ };
        iNum:number;
        iAny:any;
  904. file mixes tab and space indentation (2 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    interface I1 {
        i1P1: number;
        i1P2(): void;
    }
  905. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    export class MergedClass extends SomeBaseClass<any> {
    	public constructor() {
    		super();
    	}
  906. 32 of 54 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  907. 30 of 72 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  908. 45 of 72 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  909. 51 of 93 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  910. 49 of 90 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  911. 49 of 86 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  912. 41 of 81 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  913. 40 of 76 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  914. 18 of 34 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  915. 20 of 50 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  916. 20 of 48 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  917. 15 of 36 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  918. 23 of 47 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  919. 25 of 61 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  920. 19 of 47 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  921. 20 of 43 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  922. 28 of 67 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  923. 26 of 56 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  924. 35 of 52 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  925. 20 of 37 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  926. 19 of 33 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  927. file mixes tab and space indentation (9 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    function f1(node: A | B) {
      if (node instanceof A || node instanceof A) {
        node;  // A
      }
  928. file mixes tab and space indentation (7 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    interface IDef {
    	p1: (e:string) => void;
    	p2: () => (n: number) => any;
    }
  929. compression ratio 0.822 is >2σ above file mean 0.566 (raw pass, confidence 0.50)

    a.ts(108,7): error TS2322: Type '({ a: number; } & { b?: string | undefined; c?: IteratorZipValue<Iterable<boolean> | undefined, "c", never, {}> | undefined; })[]' is not assignable to type '{ a: number; c: boolean; }[]'.
  930. compression ratio 0.822 is >2σ above file mean 0.566 (raw pass, confidence 0.50)

              ~~~⟨U+000D⟩
    !!! error TS2322: Type '({ a: number; } & { b?: string | undefined; c?: IteratorZipValue<Iterable<boolean> | undefined, "c", never, {}> | undefined; })[]' is not assignable to type '{ a: number; c: boolean; }[]'.
  931. line length 1027 characters (raw pass, confidence 0.50)

        }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN"
  932. line length 1119 characters (raw pass, confidence 0.50)

        }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) & object ? U : never : never : never) | (Partial<TPadding> extends infer T_2 ? T_2 extends Partial<TPadding> ? T_2 extends unknown ? T_2[(K extends n
  933. line length 1177 characters (raw pass, confidence 0.50)

        }): IteratorObject<T extends Partial<Record<keyof T, undefined>> ? keyof T extends never ? Record<PropertyKey, unknown> : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) & object ? U 
  934. line length 1027 characters (raw pass, confidence 0.50)

        }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN"
  935. line length 1119 characters (raw pass, confidence 0.50)

        }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) & object ? U : never : never : never) | (Partial<TPadding> extends infer T_2 ? T_2 extends Partial<TPadding> ? T_2 extends unknown ? T_2[(K extends n
  936. line length 1163 characters (raw pass, confidence 0.50)

        }): IteratorObject<T extends Partial<Record<keyof T, undefined>> ? keyof T extends never ? Record<PropertyKey, unknown> : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) & object ? U 
  937. file mixes tab and space indentation (2 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    const SomeConstructor = function () {
    	this.x = 1;
    };
  938. file mixes tab and space indentation (2 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    const SomeConstructor = function Named() {
    	this.x = 1;
    };
  939. base64-like blob (124 bytes, compression ratio 1.00) (in comment) (raw pass, confidence 0.36)

    }⟨U+000D⟩
    //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZXMiOlsiYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsTUFBTSxDQUFDO0NBQ04ifQ==
  940. file mixes tab and space indentation (10 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    function Color(obj) {
        this.example = true
    };
    Color.prototype = {
  941. file mixes tab and space indentation (9 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  942. file mixes tab and space indentation (9 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  943. file mixes tab and space indentation (9 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  944. file mixes tab and space indentation (9 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  945. file mixes tab and space indentation (9 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  946. file mixes tab and space indentation (9 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  947. 44 of 88 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  948. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    declare module "Test" {
    	export default class Text { }
    }
  949. file mixes tab and space indentation (6 tab-indented and 52 space-indented lines) (raw pass, confidence 0.40)

    type Defaultize<Props, Defaults> =
    	// Distribute over unions
    	Props extends any // Make any properties included in Default optional
    		? Partial<Pick<Props, Extract<keyof Props, keyof Defaults>>> &
  950. file mixes tab and space indentation (6 tab-indented and 52 space-indented lines) (raw pass, confidence 0.40)

    type Defaultize<Props, Defaults> =
    	// Distribute over unions
    	Props extends any // Make any properties included in Default optional
    		? Partial<Pick<Props, Extract<keyof Props, keyof Defaults>>> &
  951. file mixes tab and space indentation (6 tab-indented and 50 space-indented lines) (raw pass, confidence 0.40)

    type Defaultize<Props, Defaults> =
    	// Distribute over unions
    	Props extends any // Make any properties included in Default optional
    		? Partial<Pick<Props, Extract<keyof Props, keyof Defaults>>> &
  952. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

    // corrupted to U+FFFD. "\uD800" is a lone high surrogate; "\uDC00" a lone low.⟨U+000D⟩
    const text = React.createElement("div", null, "\uD800a\uDC00");⟨U+000D⟩
    const attr = React.createElement("div", { title: "\uD800" });⟨U+000D⟩
    // A non-BMP code point reference is a single supplementary character.
  953. orphaned low surrogate \uDC00 (no preceding high surrogate) (token pass, confidence 0.65)

    // corrupted to U+FFFD. "\uD800" is a lone high surrogate; "\uDC00" a lone low.⟨U+000D⟩
    const text = React.createElement("div", null, "\uD800a\uDC00");⟨U+000D⟩
    const attr = React.createElement("div", { title: "\uD800" });⟨U+000D⟩
    // A non-BMP code point reference is a single supplementary character.
  954. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

    const text = React.createElement("div", null, "\uD800a\uDC00");⟨U+000D⟩
    const attr = React.createElement("div", { title: "\uD800" });⟨U+000D⟩
    // A non-BMP code point reference is a single supplementary character.⟨U+000D⟩
    const supplementary = React.createElement("div", null, "\uD83D\uDE00");
  955. surrogate pair \uD83D\uDE00 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    // A non-BMP code point reference is a single supplementary character.⟨U+000D⟩
    const supplementary = React.createElement("div", null, "\uD83D\uDE00");
  956. surrogate pair \uD83D\uDEA8 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

        // Test multiple unicode characters⟨U+000D⟩
        return (_jsx("div", { children: "\u26A0 \u26D4 \uD83D\uDEA8" }));⟨U+000D⟩
    };
  957. 26 of 53 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  958. file mixes tab and space indentation (13 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)

    
    	 private _listeners: any[] = [];
    
    	 constructor () {
  959. 134 of 325 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  960. file mixes tab and space indentation (4 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    {
    	for (let let of [1,2,3]) {}
    
    	for (const let of [1,2,3]) {}
  961. file mixes tab and space indentation (4 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    {
    	for (let let of [1,2,3]) {}
    
    	for (const let of [1,2,3]) {}
  962. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    	for (var let in [1,2,3]) {}
    }
  963. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    	for (var let in [1,2,3]) {}
    }
  964. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    	for (var let of [1,2,3]) {}
    }
  965. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    	for (var let of [1,2,3]) {}
    }
  966. 30 of 62 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  967. file mixes tab and space indentation (3 tab-indented and 60 space-indented lines) (raw pass, confidence 0.40)

    
        export class Buffer {
        	lines: List<Line> = ListMakeHead<Line>();
            
  968. line length 817 characters (raw pass, confidence 0.50)

    !!! error TS2339: Property 'p38' does not exist on type 'merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<{ p1: number; }, { p2: number; }>, { p3: number; }>, { p4: number; }>, { p5: number
  969. line length 817 characters (raw pass, confidence 0.50)

    !!! error TS2339: Property 'p51' does not exist on type 'merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<{ p1: number; }, { p2: number; }>, { p3: number; }>, { p4: number; }>, { p5: number
  970. line length 787 characters (raw pass, confidence 0.50)

    !!! error TS2339: Property 'p38' does not exist on type 'merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<{ p1: 1; }, { p2: number; }>, { p3: number; }>, { p4: number; }>, { p5: number; }>, { p6:
  971. line length 787 characters (raw pass, confidence 0.50)

    !!! error TS2339: Property 'p50' does not exist on type 'merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<{ p1: 1; }, { p2: number; }>, { p3: number; }>, { p4: number; }>, { p5: number; }>, { p6:
  972. line length 1375 characters (raw pass, confidence 0.50)

    !!! error TS2339: Property 'p38' does not exist on type 'Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<{ p1: number; } & { p2: number; }, "p2"> & { p2: number; p3: number; }, "p3"> & { p3: number; p4: number; }, "p4"> & {
  973. line length 1375 characters (raw pass, confidence 0.50)

    !!! error TS2339: Property 'p51' does not exist on type 'Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<{ p1: number; } & { p2: number; }, "p2"> & { p2: number; p3: number; }, "p3"> & { p3: number; p4: number; }, "p4"> & {
  974. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    interface ISomething {
       something: number;
    }
  975. 25 of 53 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  976. 19 of 47 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  977. 37 of 90 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  978. 56 of 123 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  979. base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/mappedTypeWithAsClauseAndLateBoundProperty2.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [mappedTypeWithAsClauseAndLateBoundProperty2.ts]
  980. 20 of 50 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  981. 51 of 77 non-conventional identifiers are single-character (66%) (token pass, confidence 0.50)

  982. mean non-conventional identifier length 1.88 over 25 names (token pass, confidence 0.50)

  983. mean non-conventional identifier length 1.79 over 28 names (token pass, confidence 0.50)

  984. 31 of 61 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  985. 38 of 74 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  986. 32 of 71 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  987. file mixes tab and space indentation (14 tab-indented and 66 space-indented lines) (raw pass, confidence 0.40)

    class A {
        public pb: number = 2;
        protected ptd: number = 1;
        private pvt: number = 0;
  988. file mixes tab and space indentation (4 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    let data = {
    	public foo: 'hey',
    	private bar: 'nay',
    	protected baz: 'oh my',
  989. 36 of 54 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  990. 39 of 58 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  991. 26 of 40 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  992. 47 of 70 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  993. 18 of 32 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  994. file mixes tab and space indentation (4 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    export class C1 {
    	public p1 = 0;
    	public p2() {}
    }
  995. file mixes tab and space indentation (10 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    export interface Bar {
    	_brand1: any;
    }
  996. file mixes tab and space indentation (3 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    export namespace TypeScript.Strasse.Street {
    	export class Rue {
    		public address:string;
    	}	
  997. 40 of 86 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  998. file mixes tab and space indentation (8 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    namespace A.B.C {
    	import XYZ = X.Y.Z;
    	export function ping(x: number) {
    		if (x>0) XYZ.pong (x-1);
  999. 16 of 38 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1000. file mixes tab and space indentation (3 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    namespace mod1 {
    	interface mInt {
    		new (bar:any):any;
            foo (bar:any):any;
  1001. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    namespace Foo {
    	1+1;
    }
  1002. file mixes tab and space indentation (2 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    export enum Animals {
    	Cat,
    	Dog
    };
  1003. 34 of 66 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1004. 38 of 68 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1005. 38 of 75 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1006. 35 of 68 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1007. 35 of 71 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1008. 29 of 58 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1009. 26 of 50 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1010. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    namespace B {
    	export function f(): A.I { return null; }
    }
  1011. file mixes tab and space indentation (33 tab-indented and 42 space-indented lines) (raw pass, confidence 0.40)

    namespace OuterMod {
    	export function someExportedOuterFunc() { return -1; }
    
    	export namespace OuterInnerMod {
  1012. file mixes tab and space indentation (33 tab-indented and 42 space-indented lines) (raw pass, confidence 0.40)

    namespace OuterMod {
    	export function someExportedOuterFunc() { return -1; }
    
    	export namespace OuterInnerMod {
  1013. 20 of 50 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1014. 18 of 41 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1015. 23 of 46 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1016. 17 of 31 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1017. 29 of 43 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  1018. 48 of 119 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1019. 14 of 32 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1020. file mixes tab and space indentation (14 tab-indented and 279 space-indented lines) (raw pass, confidence 0.40)

    function fx1(x: string | number | undefined) {
        if (isFalsy(x)) {
            x;  // "" | 0 | undefined
        }
  1021. 26 of 34 non-conventional identifiers are single-character (76%) (token pass, confidence 0.50)

  1022. mean non-conventional identifier length 1.76 over 37 names (token pass, confidence 0.50)

  1023. file mixes tab and space indentation (9 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    namespace M {
    	class Foo {}
    	class Gar {
    		public fa: Foo[];
  1024. 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1025. 52 of 83 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  1026. 18 of 40 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1027. 20 of 45 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1028. file mixes tab and space indentation (2 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    function foo(...rest: number) { // error
    	var x: string = rest[0];
    	return x;
    }
  1029. 30 of 60 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1030. file mixes tab and space indentation (2 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    interface Obj<T> {
    	ref: T;
    }
    interface Func<T> {
  1031. 29 of 65 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1032. 40 of 89 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1033. 36 of 48 non-conventional identifiers are single-character (75%) (token pass, confidence 0.50)

  1034. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function process( x: {a:number; b:string;}) {
    	return x.a;
    }
  1035. 20 of 40 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1036. 26 of 48 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  1037. line length 722 characters (raw pass, confidence 0.50)

    let _e = {}, { prop = Object.assign({}, obj) } = _e, _f = _e.more, more = _f === void 0 ? (_a = Object.assign({}, obj), obj = __rest(_a, []), _a) : _f, _g = '' + 'other', _h = _e[_g], other = _h === void 0 ? Object.assign({}, obj) : _h, _j = _e.yetAnother, _k = _j === void 0 ? Object.assign({}, obj) : _j, _l = _k.neste
  1038. 32 of 52 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  1039. 25 of 44 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1040. 21 of 34 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  1041. 15 of 33 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1042. 161 of 258 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  1043. 33 of 72 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1044. 22 of 49 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1045. 75 of 132 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1046. 20 of 46 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1047. file mixes tab and space indentation (3 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    class C {
    	m1(), m1();
    	m2(), m2() {}
    	m3() {}, m3();
  1048. 17 of 34 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1049. 20 of 39 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1050. 30 of 69 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1051. file mixes tab and space indentation (3 tab-indented and 16 space-indented lines) (raw pass, confidence 0.40)

    function attr(nameOrMap: any, value?: string): any {
        if (nameOrMap && typeof nameOrMap === "object") {
            // handle map case
            return new Accessor;
  1052. 23 of 34 non-conventional identifiers are single-character (68%) (token pass, confidence 0.50)

  1053. 16 of 36 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1054. file mixes tab and space indentation (6 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    class C1 {
    	constructor(public p1:string); // ERROR
    	constructor(private p2:number); // ERROR
    	constructor(public p3:any) {} // OK
  1055. 58 of 90 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  1056. file mixes tab and space indentation (12 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    function f0<T extends typeof a>(a: T) {
    	a.b;
    }
  1057. 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1058. file mixes tab and space indentation (4 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    try {
    	if (Math.random() > 0.5) {
    		foo = 1234;
    	}
  1059. file mixes tab and space indentation (5 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    function f() {
    	{
    		const x: string = 12;
    		const y: string = 12;
  1060. 28 of 56 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1061. 18 of 36 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1062. 16 of 38 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1063. line length 709 characters (raw pass, confidence 0.50)

    exports.m3 = exports.glo_im2_public = exports.glo_im1_public = exports.glo_im4_private_v4_public = exports.glo_im4_private_v3_public = exports.glo_im4_private_v2_public = exports.glo_im4_private_v1_public = exports.glo_im3_private_v4_public = exports.glo_im3_private_v3_public = exports.glo_im3_private_v2_public = expor
  1064. line length 881 characters (raw pass, confidence 0.50)

    exports.publicUse_im_public_mu_public = exports.publicUse_im_public_mi_public = exports.publicUse_im_public_i_public = exports.publicUse_im_public_v_public = exports.publicUse_im_public_f_public = exports.publicUse_im_public_e_public = exports.publicUse_im_public_c_public = exports.im_public_mi_public = exports.im_publ
  1065. line length 598 characters (raw pass, confidence 0.50)

    exports.publicUse_im_private_mu_public = exports.publicUse_im_private_mi_public = exports.publicUse_im_private_i_public = exports.publicUse_im_private_v_public = exports.publicUse_im_private_f_public = exports.publicUse_im_private_e_public = exports.publicUse_im_private_c_public = exports.publicUse_im_private_mu_privat
  1066. file mixes tab and space indentation (4 tab-indented and 16 space-indented lines) (raw pass, confidence 0.40)

    class Foo {
    	public pubMeth() {this.privMeth();}
    	private privMeth() {}
    	public pubProp = 0;
  1067. file mixes tab and space indentation (5 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    class Foo {
    	private pvar = 0;
    	constructor() {
    	    var n = this.pvar;
  1068. 18 of 43 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1069. 22 of 51 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1070. 32 of 75 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1071. 58 of 112 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1072. line length 619 characters (raw pass, confidence 0.50)

        type KnownIterationMapKeys = '-40' | '-39' | '-38' | '-37' | '-36' | '-35' | '-34' | '-33' | '-32' | '-31' | '-30' | '-29' | '-28' | '-27' | '-26' | '-25' | '-24' | '-23' | '-22' | '-21' | '-20' | '-19' | '-18' | '-17' | '-16' | '-15' | '-14' | '-13' | '-12' | '-11' | '-10' | '-9' | '-8' | '-7' | '-6' | '-5' | '-4'
  1073. file mixes tab and space indentation (5 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    function foo(x: any) {
    	switch(x) {
    		case 1: return;
    		default:
  1074. 28 of 58 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1075. file mixes tab and space indentation (2 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    class X {
    	method(readonly x: number) {}
    	set x(readonly value: number) {}
    }
  1076. 135 of 241 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1077. 31 of 42 non-conventional identifiers are single-character (74%) (token pass, confidence 0.50)

  1078. file mixes tab and space indentation (48 tab-indented and 72 space-indented lines) (raw pass, confidence 0.40)

    
    	export interface IWidget {
    		getDomNode(): any;
    		destroy();
  1079. 22 of 35 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  1080. 25 of 32 non-conventional identifiers are single-character (78%) (token pass, confidence 0.50)

  1081. 21 of 30 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)

  1082. 28 of 38 non-conventional identifiers are single-character (74%) (token pass, confidence 0.50)

  1083. 18 of 33 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1084. file mixes tab and space indentation (13 tab-indented and 17 space-indented lines) (raw pass, confidence 0.40)

    export namespace Foo {
    	export class C {}
    }
  1085. file mixes tab and space indentation (13 tab-indented and 14 space-indented lines) (raw pass, confidence 0.40)

    	
    		if ( top && top.doScroll ) {
    			(function doScrollCheck() {
    				if ( false ) {
  1086. file mixes tab and space indentation (8 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    function R1() {
    	R1();
    	return;
    }
  1087. 23 of 49 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1088. 25 of 62 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1089. file mixes tab and space indentation (2 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    interface Entity<T extends Entity<T>> {
       X: T;
       Y: T;
    }
  1090. 24 of 58 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1091. 36 of 86 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1092. file mixes tab and space indentation (9 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    const regexes: RegExp[] = [
    	/[𝘈-𝘡][𝘡-𝘈]/,
    	/[𝘈-𝘡][𝘡-𝘈]/u,
    	/[𝘈-𝘡][𝘡-𝘈]/v,
  1093. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    const regexes: RegExp[] = [
    	/\u{10000}[\u{10000}]/,
    	/\u{10000}[\u{10000}]/u,
    	/\u{10000}[\u{10000}]/v,
  1094. file mixes tab and space indentation (6 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    const regexes: RegExp[] = [
    	/a{7,8}/,
    	/a{9223372036854775807,9223372036854775808}/,
    	/a{8,7}/,
  1095. 28 of 35 non-conventional identifiers are single-character (80%) (token pass, confidence 0.50)

  1096. file mixes tab and space indentation (46 tab-indented and 46 space-indented lines) (raw pass, confidence 0.40)

    const regexes: RegExp[] = [
    	// Flags
    	/foo/visualstudiocode,
    	// Pattern modifiers
  1097. 28 of 35 non-conventional identifiers are single-character (80%) (token pass, confidence 0.50)

  1098. file mixes tab and space indentation (46 tab-indented and 46 space-indented lines) (raw pass, confidence 0.40)

    const regexes: RegExp[] = [
    	// Flags
    	/foo/visualstudiocode,
    	// Pattern modifiers
  1099. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    const regexes: RegExp[] = [
    	/[?&]/v,
    	/[a&]/v,
    	/[&a]/v,
  1100. 28 of 42 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  1101. file mixes tab and space indentation (7 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    export namespace Models {
    	export class Person {
            constructor(name: string) { }
    	}
  1102. base64-like blob (72 bytes, compression ratio 1.15) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/requireOfJsonFileWithModuleNodeResolutionEmitEs2015.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [file1.ts]
  1103. 55 of 110 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1104. base64-like blob (68 bytes, compression ratio 1.06) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/resolveInterfaceNameWithSameLetDeclarationName1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [resolveInterfaceNameWithSameLetDeclarationName1.ts]
  1105. base64-like blob (68 bytes, compression ratio 1.07) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/resolveInterfaceNameWithSameLetDeclarationName2.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [resolveInterfaceNameWithSameLetDeclarationName2.ts]
  1106. base64-like blob (65 bytes, compression ratio 1.08) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/resolveModuleNameWithSameLetDeclarationName1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [resolveModuleNameWithSameLetDeclarationName1.ts]
  1107. base64-like blob (65 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/resolveModuleNameWithSameLetDeclarationName2.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [resolveModuleNameWithSameLetDeclarationName2.ts]
  1108. base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/resolveTypeAliasWithSameLetDeclarationName1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [resolveTypeAliasWithSameLetDeclarationName1.ts]
  1109. line length 564 characters (raw pass, confidence 0.50)

            solomonis() : panglima.abidi<quasiater.carolinensis, rendalli.crenulata<gabriellae.klossii<julianae.nudicaudus, dogramacii.aurata>, argurus.netscheri<minutus.inez<argurus.peninsulae, julianae.nudicaudus>, julianae.oralis<lavali.xanthognathus, argurus.oreas>>>> { var x : panglima.abidi<quasiater.carolinensis, re
  1110. line length 522 characters (raw pass, confidence 0.50)

            morrisi() : ruatanica.hector<trivirgatus.oconnelli, sagitta.cinereus<nigra.caucasica<julianae.sumatrana, trivirgatus.oconnelli>, quasiater.wattsi<julianae.galapagoensis, panamensis.linulus<lavali.xanthognathus, macrorhinos.konganensis>>>> { var x : ruatanica.hector<trivirgatus.oconnelli, sagitta.cinereus<nigra.
  1111. line length 509 characters (raw pass, confidence 0.50)

                flamarioni(): imperfecta.lasiurus<amphibius<patas.uralensis, gabriellae.klossii<julianae.nudicaudus, dogramacii.aurata>>, sagitta.leptoceros<lutreolus.punicus, daubentonii.arboreus<quasiater.carolinensis, rionegrensis.caniventer>>> { var x: imperfecta.lasiurus<amphibius<patas.uralensis, gabriellae.klossii<j
  1112. line length 524 characters (raw pass, confidence 0.50)

                simulator(): macrorhinos.marmosurus<Lanthanum.nitidus<dammermani.melanops, lavali.lepturus>, macrorhinos.marmosurus<rendalli.moojeni<panglima.amphibius<trivirgatus.falconeri, caurinus.psilurus>, gabriellae.echinatus>, sagitta.stolzmanni>> { var x: macrorhinos.marmosurus<Lanthanum.nitidus<dammermani.melanops
  1113. line length 594 characters (raw pass, confidence 0.50)

                beatrix(): imperfecta.ciliolabrum<provocax.melanoleuca, panglima.amphibius<minutus.inez<rendalli.moojeni<panglima.amphibius<trivirgatus.falconeri, caurinus.psilurus>, gabriellae.echinatus>, dogramacii.aurata>, imperfecta.ciliolabrum<quasiater.carolinensis, lavali.beisa>>> { var x: imperfecta.ciliolabrum<pro
  1114. line length 614 characters (raw pass, confidence 0.50)

                pilirostris(): argurus.wetmorei<imperfecta.lasiurus<panglima.amphibius<patas.uralensis, gabriellae.klossii<julianae.nudicaudus, dogramacii.aurata>>, sagitta.leptoceros<lutreolus.punicus, daubentonii.arboreus<quasiater.carolinensis, rionegrensis.caniventer>>>, macrorhinos.konganensis> { var x: argurus.wetmor
  1115. line length 586 characters (raw pass, confidence 0.50)

                palmeri(): panglima.amphibius<howi.coludo<macrorhinos.daphaenodon, panglima.amphibius<macrorhinos.daphaenodon, patas.uralensis>>, trivirgatus.mixtus<argurus.dauricus<dogramacii.aurata, dammermani.melanops>, panglima.amphibius<lavali.lepturus, quasiater.carolinensis>>> { var x: panglima.amphibius<howi.coludo
  1116. line length 559 characters (raw pass, confidence 0.50)

        solomonis() : panglima.abidi<quasiater.carolinensis, rendalli.crenulata<gabriellae.klossii<julianae.nudicaudus, dogramacii.aurata>, argurus.netscheri<minutus.inez<argurus.peninsulae, julianae.nudicaudus>, julianae.oralis<lavali.xanthognathus, argurus.oreas>>>> { var x : panglima.abidi<quasiater.carolinensis, rendal
  1117. line length 517 characters (raw pass, confidence 0.50)

        morrisi() : ruatanica.hector<trivirgatus.oconnelli, sagitta.cinereus<nigra.caucasica<julianae.sumatrana, trivirgatus.oconnelli>, quasiater.wattsi<julianae.galapagoensis, panamensis.linulus<lavali.xanthognathus, macrorhinos.konganensis>>>> { var x : ruatanica.hector<trivirgatus.oconnelli, sagitta.cinereus<nigra.cauc
  1118. line length 504 characters (raw pass, confidence 0.50)

            flamarioni(): imperfecta.lasiurus<amphibius<patas.uralensis, gabriellae.klossii<julianae.nudicaudus, dogramacii.aurata>>, sagitta.leptoceros<lutreolus.punicus, daubentonii.arboreus<quasiater.carolinensis, rionegrensis.caniventer>>> { var x: imperfecta.lasiurus<amphibius<patas.uralensis, gabriellae.klossii<julia
  1119. line length 519 characters (raw pass, confidence 0.50)

            simulator(): macrorhinos.marmosurus<Lanthanum.nitidus<dammermani.melanops, lavali.lepturus>, macrorhinos.marmosurus<rendalli.moojeni<panglima.amphibius<trivirgatus.falconeri, caurinus.psilurus>, gabriellae.echinatus>, sagitta.stolzmanni>> { var x: macrorhinos.marmosurus<Lanthanum.nitidus<dammermani.melanops, la
  1120. line length 589 characters (raw pass, confidence 0.50)

            beatrix(): imperfecta.ciliolabrum<provocax.melanoleuca, panglima.amphibius<minutus.inez<rendalli.moojeni<panglima.amphibius<trivirgatus.falconeri, caurinus.psilurus>, gabriellae.echinatus>, dogramacii.aurata>, imperfecta.ciliolabrum<quasiater.carolinensis, lavali.beisa>>> { var x: imperfecta.ciliolabrum<provoca
  1121. line length 609 characters (raw pass, confidence 0.50)

            pilirostris(): argurus.wetmorei<imperfecta.lasiurus<panglima.amphibius<patas.uralensis, gabriellae.klossii<julianae.nudicaudus, dogramacii.aurata>>, sagitta.leptoceros<lutreolus.punicus, daubentonii.arboreus<quasiater.carolinensis, rionegrensis.caniventer>>>, macrorhinos.konganensis> { var x: argurus.wetmorei<i
  1122. line length 581 characters (raw pass, confidence 0.50)

            palmeri(): panglima.amphibius<howi.coludo<macrorhinos.daphaenodon, panglima.amphibius<macrorhinos.daphaenodon, patas.uralensis>>, trivirgatus.mixtus<argurus.dauricus<dogramacii.aurata, dammermani.melanops>, panglima.amphibius<lavali.lepturus, quasiater.carolinensis>>> { var x: panglima.amphibius<howi.coludo<mac
  1123. 30 of 69 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1124. 52 of 122 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1125. 24 of 52 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1126. 17 of 30 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1127. 19 of 40 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1128. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    try { } catch(ex1) { 
    	throw ex1;
    }
  1129. file mixes tab and space indentation (5 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    class C {
    	public p1 = 0;
    	public callback(cb:()=>void) {cb();}
    	public doit() {
  1130. file mixes tab and space indentation (8 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    interface MouseEvent {
        x: number;
        y: number;
    }
  1131. file mixes tab and space indentation (3 tab-indented and 23 space-indented lines) (raw pass, confidence 0.40)

    {
        export class Test
        {
          private name = "hello";
  1132. 28 of 50 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1133. file mixes tab and space indentation (49 tab-indented and 49 space-indented lines) (raw pass, confidence 0.40)

    (function() {
    	var s0;
    	for ({ s0 = 5 } of [{ s0: 1 }]) {
    	}
  1134. file mixes tab and space indentation (49 tab-indented and 49 space-indented lines) (raw pass, confidence 0.40)

    (function() {
    	var s0;
    	for ({ s0 = 5 } of [{ s0: 1 }]) {
    	}
  1135. identifier `啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ` mixes scripts: Han + Other (in string/comment) (raw pass, confidence 0.40)

    ⟨U+000D⟩
    //// [①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].ts]⟨U+000D⟩
    var a = 1;
    var b = 2;
  1136. identifier `〇㐀㐁䶴䶵U1` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    ⟨U+000D⟩
    //// [①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].ts]⟨U+000D⟩
    var a = 1;
    var b = 2;
  1137. identifier `啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ` mixes scripts: Han + Other (in string/comment) (raw pass, confidence 0.40)

    ⟨U+000D⟩
    //// [①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].js]⟨U+000D⟩
    "use strict";⟨U+000D⟩
    var a = 1;
  1138. identifier `〇㐀㐁䶴䶵U1` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    ⟨U+000D⟩
    //// [①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].js]⟨U+000D⟩
    "use strict";⟨U+000D⟩
    var a = 1;
  1139. mean non-conventional identifier length 1.91 over 22 names (token pass, confidence 0.50)

  1140. 28 of 52 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  1141. file mixes tab and space indentation (1 tab-indented and 235 space-indented lines) (raw pass, confidence 0.40)

    function outer<T>(x: T) {
      class Inner {
        static y: T = x;
      }
  1142. file mixes tab and space indentation (4 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    class C {
    	static s;
    	public a() {
    		s = 1;
  1143. 56 of 84 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  1144. 21 of 40 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1145. 66 of 162 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1146. file mixes tab and space indentation (4 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    class C {
    	constructor() {
    		static p1 = 0; // ERROR
    		static m1() {} // ERROR
  1147. 14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1148. file mixes tab and space indentation (7 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    interface Lifecycle<Attrs, State> {
    	oninit?(vnode: Vnode<Attrs, State>): number;
    	[_: number]: any;
    }
  1149. file mixes tab and space indentation (10 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    interface Lifecycle<Attrs, State extends Lifecycle<Attrs, State>> {
    	oninit?(vnode: Vnode<Attrs, State>): number;
    	[_: number]: any;
    }
  1150. 22 of 48 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1151. base64-like blob (66 bytes, compression ratio 1.08) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallFromClassThatDerivesFromGenericType1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericType1.ts]
  1152. base64-like blob (66 bytes, compression ratio 1.08) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallFromClassThatDerivesFromGenericType2.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericType2.ts]
  1153. base64-like blob (103 bytes, compression ratio 0.93) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts]
  1154. base64-like blob (82 bytes, compression ratio 1.01) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts]⟨U+000D⟩
    class A<T1, T2> {
        constructor(private map: (value: T1) => T2) {
  1155. base64-like blob (82 bytes, compression ratio 1.01) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js]⟨U+000D⟩
    "use strict";⟨U+000D⟩
    class A {
  1156. base64-like blob (88 bytes, compression ratio 0.98) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts]
  1157. base64-like blob (67 bytes, compression ratio 1.07) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts]⟨U+000D⟩
    class A<T1, T2> {
        constructor(private map: (value: T1) => T2) {
  1158. base64-like blob (67 bytes, compression ratio 1.07) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js]⟨U+000D⟩
    "use strict";⟨U+000D⟩
    class A {
  1159. base64-like blob (85 bytes, compression ratio 0.99) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts]
  1160. base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts]⟨U+000D⟩
    class A {
        constructor(private map: (value: number) => string) {
  1161. base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js]⟨U+000D⟩
    "use strict";⟨U+000D⟩
    class A {
  1162. base64-like blob (65 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallInJSWithWrongBaseTypeArgumentCount1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [a.ts]
  1163. base64-like blob (65 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallInJSWithWrongBaseTypeArgumentCount1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [a.ts]
  1164. base64-like blob (65 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallInJSWithWrongBaseTypeArgumentCount2.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [a.ts]
  1165. base64-like blob (65 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallInJSWithWrongBaseTypeArgumentCount2.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [a.ts]
  1166. 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1167. file mixes tab and space indentation (6 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	constructor(f: string) {
    	}
    	public blah(): string { return ""; }
  1168. 19 of 41 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1169. 14 of 35 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1170. file mixes tab and space indentation (3 tab-indented and 25 space-indented lines) (raw pass, confidence 0.40)

    function R1(index: number) {
        switch (index) {
            case 0:
            case 1:
  1171. file mixes tab and space indentation (1 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    {
      "name": "styled-components",
      "version": "3.3.3",
      "typings": "typings/styled-components.d.ts"
  1172. surrogate pair \uD83D\uDCA9 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    
    f `'\u{1f4a9}'${ " should be converted to " }'\uD83D\uDCA9'`;⟨U+000D⟩
    ⟨U+000D⟩
    //// [taggedTemplateStringsWithUnicodeEscapes.js]
  1173. surrogate pair \uD83D\uDCA9 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    }⟨U+000D⟩
    f `'\u{1f4a9}'${" should be converted to "}'\uD83D\uDCA9'`;
  1174. surrogate pair \uD83D\uDCA9 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    
    f `'\u{1f4a9}'${ " should be converted to " }'\uD83D\uDCA9'`;⟨U+000D⟩
    ⟨U+000D⟩
    //// [taggedTemplateStringsWithUnicodeEscapesES6.js]
  1175. surrogate pair \uD83D\uDCA9 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    }⟨U+000D⟩
    f `'\u{1f4a9}'${" should be converted to "}'\uD83D\uDCA9'`;
  1176. file mixes tab and space indentation (5 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    function suggest(){ 
    	var TypeScriptKeywords:string[];  
    	var result:any;	
    					
  1177. file mixes tab and space indentation (11 tab-indented and 32 space-indented lines) (raw pass, confidence 0.40)

    {
          constructor(x: number, y: number);
          public x: number;
          public y: number;
  1178. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function func2(stuff1:string, stuff2:number, stuff3:number) {
    	return func1([stuff1, stuff2, stuff3]);
    }
  1179. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function func2(stuff1:string, stuff2:number, stuff3:number) {
    	return func1([stuff1, stuff2, stuff3]);
    }
  1180. 27 of 44 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  1181. file mixes tab and space indentation (7 tab-indented and 21 space-indented lines) (raw pass, confidence 0.40)

    namespace M {
        export interface I {
    	z;
        }
  1182. 22 of 55 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1183. 16 of 37 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1184. file mixes tab and space indentation (4 tab-indented and 21 space-indented lines) (raw pass, confidence 0.40)

    interface IPoint {
        x:number;
        y:number;
    }
  1185. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    namespace M {
    	var f = () => {this.window;}
    }
  1186. line length 815 characters (raw pass, confidence 0.50)

    export enum SyntaxKind { Node0, Node1, Node2, Node3, Node4, Node5, Node6, Node7, Node8, Node9, Node10, Node11, Node12, Node13, Node14, Node15, Node16, Node17, Node18, Node19, Node20, Node21, Node22, Node23, Node24, Node25, Node26, Node27, Node28, Node29, Node30, Node31, Node32, Node33, Node34, Node35, Node36, Node37, N
  1187. line length 907 characters (raw pass, confidence 0.50)

    export type Node = Node0 | Node1 | Node2 | Node3 | Node4 | Node5 | Node6 | Node7 | Node8 | Node9 | Node10 | Node11 | Node12 | Node13 | Node14 | Node15 | Node16 | Node17 | Node18 | Node19 | Node20 | Node21 | Node22 | Node23 | Node24 | Node25 | Node26 | Node27 | Node28 | Node29 | Node30 | Node31 | Node32 | Node33 | Node3
  1188. line length 908 characters (raw pass, confidence 0.50)

    export type Node = Node0 | Node1 | Node2 | Node3 | Node4 | Node5 | Node6 | Node7 | Node8 | Node9 | Node10 | Node11 | Node12 | Node13 | Node14 | Node15 | Node16 | Node17 | Node18 | Node19 | Node20 | Node21 | Node22 | Node23 | Node24 | Node25 | Node26 | Node27 | Node28 | Node29 | Node30 | Node31 | Node32 | Node33 | Node3
  1189. 14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1190. 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1191. file mixes tab and space indentation (3 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    interface I1<T, U> {
    	m(value: T): U;
    }
  1192. file mixes tab and space indentation (1 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    namespace JSX {
        export interface IntrinsicElements {
            span: {};
        }
  1193. 52 of 91 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1194. 66 of 118 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1195. 19 of 39 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1196. 32 of 46 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)

  1197. file mixes tab and space indentation (2 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    (foo: Foo) => {
    	bar[id]++;
    	const id = foo.bar;
    }
  1198. 21 of 35 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  1199. 19 of 33 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  1200. 38 of 89 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1201. file mixes tab and space indentation (3 tab-indented and 57 space-indented lines) (raw pass, confidence 0.40)

    function f1() {
    	var a = { x: 1, y: 2 };
    	a = {}; // error
        a = { x: 1 }; // error
  1202. 27 of 53 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1203. 19 of 45 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1204. 22 of 34 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1205. 48 of 71 non-conventional identifiers are single-character (68%) (token pass, confidence 0.50)

  1206. 32 of 49 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1207. 33 of 68 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1208. 34 of 52 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1209. 34 of 70 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1210. 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1211. 13 of 32 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1212. 16 of 33 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1213. 17 of 37 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1214. mean non-conventional identifier length 1.29 over 56 names (token pass, confidence 0.50)

  1215. 22 of 39 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1216. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function p(undefined = "wat") {
    	return undefined;
    }
  1217. file mixes tab and space indentation (3 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    class undefined {
    	foo: string;
    }
    interface undefined {
  1218. 17 of 35 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1219. file mixes tab and space indentation (4 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    namespace M{
    	class A{
    		constructor(val:string){}
    	}
  1220. U+00AD SOFT HYPHEN in source (in string/comment) (raw pass, confidence 0.45)

    //// [unicodeStringLiteral.ts]⟨U+000D⟩
    var ੳ = "Ü⟨U+00AD⟩ਲ⟨U+000E⟩ĭ";⟨U+000D⟩
    ⟨U+000D⟩
    //// [unicodeStringLiteral.js]
  1221. U+00AD SOFT HYPHEN in source (in string/comment) (raw pass, confidence 0.45)

    "use strict";⟨U+000D⟩
    var ੳ = "Ü⟨U+00AD⟩ਲ⟨U+000E⟩ĭ";
  1222. surrogate pair \uD83D\uDE03 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    // low-high surrogate pair - the "correct" case
    export const highLow = "\ud83d\ude03" as const;
    
    // high surrogate
  1223. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // high surrogate
    export const high = "\ud83d" as const;
    
    // low surrogate
  1224. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // low surrogate
    export const low = "\ude03" as const;
    
    // two high surrogates
  1225. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // two high surrogates
    export const highHigh = "\ud83d\ud83d" as const;
    
    // two low surrogates
  1226. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // two high surrogates
    export const highHigh = "\ud83d\ud83d" as const;
    
    // two low surrogates
  1227. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // two low surrogates
    export const lowLow = "\ude03\ude03" as const;
    
    // swapped expected order of surrogates
  1228. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // two low surrogates
    export const lowLow = "\ude03\ude03" as const;
    
    // swapped expected order of surrogates
  1229. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // swapped expected order of surrogates
    export const lowHigh = "\ude03\ud83d" as const;
  1230. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // swapped expected order of surrogates
    export const lowHigh = "\ude03\ud83d" as const;
  1231. surrogate pair \uD83D\uDE03 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    // low-high surrogate pair - the "correct" case⟨U+000D⟩
    export const highLow = "\ud83d\ude03";⟨U+000D⟩
    // high surrogate⟨U+000D⟩
    export const high = "\ud83d";
  1232. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // high surrogate⟨U+000D⟩
    export const high = "\ud83d";⟨U+000D⟩
    // low surrogate⟨U+000D⟩
    export const low = "\ude03";
  1233. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // low surrogate⟨U+000D⟩
    export const low = "\ude03";⟨U+000D⟩
    // two high surrogates⟨U+000D⟩
    export const highHigh = "\ud83d\ud83d";
  1234. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // two high surrogates⟨U+000D⟩
    export const highHigh = "\ud83d\ud83d";⟨U+000D⟩
    // two low surrogates⟨U+000D⟩
    export const lowLow = "\ude03\ude03";
  1235. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // two high surrogates⟨U+000D⟩
    export const highHigh = "\ud83d\ud83d";⟨U+000D⟩
    // two low surrogates⟨U+000D⟩
    export const lowLow = "\ude03\ude03";
  1236. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // two low surrogates⟨U+000D⟩
    export const lowLow = "\ude03\ude03";⟨U+000D⟩
    // swapped expected order of surrogates⟨U+000D⟩
    export const lowHigh = "\ude03\ud83d";
  1237. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // two low surrogates⟨U+000D⟩
    export const lowLow = "\ude03\ude03";⟨U+000D⟩
    // swapped expected order of surrogates⟨U+000D⟩
    export const lowHigh = "\ude03\ud83d";
  1238. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // swapped expected order of surrogates⟨U+000D⟩
    export const lowHigh = "\ude03\ud83d";
  1239. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // swapped expected order of surrogates⟨U+000D⟩
    export const lowHigh = "\ude03\ud83d";
  1240. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    export declare const highLow: "😃";⟨U+000D⟩
    export declare const high: "\uD83D";⟨U+000D⟩
    export declare const low: "\uDE03";⟨U+000D⟩
    export declare const highHigh: "\uD83D\uD83D";
  1241. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    export declare const high: "\uD83D";⟨U+000D⟩
    export declare const low: "\uDE03";⟨U+000D⟩
    export declare const highHigh: "\uD83D\uD83D";⟨U+000D⟩
    export declare const lowLow: "\uDE03\uDE03";
  1242. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    export declare const low: "\uDE03";⟨U+000D⟩
    export declare const highHigh: "\uD83D\uD83D";⟨U+000D⟩
    export declare const lowLow: "\uDE03\uDE03";⟨U+000D⟩
    export declare const lowHigh: "\uDE03\uD83D";
  1243. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    export declare const low: "\uDE03";⟨U+000D⟩
    export declare const highHigh: "\uD83D\uD83D";⟨U+000D⟩
    export declare const lowLow: "\uDE03\uDE03";⟨U+000D⟩
    export declare const lowHigh: "\uDE03\uD83D";
  1244. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    export declare const highHigh: "\uD83D\uD83D";⟨U+000D⟩
    export declare const lowLow: "\uDE03\uDE03";⟨U+000D⟩
    export declare const lowHigh: "\uDE03\uD83D";
  1245. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    export declare const highHigh: "\uD83D\uD83D";⟨U+000D⟩
    export declare const lowLow: "\uDE03\uDE03";⟨U+000D⟩
    export declare const lowHigh: "\uDE03\uD83D";
  1246. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    export declare const lowLow: "\uDE03\uDE03";⟨U+000D⟩
    export declare const lowHigh: "\uDE03\uD83D";
  1247. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    export declare const lowLow: "\uDE03\uDE03";⟨U+000D⟩
    export declare const lowHigh: "\uDE03\uD83D";
  1248. file mixes tab and space indentation (1 tab-indented and 28 space-indented lines) (raw pass, confidence 0.40)

    declare class Test<T> {
        obj: T;
        get<K extends keyof T>(k: K): T[K];
    }
  1249. file mixes tab and space indentation (2 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    interface Interface<T extends Enum> {
    	type: T;
    }
  1250. file mixes tab and space indentation (16 tab-indented and 94 space-indented lines) (raw pass, confidence 0.40)

    function func1() {
        aFunc();
    
        console.log(EnumA.Value);
  1251. file mixes tab and space indentation (16 tab-indented and 102 space-indented lines) (raw pass, confidence 0.40)

    function func1() {
        aFunc();
    
        console.log(EnumA.Value);
  1252. 45 of 62 non-conventional identifiers are single-character (73%) (token pass, confidence 0.50)

  1253. mean non-conventional identifier length 1.96 over 24 names (token pass, confidence 0.50)

  1254. mean non-conventional identifier length 1.96 over 24 names (token pass, confidence 0.50)

  1255. mean non-conventional identifier length 1.96 over 24 names (token pass, confidence 0.50)

  1256. 21 of 49 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1257. 36 of 63 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1258. 50 of 91 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1259. 37 of 87 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1260. file mixes tab and space indentation (6 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    interface Controller<out T> {
    	createAnimal: () => T;
    	run: (animal: T) => void;
    }
  1261. 30 of 46 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1262. file mixes tab and space indentation (5 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": true,
    		"include": ["0.d.ts", "1.d.ts"],
  1263. file mixes tab and space indentation (5 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": true,
    		"include": ["0.d.ts", "1.d.ts"],
  1264. file mixes tab and space indentation (3 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enableAutoDiscovy": true,
    	},
  1265. file mixes tab and space indentation (3 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enableAutoDiscovy": true,
    	},
  1266. file mixes tab and space indentation (3 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enableAutoDiscovy": true,
    	}
  1267. file mixes tab and space indentation (3 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enableAutoDiscovy": true,
    	}
  1268. file mixes tab and space indentation (5 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": false,
    		"include": ["0.d.ts"],
  1269. file mixes tab and space indentation (5 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": false,
    		"include": ["0.d.ts"],
  1270. file mixes tab and space indentation (3 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": false,
    	},
  1271. file mixes tab and space indentation (3 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": false,
    	},
  1272. file mixes tab and space indentation (3 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": true,
    	},
  1273. file mixes tab and space indentation (3 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": true,
    	},
  1274. file mixes tab and space indentation (4 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    {
    			    "compilerOptions": {
    					"types": []
    				}
  1275. file mixes tab and space indentation (4 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    {
    			    "compilerOptions": {
    					"types": []
    				}
  1276. file mixes tab and space indentation (2 tab-indented and 31 space-indented lines) (raw pass, confidence 0.40)

    {
      "compilerOptions": {
        "outDir": "./dist",
        "strict": true,
  1277. file mixes tab and space indentation (2 tab-indented and 31 space-indented lines) (raw pass, confidence 0.40)

    {
      "compilerOptions": {
        "outDir": "./dist",
        "strict": true,
  1278. file mixes tab and space indentation (2 tab-indented and 15 space-indented lines) (raw pass, confidence 0.40)

    {
      "compilerOptions": {
        "outFile": "${configDir}/outFile",
        "outDir": "${configDir}/outDir",
  1279. file mixes tab and space indentation (2 tab-indented and 15 space-indented lines) (raw pass, confidence 0.40)

    {
      "compilerOptions": {
        "outFile": "${configDir}/outFile",
        "outDir": "${configDir}/outDir",
  1280. file mixes tab and space indentation (6 tab-indented and 16 space-indented lines) (raw pass, confidence 0.40)

    {
    				"extends": "./tsconfigWithExtends.json",
    				"compilerOptions": {
    				    "outDir": "./dist",
  1281. file mixes tab and space indentation (6 tab-indented and 16 space-indented lines) (raw pass, confidence 0.40)

    {
    				"extends": "./tsconfigWithExtends.json",
    				"compilerOptions": {
    				    "outDir": "./dist",
  1282. file mixes tab and space indentation (13 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    			    "compilerOptions": {
    				"sourcemap": true,
    				"declarationmap": true,
  1283. file mixes tab and space indentation (13 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    			    "compilerOptions": {
    				"sourcemap": true,
    				"declarationmap": true,
  1284. 56 of 140 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1285. 56 of 140 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1286. mean non-conventional identifier length 1.92 over 26 names (token pass, confidence 0.50)

  1287. mean non-conventional identifier length 1.83 over 24 names (token pass, confidence 0.50)

  1288. 39 of 97 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1289. 71 of 140 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1290. 54 of 114 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1291. 73 of 135 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  1292. 14 of 32 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1293. 109 of 233 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1294. 22 of 52 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1295. 95 of 223 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1296. mean non-conventional identifier length 1.85 over 158 names (token pass, confidence 0.50)

  1297. 106 of 218 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1298. 91 of 175 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1299. mean non-conventional identifier length 1.95 over 1109 names (token pass, confidence 0.50)

  1300. mean non-conventional identifier length 1.95 over 1124 names (token pass, confidence 0.50)

  1301. 2181 of 4122 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  1302. 454 of 912 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1303. 22 of 35 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  1304. 54 of 116 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1305. 65 of 118 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1306. 18 of 36 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1307. 59 of 125 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1308. 91 of 169 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  1309. 43 of 103 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1310. 57 of 127 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1311. mean non-conventional identifier length 1.41 over 39 names (token pass, confidence 0.50)

  1312. 252 of 610 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1313. 164 of 244 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  1314. 135 of 242 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1315. 135 of 242 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1316. 28 of 70 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1317. 32 of 63 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1318. file mixes tab and space indentation (10 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    let o = {
    	async m1() { },
    	async m2(): Promise<void> { },
    	async m3(): MyPromise<void> { }
  1319. file mixes tab and space indentation (10 tab-indented and 44 space-indented lines) (raw pass, confidence 0.40)

    let o = {
    	async m1() { },
    	async m2(): Promise<void> { },
    	async m3(): MyPromise<void> { }
  1320. file mixes tab and space indentation (10 tab-indented and 44 space-indented lines) (raw pass, confidence 0.40)

    let o = {
    	async m1() { },
    	async m2(): Promise<void> { },
    	async m3(): MyPromise<void> { }
  1321. file mixes tab and space indentation (10 tab-indented and 19 space-indented lines) (raw pass, confidence 0.40)

    let o = {
    	async m1() { },
    	async m2(): Promise<void> { },
    	async m3(): MyPromise<void> { }
  1322. file mixes tab and space indentation (10 tab-indented and 54 space-indented lines) (raw pass, confidence 0.40)

    let o = {
    	async m1() { },
    	async m2(): Promise<void> { },
    	async m3(): MyPromise<void> { }
  1323. file mixes tab and space indentation (10 tab-indented and 54 space-indented lines) (raw pass, confidence 0.40)

    let o = {
    	async m1() { },
    	async m2(): Promise<void> { },
    	async m3(): MyPromise<void> { }
  1324. line length 980 characters (raw pass, confidence 0.50)

    _a = C1, _C1_instances = new WeakSet(), _C1_a_accessor_storage = new WeakMap(), _C1_b_accessor_storage = new WeakMap(), _C1_a_get = function _C1_a_get() { return __classPrivateFieldGet(this, _C1_a_accessor_storage, "f"); }, _C1_a_set = function _C1_a_set(value) { __classPrivateFieldSet(this, _C1_a_accessor_storage, val
  1325. line length 520 characters (raw pass, confidence 0.50)

    _b = C2, _C2_instances = new WeakSet(), _C2_a_1_accessor_storage = new WeakMap(), _C2_a_get = function _C2_a_get() { return __classPrivateFieldGet(this, _C2_a_1_accessor_storage, "f"); }, _C2_a_set = function _C2_a_set(value) { __classPrivateFieldSet(this, _C2_a_1_accessor_storage, value, "f"); }, _C2_b_get = function 
  1326. file mixes tab and space indentation (5 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    async function f() {
    	let await_a = await a;
    	let await_b = await b;
    	let await_c = await c;
  1327. file mixes tab and space indentation (5 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    async function f() {
    	let await_a = await a;
    	let await_b = await b;
    	let await_c = await c;
  1328. 115 of 215 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  1329. 74 of 166 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1330. 51 of 121 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1331. 18 of 41 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1332. 53 of 126 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1333. 51 of 113 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1334. file mixes tab and space indentation (8 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface ElementAttributesProperty { props: {} }
    	interface IntrinsicElements { 
  1335. file mixes tab and space indentation (8 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface ElementAttributesProperty { props: {} }
    	interface IntrinsicElements { 
  1336. file mixes tab and space indentation (14 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    interface ButtonProp {
        a: number,
        b: string,
        children: Button;
  1337. file mixes tab and space indentation (4 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    interface ButtonProp {
        a: number,
        b: string,
        children: Button;
  1338. 20 of 32 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  1339. 45 of 74 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  1340. file mixes tab and space indentation (21 tab-indented and 19 space-indented lines) (raw pass, confidence 0.40)

    export namespace M1 {
    	export class C1 {
    		m1: foo2.M1.C1;
    		x: number;
  1341. 18 of 44 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1342. 52 of 101 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1343. 16 of 33 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1344. 25 of 41 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  1345. 39 of 71 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1346. 22 of 54 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1347. 17 of 40 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1348. file mixes tab and space indentation (17 tab-indented and 17 space-indented lines) (raw pass, confidence 0.40)

    class A {
    	public constructor(a: boolean) // error
    	protected constructor(a: number) // error
    	private constructor(a: string)
  1349. 24 of 50 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1350. 24 of 50 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1351. 18 of 38 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1352. 62 of 130 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1353. 31 of 76 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1354. 31 of 76 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1355. 32 of 69 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1356. 18 of 30 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  1357. 18 of 32 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1358. 18 of 32 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1359. 21 of 41 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1360. 21 of 41 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1361. 24 of 57 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1362. 22 of 46 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1363. 22 of 46 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1364. 30 of 50 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  1365. 24 of 51 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1366. 50 of 117 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1367. 54 of 127 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1368. 50 of 117 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1369. file mixes tab and space indentation (3 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    export class C1 {
    	m1 = 42;
    	static s1 = true;
    }
  1370. file mixes tab and space indentation (8 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    export class C1 {
    	m1 = 42;
    	static s1 = true;
    }
  1371. mean non-conventional identifier length 1.92 over 72 names (token pass, confidence 0.50)

  1372. 68 of 144 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1373. 660 of 1317 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1374. 518 of 1025 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1375. mean non-conventional identifier length 1.92 over 443 names (token pass, confidence 0.50)

  1376. 75 of 148 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1377. mean non-conventional identifier length 1.78 over 69 names (token pass, confidence 0.50)

  1378. 272 of 537 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1379. 18 of 32 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1380. 18 of 32 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1381. 18 of 40 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1382. 18 of 40 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1383. 17 of 33 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1384. 17 of 33 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1385. 20 of 34 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  1386. 20 of 34 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  1387. 17 of 31 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1388. 17 of 31 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1389. 20 of 35 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1390. 20 of 35 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1391. file mixes tab and space indentation (1 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    class C {
        ["hello"]() {
            debugger;
        }
  1392. file mixes tab and space indentation (4 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    class C {
        ["hello"]() {
            debugger;
    	}
  1393. file mixes tab and space indentation (3 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    var v = {
        ["hello"]() {
            debugger;
    	},
  1394. file mixes tab and space indentation (4 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    var v = {
        ["hello"]() {
            debugger;
    	},
  1395. file mixes tab and space indentation (8 tab-indented and 161 space-indented lines) (raw pass, confidence 0.40)

    interface Covariant<T> {
        foo: T extends string ? T : number;
    }
  1396. mean non-conventional identifier length 1.67 over 30 names (token pass, confidence 0.50)

  1397. 46 of 97 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1398. 31 of 61 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1399. 19 of 39 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1400. 130 of 291 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1401. 74 of 182 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1402. 35 of 83 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1403. 86 of 155 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1404. 52 of 110 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1405. 52 of 110 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1406. file mixes tab and space indentation (1 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    namespace JSX {
        export interface IntrinsicElements {
            span: {};
        }
  1407. 26 of 40 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1408. 15 of 36 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1409. file mixes tab and space indentation (1 tab-indented and 70 space-indented lines) (raw pass, confidence 0.40)

    class C1 {
        a!: number;
        b: string;  // Error
    }
  1410. 26 of 60 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1411. 26 of 63 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1412. 35 of 71 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1413. 26 of 63 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1414. 52 of 64 non-conventional identifiers are single-character (81%) (token pass, confidence 0.50)

  1415. 22 of 44 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1416. 82 of 173 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1417. 44 of 94 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1418. mean non-conventional identifier length 1.50 over 24 names (token pass, confidence 0.50)

  1419. mean non-conventional identifier length 1.46 over 24 names (token pass, confidence 0.50)

  1420. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    const { [a]: aVal, [b]: bVal } = (() => {
    	return { [a]: 1, [b]: 1 };
    })();
    console.log(aVal, bVal);
  1421. 25 of 44 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1422. file mixes tab and space indentation (1 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    enum K {
        a = "a",
        b = "b"
    }
  1423. 22 of 40 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1424. file mixes tab and space indentation (1 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    const K = {
        a: "a",
        b: "b"
    }
  1425. 26 of 50 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1426. file mixes tab and space indentation (5 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    type Correct = {
    	code: string
    	property: true
    	err: undefined
  1427. file mixes tab and space indentation (4 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    namespace x {
    	export var x = 10;
    }
    class y {
  1428. `Function(...)` called with a non-literal body (ast pass, confidence 0.75)

    
    Function(import.defer);
    
    import.defer
    likely benign LLM, confidence 0.85 Conformance test fixture for invalid import.defer usage passed to Function.
    Reasoning

    This is a conformance test for import.defer syntax errors; Function(import.defer) is a deliberately invalid construct being parsed, not executed malicious code. The critical severity is a false positive from the scanner pattern matching.

  1429. `Function(...)` called with a non-literal body (ast pass, confidence 0.75)

    (import.defer)("a");⟨U+000D⟩
    Function(import.defer);⟨U+000D⟩
    import.defer;
    likely benign LLM, confidence 0.85 Second invalid import.defer conformance case in a test baseline.
    Reasoning

    Same conformance test for invalid import.defer syntax; the Function call is a parser test input, not a real dynamic execution payload.

  1430. file mixes tab and space indentation (6 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    var a = () => {
        var arg = arguments[0];  // error
    }
  1431. file mixes tab and space indentation (6 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    var a = () => {
        var arg = arguments[0];  // error
    }
  1432. 19 of 40 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1433. 32 of 67 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1434. 24 of 50 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1435. 138 of 244 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1436. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    export enum Animals {
    	Cat = 1
    }
    export enum Animals {
  1437. 232 of 478 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1438. 40 of 90 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1439. 45 of 90 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1440. mean non-conventional identifier length 1.88 over 34 names (token pass, confidence 0.50)

  1441. file mixes tab and space indentation (22 tab-indented and 54 space-indented lines) (raw pass, confidence 0.40)

    class B extends A {
    	public constructor() {
    		'inject';
    		super();
  1442. line length 746 characters (raw pass, confidence 0.50)

                __esDecorate(_a, _private_field1_descriptor = { get: __setFunctionName(function () { return __classPrivateFieldGet(this, _C_field1_accessor_storage, "f"); }, "#field1", "get"), set: __setFunctionName(function (value) { __classPrivateFieldSet(this, _C_field1_accessor_storage, value, "f"); }, "#field1", "set"
  1443. line length 560 characters (raw pass, confidence 0.50)

                __esDecorate(this, _private_field1_descriptor = { get: __setFunctionName(function () { return this.#field1_accessor_storage; }, "#field1", "get"), set: __setFunctionName(function (value) { this.#field1_accessor_storage = value; }, "#field1", "set") }, _private_field1_decorators, { kind: "accessor", name: "#
  1444. line length 747 characters (raw pass, confidence 0.50)

                __esDecorate(_a, _static_private_field1_descriptor = { get: __setFunctionName(function () { return __classPrivateFieldGet(_a, _a, "f", _C_field1_accessor_storage); }, "#field1", "get"), set: __setFunctionName(function (value) { __classPrivateFieldSet(_a, _a, value, "f", _C_field1_accessor_storage); }, "#fie
  1445. line length 587 characters (raw pass, confidence 0.50)

                __esDecorate(this, _static_private_field1_descriptor = { get: __setFunctionName(function () { return this.#field1_accessor_storage; }, "#field1", "get"), set: __setFunctionName(function (value) { this.#field1_accessor_storage = value; }, "#field1", "set") }, _static_private_field1_decorators, { kind: "acces
  1446. line length 758 characters (raw pass, confidence 0.50)

    10>                                                                                                                                                                                                                                                                                                                             
  1447. line length 755 characters (raw pass, confidence 0.50)

    10>                                                                                                                                                                                                                                                                                                                             
  1448. line length 744 characters (raw pass, confidence 0.50)

    10>                                                                                                                                                                                                                                                                                                                             
  1449. line length 741 characters (raw pass, confidence 0.50)

    10>                                                                                                                                                                                                                                                                                                                             
  1450. 110 of 172 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  1451. 44 of 95 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1452. 88 of 194 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1453. 68 of 139 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1454. 120 of 256 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1455. 45 of 90 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1456. 111 of 195 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1457. file mixes tab and space indentation (19 tab-indented and 316 space-indented lines) (raw pass, confidence 0.40)

    function f1(x: 1 | 2): string {
        if (!!true) {
            switch (x) {
                case 1: return 'a';
  1458. 78 of 161 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1459. 90 of 176 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1460. 237 of 546 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1461. 24 of 53 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1462. 58 of 142 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1463. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    export function x(){
    	return true;
    }
  1464. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    export function x(){
    	return true;
    }
  1465. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function x<T>(a: T){
    	return a;
    }
    export = x;
  1466. file mixes tab and space indentation (1 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    export enum E1 {
    	A,B,C
    }
  1467. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    namespace Foo {
    	export var x = foo1.x;
    }
    export = Foo;
  1468. file mixes tab and space indentation (2 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    class Foo<T extends {a: string; b:number;}>{
    	test: T;
    	constructor(x: T){}
    }
  1469. file mixes tab and space indentation (11 tab-indented and 14 space-indented lines) (raw pass, confidence 0.40)

    namespace Foo {
    	export function a(){
    		return 5;
    	}
  1470. file mixes tab and space indentation (3 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    class Foo {
    	test = "test";
    }
    namespace Foo {
  1471. file mixes tab and space indentation (3 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    enum foo {
    	red, green, blue
    }
    namespace foo {
  1472. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    function foo() {
    	return "test";
    }
    namespace foo {
  1473. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    namespace Foo {
    	export var answer = 42;
    }
    export = Foo;
  1474. 113 of 250 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1475. line length 692 characters (raw pass, confidence 0.50)

                "Motorola": "Motorola|DROIDX|DROID BIONIC|\\bDroid\\b.*Build|Android.*Xoom|HRI39|MOT-|A1260|A1680|A555|A853|A855|A953|A955|A956|Motorola.*ELECTRIFY|Motorola.*i1|i867|i940|MB200|MB300|MB501|MB502|MB508|MB511|MB520|MB525|MB526|MB611|MB612|MB632|MB810|MB855|MB860|MB861|MB865|MB870|ME501|ME502|ME511|ME525|ME600
  1476. line length 1627 characters (raw pass, confidence 0.50)

                "SamsungTablet": "SAMSUNG.*Tablet|Galaxy.*Tab|SC-01C|GT-P1000|GT-P1003|GT-P1010|GT-P3105|GT-P6210|GT-P6800|GT-P6810|GT-P7100|GT-P7300|GT-P7310|GT-P7500|GT-P7510|SCH-I800|SCH-I815|SCH-I905|SGH-I957|SGH-I987|SGH-T849|SGH-T859|SGH-T869|SPH-P100|GT-P3100|GT-P3108|GT-P3110|GT-P5100|GT-P5110|GT-P6200|GT-P7320|GT-
  1477. line length 526 characters (raw pass, confidence 0.50)

                "YarvikTablet": "Android.*\\b(TAB210|TAB211|TAB224|TAB250|TAB260|TAB264|TAB310|TAB360|TAB364|TAB410|TAB411|TAB420|TAB424|TAB450|TAB460|TAB461|TAB464|TAB465|TAB467|TAB468|TAB07-100|TAB07-101|TAB07-150|TAB07-151|TAB07-152|TAB07-200|TAB07-201-3G|TAB07-210|TAB07-211|TAB07-212|TAB07-214|TAB07-220|TAB07-400|TAB07
  1478. line length 646 characters (raw pass, confidence 0.50)

                "TexetTablet": "NaviPad|TB-772A|TM-7045|TM-7055|TM-9750|TM-7016|TM-7024|TM-7026|TM-7041|TM-7043|TM-7047|TM-8041|TM-9741|TM-9747|TM-9748|TM-9751|TM-7022|TM-7021|TM-7020|TM-7011|TM-7010|TM-7023|TM-7025|TM-7037W|TM-7038W|TM-7027W|TM-9720|TM-9725|TM-9737W|TM-1020|TM-9738W|TM-9740|TM-9743W|TB-807A|TB-771A|TB-727
  1479. line length 531 characters (raw pass, confidence 0.50)

                "iJoyTablet": "Tablet (Spirit 7|Essentia|Galatea|Fusion|Onix 7|Landa|Titan|Scooby|Deox|Stella|Themis|Argon|Unique 7|Sygnus|Hexen|Finity 7|Cream|Cream X2|Jade|Neon 7|Neron 7|Kandy|Scape|Saphyr 7|Rebel|Biox|Rebel|Rebel 8GB|Myst|Draco 7|Myst|Tab7-004|Myst|Tadeo Jones|Tablet Boing|Arrow|Draco Dual Cam|Aurix|Min
  1480. line length 936 characters (raw pass, confidence 0.50)

                "TeclastTablet": "T98 4G|\\bP80\\b|\\bX90HD\\b|X98 Air|X98 Air 3G|\\bX89\\b|P80 3G|\\bX80h\\b|P98 Air|\\bX89HD\\b|P98 3G|\\bP90HD\\b|P89 3G|X98 3G|\\bP70h\\b|P79HD 3G|G18d 3G|\\bP79HD\\b|\\bP89s\\b|\\bA88\\b|\\bP10HD\\b|\\bP19HD\\b|G18 3G|\\bP78HD\\b|\\bA78\\b|\\bP75\\b|G17s 3G|G17h 3G|\\bP85t\\b|\\bP90\\b|
  1481. line length 1637 characters (raw pass, confidence 0.50)

                shortPattern: /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte
  1482. line length 1632 characters (raw pass, confidence 0.50)

            shortPattern: /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\
  1483. line length 1637 characters (raw pass, confidence 0.50)

                shortPattern: /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte
  1484. 54 of 109 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1485. file mixes tab and space indentation (6 tab-indented and 79 space-indented lines) (raw pass, confidence 0.40)

    function* g001() { // Generator<undefined, void, unknown>
        yield;
    }
  1486. file mixes tab and space indentation (6 tab-indented and 83 space-indented lines) (raw pass, confidence 0.40)

    function* g001() { // Generator<any (implicit), void, unknown>
        yield;
    }
  1487. 30 of 65 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1488. 162 of 370 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1489. 23 of 53 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1490. 29 of 70 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1491. 96 of 228 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1492. 214 of 416 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1493. 31 of 75 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1494. 302 of 587 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1495. 73 of 145 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1496. 64 of 130 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1497. 35 of 70 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1498. 44 of 88 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1499. 34 of 52 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1500. 236 of 584 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1501. 20 of 31 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1502. 27 of 61 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1503. file mixes tab and space indentation (2 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    export class C1 {
    	m1 = 42;
    	static s1 = true;
    }
  1504. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    namespace foo {
    	export var answer = 42;
    }
  1505. info critical → info by review dynamic-execution tsc/testdata/baselines/reference/conformance/importSource5.js:9:1

    `Function(...)` called with a non-literal body (ast pass, confidence 0.75)

    (import.source)("./a.js");
    Function(import.source);
    import.source.unknown;
    likely benign LLM, confidence 0.85 Conformance test fixture for import.source syntax errors.
    Reasoning

    This is a conformance test for import source syntax in a TypeScript test baseline; the Function call wraps an invalid-syntax expression for error checking and is not an attack.

  1506. info critical → info by review dynamic-execution tsc/testdata/baselines/reference/conformance/importSource5.js:37:1

    `Function(...)` called with a non-literal body (ast pass, confidence 0.75)

    (import.source)("./a.js");⟨U+000D⟩
    Function(import.source);⟨U+000D⟩
    import.source.unknown;⟨U+000D⟩
    import.source();
    likely benign LLM, confidence 0.93 Test fixture exercising import.source syntax inside a Function() call.
    Reasoning

    This is a TypeScript conformance baseline for import.source syntax. The Function(import.source) call is a parser test input, not a runtime dropper. The file is a reference output in the compiler's test suite.

  1507. 49 of 117 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1508. 38 of 91 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1509. mean non-conventional identifier length 1.47 over 86 names (token pass, confidence 0.50)

  1510. file mixes tab and space indentation (1 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    function foo<T = number>(): [T] {
    	return [42 as any]
    }
    const [x] = foo();  // [number]
  1511. 16 of 33 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1512. 18 of 40 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1513. 77 of 179 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1514. 62 of 155 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1515. 18 of 33 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1516. 18 of 30 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  1517. 592 of 1397 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1518. 64 of 110 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  1519. 21 of 45 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1520. mean non-conventional identifier length 1.67 over 171 names (token pass, confidence 0.50)

  1521. 24 of 38 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  1522. 25 of 61 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1523. 74 of 163 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1524. 28 of 51 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1525. 46 of 95 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1526. 40 of 71 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1527. 28 of 49 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1528. 52 of 116 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1529. 33 of 75 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1530. 42 of 89 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1531. 41 of 66 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  1532. 53 of 85 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  1533. 49 of 95 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1534. 45 of 71 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  1535. file mixes tab and space indentation (5 tab-indented and 16 space-indented lines) (raw pass, confidence 0.40)

    class Handler {
    	static get OPTIONS() {
    		return 1;
    	}
  1536. 151 of 301 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1537. 18 of 31 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  1538. 18 of 31 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  1539. file mixes tab and space indentation (11 tab-indented and 108 space-indented lines) (raw pass, confidence 0.40)

    function fn() {
        try { } catch (x) { }                                            // should be OK
        try { } catch (/** @type {any} */ err) { }                       // should be OK
        try { } catch (/** @type {Any} */ err) { }                       // should be OK
  1540. 40 of 100 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1541. 64 of 142 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1542. file mixes tab and space indentation (1 tab-indented and 27 space-indented lines) (raw pass, confidence 0.40)

    class SomeBase {
        constructor() {
            this.p = 42;
        }
  1543. 81 of 174 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1544. 110 of 170 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1545. file mixes tab and space indentation (10 tab-indented and 566 space-indented lines) (raw pass, confidence 0.40)

    class Shape {
        name: string;
        width: number;
        height: number;
  1546. file mixes tab and space indentation (3 tab-indented and 127 space-indented lines) (raw pass, confidence 0.40)

    function f1(obj: { a: number, b: 0 | 1, c: string }, k0: 'a', k1: 'a' | 'b', k2: 'a' | 'b' | 'c') {
        obj[k0] = 1;
        obj[k0] = 2;
        obj[k0] = 'x';  // Error
  1547. 19 of 44 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1548. 92 of 227 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1549. mean non-conventional identifier length 1.96 over 48 names (token pass, confidence 0.50)

  1550. 256 of 422 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  1551. 66 of 143 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1552. mean non-conventional identifier length 1.88 over 101 names (token pass, confidence 0.50)

  1553. 36 of 72 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1554. 32 of 62 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1555. 24 of 54 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1556. 24 of 54 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1557. 19 of 43 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1558. 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1559. 14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1560. 82 of 128 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  1561. 78 of 120 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1562. 72 of 114 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  1563. 72 of 114 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  1564. 87 of 158 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1565. 67 of 167 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1566. 490 of 1208 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1567. 320 of 660 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1568. 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1569. 21 of 42 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1570. 13 of 32 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1571. 47 of 96 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1572. 60 of 136 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1573. 29 of 63 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1574. 29 of 63 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1575. file mixes tab and space indentation (62 tab-indented and 84 space-indented lines) (raw pass, confidence 0.40)

    class Private {
    	constructor (...args: any[]) {}
    	private p: string;
    }
  1576. 70 of 145 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1577. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    export function f(){
    	return 42;
    }
  1578. 54 of 113 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1579. 33 of 78 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1580. file mixes tab and space indentation (48 tab-indented and 299 space-indented lines) (raw pass, confidence 0.40)

    function fail(message?: string): never {
        throw new Error(message);
    }
  1581. 179 of 304 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  1582. 179 of 304 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  1583. 179 of 304 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  1584. 21 of 47 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1585. 43 of 87 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1586. 20 of 36 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1587. 36 of 85 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1588. 36 of 59 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  1589. 40 of 80 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1590. 102 of 222 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1591. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function f(): object {
    	return {};
    }
  1592. 74 of 174 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1593. 91 of 144 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  1594. 35 of 79 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1595. 29 of 71 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1596. mean non-conventional identifier length 1.72 over 342 names (token pass, confidence 0.50)

  1597. mean non-conventional identifier length 1.95 over 38 names (token pass, confidence 0.50)

  1598. mean non-conventional identifier length 1.95 over 38 names (token pass, confidence 0.50)

  1599. 34 of 78 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1600. 67 of 151 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1601. line length 1809 characters (raw pass, confidence 0.50)

        return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(O
  1602. 29 of 48 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  1603. 29 of 50 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  1604. 15 of 32 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1605. base64-like blob (66 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts]⟨U+000D⟩
    // Two call or construct signatures are considered identical when they have the same number of type parameters and, considering those 
  1606. base64-like blob (66 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.js]⟨U+000D⟩
    "use strict";⟨U+000D⟩
    // Two call or construct signatures are considered identical when they have the same number of type parameters and, considering those 
  1607. line length 593 characters (raw pass, confidence 0.50)

        var oct3 = 0o777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1608. line length 591 characters (raw pass, confidence 0.50)

            0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1609. line length 588 characters (raw pass, confidence 0.50)

    var oct3 = 0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1610. line length 586 characters (raw pass, confidence 0.50)

        0o77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1611. line length 589 characters (raw pass, confidence 0.50)

    var oct3 = 0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1612. line length 587 characters (raw pass, confidence 0.50)

        0o77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1613. line length 593 characters (raw pass, confidence 0.50)

        var oct3 = 0o777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1614. line length 591 characters (raw pass, confidence 0.50)

            0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1615. line length 588 characters (raw pass, confidence 0.50)

    var oct3 = 0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1616. line length 586 characters (raw pass, confidence 0.50)

        0o77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1617. line length 589 characters (raw pass, confidence 0.50)

    var oct3 = 0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1618. line length 587 characters (raw pass, confidence 0.50)

        0o77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1619. 96 of 230 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1620. file mixes tab and space indentation (2 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    function f<T>() {
    	let optional: { k1?: T } = undefined!;
    	let dict: { [key: string]: T | number } = optional; // ok
    }
  1621. 110 of 168 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1622. 40 of 89 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1623. mean non-conventional identifier length 1.91 over 22 names (token pass, confidence 0.50)

  1624. mean non-conventional identifier length 1.91 over 22 names (token pass, confidence 0.50)

  1625. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    export function removeClass (node:HTMLElement, className:string) {
    	node.className = node.className.replace(_classNameRegexp(className), function (everything, leftDelimiter, name, rightDelimiter) {
    		return leftDelimiter.length + rightDelimiter.length === 2 ? ' ' : '';
    	});
  1626. mean non-conventional identifier length 1.00 over 22 names (token pass, confidence 0.50)

  1627. mean non-conventional identifier length 1.00 over 24 names (token pass, confidence 0.50)

  1628. mean non-conventional identifier length 1.00 over 20 names (token pass, confidence 0.50)

  1629. file mixes tab and space indentation (4 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    ({
    	async m() {
    		for (;;) {
    		}
  1630. mean non-conventional identifier length 1.52 over 62 names (token pass, confidence 0.50)

  1631. mean non-conventional identifier length 1.80 over 30 names (token pass, confidence 0.50)

  1632. mean non-conventional identifier length 1.60 over 20 names (token pass, confidence 0.50)

  1633. mean non-conventional identifier length 1.60 over 20 names (token pass, confidence 0.50)

  1634. mean non-conventional identifier length 1.64 over 28 names (token pass, confidence 0.50)

  1635. 26 of 61 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1636. 62 of 97 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  1637. 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1638. 30 of 70 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1639. 1 line of text indented with invisible whitespace (U+00A0), first at line 32 (raw pass, confidence 0.40)

        //CHECK#2⟨U+000D⟩
        ⟨U+00A0⟩var x⟨U+00A0⟩= 1⟨U+00A0⟩;⟨U+000D⟩
        if (x !== 1) {⟨U+000D⟩
          $ERROR('#2: ⟨U+00A0⟩var x⟨U+00A0⟩= 1⟨U+00A0⟩; x === 1. Actual: ' + (x));
  1640. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

    
    //CHECK#А-Я
    var \u0410 = 1;
    if (А !== 1) {
  1641. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

    if (А !== 1) {
      $ERROR('#А');
    }
    var \u0411 = 1;
  1642. identifier `В` contains homoglyph candidates: В (0412)→B (in string/comment) (raw pass, confidence 0.35)

    if (В !== 1) {
      $ERROR('#В');
    }
    var \u0413 = 1;
  1643. identifier `Е` contains homoglyph candidates: Е (0415)→E (in string/comment) (raw pass, confidence 0.35)

    if (Е !== 1) {
      $ERROR('#Е');
    }
    var \u0416 = 1;
  1644. identifier `К` contains homoglyph candidates: К (041A)→K (in string/comment) (raw pass, confidence 0.35)

    if (К !== 1) {
      $ERROR('#К');
    }
    var \u041B = 1;
  1645. identifier `М` contains homoglyph candidates: М (041C)→M (in string/comment) (raw pass, confidence 0.35)

    if (М !== 1) {
      $ERROR('#М');
    }
    var \u041D = 1;
  1646. identifier `Н` contains homoglyph candidates: Н (041D)→H (in string/comment) (raw pass, confidence 0.35)

    if (Н !== 1) {
      $ERROR('#Н');
    }
    var \u041E = 1;
  1647. identifier `О` contains homoglyph candidates: О (041E)→O (in string/comment) (raw pass, confidence 0.35)

    if (О !== 1) {
      $ERROR('#О');
    }
    var \u041F = 1;
  1648. identifier `Р` contains homoglyph candidates: Р (0420)→P (in string/comment) (raw pass, confidence 0.35)

    if (Р !== 1) {
      $ERROR('#Р');
    }
    var \u0421 = 1;
  1649. identifier `С` contains homoglyph candidates: С (0421)→C (in string/comment) (raw pass, confidence 0.35)

    if (С !== 1) {
      $ERROR('#С');
    }
    var \u0422 = 1;
  1650. identifier `Т` contains homoglyph candidates: Т (0422)→T (in string/comment) (raw pass, confidence 0.35)

    if (Т !== 1) {
      $ERROR('#Т');
    }
    var \u0423 = 1;
  1651. identifier `Х` contains homoglyph candidates: Х (0425)→X (in string/comment) (raw pass, confidence 0.35)

    if (Х !== 1) {
      $ERROR('#Х');
    }
    var \u0426 = 1;
  1652. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

     */⟨U+000D⟩
    //CHECK#А-Я⟨U+000D⟩
    var \u0410 = 1;⟨U+000D⟩
    if (А !== 1) {
  1653. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

    if (А !== 1) {⟨U+000D⟩
        $ERROR('#А');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0411 = 1;
  1654. identifier `В` contains homoglyph candidates: В (0412)→B (in string/comment) (raw pass, confidence 0.35)

    if (В !== 1) {⟨U+000D⟩
        $ERROR('#В');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0413 = 1;
  1655. identifier `Е` contains homoglyph candidates: Е (0415)→E (in string/comment) (raw pass, confidence 0.35)

    if (Е !== 1) {⟨U+000D⟩
        $ERROR('#Е');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0416 = 1;
  1656. identifier `К` contains homoglyph candidates: К (041A)→K (in string/comment) (raw pass, confidence 0.35)

    if (К !== 1) {⟨U+000D⟩
        $ERROR('#К');⟨U+000D⟩
    }⟨U+000D⟩
    var \u041B = 1;
  1657. identifier `М` contains homoglyph candidates: М (041C)→M (in string/comment) (raw pass, confidence 0.35)

    if (М !== 1) {⟨U+000D⟩
        $ERROR('#М');⟨U+000D⟩
    }⟨U+000D⟩
    var \u041D = 1;
  1658. identifier `Н` contains homoglyph candidates: Н (041D)→H (in string/comment) (raw pass, confidence 0.35)

    if (Н !== 1) {⟨U+000D⟩
        $ERROR('#Н');⟨U+000D⟩
    }⟨U+000D⟩
    var \u041E = 1;
  1659. identifier `О` contains homoglyph candidates: О (041E)→O (in string/comment) (raw pass, confidence 0.35)

    if (О !== 1) {⟨U+000D⟩
        $ERROR('#О');⟨U+000D⟩
    }⟨U+000D⟩
    var \u041F = 1;
  1660. identifier `Р` contains homoglyph candidates: Р (0420)→P (in string/comment) (raw pass, confidence 0.35)

    if (Р !== 1) {⟨U+000D⟩
        $ERROR('#Р');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0421 = 1;
  1661. identifier `С` contains homoglyph candidates: С (0421)→C (in string/comment) (raw pass, confidence 0.35)

    if (С !== 1) {⟨U+000D⟩
        $ERROR('#С');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0422 = 1;
  1662. identifier `Т` contains homoglyph candidates: Т (0422)→T (in string/comment) (raw pass, confidence 0.35)

    if (Т !== 1) {⟨U+000D⟩
        $ERROR('#Т');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0423 = 1;
  1663. identifier `Х` contains homoglyph candidates: Х (0425)→X (in string/comment) (raw pass, confidence 0.35)

    if (Х !== 1) {⟨U+000D⟩
        $ERROR('#Х');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0426 = 1;
  1664. U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (in string/comment) (raw pass, confidence 0.45)

    //// [parserharness.ts]⟨U+000D⟩
    //⟨U+FEFF⟩
    // Copyright (c) Microsoft Corporation.  All rights reserved.
    // 
  1665. info critical → info by review dynamic-execution tsc/testdata/baselines/reference/conformance/parserharness.js:45:5

    `eval` called with a non-literal expression (ast pass, confidence 0.75)

    if (typeof ActiveXObject === "function") {
        eval(typescriptServiceFile);
    } else if (typeof require === "function") {
        var vm = require('vm');
    likely benign LLM, confidence 0.85 Test harness eval of the TypeScript service file under a conditional environment check.
    Reasoning

    This is the TypeScript parser test harness. It evals a bundled service file only in a test environment branch, and the file is a compiler test baseline. The eval is a legitimate harness mechanism, though non-literal eval is still a dynamic-execution pattern worth noting.

  1666. info critical → info by review dynamic-execution tsc/testdata/baselines/reference/conformance/parserharness.js:1889:27

    `eval` called with a non-literal expression (ast pass, confidence 0.75)

                try {
                    var res = eval(code);
    
                    for (n in dangerNames) {
    likely benign LLM, confidence 0.85 Test harness eval of code strings with global-state restoration afterwards.
    Reasoning

    This eval runs test code inside a try block in the TypeScript parser test harness, then restores globals. It is an ordinary test-runner pattern in a compiler test baseline.

  1667. U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (in string/comment) (raw pass, confidence 0.45)

    "use strict";⟨U+000D⟩
    //⟨U+FEFF⟩⟨U+000D⟩
    // Copyright (c) Microsoft Corporation.  All rights reserved.⟨U+000D⟩
    // 
  1668. info critical → info by review dynamic-execution tsc/testdata/baselines/reference/conformance/parserharness.js:2118:5

    `eval` called with a non-literal expression (ast pass, confidence 0.75)

    if (typeof ActiveXObject === "function") {⟨U+000D⟩
        eval(typescriptServiceFile);⟨U+000D⟩
    }⟨U+000D⟩
    else if (typeof require === "function") {
    likely benign LLM, confidence 0.85 Test harness eval of the TypeScript service file in a conditional branch.
    Reasoning

    Same parser harness pattern as the other eval at line 45: a conditional eval of the TypeScript service file in a compiler test baseline.

  1669. info critical → info by review dynamic-execution tsc/testdata/baselines/reference/conformance/parserharness.js:3661:27

    `eval` called with a non-literal expression (ast pass, confidence 0.75)

                try {⟨U+000D⟩
                    var res = eval(code);⟨U+000D⟩
                    for (n in dangerNames) {⟨U+000D⟩
                        global[dangerNames[n]] = globalBackup[dangerNames[n]];
    likely benign LLM, confidence 0.85 Test harness eval of code strings with global-state restoration.
    Reasoning

    Same test harness eval-with-restore pattern as line 1889, in a compiler test baseline file.

  1670. U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (in string/comment) (raw pass, confidence 0.45)

    //// [parserindenter.ts]⟨U+000D⟩
    //⟨U+FEFF⟩
    // Copyright (c) Microsoft Corporation.  All rights reserved.
    // 
  1671. U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (in string/comment) (raw pass, confidence 0.45)

    "use strict";⟨U+000D⟩
    //⟨U+FEFF⟩⟨U+000D⟩
    // Copyright (c) Microsoft Corporation.  All rights reserved.⟨U+000D⟩
    // 
  1672. 18 of 36 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1673. 68 of 163 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1674. 68 of 163 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1675. line length 509 characters (raw pass, confidence 0.50)

        var _A_Field_Field_foo, _A_Field_Field_foo_1, _A_Field_Method_instances, _A_Field_Method_foo, _A_Field_Method_foo_1, _A_Field_Getter_instances, _A_Field_Getter_foo, _A_Field_Getter_foo_get, _A_Field_Setter_instances, _A_Field_Setter_foo, _A_Field_Setter_foo_set, _a, _A_Field_StaticField_foo, _A_Field_StaticField_fo
  1676. line length 690 characters (raw pass, confidence 0.50)

        var _A_Method_Field_instances, _A_Method_Field_foo, _A_Method_Field_foo_1, _A_Method_Method_instances, _A_Method_Method_foo, _A_Method_Method_foo_1, _A_Method_Getter_instances, _A_Method_Getter_foo, _A_Method_Getter_foo_get, _A_Method_Setter_instances, _A_Method_Setter_foo, _A_Method_Setter_foo_set, _A_Method_Stati
  1677. line length 718 characters (raw pass, confidence 0.50)

        var _A_Getter_Field_instances, _A_Getter_Field_foo_get, _A_Getter_Field_foo, _A_Getter_Method_instances, _A_Getter_Method_foo_get, _A_Getter_Method_foo, _A_Getter_Getter_instances, _A_Getter_Getter_foo_get, _A_Getter_Getter_foo_1_get, _A_Getter_Setter_instances, _A_Getter_Setter_foo_get, _A_Getter_Setter_foo_set, _
  1678. line length 718 characters (raw pass, confidence 0.50)

        var _A_Setter_Field_instances, _A_Setter_Field_foo_set, _A_Setter_Field_foo, _A_Setter_Method_instances, _A_Setter_Method_foo_set, _A_Setter_Method_foo, _A_Setter_Getter_instances, _A_Setter_Getter_foo_set, _A_Setter_Getter_foo_get, _A_Setter_Setter_instances, _A_Setter_Setter_foo_set, _A_Setter_Setter_foo_1_set, _
  1679. line length 639 characters (raw pass, confidence 0.50)

        var _a, _A_StaticField_Field_foo, _A_StaticField_Field_foo_1, _A_StaticField_Method_instances, _b, _A_StaticField_Method_foo, _A_StaticField_Method_foo_1, _A_StaticField_Getter_instances, _c, _A_StaticField_Getter_foo, _A_StaticField_Getter_foo_get, _A_StaticField_Setter_instances, _d, _A_StaticField_Setter_foo, _A
  1680. line length 658 characters (raw pass, confidence 0.50)

        var _a, _A_StaticMethod_Field_foo, _A_StaticMethod_Field_foo_1, _A_StaticMethod_Method_instances, _b, _A_StaticMethod_Method_foo, _A_StaticMethod_Method_foo_1, _A_StaticMethod_Getter_instances, _c, _A_StaticMethod_Getter_foo, _A_StaticMethod_Getter_foo_get, _A_StaticMethod_Setter_instances, _d, _A_StaticMethod_Sett
  1681. line length 686 characters (raw pass, confidence 0.50)

        var _a, _A_StaticGetter_Field_foo_get, _A_StaticGetter_Field_foo, _A_StaticGetter_Method_instances, _b, _A_StaticGetter_Method_foo_get, _A_StaticGetter_Method_foo, _A_StaticGetter_Getter_instances, _c, _A_StaticGetter_Getter_foo_get, _A_StaticGetter_Getter_foo_1_get, _A_StaticGetter_Setter_instances, _d, _A_StaticG
  1682. line length 686 characters (raw pass, confidence 0.50)

        var _a, _A_StaticSetter_Field_foo_set, _A_StaticSetter_Field_foo, _A_StaticSetter_Method_instances, _b, _A_StaticSetter_Method_foo_set, _A_StaticSetter_Method_foo, _A_StaticSetter_Getter_instances, _c, _A_StaticSetter_Getter_foo_set, _A_StaticSetter_Getter_foo_get, _A_StaticSetter_Setter_instances, _d, _A_StaticSet
  1683. line length 814 characters (raw pass, confidence 0.50)

    }, _A_genMethod = function* _A_genMethod() { return 1; }, _A_asyncGenMethod = function _A_asyncGenMethod() { return __asyncGenerator(this, arguments, function* _A_asyncGenMethod_1() { return yield __await(1); }); }, _A_fooProp_get = function _A_fooProp_get() { return 3; }, _A_fooProp_set = function _A_fooProp_set(value
  1684. line length 555 characters (raw pass, confidence 0.50)

    _A_a = new WeakMap(), _A_b = new WeakMap(), _A_c = new WeakMap(), _A_instances = new WeakSet(), _A_aMethod = function _A_aMethod() { return 1; }, _A_bMethod = function _A_bMethod() { return 1; }, _A_cMethod = function _A_cMethod() { return 1; }, _A_aProp_get = function _A_aProp_get() { return 1; }, _A_aProp_set = funct
  1685. 95 of 227 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1686. 89 of 207 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1687. 13 of 30 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1688. 16 of 36 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1689. 17 of 36 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1690. 1 line of text indented with invisible whitespace (U+00A0), first at line 32 (raw pass, confidence 0.40)

        //CHECK#2⟨U+000D⟩
        ⟨U+00A0⟩var x⟨U+00A0⟩= 1⟨U+00A0⟩;⟨U+000D⟩
        if (x !== 1) {⟨U+000D⟩
          $ERROR('#2: ⟨U+00A0⟩var x⟨U+00A0⟩= 1⟨U+00A0⟩; x === 1. Actual: ' + (x));
  1691. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

    
    //CHECK#А-Я
    var \u0410 = 1;
    if (А !== 1) {
  1692. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

    if (А !== 1) {
      $ERROR('#А');
    }
    var \u0411 = 1;
  1693. identifier `В` contains homoglyph candidates: В (0412)→B (in string/comment) (raw pass, confidence 0.35)

    if (В !== 1) {
      $ERROR('#В');
    }
    var \u0413 = 1;
  1694. identifier `Е` contains homoglyph candidates: Е (0415)→E (in string/comment) (raw pass, confidence 0.35)

    if (Е !== 1) {
      $ERROR('#Е');
    }
    var \u0416 = 1;
  1695. identifier `К` contains homoglyph candidates: К (041A)→K (in string/comment) (raw pass, confidence 0.35)

    if (К !== 1) {
      $ERROR('#К');
    }
    var \u041B = 1;
  1696. identifier `М` contains homoglyph candidates: М (041C)→M (in string/comment) (raw pass, confidence 0.35)

    if (М !== 1) {
      $ERROR('#М');
    }
    var \u041D = 1;
  1697. identifier `Н` contains homoglyph candidates: Н (041D)→H (in string/comment) (raw pass, confidence 0.35)

    if (Н !== 1) {
      $ERROR('#Н');
    }
    var \u041E = 1;
  1698. identifier `О` contains homoglyph candidates: О (041E)→O (in string/comment) (raw pass, confidence 0.35)

    if (О !== 1) {
      $ERROR('#О');
    }
    var \u041F = 1;
  1699. identifier `Р` contains homoglyph candidates: Р (0420)→P (in string/comment) (raw pass, confidence 0.35)

    if (Р !== 1) {
      $ERROR('#Р');
    }
    var \u0421 = 1;
  1700. identifier `С` contains homoglyph candidates: С (0421)→C (in string/comment) (raw pass, confidence 0.35)

    if (С !== 1) {
      $ERROR('#С');
    }
    var \u0422 = 1;
  1701. identifier `Т` contains homoglyph candidates: Т (0422)→T (in string/comment) (raw pass, confidence 0.35)

    if (Т !== 1) {
      $ERROR('#Т');
    }
    var \u0423 = 1;
  1702. identifier `Х` contains homoglyph candidates: Х (0425)→X (in string/comment) (raw pass, confidence 0.35)

    if (Х !== 1) {
      $ERROR('#Х');
    }
    var \u0426 = 1;
  1703. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

     */⟨U+000D⟩
    //CHECK#А-Я⟨U+000D⟩
    var \u0410 = 1;⟨U+000D⟩
    if (А !== 1) {
  1704. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

    if (А !== 1) {⟨U+000D⟩
        $ERROR('#А');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0411 = 1;
  1705. identifier `В` contains homoglyph candidates: В (0412)→B (in string/comment) (raw pass, confidence 0.35)

    if (В !== 1) {⟨U+000D⟩
        $ERROR('#В');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0413 = 1;
  1706. identifier `Е` contains homoglyph candidates: Е (0415)→E (in string/comment) (raw pass, confidence 0.35)

    if (Е !== 1) {⟨U+000D⟩
        $ERROR('#Е');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0416 = 1;
  1707. identifier `К` contains homoglyph candidates: К (041A)→K (in string/comment) (raw pass, confidence 0.35)

    if (К !== 1) {⟨U+000D⟩
        $ERROR('#К');⟨U+000D⟩
    }⟨U+000D⟩
    var \u041B = 1;
  1708. identifier `М` contains homoglyph candidates: М (041C)→M (in string/comment) (raw pass, confidence 0.35)

    if (М !== 1) {⟨U+000D⟩
        $ERROR('#М');⟨U+000D⟩
    }⟨U+000D⟩
    var \u041D = 1;
  1709. identifier `Н` contains homoglyph candidates: Н (041D)→H (in string/comment) (raw pass, confidence 0.35)

    if (Н !== 1) {⟨U+000D⟩
        $ERROR('#Н');⟨U+000D⟩
    }⟨U+000D⟩
    var \u041E = 1;
  1710. identifier `О` contains homoglyph candidates: О (041E)→O (in string/comment) (raw pass, confidence 0.35)

    if (О !== 1) {⟨U+000D⟩
        $ERROR('#О');⟨U+000D⟩
    }⟨U+000D⟩
    var \u041F = 1;
  1711. identifier `Р` contains homoglyph candidates: Р (0420)→P (in string/comment) (raw pass, confidence 0.35)

    if (Р !== 1) {⟨U+000D⟩
        $ERROR('#Р');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0421 = 1;
  1712. identifier `С` contains homoglyph candidates: С (0421)→C (in string/comment) (raw pass, confidence 0.35)

    if (С !== 1) {⟨U+000D⟩
        $ERROR('#С');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0422 = 1;
  1713. identifier `Т` contains homoglyph candidates: Т (0422)→T (in string/comment) (raw pass, confidence 0.35)

    if (Т !== 1) {⟨U+000D⟩
        $ERROR('#Т');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0423 = 1;
  1714. identifier `Х` contains homoglyph candidates: Х (0425)→X (in string/comment) (raw pass, confidence 0.35)

    if (Х !== 1) {⟨U+000D⟩
        $ERROR('#Х');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0426 = 1;
  1715. 50 of 119 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1716. 21 of 49 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1717. 80 of 153 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1718. 16 of 33 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1719. 16 of 35 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1720. 77 of 124 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  1721. 28 of 56 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1722. 18 of 39 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1723. 18 of 41 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1724. 232 of 478 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1725. 40 of 76 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  1726. mean non-conventional identifier length 1.98 over 87 names (token pass, confidence 0.50)

  1727. 23 of 51 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1728. 43 of 106 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1729. 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1730. 36 of 68 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  1731. 28 of 60 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1732. 28 of 58 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1733. 28 of 60 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1734. 28 of 58 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1735. 30 of 69 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1736. mean non-conventional identifier length 1.63 over 41 names (token pass, confidence 0.50)

  1737. mean non-conventional identifier length 1.63 over 41 names (token pass, confidence 0.50)

  1738. 34 of 53 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  1739. 34 of 53 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  1740. 43 of 78 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1741. 74 of 182 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1742. 236 of 521 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1743. 236 of 590 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1744. 27 of 42 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  1745. 16 of 32 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1746. mean non-conventional identifier length 1.75 over 24 names (token pass, confidence 0.50)

  1747. mean non-conventional identifier length 1.75 over 24 names (token pass, confidence 0.50)

  1748. mean non-conventional identifier length 1.42 over 90 names (token pass, confidence 0.50)

  1749. mean non-conventional identifier length 1.75 over 24 names (token pass, confidence 0.50)

  1750. mean non-conventional identifier length 1.53 over 45 names (token pass, confidence 0.50)

  1751. mean non-conventional identifier length 1.69 over 26 names (token pass, confidence 0.50)

  1752. mean non-conventional identifier length 1.47 over 38 names (token pass, confidence 0.50)

  1753. mean non-conventional identifier length 1.89 over 36 names (token pass, confidence 0.50)

  1754. 32 of 58 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1755. 32 of 58 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1756. 34 of 49 non-conventional identifiers are single-character (69%) (token pass, confidence 0.50)

  1757. 34 of 49 non-conventional identifiers are single-character (69%) (token pass, confidence 0.50)

  1758. 31 of 55 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1759. 31 of 55 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1760. 44 of 110 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1761. 18 of 44 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1762. 18 of 44 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1763. 20 of 50 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1764. file mixes tab and space indentation (8 tab-indented and 117 space-indented lines) (raw pass, confidence 0.40)

    class C {
        n: number;
        explicitThis(this: this, m: number): number {
            return this.n + m;
  1765. 15 of 35 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1766. 20 of 45 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1767. 50 of 101 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1768. file mixes tab and space indentation (5 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		test1: { "data-foo"?: string };
  1769. file mixes tab and space indentation (6 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    	}
  1770. file mixes tab and space indentation (10 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    	}
  1771. file mixes tab and space indentation (3 tab-indented and 21 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
            div: any;
  1772. file mixes tab and space indentation (10 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		test1: Attribs1;
  1773. file mixes tab and space indentation (6 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    	}
  1774. file mixes tab and space indentation (3 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
            div: any
  1775. file mixes tab and space indentation (1 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {
    	class Component<T, U> { }
    }
  1776. file mixes tab and space indentation (1 tab-indented and 14 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {
    	class Component<T, U> { }
    }
  1777. file mixes tab and space indentation (1 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {
    	class Component<T, U> { }
    }
  1778. file mixes tab and space indentation (1 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {
    	class Component<T, U> { }
    }
  1779. file mixes tab and space indentation (6 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface IntrinsicElements {
    		foundFirst: { x: string };
    		'string_named';
  1780. file mixes tab and space indentation (2 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements { }
    }
  1781. file mixes tab and space indentation (12 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  1782. 48 of 113 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1783. file mixes tab and space indentation (21 tab-indented and 26 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements { }
    }
  1784. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function foo() {
    	var x = <div>  { </div>
    }
    // Shouldn't see any errors down here
  1785. file mixes tab and space indentation (1 tab-indented and 62 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {
    	class Component<T, U> { }
    }
  1786. file mixes tab and space indentation (4 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  1787. file mixes tab and space indentation (4 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  1788. file mixes tab and space indentation (7 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    export function makeP<P>(Ctor: React.ComponentClass<P>) {
    	return class extends React.PureComponent<P, void> {
    		public render(): JSX.Element {
    			return (
  1789. 20 of 31 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1790. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    }
  1791. file mixes tab and space indentation (12 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  1792. file mixes tab and space indentation (4 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  1793. file mixes tab and space indentation (11 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  1794. surrogate pair \uD83D\uDC08 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    // https://github.com/microsoft/TypeScript/issues/35732⟨U+000D⟩
    React.createElement("div", null, "\uD83D\uDC08\uD83D\uDC15\uD83D\uDC07\uD83D\uDC11");
  1795. surrogate pair \uD83D\uDC15 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    // https://github.com/microsoft/TypeScript/issues/35732⟨U+000D⟩
    React.createElement("div", null, "\uD83D\uDC08\uD83D\uDC15\uD83D\uDC07\uD83D\uDC11");
  1796. surrogate pair \uD83D\uDC07 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    // https://github.com/microsoft/TypeScript/issues/35732⟨U+000D⟩
    React.createElement("div", null, "\uD83D\uDC08\uD83D\uDC15\uD83D\uDC07\uD83D\uDC11");
  1797. surrogate pair \uD83D\uDC11 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    // https://github.com/microsoft/TypeScript/issues/35732⟨U+000D⟩
    React.createElement("div", null, "\uD83D\uDC08\uD83D\uDC15\uD83D\uDC07\uD83D\uDC11");
  1798. file mixes tab and space indentation (4 tab-indented and 17 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  1799. file mixes tab and space indentation (4 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  1800. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function Greet(x: {name?: string}) {
    	return null;
    }
  1801. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function Greet(x: {name?: string}) {
    	return null;
    }
  1802. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function Greet(x: {name?: string}) {
    	return undefined;
    }
  1803. file mixes tab and space indentation (4 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  1804. file mixes tab and space indentation (4 tab-indented and 16 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  1805. file mixes tab and space indentation (4 tab-indented and 16 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  1806. file mixes tab and space indentation (3 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    function EmptyPropSFC() {
        return <div> Default Greeting </div>;
    }
  1807. file mixes tab and space indentation (5 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    function Greet(x: {name?: string}) {
    	return <div>Hello, {x}</div>;
    }
  1808. file mixes tab and space indentation (2 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    var MainMenu: React.StatelessComponent<{}> = (props) => (<div>
        <h3>Main Menu</h3>
    </div>);
  1809. 97 of 224 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1810. file mixes tab and space indentation (2 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    class MyClass {
      props: {
        pt?: { x: number; y: number; };
    	name?: string;
  1811. 45 of 68 non-conventional identifiers are single-character (66%) (token pass, confidence 0.50)

  1812. 33 of 52 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  1813. 44 of 93 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1814. 29 of 48 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  1815. 55 of 120 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1816. 43 of 93 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1817. 31 of 70 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1818. 24 of 49 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1819. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    class SomeBase {
        private p;
    }
    class SomeDerived extends SomeBase {
  1820. 14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1821. 118 of 197 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  1822. file mixes tab and space indentation (8 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    if ((typeof strOrBool === 'boolean' && !strOrBool) || typeof strOrBool === 'string') {
    	let label: string = (typeof strOrBool === 'string') ? strOrBool : "string";
    	let bool: boolean = (typeof strOrBool === 'boolean') ? strOrBool : false;
    	let label2: string = (typeof strOrBool !== 'boolean') ? strOrBool : "string";
  1823. file mixes tab and space indentation (69 tab-indented and 71 space-indented lines) (raw pass, confidence 0.40)

    namespace Test {
    	export class FileSystemObject {
    		isFSO: this is FileSystemObject;
    		get isFile(): this is File {
  1824. file mixes tab and space indentation (27 tab-indented and 48 space-indented lines) (raw pass, confidence 0.40)

    namespace Test {
    	export class FileSystemObject {
    		isFSO: this is FileSystemObject;
    		get isFile(): this is File {
  1825. 40 of 88 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1826. 176 of 432 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1827. file mixes tab and space indentation (8 tab-indented and 264 space-indented lines) (raw pass, confidence 0.40)

    function test1(a: any) {
        if (typeof a !== "undefined") {
            if (typeof a === "boolean") {
                a;
  1828. 24 of 53 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1829. 30 of 59 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1830. 24 of 53 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1831. 24 of 48 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1832. 24 of 48 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1833. 24 of 48 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1834. 30 of 59 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1835. 24 of 48 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1836. 15 of 30 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1837. 21 of 34 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  1838. 55 of 118 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1839. 53 of 112 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1840. mean non-conventional identifier length 1.90 over 20 names (token pass, confidence 0.50)

  1841. mean non-conventional identifier length 1.90 over 292 names (token pass, confidence 0.50)

  1842. 56 of 90 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  1843. 34 of 69 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1844. 23 of 42 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1845. 71 of 136 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1846. 119 of 284 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1847. 38 of 82 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1848. 130 of 244 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  1849. 122 of 210 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  1850. 114 of 216 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  1851. 27 of 65 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1852. 19 of 37 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1853. 58 of 96 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  1854. 16 of 34 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1855. 24 of 43 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1856. 24 of 42 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1857. 21 of 43 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1858. 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1859. 14 of 31 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1860. 132 of 246 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  1861. 14 of 33 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1862. 20 of 35 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1863. 32 of 67 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1864. file mixes tab and space indentation (10 tab-indented and 25 space-indented lines) (raw pass, confidence 0.40)

    export interface Point {
    	x: number;
    	y: number;
    }
  1865. file mixes tab and space indentation (15 tab-indented and 25 space-indented lines) (raw pass, confidence 0.40)

    declare namespace M2D {
    	interface Point {
    		x: number;
    		y: number;
  1866. 107 of 252 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1867. mean non-conventional identifier length 1.84 over 77 names (token pass, confidence 0.50)

  1868. 58 of 128 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1869. 25 of 43 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  1870. 34 of 70 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1871. 16 of 31 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1872. base64-like blob (116 bytes, compression ratio 1.00) (in comment) (raw pass, confidence 0.36)

    export {};
    //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmpzIiwic291cmNlcyI6WyJpbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9⟨U+000D⟩
    //// [class.js] ////⟨U+000D⟩
    var _Bar_d;
  1873. base64-like blob (260 bytes, compression ratio 0.75) (in comment) (raw pass, confidence 0.36)

    }
    //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3MuanMiLCJzb3VyY2VzIjpbImNsYXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxNQUFNLENBQUMsR0FBRyxNQUFNLEVBQUUsQ0FBQztBQUNuQixNQUFNLE9BQU8sR0FBRztJQUFoQjtRQUlJLHlCQUFXO0lBTWYsQ0FBQztDQUFBOztBQUVELE1BQU0sT0FBZ0IsR0FBRztDQUd4QiJ9
  1874. base64-like blob (108 bytes, compression ratio 1.02) (in comment) (raw pass, confidence 0.36)

    export {};
    //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxpYXMuanMiLCJzb3VyY2VzIjpbImFsaWFzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==
  1875. compression ratio 0.636 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

    t aaa = 10;\n","impliedNodeFormat":1},{"version":"5ec434ed3f5c4b5bf474f907d0251bc7-export const b = 10;const bLocal = 10;const alocal = 10;const aaaa = 10;export const aaaaa = 10;","signature":"b41428b0658a7579227ae092a39341d9-export declare const b = 10;\nexport declare const aaaaa = 10;\n","impliedNodeFormat":1},{"ve
  1876. compression ratio 0.636 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

          "fileName": "./b.ts",
          "version": "5ec434ed3f5c4b5bf474f907d0251bc7-export const b = 10;const bLocal = 10;const alocal = 10;const aaaa = 10;export const aaaaa = 10;",
          "signature": "b41428b0658a7579227ae092a39341d9-export declare const b = 10;\nexport declare const aaaaa = 10;\n",
  1877. compression ratio 0.636 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

          "original": {
            "version": "5ec434ed3f5c4b5bf474f907d0251bc7-export const b = 10;const bLocal = 10;const alocal = 10;const aaaa = 10;export const aaaaa = 10;",
            "signature": "b41428b0658a7579227ae092a39341d9-export declare const b = 10;\nexport declare const aaaaa = 10;\n",
  1878. compression ratio 0.609 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

    st aaaaa = 10;export const a2 = 10;","signature":"c354a25014e4712419cbd9266c28e943-export declare const b = 10;\nexport declare const aaaaa = 10;\nexport declare const a2 = 10;\n","impliedNodeFormat":1},{"version":"28822e22fad7308e03af07d91b210c8f-import { a } from \"./a\";export const c = a;","signature":"6bc89426f721
  1879. compression ratio 0.609 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

          "signature": "c354a25014e4712419cbd9266c28e943-export declare const b = 10;\nexport declare const aaaaa = 10;\nexport declare const a2 = 10;\n",
          "impliedNodeFormat": "CommonJS",
          "original": {
  1880. compression ratio 0.609 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

            "signature": "c354a25014e4712419cbd9266c28e943-export declare const b = 10;\nexport declare const aaaaa = 10;\nexport declare const a2 = 10;\n",
            "impliedNodeFormat": 1
          }
  1881. compression ratio 0.609 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

     declare const f = 10;\n","impliedNodeFormat":1},"c354a25014e4712419cbd9266c28e943-export declare const b = 10;\nexport declare const aaaaa = 10;\nexport declare const a2 = 10;\n",{"version":"06b9b3562579ebca65e399849c2a6a3a-import { b } from \"../../project1/src/b\"; export const g = b;","signature":"4b3f5082fb1783241
  1882. compression ratio 0.609 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

          "version": "c354a25014e4712419cbd9266c28e943-export declare const b = 10;\nexport declare const aaaaa = 10;\nexport declare const a2 = 10;\n",
          "signature": "c354a25014e4712419cbd9266c28e943-export declare const b = 10;\nexport declare const aaaaa = 10;\nexport declare const a2 = 10;\n",
  1883. compression ratio 0.609 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

          "signature": "c354a25014e4712419cbd9266c28e943-export declare const b = 10;\nexport declare const aaaaa = 10;\nexport declare const a2 = 10;\n",
          "impliedNodeFormat": "CommonJS"
        },
  1884. compression ratio 0.636 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

    t aaa = 10;\n","impliedNodeFormat":1},{"version":"5ec434ed3f5c4b5bf474f907d0251bc7-export const b = 10;const bLocal = 10;const alocal = 10;const aaaa = 10;export const aaaaa = 10;","signature":"b41428b0658a7579227ae092a39341d9-export declare const b = 10;\nexport declare const aaaaa = 10;\n","impliedNodeFormat":1},{"ve
  1885. compression ratio 0.636 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

          "fileName": "./b.ts",
          "version": "5ec434ed3f5c4b5bf474f907d0251bc7-export const b = 10;const bLocal = 10;const alocal = 10;const aaaa = 10;export const aaaaa = 10;",
          "signature": "b41428b0658a7579227ae092a39341d9-export declare const b = 10;\nexport declare const aaaaa = 10;\n",
  1886. compression ratio 0.636 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

          "original": {
            "version": "5ec434ed3f5c4b5bf474f907d0251bc7-export const b = 10;const bLocal = 10;const alocal = 10;const aaaa = 10;export const aaaaa = 10;",
            "signature": "b41428b0658a7579227ae092a39341d9-export declare const b = 10;\nexport declare const aaaaa = 10;\n",
  1887. compression ratio 0.609 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

    st aaaaa = 10;export const a2 = 10;","signature":"c354a25014e4712419cbd9266c28e943-export declare const b = 10;\nexport declare const aaaaa = 10;\nexport declare const a2 = 10;\n","impliedNodeFormat":1},{"version":"28822e22fad7308e03af07d91b210c8f-import { a } from \"./a\";export const c = a;","signature":"6bc89426f721
  1888. compression ratio 0.609 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

          "signature": "c354a25014e4712419cbd9266c28e943-export declare const b = 10;\nexport declare const aaaaa = 10;\nexport declare const a2 = 10;\n",
          "impliedNodeFormat": "CommonJS",
          "original": {
  1889. compression ratio 0.609 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

            "signature": "c354a25014e4712419cbd9266c28e943-export declare const b = 10;\nexport declare const aaaaa = 10;\nexport declare const a2 = 10;\n",
            "impliedNodeFormat": 1
          }
  1890. compression ratio 0.609 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

     declare const f = 10;\n","impliedNodeFormat":1},"c354a25014e4712419cbd9266c28e943-export declare const b = 10;\nexport declare const aaaaa = 10;\nexport declare const a2 = 10;\n",{"version":"06b9b3562579ebca65e399849c2a6a3a-import { b } from \"../../project1/src/b\"; export const g = b;","signature":"4b3f5082fb1783241
  1891. compression ratio 0.609 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

          "version": "c354a25014e4712419cbd9266c28e943-export declare const b = 10;\nexport declare const aaaaa = 10;\nexport declare const a2 = 10;\n",
          "signature": "c354a25014e4712419cbd9266c28e943-export declare const b = 10;\nexport declare const aaaaa = 10;\nexport declare const a2 = 10;\n",
  1892. compression ratio 0.609 is >2σ above file mean 0.494 (raw pass, confidence 0.50)

          "signature": "c354a25014e4712419cbd9266c28e943-export declare const b = 10;\nexport declare const aaaaa = 10;\nexport declare const a2 = 10;\n",
          "impliedNodeFormat": "CommonJS"
        },
  1893. file mixes tab and space indentation (3 tab-indented and 52 space-indented lines) (raw pass, confidence 0.40)

    {
    	"name": "mapper",
    	"version": "1.0.0",
    	"typescript": { "contentMapper": { "exec": ["verbatim-mapper"] } }
  1894. file mixes tab and space indentation (5 tab-indented and 119 space-indented lines) (raw pass, confidence 0.40)

    const notAny: false = null as unknown as
        IsAny<typeof indexed[string] | typeof deep.a.b.c.d | typeof named.node.leaf>;
    const invalidIndex: number = indexed["name"];
    const invalidDeep: number = deep.a.b.c.d;
  1895. compression ratio 0.657 is >2σ above file mean 0.498 (raw pass, confidence 0.50)

     file = 10;\n","impliedNodeFormat":1},{"version":"76f8c505d1aaf1122ce1da0807c21477-/// <reference lib=\"webworker\"/>\n/// <reference lib=\"scripthost\"/>\n/// <reference lib=\"es5\"/>","signature":"99aa06d3014798d86001c324468d497f-","impliedNodeFormat":1},{"version":"aeb695aed936d7539a32fc3cd25af558-export const x = \
  1896. compression ratio 0.657 is >2σ above file mean 0.498 (raw pass, confidence 0.50)

          "fileName": "./file2.ts",
          "version": "76f8c505d1aaf1122ce1da0807c21477-/// <reference lib=\"webworker\"/>\n/// <reference lib=\"scripthost\"/>\n/// <reference lib=\"es5\"/>",
          "signature": "99aa06d3014798d86001c324468d497f-",
          "impliedNodeFormat": "CommonJS",
  1897. compression ratio 0.657 is >2σ above file mean 0.498 (raw pass, confidence 0.50)

          "original": {
            "version": "76f8c505d1aaf1122ce1da0807c21477-/// <reference lib=\"webworker\"/>\n/// <reference lib=\"scripthost\"/>\n/// <reference lib=\"es5\"/>",
            "signature": "99aa06d3014798d86001c324468d497f-",
            "impliedNodeFormat": 1
  1898. compression ratio 0.657 is >2σ above file mean 0.498 (raw pass, confidence 0.50)

     file = 10;\n","impliedNodeFormat":1},{"version":"76f8c505d1aaf1122ce1da0807c21477-/// <reference lib=\"webworker\"/>\n/// <reference lib=\"scripthost\"/>\n/// <reference lib=\"es5\"/>","signature":"99aa06d3014798d86001c324468d497f-","impliedNodeFormat":1},{"version":"aeb695aed936d7539a32fc3cd25af558-export const x = \
  1899. compression ratio 0.657 is >2σ above file mean 0.498 (raw pass, confidence 0.50)

          "fileName": "./file2.ts",
          "version": "76f8c505d1aaf1122ce1da0807c21477-/// <reference lib=\"webworker\"/>\n/// <reference lib=\"scripthost\"/>\n/// <reference lib=\"es5\"/>",
          "signature": "99aa06d3014798d86001c324468d497f-",
          "impliedNodeFormat": "CommonJS",
  1900. compression ratio 0.657 is >2σ above file mean 0.498 (raw pass, confidence 0.50)

          "original": {
            "version": "76f8c505d1aaf1122ce1da0807c21477-/// <reference lib=\"webworker\"/>\n/// <reference lib=\"scripthost\"/>\n/// <reference lib=\"es5\"/>",
            "signature": "99aa06d3014798d86001c324468d497f-",
            "impliedNodeFormat": 1
  1901. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

    onst a = class { private p = 10; };","signature":"797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variabl
  1902. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

          "signature": "797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1903. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

            "signature": "797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1904. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

    onst a = class { private p = 10; };","signature":"797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variabl
  1905. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

          "signature": "797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1906. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

            "signature": "797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1907. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

    onst a = class { private p = 10; };","signature":"797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variabl
  1908. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

          "signature": "797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1909. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

            "signature": "797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1910. file mixes tab and space indentation (6 tab-indented and 64 space-indented lines) (raw pass, confidence 0.40)

    {
    					"version": "FakeTSVersion",
    					"fileNames": ["lib.es2025.full.d.ts", "../src/a.ts", "../src/b.ts"],
    					"fileInfos": ["abc123"],
  1911. compression ratio 0.657 is >2σ above file mean 0.498 (raw pass, confidence 0.50)

     file = 10;\n","impliedNodeFormat":1},{"version":"76f8c505d1aaf1122ce1da0807c21477-/// <reference lib=\"webworker\"/>\n/// <reference lib=\"scripthost\"/>\n/// <reference lib=\"es5\"/>","signature":"99aa06d3014798d86001c324468d497f-","impliedNodeFormat":1},{"version":"aeb695aed936d7539a32fc3cd25af558-export const x = \
  1912. compression ratio 0.657 is >2σ above file mean 0.498 (raw pass, confidence 0.50)

          "fileName": "./file2.ts",
          "version": "76f8c505d1aaf1122ce1da0807c21477-/// <reference lib=\"webworker\"/>\n/// <reference lib=\"scripthost\"/>\n/// <reference lib=\"es5\"/>",
          "signature": "99aa06d3014798d86001c324468d497f-",
          "impliedNodeFormat": "CommonJS",
  1913. compression ratio 0.657 is >2σ above file mean 0.498 (raw pass, confidence 0.50)

          "original": {
            "version": "76f8c505d1aaf1122ce1da0807c21477-/// <reference lib=\"webworker\"/>\n/// <reference lib=\"scripthost\"/>\n/// <reference lib=\"es5\"/>",
            "signature": "99aa06d3014798d86001c324468d497f-",
            "impliedNodeFormat": 1
  1914. compression ratio 0.657 is >2σ above file mean 0.498 (raw pass, confidence 0.50)

     file = 10;\n","impliedNodeFormat":1},{"version":"76f8c505d1aaf1122ce1da0807c21477-/// <reference lib=\"webworker\"/>\n/// <reference lib=\"scripthost\"/>\n/// <reference lib=\"es5\"/>","signature":"99aa06d3014798d86001c324468d497f-","impliedNodeFormat":1},{"version":"aeb695aed936d7539a32fc3cd25af558-export const x = \
  1915. compression ratio 0.657 is >2σ above file mean 0.498 (raw pass, confidence 0.50)

          "fileName": "./file2.ts",
          "version": "76f8c505d1aaf1122ce1da0807c21477-/// <reference lib=\"webworker\"/>\n/// <reference lib=\"scripthost\"/>\n/// <reference lib=\"es5\"/>",
          "signature": "99aa06d3014798d86001c324468d497f-",
          "impliedNodeFormat": "CommonJS",
  1916. compression ratio 0.657 is >2σ above file mean 0.498 (raw pass, confidence 0.50)

          "original": {
            "version": "76f8c505d1aaf1122ce1da0807c21477-/// <reference lib=\"webworker\"/>\n/// <reference lib=\"scripthost\"/>\n/// <reference lib=\"es5\"/>",
            "signature": "99aa06d3014798d86001c324468d497f-",
            "impliedNodeFormat": 1
  1917. compression ratio 0.693 is >2σ above file mean 0.493 (raw pass, confidence 0.50)

    onst a = class { private p = 10; };","signature":"562dfe29cab6c7ded7ded341fc9c8131-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(53,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(53,1): error9027: Add_a_type_annotation_to_the_variabl
  1918. compression ratio 0.693 is >2σ above file mean 0.493 (raw pass, confidence 0.50)

          "signature": "562dfe29cab6c7ded7ded341fc9c8131-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(53,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(53,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1919. compression ratio 0.693 is >2σ above file mean 0.493 (raw pass, confidence 0.50)

            "signature": "562dfe29cab6c7ded7ded341fc9c8131-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(53,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(53,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1920. compression ratio 0.693 is >2σ above file mean 0.493 (raw pass, confidence 0.50)

    onst a = class { private p = 10; };","signature":"562dfe29cab6c7ded7ded341fc9c8131-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(53,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(53,1): error9027: Add_a_type_annotation_to_the_variabl
  1921. compression ratio 0.693 is >2σ above file mean 0.493 (raw pass, confidence 0.50)

          "signature": "562dfe29cab6c7ded7ded341fc9c8131-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(53,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(53,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1922. compression ratio 0.693 is >2σ above file mean 0.493 (raw pass, confidence 0.50)

            "signature": "562dfe29cab6c7ded7ded341fc9c8131-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(53,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(53,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1923. line length 1611 characters (raw pass, confidence 0.50)

    one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, 
  1924. line length 1748 characters (raw pass, confidence 0.50)

    one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, es2026, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.it
  1925. line length 1748 characters (raw pass, confidence 0.50)

    one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, es2026, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.it
  1926. line length 1748 characters (raw pass, confidence 0.50)

    one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, es2026, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.it
  1927. file mixes tab and space indentation (3 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    {
    	"name": "mapper",
    	"version": "1.0.0",
    	"typescript": { "contentMapper": { "exec": ["dynamic-verbatim-mapper"], "dynamicConfig": true } }
  1928. line length 1748 characters (raw pass, confidence 0.50)

    one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, es2026, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.it
  1929. line length 1748 characters (raw pass, confidence 0.50)

    one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, es2026, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.it
  1930. compression ratio 0.787 is >2σ above file mean 0.510 (raw pass, confidence 0.50)

    ca5-export const enum AWorker {\n    ONE = 3\n}","85de628566e341d0050fe40f7319973e-export { AWorker as A } from \"./worker\";export const randomThing = 10;export const randomThing2 = 10;",{"version":"27be335cb83f09e0543d1a6458f51e79-import {A} from \"./b\"\nlet b = A.ONE\nexport {A}","signature":"f6d90ac6a94594899853de
  1931. compression ratio 0.787 is >2σ above file mean 0.510 (raw pass, confidence 0.50)

          "version": "85de628566e341d0050fe40f7319973e-export { AWorker as A } from \"./worker\";export const randomThing = 10;export const randomThing2 = 10;",
          "signature": "85de628566e341d0050fe40f7319973e-export { AWorker as A } from \"./worker\";export const randomThing = 10;export const randomThing2 = 10;",
  1932. compression ratio 0.787 is >2σ above file mean 0.510 (raw pass, confidence 0.50)

          "signature": "85de628566e341d0050fe40f7319973e-export { AWorker as A } from \"./worker\";export const randomThing = 10;export const randomThing2 = 10;",
          "impliedNodeFormat": "CommonJS"
        },
  1933. compression ratio 0.856 is >2σ above file mean 0.542 (raw pass, confidence 0.50)

    "affectsGlobalScope":true,"impliedNodeFormat":1},"842b68cd3ee2dcec7d1df8517668c731-export const enum AWorker {\n    ONE = 3\n}\nexport { AWorker as A };export const randomThing = 10;",{"version":"27be335cb83f09e0543d1a6458f51e79-import {A} from \"./b\"\nlet b = A.ONE\nexport {A}","signature":"f6d90ac6a94594899853de488f
  1934. compression ratio 0.856 is >2σ above file mean 0.542 (raw pass, confidence 0.50)

          "version": "842b68cd3ee2dcec7d1df8517668c731-export const enum AWorker {\n    ONE = 3\n}\nexport { AWorker as A };export const randomThing = 10;",
          "signature": "842b68cd3ee2dcec7d1df8517668c731-export const enum AWorker {\n    ONE = 3\n}\nexport { AWorker as A };export const randomThing = 10;",
  1935. compression ratio 0.856 is >2σ above file mean 0.542 (raw pass, confidence 0.50)

          "signature": "842b68cd3ee2dcec7d1df8517668c731-export const enum AWorker {\n    ONE = 3\n}\nexport { AWorker as A };export const randomThing = 10;",
          "impliedNodeFormat": "CommonJS"
        },
  1936. compression ratio 0.748 is >2σ above file mean 0.505 (raw pass, confidence 0.50)

    "affectsGlobalScope":true,"impliedNodeFormat":1},"ee6472d5ac80e48bb4cea44493dd5fe8-export const enum A {\n    ONE = 3\n}export const randomThing = 10;export const randomThing2 = 10;",{"version":"27be335cb83f09e0543d1a6458f51e79-import {A} from \"./b\"\nlet b = A.ONE\nexport {A}","signature":"f6d90ac6a94594899853de488fc
  1937. compression ratio 0.748 is >2σ above file mean 0.505 (raw pass, confidence 0.50)

          "version": "ee6472d5ac80e48bb4cea44493dd5fe8-export const enum A {\n    ONE = 3\n}export const randomThing = 10;export const randomThing2 = 10;",
          "signature": "ee6472d5ac80e48bb4cea44493dd5fe8-export const enum A {\n    ONE = 3\n}export const randomThing = 10;export const randomThing2 = 10;",
  1938. compression ratio 0.748 is >2σ above file mean 0.505 (raw pass, confidence 0.50)

          "signature": "ee6472d5ac80e48bb4cea44493dd5fe8-export const enum A {\n    ONE = 3\n}export const randomThing = 10;export const randomThing2 = 10;",
          "impliedNodeFormat": "CommonJS"
        },
  1939. compression ratio 0.578 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

    Resolving real path for '/home/src/projects/component-type-checker/packages/app/node_modules/@component-type-checker/button/src/index.ts', result '/home/src/projects/component-type-checker/node_modules/.pnpm/@component-type-checker+button@0.0.2/node_modules/@component-type-checker/button/src/index.ts'.
  1940. compression ratio 0.578 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

    ======== Module name '@component-type-checker/button' was successfully resolved to '/home/src/projects/component-type-checker/node_modules/.pnpm/@component-type-checker+button@0.0.2/node_modules/@component-type-checker/button/src/index.ts' with Package ID '@component-type-checker/button/src/index.ts@0.0.2'. ========
  1941. compression ratio 0.578 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

    ponent-type-checker/button/src/index.ts', result '/home/src/projects/component-type-checker/node_modules/.pnpm/@component-type-checker+button@0.0.1/node_modules/@component-type-checker/button/src/index.ts'.
  1942. compression ratio 0.578 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

    ======== Module name '@component-type-checker/button' was successfully resolved to '/home/src/projects/component-type-checker/node_modules/.pnpm/@component-type-checker+button@0.0.1/node_modules/@component-type-checker/button/src/index.ts' with Package ID '@component-type-checker/button/src/index.ts@0.0.1'. ========
  1943. compression ratio 0.578 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

    ponent-type-checker/button/src/index.ts', result '/home/src/projects/component-type-checker/node_modules/.pnpm/@component-type-checker+button@0.0.2/node_modules/@component-type-checker/button/src/index.ts'.
  1944. compression ratio 0.578 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

    ======== Module name '@component-type-checker/button' was successfully resolved to '/home/src/projects/component-type-checker/node_modules/.pnpm/@component-type-checker+button@0.0.2/node_modules/@component-type-checker/button/src/index.ts' with Package ID '@component-type-checker/button/src/index.ts@0.0.2'. ========
  1945. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

    onst a = class { private p = 10; };","signature":"797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variabl
  1946. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

          "signature": "797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1947. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

            "signature": "797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1948. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

    onst a = class { private p = 10; };","signature":"797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variabl
  1949. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

          "signature": "797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1950. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

            "signature": "797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1951. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

    onst a = class { private p = 10; };","signature":"797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variabl
  1952. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

          "signature": "797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1953. compression ratio 0.703 is >2σ above file mean 0.508 (raw pass, confidence 0.50)

            "signature": "797d7267ef7f35dc3f989be23b6d4fe3-export declare const a: {\n    new (): {\n        p: number;\n    };\n};\n\n(13,1): error4094: Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected_4094\np\n\n(13,1): error9027: Add_a_type_annotation_to_the_variable_0_9027\na\n",
  1954. file mixes tab and space indentation (2 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    {
    	"compilerOptions": {},
    	"include": ["src/**/*.ts"]
    }
  1955. file mixes tab and space indentation (2 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    {
    	"compilerOptions": {},
    	"include": ["src/**/*.ts"]
    }
  1956. file mixes tab and space indentation (2 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    {
    	"compilerOptions": {},
    	"include": ["index.ts", "src/**/*.ts"]
    }
  1957. file mixes tab and space indentation (2 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    {
    	"compilerOptions": {},
    	"include": ["src/**/*.ts"]
    }
  1958. file mixes tab and space indentation (2 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    {
    	"compilerOptions": {},
    	"include": ["src/**/*.ts"]
    }
  1959. file mixes tab and space indentation (2 tab-indented and 20 space-indented lines) (raw pass, confidence 0.40)

    {
    	"compilerOptions": {},
  1960. line length 1749 characters (raw pass, confidence 0.50)

    -one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, es2026, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.i
  1961. file mixes tab and space indentation (3 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    {
    	"compilerOptions": { "strict": false }
    }
    //// [/home/src/workspaces/project/index.ts] *new* 
  1962. file mixes tab and space indentation (4 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    {
    	"compilerOptions": {},
    	"include": ["*.ts"]
    }
  1963. file mixes tab and space indentation (2 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)

    {
    	"compilerOptions": {},
    	"files": ["a.ts", "b.ts"]
    }
  1964. file mixes tab and space indentation (10 tab-indented and 22 space-indented lines) (raw pass, confidence 0.40)

    {
    	"compilerOptions": {
                "noEmit": true
    	}
  1965. file mixes tab and space indentation (10 tab-indented and 39 space-indented lines) (raw pass, confidence 0.40)

    {
    	"compilerOptions": {
                "noEmit": true,
                "declaration": true
  1966. file mixes tab and space indentation (10 tab-indented and 21 space-indented lines) (raw pass, confidence 0.40)

    {
    	"compilerOptions": {
                "noEmit": true
    	}
  1967. file mixes tab and space indentation (10 tab-indented and 21 space-indented lines) (raw pass, confidence 0.40)

    {
    	"compilerOptions": {
                "noEmit": true
    	}
  1968. line length 932 characters (raw pass, confidence 0.50)

        General_Category: new Set(["C", "Other", "Cc", "Control", "cntrl", "Cf", "Format", "Cn", "Unassigned", "Co", "Private_Use", "Cs", "Surrogate", "L", "Letter", "LC", "Cased_Letter", "Ll", "Lowercase_Letter", "Lm", "Modifier_Letter", "Lo", "Other_Letter", "Lt", "Titlecase_Letter", "Lu", "Uppercase_Letter", "M", "Mark"
  1969. line length 531 characters (raw pass, confidence 0.50)

    export function createWatchCompilerHost<T extends BuilderProgram>(rootFilesOrConfigFileName: string | string[], options: CompilerOptions | undefined, system: System, createProgram?: CreateProgram<T>, reportDiagnostic?: DiagnosticReporter, reportWatchStatus?: WatchStatusReporter, projectReferencesOrWatchOptionsToExtend?
  1970. compression ratio 0.807 is >2σ above file mean 0.697 (in comment) (raw pass, confidence 0.30)

    /**
     * The **`CharacterData`** abstract interface represents a Node object that contains characters. This is an abstract interface, meaning there aren't any objects of type CharacterData: it is implemented by other interfaces like Text, Comment, CDATASection, or ProcessingInstruction, which aren't abstract.
     *
  1971. line length 627 characters (raw pass, confidence 0.50)

    type AutoFillNormalField = "additional-name" | "address-level1" | "address-level2" | "address-level3" | "address-level4" | "address-line1" | "address-line2" | "address-line3" | "bday-day" | "bday-month" | "bday-year" | "cc-csc" | "cc-exp" | "cc-exp-month" | "cc-exp-year" | "cc-family-name" | "cc-given-name" | "cc-name"
  1972. line length 549 characters (raw pass, confidence 0.50)

    type GPUVertexFormat = "float16" | "float16x2" | "float16x4" | "float32" | "float32x2" | "float32x3" | "float32x4" | "sint16" | "sint16x2" | "sint16x4" | "sint32" | "sint32x2" | "sint32x3" | "sint32x4" | "sint8" | "sint8x2" | "sint8x4" | "snorm16" | "snorm16x2" | "snorm16x4" | "snorm8" | "snorm8x2" | "snorm8x4" | "uint
  1973. line length 564 characters (raw pass, confidence 0.50)

    G@⟨U+0004⟩�⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩⟨U+0004⟩G@⟨U+0005⟩�⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩⟨U+0005⟩
  1974. 15 of 36 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1975. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    declare namespace Foo {⟨U+000D⟩
    	function a():void;⟨U+000D⟩
    	var b:number;⟨U+000D⟩
    	class C {}
  1976. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    interface I1 {⟨U+000D⟩
    	IM1():void[];⟨U+000D⟩
    }
  1977. file mixes tab and space indentation (5 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    interface I1 {⟨U+000D⟩
    	IM1():void[];⟨U+000D⟩
    }
  1978. 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1979. file mixes tab and space indentation (4 tab-indented and 17 space-indented lines) (raw pass, confidence 0.40)

    interface IOptions {⟨U+000D⟩
        name?: string;⟨U+000D⟩
        flag?: boolean;⟨U+000D⟩
        short?: string;
  1980. file mixes tab and space indentation (1 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    namespace M {⟨U+000D⟩
        interface I {⟨U+000D⟩
    	f(n:number):boolean;⟨U+000D⟩
        }
  1981. 24 of 57 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1982. file mixes tab and space indentation (3 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    function makePoint(x: number, y: number) {⟨U+000D⟩
        return {⟨U+000D⟩
            get x() { return x;}, // shouldn't be "void"⟨U+000D⟩
            get y() { return y;}, // shouldn't be "void"
  1983. 20 of 40 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1984. 18 of 32 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1985. file mixes tab and space indentation (6 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    async function main() {⟨U+000D⟩
        let aaa: number;⟨U+000D⟩
        let bbb: string;⟨U+000D⟩
        [
  1986. file mixes tab and space indentation (4 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    class Greeter {⟨U+000D⟩
        constructor() {⟨U+000D⟩
    		foo(() => {⟨U+000D⟩
                bar(() => {
  1987. mean non-conventional identifier length 1.69 over 4925 names (token pass, confidence 0.50)

  1988. mean non-conventional identifier length 1.76 over 55 names (token pass, confidence 0.50)

  1989. file mixes tab and space indentation (10 tab-indented and 75 space-indented lines) (raw pass, confidence 0.40)

    export declare class Promise<R> implements Promise.Thenable<R> {⟨U+000D⟩
    	constructor(callback: (resolve: (thenableOrResult: R | Promise.Thenable<R>) => void, reject: (error: any) => void) => void);⟨U+000D⟩
        static try<R>(dit: typeof Promise, fn: () => Promise.Thenable<R>, args?: any[], ctx?: any): Promise<R>;
  1990. surrogate pair \uD83D\uDE00 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    const braceEscaped = "\u{D83D}\u{DE00}" as const;
    const adjacentEscaped = "\uD83D\uDE00" as const;
    
    const a: "😀" = braceEscaped;
  1991. file mixes tab and space indentation (2 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    class Foo { // error⟨U+000D⟩
    	bar1(s:string);⟨U+000D⟩
    	bar1(n:number);⟨U+000D⟩
        bar1(a:any) { /*WScript.Echo(a);*/ }
  1992. 23 of 43 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  1993. 23 of 38 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  1994. 22 of 50 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1995. 14 of 31 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1996. 15 of 33 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1997. 16 of 30 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  1998. file mixes tab and space indentation (3 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    namespace M {
      export interface I1 {}
      export interface I2<T> {}
    }
  1999. 14 of 33 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2000. 13 of 32 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2001. 20 of 47 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2002. 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2003. 23 of 37 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  2004. file mixes tab and space indentation (27 tab-indented and 424 space-indented lines) (raw pass, confidence 0.40)

     */
     /* tslint:disable */
    
    // import * as import0 from '@angular/core/src/linker/ng_module_factory';
  2005. 14 of 32 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2006. file mixes tab and space indentation (2 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    interface Array<T> {
        concat(...items: T[][]): T[]; // Note: This overload needs to be picked for arrays of arrays, even though both are applicable
        concat(...items: T[]): T[];
    }
  2007. 17 of 41 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2008. mean non-conventional identifier length 1.52 over 61 names (token pass, confidence 0.50)

  2009. 23 of 50 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2010. 31 of 39 non-conventional identifiers are single-character (79%) (token pass, confidence 0.50)

  2011. 31 of 40 non-conventional identifiers are single-character (78%) (token pass, confidence 0.50)

  2012. 61 of 145 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2013. 27 of 67 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2014. 146 of 350 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2015. 25 of 52 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2016. file mixes tab and space indentation (2 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    interface A {
    	a: number;
    }
  2017. file mixes tab and space indentation (1 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    declare class FooBase {⟨U+000D⟩
        constructor(s: string);⟨U+000D⟩
        constructor(n: number);⟨U+000D⟩
        constructor(x: any) {
  2018. 22 of 45 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2019. mean non-conventional identifier length 1.40 over 35 names (token pass, confidence 0.50)

  2020. 20 of 30 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  2021. 15 of 36 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2022. 16 of 39 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2023. 17 of 41 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2024. 17 of 42 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2025. 352 of 630 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2026. 14 of 32 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2027. mean non-conventional identifier length 1.86 over 28 names (token pass, confidence 0.50)

  2028. 85 of 161 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2029. 17 of 37 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2030. 26 of 54 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2031. 26 of 61 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2032. 16 of 39 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2033. file mixes tab and space indentation (28 tab-indented and 24 space-indented lines) (raw pass, confidence 0.40)

    function referencedInCode({ name: alias }: Named) {⟨U+000D⟩
        return alias;⟨U+000D⟩
    }
  2034. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    export class ExportedClass<T> {⟨U+000D⟩
    	x: T;⟨U+000D⟩
    }
  2035. 44 of 99 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2036. 63 of 139 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2037. 26 of 52 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2038. 29 of 61 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2039. 14 of 31 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2040. 19 of 42 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2041. mean non-conventional identifier length 1.95 over 110 names (token pass, confidence 0.50)

  2042. 15 of 37 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2043. 71 of 145 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2044. 22 of 55 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2045. 19 of 47 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2046. file mixes tab and space indentation (1 tab-indented and 20 space-indented lines) (raw pass, confidence 0.40)

    {
      "name": "package-b",
      "type": "module",
      "exports": {
  2047. 18 of 35 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2048. 28 of 44 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  2049. 37 of 70 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2050. 101 of 211 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2051. 31 of 74 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2052. file mixes tab and space indentation (6 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    class C {⟨U+000D⟩
    	fun(a: string);⟨U+000D⟩
    	fun(a = 3);⟨U+000D⟩
    	fun(a = null) { }
  2053. 39 of 89 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2054. 58 of 122 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2055. 20 of 50 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2056. file mixes tab and space indentation (4 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    if (null as any) {⟨U+000D⟩
        ({ exportedFoo, nonexportedFoo } = null as any);⟨U+000D⟩
    }⟨U+000D⟩
    else if (null as any) {
  2057. 16 of 38 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2058. 103 of 257 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2059. file mixes tab and space indentation (18 tab-indented and 37 space-indented lines) (raw pass, confidence 0.40)

    type Issue1<A, B extends A> =⟨U+000D⟩
      A extends unknown ?⟨U+000D⟩
        B extends unknown ?⟨U+000D⟩
            Show<A, B> :  // Error
  2060. 15 of 33 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2061. file mixes tab and space indentation (7 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    namespace M {⟨U+000D⟩
        export namespace N {⟨U+000D⟩
    	export function f(x:number)=>2*x;⟨U+000D⟩
    	export namespace X.Y.Z {
  2062. 16 of 40 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2063. 26 of 44 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  2064. 26 of 44 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  2065. 18 of 36 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2066. 16 of 40 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2067. 49 of 78 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  2068. 49 of 78 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  2069. 20 of 33 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  2070. 17 of 31 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2071. 33 of 82 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2072. mean non-conventional identifier length 1.86 over 28 names (token pass, confidence 0.50)

  2073. 29 of 50 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  2074. 26 of 45 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  2075. 14 of 33 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2076. 22 of 53 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2077. file mixes tab and space indentation (6 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    class A {⟨U+000D⟩
    	constructor(str1:string, str2:string) {}⟨U+000D⟩
    }⟨U+000D⟩
    class B extends A {
  2078. file mixes tab and space indentation (18 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    class Bar {⟨U+000D⟩
        public goo: number;⟨U+000D⟩
        public prop1(x) {⟨U+000D⟩
            return x;
  2079. file mixes tab and space indentation (10 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    namespace M {	⟨U+000D⟩
    	class Visibility {⟨U+000D⟩
    	    public foo() { };⟨U+000D⟩
    	    private bar() { };
  2080. file mixes tab and space indentation (3 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    class C1T5 {⟨U+000D⟩
        foo: (i: number, s: string) => number = ⟨U+000D⟩
    	   	(i) => {⟨U+000D⟩
    	        return i;
  2081. 16 of 30 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2082. 16 of 35 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2083. file mixes tab and space indentation (1 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    declare namespace http {⟨U+000D⟩
    	export interface Server { openPort: number; }⟨U+000D⟩
    }
  2084. file mixes tab and space indentation (1 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    //@module: commonjs⟨U+000D⟩
        export declare class eaC {⟨U+000D⟩
            static tF() { };⟨U+000D⟩
            static tsF(param:any) { };
  2085. file mixes tab and space indentation (3 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    export interface ProgressCallback {⟨U+000D⟩
    	(progress:any):any;⟨U+000D⟩
    }	
  2086. mean non-conventional identifier length 1.17 over 260 names (token pass, confidence 0.50)

  2087. file mixes tab and space indentation (1 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    namespace M {⟨U+000D⟩
        export class B {⟨U+000D⟩
    	    public x=10;⟨U+000D⟩
        }
  2088. 14 of 35 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2089. file mixes tab and space indentation (23 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    declare module {⟨U+000D⟩
        export class XDate {⟨U+000D⟩
    		public getDay():number;⟨U+000D⟩
    		public getXDate():number;
  2090. file mixes tab and space indentation (1 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    function foo(x:any) {⟨U+000D⟩
    	return x();⟨U+000D⟩
    }
  2091. mean non-conventional identifier length 1.60 over 20 names (token pass, confidence 0.50)

  2092. 19 of 43 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2093. 23 of 33 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)

  2094. file mixes tab and space indentation (2 tab-indented and 21 space-indented lines) (raw pass, confidence 0.40)

    function f1() {⟨U+000D⟩
        if (!!true) {⟨U+000D⟩
            return { valid: true }⟨U+000D⟩
        }
  2095. file mixes tab and space indentation (4 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    function foo(x: A) {⟨U+000D⟩
       var x: B = new B();⟨U+000D⟩
         x.bar(); // the property bar does not exist on a value of type A⟨U+000D⟩
    }
  2096. 22 of 34 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  2097. 23 of 51 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2098. 20 of 36 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2099. 14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2100. 17 of 37 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2101. 29 of 64 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2102. 14 of 32 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2103. 25 of 57 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2104. 956 of 1631 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  2105. 26 of 44 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  2106. 33 of 71 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2107. 51 of 92 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2108. 41 of 65 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  2109. 24 of 58 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2110. 23 of 41 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2111. 23 of 41 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2112. 33 of 65 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2113. 60 of 141 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2114. 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2115. 19 of 39 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2116. 17 of 42 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2117. 31 of 59 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2118. 25 of 42 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  2119. 32 of 64 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2120. 26 of 47 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2121. mean non-conventional identifier length 1.27 over 67 names (token pass, confidence 0.50)

  2122. 44 of 63 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)

  2123. 39 of 70 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2124. 15 of 30 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2125. 13 of 30 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2126. 22 of 30 non-conventional identifiers are single-character (73%) (token pass, confidence 0.50)

  2127. 20 of 38 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2128. 20 of 42 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2129. 59 of 88 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  2130. mean non-conventional identifier length 1.89 over 63 names (token pass, confidence 0.50)

  2131. file mixes tab and space indentation (15 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    interface I {⟨U+000D⟩
        ({descendants, read}?: {⟨U+000D⟩
            descendants?: boolean;⟨U+000D⟩
            read?: any;
  2132. file mixes tab and space indentation (14 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    interface Red {⟨U+000D⟩
    	[n:number]; // ok⟨U+000D⟩
    	[s:string]; // ok⟨U+000D⟩
    }
  2133. 31 of 54 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  2134. 20 of 32 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  2135. 16 of 38 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2136. 34 of 74 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2137. 33 of 62 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2138. 47 of 109 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2139. file mixes tab and space indentation (16 tab-indented and 53 space-indented lines) (raw pass, confidence 0.40)

    function truePromise(): Promise<true> {
        return Promise.resolve(true);
    }
  2140. 17 of 32 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2141. file mixes tab and space indentation (2 tab-indented and 93 space-indented lines) (raw pass, confidence 0.40)

    const evenSquaresInline: number[] =  // should error
        [1, 2, 3, 4]
            .map(x => x % 2 === 0 ? x * x : null)
            .filter(x => !!x); // tests truthiness, not non-nullishness
  2142. 60 of 144 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2143. 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2144. 13 of 31 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2145. file mixes tab and space indentation (7 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    export type inferPipe<t, pipe> =
        pipe extends (In: t) => unknown ? (In: t) => ReturnType<pipe> : never
    
    interface Type<t> {
  2146. 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2147. 25 of 39 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  2148. file mixes tab and space indentation (3 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    interface A {⟨U+000D⟩
      (key:string):void;⟨U+000D⟩
    }
  2149. 20 of 33 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  2150. 24 of 57 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2151. file mixes tab and space indentation (2 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

     
    	function inner(n) {
                    // this line should raise an error
                    // otherwise, there's a bug in overload resolution / partial typechecking
  2152. 25 of 32 non-conventional identifiers are single-character (78%) (token pass, confidence 0.50)

  2153. file mixes tab and space indentation (21 tab-indented and 38 space-indented lines) (raw pass, confidence 0.40)

    export interface A<a> {⟨U+000D⟩
        value: a;⟨U+000D⟩
    }
  2154. 33 of 51 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  2155. file mixes tab and space indentation (3 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)

    interface I1 {⟨U+000D⟩
        item:number;⟨U+000D⟩
        item:number;⟨U+000D⟩
    }
  2156. file mixes tab and space indentation (2 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    namespace Foo {⟨U+000D⟩
        export interface I1 { item: string; }⟨U+000D⟩
        export class C1 { }⟨U+000D⟩
    }
  2157. 19 of 46 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2158. file mixes tab and space indentation (2 tab-indented and 14 space-indented lines) (raw pass, confidence 0.40)

    interface I1 {⟨U+000D⟩
        iObj:{ };⟨U+000D⟩
        iNum:number;⟨U+000D⟩
        iAny:any;
  2159. file mixes tab and space indentation (2 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    interface I1 {⟨U+000D⟩
        i1P1: number;⟨U+000D⟩
        i1P2(): void;⟨U+000D⟩
    }
  2160. 15 of 30 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2161. line length 915 characters (raw pass, confidence 0.50)

    class __Mixin27Base extends (Object as unknown as AnyConstructor & ClassStatics<typeof Mixin0> & ClassStatics<typeof Mixin1> & ClassStatics<typeof Mixin2> & ClassStatics<typeof Mixin3> & ClassStatics<typeof Mixin4> & ClassStatics<typeof Mixin5> & ClassStatics<typeof Mixin6> & ClassStatics<typeof Mixin7> & ClassStatics<
  2162. line length 925 characters (raw pass, confidence 0.50)

    class __ConsumerBase extends (__ConsumerEmpty as unknown as AnyConstructor & ClassStatics<typeof Mixin0> & ClassStatics<typeof Mixin1> & ClassStatics<typeof Mixin2> & ClassStatics<typeof Mixin3> & ClassStatics<typeof Mixin4> & ClassStatics<typeof Mixin5> & ClassStatics<typeof Mixin6> & ClassStatics<typeof Mixin7> & Cla
  2163. file mixes tab and space indentation (9 tab-indented and 15 space-indented lines) (raw pass, confidence 0.40)

    function f1(node: A | B) {⟨U+000D⟩
      if (node instanceof A || node instanceof A) {⟨U+000D⟩
        node;  // A⟨U+000D⟩
      }
  2164. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

    // A lone surrogate has no case mapping, so it passes through unchanged.
    type U = Uppercase<"\uD800">;
    type L = Lowercase<"A\uD800B">;
    type C = Capitalize<"\uDC00x">;
  2165. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

    type U = Uppercase<"\uD800">;
    type L = Lowercase<"A\uD800B">;
    type C = Capitalize<"\uDC00x">;
    type Un = Uncapitalize<"\uD834X">;
  2166. orphaned low surrogate \uDC00 (no preceding high surrogate) (token pass, confidence 0.65)

    type L = Lowercase<"A\uD800B">;
    type C = Capitalize<"\uDC00x">;
    type Un = Uncapitalize<"\uD834X">;
  2167. orphaned high surrogate \uD834 (no matching low surrogate) (token pass, confidence 0.65)

    type C = Capitalize<"\uDC00x">;
    type Un = Uncapitalize<"\uD834X">;
    
    const u: "\uD800" = "x" as unknown as U;
  2168. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

    
    const u: "\uD800" = "x" as unknown as U;
    const l: "a\uD800b" = "x" as unknown as L;
  2169. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

    const u: "\uD800" = "x" as unknown as U;
    const l: "a\uD800b" = "x" as unknown as L;
  2170. 29 of 68 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2171. 20 of 41 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2172. file mixes tab and space indentation (2 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    const SomeConstructor = function Named() {⟨U+000D⟩
    	this.x = 1;⟨U+000D⟩
    };
  2173. file mixes tab and space indentation (10 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function Color(obj) {⟨U+000D⟩
        this.example = true⟨U+000D⟩
    };⟨U+000D⟩
    Color.prototype = {
  2174. 22 of 55 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2175. file mixes tab and space indentation (9 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  2176. file mixes tab and space indentation (2 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)

    declare global {
        namespace JSX {
            type Element = any;
            interface ElementAttributesProperty {
  2177. file mixes tab and space indentation (9 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  2178. file mixes tab and space indentation (9 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  2179. file mixes tab and space indentation (9 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  2180. file mixes tab and space indentation (9 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  2181. file mixes tab and space indentation (9 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  2182. 22 of 44 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2183. file mixes tab and space indentation (6 tab-indented and 52 space-indented lines) (raw pass, confidence 0.40)

    type Defaultize<Props, Defaults> =⟨U+000D⟩
    	// Distribute over unions⟨U+000D⟩
    	Props extends any // Make any properties included in Default optional⟨U+000D⟩
    		? Partial<Pick<Props, Extract<keyof Props, keyof Defaults>>> &
  2184. file mixes tab and space indentation (6 tab-indented and 52 space-indented lines) (raw pass, confidence 0.40)

    type Defaultize<Props, Defaults> =⟨U+000D⟩
    	// Distribute over unions⟨U+000D⟩
    	Props extends any // Make any properties included in Default optional⟨U+000D⟩
    		? Partial<Pick<Props, Extract<keyof Props, keyof Defaults>>> &
  2185. file mixes tab and space indentation (6 tab-indented and 50 space-indented lines) (raw pass, confidence 0.40)

    type Defaultize<Props, Defaults> =⟨U+000D⟩
    	// Distribute over unions⟨U+000D⟩
    	Props extends any // Make any properties included in Default optional⟨U+000D⟩
    		? Partial<Pick<Props, Extract<keyof Props, keyof Defaults>>> &
  2186. 19 of 39 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2187. 67 of 164 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2188. file mixes tab and space indentation (3 tab-indented and 25 space-indented lines) (raw pass, confidence 0.40)

    
        export class Buffer {
        	lines: List<Line> = ListMakeHead<Line>();
            
  2189. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

    
    const x: "\uD800" = "\uDC00";
  2190. orphaned low surrogate \uDC00 (no preceding high surrogate) (token pass, confidence 0.65)

    
    const x: "\uD800" = "\uDC00";
  2191. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    interface ISomething {⟨U+000D⟩
       something: number;⟨U+000D⟩
    }
  2192. 17 of 41 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2193. 27 of 57 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2194. 16 of 37 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2195. 16 of 37 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2196. 29 of 68 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2197. 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2198. 37 of 81 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2199. 18 of 32 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2200. 20 of 43 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2201. 21 of 43 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2202. file mixes tab and space indentation (14 tab-indented and 24 space-indented lines) (raw pass, confidence 0.40)

    class A {
        public pb: number = 2;
        protected ptd: number = 1;
        private pvt: number = 0;
  2203. file mixes tab and space indentation (3 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    namespace mod1 {⟨U+000D⟩
    	interface mInt {⟨U+000D⟩
    		new (bar:any):any;⟨U+000D⟩
            foo (bar:any):any;
  2204. file mixes tab and space indentation (33 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    namespace OuterMod {⟨U+000D⟩
    	export function someExportedOuterFunc() { return -1; }⟨U+000D⟩
    ⟨U+000D⟩
    	export namespace OuterInnerMod {
  2205. file mixes tab and space indentation (33 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    namespace OuterMod {⟨U+000D⟩
    	export function someExportedOuterFunc() { return -1; }⟨U+000D⟩
    ⟨U+000D⟩
    	export namespace OuterInnerMod {
  2206. 16 of 31 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  2207. 24 of 59 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2208. file mixes tab and space indentation (14 tab-indented and 123 space-indented lines) (raw pass, confidence 0.40)

    function fx1(x: string | number | undefined) {⟨U+000D⟩
        if (isFalsy(x)) {⟨U+000D⟩
            x;  // "" | 0 | undefined⟨U+000D⟩
        }
  2209. mean non-conventional identifier length 1.52 over 25 names (token pass, confidence 0.50)

  2210. 27 of 42 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  2211. 48 of 115 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2212. file mixes tab and space indentation (2 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    interface Obj<T> {⟨U+000D⟩
    	ref: T;⟨U+000D⟩
    }⟨U+000D⟩
    interface Func<T> {
  2213. 20 of 46 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2214. 22 of 32 non-conventional identifiers are single-character (69%) (token pass, confidence 0.50)

  2215. 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2216. 17 of 32 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2217. 20 of 34 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  2218. 36 of 63 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  2219. 93 of 163 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  2220. 25 of 56 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2221. 18 of 43 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2222. 40 of 84 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2223. 23 of 46 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2224. file mixes tab and space indentation (3 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    function attr(nameOrMap: any, value?: string): any {⟨U+000D⟩
        if (nameOrMap && typeof nameOrMap === "object") {⟨U+000D⟩
            // handle map case⟨U+000D⟩
            return new Accessor;
  2225. 39 of 61 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  2226. mean non-conventional identifier length 1.03 over 797 names (token pass, confidence 0.50)

  2227. 15 of 32 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2228. file mixes tab and space indentation (4 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    class Foo {⟨U+000D⟩
    	public pubMeth() {this.privMeth();}⟨U+000D⟩
    	private privMeth() {}⟨U+000D⟩
    	public pubProp = 0;
  2229. 28 of 67 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2230. 18 of 40 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2231. 22 of 48 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2232. 28 of 67 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2233. 32 of 65 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2234. line length 620 characters (raw pass, confidence 0.50)

        type KnownIterationMapKeys = '-40' | '-39' | '-38' | '-37' | '-36' | '-35' | '-34' | '-33' | '-32' | '-31' | '-30' | '-29' | '-28' | '-27' | '-26' | '-25' | '-24' | '-23' | '-22' | '-21' | '-20' | '-19' | '-18' | '-17' | '-16' | '-15' | '-14' | '-13' | '-12' | '-11' | '-10' | '-9' | '-8' | '-7' | '-6' | '-5' | '-4'
  2235. 14 of 32 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2236. 66 of 134 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2237. file mixes tab and space indentation (48 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    ⟨U+000D⟩
    	export interface IWidget {⟨U+000D⟩
    		getDomNode(): any;⟨U+000D⟩
    		destroy();
  2238. 25 of 32 non-conventional identifiers are single-character (78%) (token pass, confidence 0.50)

  2239. 18 of 39 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2240. 18 of 38 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2241. 23 of 52 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2242. file mixes tab and space indentation (2 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    interface Entity<T extends Entity<T>> {
       X: T;
       Y: T;
    }
  2243. 25 of 37 non-conventional identifiers are single-character (68%) (token pass, confidence 0.50)

  2244. file mixes tab and space indentation (7 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    export namespace Models {⟨U+000D⟩
    	export class Person {⟨U+000D⟩
            constructor(name: string) { }⟨U+000D⟩
    	}
  2245. 31 of 62 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2246. line length 560 characters (raw pass, confidence 0.50)

        solomonis() : panglima.abidi<quasiater.carolinensis, rendalli.crenulata<gabriellae.klossii<julianae.nudicaudus, dogramacii.aurata>, argurus.netscheri<minutus.inez<argurus.peninsulae, julianae.nudicaudus>, julianae.oralis<lavali.xanthognathus, argurus.oreas>>>> { var x : panglima.abidi<quasiater.carolinensis, rendal
  2247. line length 518 characters (raw pass, confidence 0.50)

        morrisi() : ruatanica.hector<trivirgatus.oconnelli, sagitta.cinereus<nigra.caucasica<julianae.sumatrana, trivirgatus.oconnelli>, quasiater.wattsi<julianae.galapagoensis, panamensis.linulus<lavali.xanthognathus, macrorhinos.konganensis>>>> { var x : ruatanica.hector<trivirgatus.oconnelli, sagitta.cinereus<nigra.cauc
  2248. line length 520 characters (raw pass, confidence 0.50)

            simulator(): macrorhinos.marmosurus<Lanthanum.nitidus<dammermani.melanops, lavali.lepturus>, macrorhinos.marmosurus<rendalli.moojeni<panglima.amphibius<trivirgatus.falconeri, caurinus.psilurus>, gabriellae.echinatus>, sagitta.stolzmanni>> { var x: macrorhinos.marmosurus<Lanthanum.nitidus<dammermani.melanops, la
  2249. line length 590 characters (raw pass, confidence 0.50)

            beatrix(): imperfecta.ciliolabrum<provocax.melanoleuca, panglima.amphibius<minutus.inez<rendalli.moojeni<panglima.amphibius<trivirgatus.falconeri, caurinus.psilurus>, gabriellae.echinatus>, dogramacii.aurata>, imperfecta.ciliolabrum<quasiater.carolinensis, lavali.beisa>>> { var x: imperfecta.ciliolabrum<provoca
  2250. line length 610 characters (raw pass, confidence 0.50)

            pilirostris(): argurus.wetmorei<imperfecta.lasiurus<panglima.amphibius<patas.uralensis, gabriellae.klossii<julianae.nudicaudus, dogramacii.aurata>>, sagitta.leptoceros<lutreolus.punicus, daubentonii.arboreus<quasiater.carolinensis, rionegrensis.caniventer>>>, macrorhinos.konganensis> { var x: argurus.wetmorei<i
  2251. line length 582 characters (raw pass, confidence 0.50)

            palmeri(): panglima.amphibius<howi.coludo<macrorhinos.daphaenodon, panglima.amphibius<macrorhinos.daphaenodon, patas.uralensis>>, trivirgatus.mixtus<argurus.dauricus<dogramacii.aurata, dammermani.melanops>, panglima.amphibius<lavali.lepturus, quasiater.carolinensis>>> { var x: panglima.amphibius<howi.coludo<mac
  2252. 23 of 52 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2253. file mixes tab and space indentation (8 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)

    interface MouseEvent {⟨U+000D⟩
        x: number;⟨U+000D⟩
        y: number;⟨U+000D⟩
    }
  2254. file mixes tab and space indentation (3 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    {⟨U+000D⟩
        export class Test⟨U+000D⟩
        {⟨U+000D⟩
          private name = "hello";
  2255. 15 of 36 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2256. identifier `啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ` mixes scripts: Han + Other (in string/comment) (raw pass, confidence 0.40)

    
    // @Filename: ①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].ts
    var a = 1;
    var b = 2;
  2257. identifier `〇㐀㐁䶴䶵U1` mixes scripts: Other + Han + Latin (in string/comment) (raw pass, confidence 0.40)

    
    // @Filename: ①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].ts
    var a = 1;
    var b = 2;
  2258. 28 of 52 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  2259. 36 of 79 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2260. 22 of 46 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2261. file mixes tab and space indentation (1 tab-indented and 115 space-indented lines) (raw pass, confidence 0.40)

    function outer<T>(x: T) {⟨U+000D⟩
      class Inner {⟨U+000D⟩
        static y: T = x;⟨U+000D⟩
      }
  2262. file mixes tab and space indentation (4 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    class C {⟨U+000D⟩
    	static s;⟨U+000D⟩
    	public a() {⟨U+000D⟩
    		s = 1;
  2263. 44 of 101 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2264. 30 of 46 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  2265. identifier `fioo` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    
    type Upper = Uppercase<"ßfoo" | "fioo">;
    
    const upperMap: Record<Upper, string> = {
  2266. identifier `fioo` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    
    type Capitalized = Capitalize<"ßfoo" | "fioo">;
    
    const capitalizedMap: Record<Capitalized, string> = {
  2267. file mixes tab and space indentation (3 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    function R1(index: number) {⟨U+000D⟩
        switch (index) {⟨U+000D⟩
            case 0:⟨U+000D⟩
            case 1:
  2268. file mixes tab and space indentation (1 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    {⟨U+000D⟩
      "name": "styled-components",⟨U+000D⟩
      "version": "3.3.3",⟨U+000D⟩
      "typings": "typings/styled-components.d.ts"
  2269. surrogate pair \uD83D\uDCA9 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    
    f `'\u{1f4a9}'${ " should be converted to " }'\uD83D\uDCA9'`;
  2270. surrogate pair \uD83D\uDCA9 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    
    f `'\u{1f4a9}'${ " should be converted to " }'\uD83D\uDCA9'`;
  2271. file mixes tab and space indentation (11 tab-indented and 15 space-indented lines) (raw pass, confidence 0.40)

    {⟨U+000D⟩
          constructor(x: number, y: number);⟨U+000D⟩
          public x: number;⟨U+000D⟩
          public y: number;
  2272. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

    
    type H = Head<"\uD800abc">;
    type R = Rest<"\uD800abc">;
  2273. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

    type H = Head<"\uD800abc">;
    type R = Rest<"\uD800abc">;
    
    const h: "\uD800" = "x" as unknown as H;
  2274. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

    
    const h: "\uD800" = "x" as unknown as H;
    const r: "abc" = "x" as unknown as R;
  2275. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // "😀", with no leftover lone surrogates.
    type Hi = "\uD83D";
    type Lo = "\uDE00";
    type Pair = `${Hi}${Lo}`;
  2276. orphaned low surrogate \uDE00 (no preceding high surrogate) (token pass, confidence 0.65)

    type Hi = "\uD83D";
    type Lo = "\uDE00";
    type Pair = `${Hi}${Lo}`;
  2277. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    type Gapped = `${Hi}-${Lo}`;
    const g: Gapped = "\uD83D-\uDE00";
  2278. orphaned low surrogate \uDE00 (no preceding high surrogate) (token pass, confidence 0.65)

    type Gapped = `${Hi}-${Lo}`;
    const g: Gapped = "\uD83D-\uDE00";
  2279. file mixes tab and space indentation (7 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    namespace M {⟨U+000D⟩
        export interface I {⟨U+000D⟩
    	z;⟨U+000D⟩
        }
  2280. 16 of 38 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2281. file mixes tab and space indentation (4 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    interface IPoint {⟨U+000D⟩
        x:number;⟨U+000D⟩
        y:number;⟨U+000D⟩
    }
  2282. line length 816 characters (raw pass, confidence 0.50)

    export enum SyntaxKind { Node0, Node1, Node2, Node3, Node4, Node5, Node6, Node7, Node8, Node9, Node10, Node11, Node12, Node13, Node14, Node15, Node16, Node17, Node18, Node19, Node20, Node21, Node22, Node23, Node24, Node25, Node26, Node27, Node28, Node29, Node30, Node31, Node32, Node33, Node34, Node35, Node36, Node37, N
  2283. line length 908 characters (raw pass, confidence 0.50)

    export type Node = Node0 | Node1 | Node2 | Node3 | Node4 | Node5 | Node6 | Node7 | Node8 | Node9 | Node10 | Node11 | Node12 | Node13 | Node14 | Node15 | Node16 | Node17 | Node18 | Node19 | Node20 | Node21 | Node22 | Node23 | Node24 | Node25 | Node26 | Node27 | Node28 | Node29 | Node30 | Node31 | Node32 | Node33 | Node3
  2284. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    namespace JSX {⟨U+000D⟩
        export interface IntrinsicElements {⟨U+000D⟩
            span: {};⟨U+000D⟩
        }
  2285. 48 of 83 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  2286. 51 of 85 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  2287. 26 of 38 non-conventional identifiers are single-character (68%) (token pass, confidence 0.50)

  2288. 34 of 65 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  2289. file mixes tab and space indentation (3 tab-indented and 27 space-indented lines) (raw pass, confidence 0.40)

    function f1() {⟨U+000D⟩
    	var a = { x: 1, y: 2 };⟨U+000D⟩
    	a = {}; // error⟨U+000D⟩
        a = { x: 1 }; // error
  2290. 14 of 33 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2291. 42 of 100 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2292. 16 of 34 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2293. 26 of 63 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2294. 32 of 45 non-conventional identifiers are single-character (71%) (token pass, confidence 0.50)

  2295. 26 of 37 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)

  2296. 27 of 48 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2297. 26 of 37 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)

  2298. 26 of 47 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2299. mean non-conventional identifier length 1.53 over 30 names (token pass, confidence 0.50)

  2300. file mixes tab and space indentation (4 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    namespace M{
    	class A{
    		constructor(val:string){}
    	}
  2301. U+00AD SOFT HYPHEN in source (in string/comment) (raw pass, confidence 0.45)

    // @target: es2015
    var ੳ = "Ü⟨U+00AD⟩ਲ⟨U+000E⟩ĭ";
  2302. surrogate pair \uD83D\uDE03 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    // low-high surrogate pair - the "correct" case
    export const highLow = "\ud83d\ude03" as const;
    
    // high surrogate
  2303. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // high surrogate
    export const high = "\ud83d" as const;
    
    // low surrogate
  2304. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // low surrogate
    export const low = "\ude03" as const;
    
    // two high surrogates
  2305. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // two high surrogates
    export const highHigh = "\ud83d\ud83d" as const;
    
    // two low surrogates
  2306. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // two high surrogates
    export const highHigh = "\ud83d\ud83d" as const;
    
    // two low surrogates
  2307. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // two low surrogates
    export const lowLow = "\ude03\ude03" as const;
    
    // swapped expected order of surrogates
  2308. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // two low surrogates
    export const lowLow = "\ude03\ude03" as const;
    
    // swapped expected order of surrogates
  2309. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // swapped expected order of surrogates
    export const lowHigh = "\ude03\ud83d" as const;
  2310. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // swapped expected order of surrogates
    export const lowHigh = "\ude03\ud83d" as const;
  2311. 17 of 33 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  2312. file mixes tab and space indentation (1 tab-indented and 16 space-indented lines) (raw pass, confidence 0.40)

    declare class Test<T> {⟨U+000D⟩
        obj: T;⟨U+000D⟩
        get<K extends keyof T>(k: K): T[K];⟨U+000D⟩
    }
  2313. file mixes tab and space indentation (16 tab-indented and 31 space-indented lines) (raw pass, confidence 0.40)

    function func1() {⟨U+000D⟩
        aFunc();⟨U+000D⟩
    ⟨U+000D⟩
        console.log(EnumA.Value);
  2314. 23 of 33 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)

  2315. 21 of 45 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2316. 21 of 52 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2317. 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2318. 23 of 42 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2319. 31 of 74 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2320. 24 of 36 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  2321. 23 of 49 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2322. file mixes tab and space indentation (10 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    let o = {⟨U+000D⟩
    	async m1() { },⟨U+000D⟩
    	async m2(): Promise<void> { },⟨U+000D⟩
    	async m3(): MyPromise<void> { }
  2323. file mixes tab and space indentation (10 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    let o = {⟨U+000D⟩
    	async m1() { },⟨U+000D⟩
    	async m2(): Promise<void> { },⟨U+000D⟩
    	async m3(): MyPromise<void> { }
  2324. file mixes tab and space indentation (10 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    let o = {⟨U+000D⟩
    	async m1() { },⟨U+000D⟩
    	async m2(): Promise<void> { },⟨U+000D⟩
    	async m3(): MyPromise<void> { }
  2325. 35 of 63 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2326. 21 of 38 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2327. 24 of 60 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2328. 22 of 50 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2329. 17 of 37 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2330. 41 of 90 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2331. 30 of 74 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2332. 16 of 37 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2333. 16 of 40 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2334. 25 of 48 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  2335. 16 of 40 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2336. 34 of 85 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2337. 17 of 42 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2338. 23 of 52 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2339. 21 of 46 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2340. 14 of 31 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2341. 42 of 78 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  2342. 16 of 33 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2343. 24 of 41 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  2344. mean non-conventional identifier length 1.88 over 26 names (token pass, confidence 0.50)

  2345. 19 of 30 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  2346. 81 of 168 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2347. 25 of 59 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2348. file mixes tab and space indentation (1 tab-indented and 32 space-indented lines) (raw pass, confidence 0.40)

    class C1 {⟨U+000D⟩
        a!: number;⟨U+000D⟩
        b: string;  // Error⟨U+000D⟩
    }
  2349. 87 of 120 non-conventional identifiers are single-character (72%) (token pass, confidence 0.50)

  2350. file mixes tab and space indentation (19 tab-indented and 123 space-indented lines) (raw pass, confidence 0.40)

    function f1(x: 1 | 2): string {⟨U+000D⟩
        if (!!true) {⟨U+000D⟩
            switch (x) {⟨U+000D⟩
                case 1: return 'a';
  2351. file mixes tab and space indentation (48 tab-indented and 123 space-indented lines) (raw pass, confidence 0.40)

    function fail(message?: string): never {⟨U+000D⟩
        throw new Error(message);⟨U+000D⟩
    }
  2352. 30 of 51 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  2353. 51 of 111 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2354. 37 of 64 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  2355. 23 of 40 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  2356. 19 of 35 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  2357. 23 of 43 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2358. 22 of 44 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2359. 39 of 66 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  2360. 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2361. mean non-conventional identifier length 1.42 over 45 names (token pass, confidence 0.50)

  2362. mean non-conventional identifier length 1.57 over 23 names (token pass, confidence 0.50)

  2363. file mixes tab and space indentation (6 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    var a = () => {⟨U+000D⟩
        var arg = arguments[0];  // error⟨U+000D⟩
    }
  2364. file mixes tab and space indentation (6 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    var a = () => {⟨U+000D⟩
        var arg = arguments[0];  // error⟨U+000D⟩
    }
  2365. line length 589 characters (raw pass, confidence 0.50)

    var oct3 = 0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  2366. line length 587 characters (raw pass, confidence 0.50)

        0o77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  2367. line length 589 characters (raw pass, confidence 0.50)

    var oct3 = 0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  2368. line length 587 characters (raw pass, confidence 0.50)

        0o77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  2369. 24 of 46 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  2370. 18 of 31 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  2371. 18 of 31 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  2372. file mixes tab and space indentation (1 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    class C {⟨U+000D⟩
        ["hello"]() {⟨U+000D⟩
            debugger;⟨U+000D⟩
        }
  2373. file mixes tab and space indentation (4 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    class C {⟨U+000D⟩
        ["hello"]() {⟨U+000D⟩
            debugger;⟨U+000D⟩
    	}
  2374. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    var v = {⟨U+000D⟩
        ["hello"]() {⟨U+000D⟩
            debugger;⟨U+000D⟩
    	},
  2375. file mixes tab and space indentation (4 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    var v = {⟨U+000D⟩
        ["hello"]() {⟨U+000D⟩
            debugger;⟨U+000D⟩
    	},
  2376. 26 of 32 non-conventional identifiers are single-character (81%) (token pass, confidence 0.50)

  2377. 37 of 69 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  2378. file mixes tab and space indentation (1 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    enum K {
        a = "a",
        b = "b"
    }
  2379. file mixes tab and space indentation (1 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    const K = {
        a: "a",
        b: "b"
    }
  2380. 58 of 80 non-conventional identifiers are single-character (72%) (token pass, confidence 0.50)

  2381. 58 of 80 non-conventional identifiers are single-character (72%) (token pass, confidence 0.50)

  2382. 21 of 40 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  2383. 21 of 40 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  2384. 20 of 37 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  2385. 20 of 37 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  2386. mean non-conventional identifier length 1.82 over 67 names (token pass, confidence 0.50)

  2387. mean non-conventional identifier length 1.81 over 72 names (token pass, confidence 0.50)

  2388. 119 of 234 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2389. mean non-conventional identifier length 1.91 over 22 names (token pass, confidence 0.50)

  2390. 30 of 63 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2391. 55 of 86 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  2392. 22 of 49 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2393. 36 of 81 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2394. 51 of 117 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2395. 16 of 37 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2396. mean non-conventional identifier length 1.85 over 75 names (token pass, confidence 0.50)

  2397. 53 of 112 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2398. mean non-conventional identifier length 1.95 over 553 names (token pass, confidence 0.50)

  2399. mean non-conventional identifier length 1.95 over 558 names (token pass, confidence 0.50)

  2400. 1091 of 2070 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2401. 228 of 459 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2402. mean non-conventional identifier length 1.89 over 37 names (token pass, confidence 0.50)

  2403. 36 of 80 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2404. 330 of 665 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2405. 259 of 515 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2406. mean non-conventional identifier length 1.93 over 219 names (token pass, confidence 0.50)

  2407. 41 of 80 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2408. mean non-conventional identifier length 1.80 over 35 names (token pass, confidence 0.50)

  2409. 139 of 272 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2410. mean non-conventional identifier length 1.87 over 54 names (token pass, confidence 0.50)

  2411. 54 of 93 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  2412. 30 of 59 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2413. 20 of 31 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  2414. 96 of 169 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  2415. 96 of 169 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  2416. 96 of 169 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  2417. 26 of 53 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2418. 16 of 31 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  2419. 39 of 93 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2420. 26 of 55 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2421. 26 of 55 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2422. 39 of 51 non-conventional identifiers are single-character (76%) (token pass, confidence 0.50)

  2423. mean non-conventional identifier length 1.45 over 40 names (token pass, confidence 0.50)

  2424. 51 of 104 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2425. 33 of 78 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2426. mean non-conventional identifier length 1.96 over 73 names (token pass, confidence 0.50)

  2427. 32 of 70 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2428. file mixes tab and space indentation (1 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    class SomeBase {⟨U+000D⟩
        private p;⟨U+000D⟩
    }⟨U+000D⟩
    class SomeDerived extends SomeBase {
  2429. 20 of 48 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2430. file mixes tab and space indentation (8 tab-indented and 128 space-indented lines) (raw pass, confidence 0.40)

    function test1(a: any) {⟨U+000D⟩
        if (typeof a !== "undefined") {⟨U+000D⟩
            if (typeof a === "boolean") {⟨U+000D⟩
                a;
  2431. 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2432. 17 of 39 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2433. 19 of 36 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2434. 16 of 32 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2435. 16 of 36 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2436. 16 of 40 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2437. line length 1633 characters (raw pass, confidence 0.50)

            shortPattern: /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\
  2438. 55 of 84 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  2439. file mixes tab and space indentation (6 tab-indented and 35 space-indented lines) (raw pass, confidence 0.40)

    function* g001() { // Generator<undefined, void, unknown>⟨U+000D⟩
        yield;⟨U+000D⟩
    }
  2440. file mixes tab and space indentation (6 tab-indented and 37 space-indented lines) (raw pass, confidence 0.40)

    function* g001() { // Generator<any (implicit), void, unknown>⟨U+000D⟩
        yield;⟨U+000D⟩
    }
  2441. file mixes tab and space indentation (4 tab-indented and 64 space-indented lines) (raw pass, confidence 0.40)

    f1<0, 0, 1>(function* () {⟨U+000D⟩
    	const a = yield 0;⟨U+000D⟩
    	return 0;⟨U+000D⟩
    });
  2442. file mixes tab and space indentation (2 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    declare global {
        interface ImportAttributes {
            type: "json"
        }
  2443. `Function(...)` called with a non-literal body (ast pass, confidence 0.75)

    
    Function(import.defer);
    
    import.defer
    likely benign LLM, confidence 0.93 Conformance test for invalid import.defer syntax inside a Function call.
    Reasoning

    This is a TypeScript conformance test for invalid import.defer usage. The Function call wraps a syntax-test expression and is not executed as an attack payload.

  2444. info critical → info by review dynamic-execution tsc/testdata/tests/cases/conformance/importSource/importSource11.ts:25:1

    `Function(...)` called with a non-literal body (ast pass, confidence 0.75)

    (import.source)("./a.js");
    Function(import.source);
    import.source.unknown;
    likely benign LLM, confidence 0.93 Conformance test fixture for import.source syntax.
    Reasoning

    Compiler conformance test for import.source syntax. The Function(import.source) line is a parser test input in a TypeScript test case.

  2445. info critical → info by review dynamic-execution tsc/testdata/tests/cases/conformance/importSource/importSource5.ts:10:1

    `Function(...)` called with a non-literal body (ast pass, confidence 0.75)

    (import.source)("./a.js");
    Function(import.source);
    import.source.unknown;
    likely benign LLM, confidence 0.93 Conformance test fixture for import.source syntax.
    Reasoning

    Compiler conformance test for import.source syntax, matching the baseline fixture. The Function call is a syntax test, not a malicious dropper.

  2446. file mixes tab and space indentation (1 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    function foo<T = number>(): [T] {⟨U+000D⟩
    	return [42 as any]⟨U+000D⟩
    }⟨U+000D⟩
    const [x] = foo();  // [number]
  2447. 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2448. 21 of 42 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2449. 35 of 72 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2450. 48 of 104 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2451. 27 of 53 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2452. 27 of 53 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2453. 45 of 68 non-conventional identifiers are single-character (66%) (token pass, confidence 0.50)

  2454. 33 of 52 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  2455. 44 of 93 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2456. 29 of 48 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  2457. 48 of 101 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2458. 28 of 59 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2459. 37 of 70 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2460. 15 of 34 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2461. file mixes tab and space indentation (5 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    class Handler {⟨U+000D⟩
    	static get OPTIONS() {⟨U+000D⟩
    		return 1;⟨U+000D⟩
    	}
  2462. 38 of 78 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2463. 27 of 67 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2464. file mixes tab and space indentation (3 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    export type T = {
        a: number;
    };
  2465. file mixes tab and space indentation (11 tab-indented and 26 space-indented lines) (raw pass, confidence 0.40)

    function fn() {
        try { } catch (x) { }                                            // should be OK
        try { } catch (/** @type {any} */ err) { }                       // should be OK
        try { } catch (/** @type {Any} */ err) { }                       // should be OK
  2466. 26 of 51 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2467. 16 of 34 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2468. 26 of 39 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  2469. 18 of 35 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2470. line length 1927 characters (raw pass, confidence 0.50)

    exports.wrapSync = exports.selectSeries = exports.selectLimit = exports.select = exports.foldr = exports.foldl = exports.inject = exports.forEachOfLimit = exports.forEachOfSeries = exports.forEachOf = exports.forEachLimit = exports.forEachSeries = exports.forEach = exports.findSeries = exports.findLimit = exports.find 
  2471. 13 of 31 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2472. file mixes tab and space indentation (1 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)

    class SomeBase {⟨U+000D⟩
        constructor() {⟨U+000D⟩
            this.p = 42;⟨U+000D⟩
        }
  2473. 20 of 32 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  2474. 37 of 75 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2475. file mixes tab and space indentation (8 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface ElementAttributesProperty { props: {} }⟨U+000D⟩
    	interface IntrinsicElements { 
  2476. file mixes tab and space indentation (8 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface ElementAttributesProperty { props: {} }⟨U+000D⟩
    	interface IntrinsicElements { 
  2477. file mixes tab and space indentation (12 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    interface ButtonProp {⟨U+000D⟩
        a: number,⟨U+000D⟩
        b: string,⟨U+000D⟩
        children: Button;
  2478. file mixes tab and space indentation (4 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    interface ButtonProp {⟨U+000D⟩
        a: number,⟨U+000D⟩
        b: string,⟨U+000D⟩
        children: Button;
  2479. 41 of 99 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2480. 55 of 87 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  2481. file mixes tab and space indentation (6 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
    	}
  2482. file mixes tab and space indentation (10 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
    	}
  2483. file mixes tab and space indentation (3 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
            div: any;
  2484. file mixes tab and space indentation (6 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
    	}
  2485. file mixes tab and space indentation (3 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
            div: any
  2486. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {⟨U+000D⟩
    	class Component<T, U> { }⟨U+000D⟩
    }
  2487. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {⟨U+000D⟩
    	class Component<T, U> { }⟨U+000D⟩
    }
  2488. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {⟨U+000D⟩
    	class Component<T, U> { }⟨U+000D⟩
    }
  2489. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {⟨U+000D⟩
    	class Component<T, U> { }⟨U+000D⟩
    }
  2490. file mixes tab and space indentation (2 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements { }⟨U+000D⟩
    }
  2491. file mixes tab and space indentation (12 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
    		[s: string]: any;
  2492. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {⟨U+000D⟩
    	class Component<T, U> { }⟨U+000D⟩
    }
  2493. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    }
  2494. file mixes tab and space indentation (12 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
    		[s: string]: any;
  2495. file mixes tab and space indentation (4 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
    		[s: string]: any;
  2496. file mixes tab and space indentation (4 tab-indented and 14 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
    		[s: string]: any;
  2497. file mixes tab and space indentation (4 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  2498. file mixes tab and space indentation (4 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  2499. file mixes tab and space indentation (3 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    function EmptyPropSFC() {⟨U+000D⟩
        return <div> Default Greeting </div>;⟨U+000D⟩
    }
  2500. file mixes tab and space indentation (1 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    var MainMenu: React.StatelessComponent<{}> = (props) => (<div>⟨U+000D⟩
        <h3>Main Menu</h3>⟨U+000D⟩
    </div>);
  2501. 61 of 148 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2502. file mixes tab and space indentation (2 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    class MyClass {⟨U+000D⟩
      props: {⟨U+000D⟩
        pt?: { x: number; y: number; };⟨U+000D⟩
    	name?: string;
  2503. 36 of 90 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2504. mean non-conventional identifier length 1.46 over 35 names (token pass, confidence 0.50)

  2505. 23 of 41 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2506. mean non-conventional identifier length 1.69 over 77 names (token pass, confidence 0.50)

  2507. 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2508. U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (in string/comment) (raw pass, confidence 0.45)

    // @lib: es5⟨U+000D⟩
    //⟨U+FEFF⟩⟨U+000D⟩
    // Copyright (c) Microsoft Corporation.  All rights reserved.⟨U+000D⟩
    // 
  2509. `eval` called with a non-literal expression (ast pass, confidence 0.75)

    if (typeof ActiveXObject === "function") {⟨U+000D⟩
        eval(typescriptServiceFile);⟨U+000D⟩
    } else if (typeof require === "function") {⟨U+000D⟩
        var vm = require('vm');
    likely benign LLM, confidence 0.85 Parser test harness eval of the TypeScript service file under an environment check.
    Reasoning

    This is the TypeScript RealWorld parser harness test case. The conditional eval of the service file is a test-environment mechanism, not obfuscation or an attack.

  2510. `eval` called with a non-literal expression (ast pass, confidence 0.75)

                try {⟨U+000D⟩
                    var res = eval(code);⟨U+000D⟩
    ⟨U+000D⟩
                    for (n in dangerNames) {
    likely benign LLM, confidence 0.85 Parser test harness eval of code strings with global restoration.
    Reasoning

    Test harness eval inside a try block with global restoration, in a TypeScript conformance test case. This is a standard test-runner pattern.

  2511. U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (in string/comment) (raw pass, confidence 0.45)

    ⟨U+FEFF⟩// @target: es2015⟨U+000D⟩
    //⟨U+FEFF⟩⟨U+000D⟩
    // Copyright (c) Microsoft Corporation.  All rights reserved.⟨U+000D⟩
    // 
  2512. 15 of 35 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2513. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

    
    //CHECK#А-Я
    var \u0410 = 1;
    if (А !== 1) {
  2514. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

    if (А !== 1) {
      $ERROR('#А');
    }
    var \u0411 = 1;
  2515. identifier `В` contains homoglyph candidates: В (0412)→B (in string/comment) (raw pass, confidence 0.35)

    if (В !== 1) {
      $ERROR('#В');
    }
    var \u0413 = 1;
  2516. identifier `Е` contains homoglyph candidates: Е (0415)→E (in string/comment) (raw pass, confidence 0.35)

    if (Е !== 1) {
      $ERROR('#Е');
    }
    var \u0416 = 1;
  2517. identifier `К` contains homoglyph candidates: К (041A)→K (in string/comment) (raw pass, confidence 0.35)

    if (К !== 1) {
      $ERROR('#К');
    }
    var \u041B = 1;
  2518. identifier `М` contains homoglyph candidates: М (041C)→M (in string/comment) (raw pass, confidence 0.35)

    if (М !== 1) {
      $ERROR('#М');
    }
    var \u041D = 1;
  2519. identifier `Н` contains homoglyph candidates: Н (041D)→H (in string/comment) (raw pass, confidence 0.35)

    if (Н !== 1) {
      $ERROR('#Н');
    }
    var \u041E = 1;
  2520. identifier `О` contains homoglyph candidates: О (041E)→O (in string/comment) (raw pass, confidence 0.35)

    if (О !== 1) {
      $ERROR('#О');
    }
    var \u041F = 1;
  2521. identifier `Р` contains homoglyph candidates: Р (0420)→P (in string/comment) (raw pass, confidence 0.35)

    if (Р !== 1) {
      $ERROR('#Р');
    }
    var \u0421 = 1;
  2522. identifier `С` contains homoglyph candidates: С (0421)→C (in string/comment) (raw pass, confidence 0.35)

    if (С !== 1) {
      $ERROR('#С');
    }
    var \u0422 = 1;
  2523. identifier `Т` contains homoglyph candidates: Т (0422)→T (in string/comment) (raw pass, confidence 0.35)

    if (Т !== 1) {
      $ERROR('#Т');
    }
    var \u0423 = 1;
  2524. identifier `Х` contains homoglyph candidates: Х (0425)→X (in string/comment) (raw pass, confidence 0.35)

    if (Х !== 1) {
      $ERROR('#Х');
    }
    var \u0426 = 1;
  2525. 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2526. 137 of 255 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  2527. 56 of 131 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2528. 43 of 96 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2529. 37 of 92 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2530. 59 of 99 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  2531. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

    
    //CHECK#А-Я
    var \u0410 = 1;
    if (А !== 1) {
  2532. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

    if (А !== 1) {
      $ERROR('#А');
    }
    var \u0411 = 1;
  2533. identifier `В` contains homoglyph candidates: В (0412)→B (in string/comment) (raw pass, confidence 0.35)

    if (В !== 1) {
      $ERROR('#В');
    }
    var \u0413 = 1;
  2534. identifier `Е` contains homoglyph candidates: Е (0415)→E (in string/comment) (raw pass, confidence 0.35)

    if (Е !== 1) {
      $ERROR('#Е');
    }
    var \u0416 = 1;
  2535. identifier `К` contains homoglyph candidates: К (041A)→K (in string/comment) (raw pass, confidence 0.35)

    if (К !== 1) {
      $ERROR('#К');
    }
    var \u041B = 1;
  2536. identifier `М` contains homoglyph candidates: М (041C)→M (in string/comment) (raw pass, confidence 0.35)

    if (М !== 1) {
      $ERROR('#М');
    }
    var \u041D = 1;
  2537. identifier `Н` contains homoglyph candidates: Н (041D)→H (in string/comment) (raw pass, confidence 0.35)

    if (Н !== 1) {
      $ERROR('#Н');
    }
    var \u041E = 1;
  2538. identifier `О` contains homoglyph candidates: О (041E)→O (in string/comment) (raw pass, confidence 0.35)

    if (О !== 1) {
      $ERROR('#О');
    }
    var \u041F = 1;
  2539. identifier `Р` contains homoglyph candidates: Р (0420)→P (in string/comment) (raw pass, confidence 0.35)

    if (Р !== 1) {
      $ERROR('#Р');
    }
    var \u0421 = 1;
  2540. identifier `С` contains homoglyph candidates: С (0421)→C (in string/comment) (raw pass, confidence 0.35)

    if (С !== 1) {
      $ERROR('#С');
    }
    var \u0422 = 1;
  2541. identifier `Т` contains homoglyph candidates: Т (0422)→T (in string/comment) (raw pass, confidence 0.35)

    if (Т !== 1) {
      $ERROR('#Т');
    }
    var \u0423 = 1;
  2542. identifier `Х` contains homoglyph candidates: Х (0425)→X (in string/comment) (raw pass, confidence 0.35)

    if (Х !== 1) {
      $ERROR('#Х');
    }
    var \u0426 = 1;
  2543. 27 of 64 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2544. 34 of 65 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  2545. file mixes tab and space indentation (8 tab-indented and 62 space-indented lines) (raw pass, confidence 0.40)

    interface Covariant<T> {⟨U+000D⟩
        foo: T extends string ? T : number;⟨U+000D⟩
    }
  2546. 16 of 33 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2547. file mixes tab and space indentation (1 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    namespace JSX {⟨U+000D⟩
        export interface IntrinsicElements {⟨U+000D⟩
            span: {};⟨U+000D⟩
        }
  2548. 36 of 78 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2549. 15 of 34 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2550. mean non-conventional identifier length 1.45 over 135 names (token pass, confidence 0.50)

  2551. 16 of 30 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2552. 25 of 48 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  2553. 31 of 63 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2554. 54 of 118 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2555. file mixes tab and space indentation (10 tab-indented and 245 space-indented lines) (raw pass, confidence 0.40)

    class Shape {⟨U+000D⟩
        name: string;⟨U+000D⟩
        width: number;⟨U+000D⟩
        height: number;
  2556. file mixes tab and space indentation (3 tab-indented and 65 space-indented lines) (raw pass, confidence 0.40)

    function f1(obj: { a: number, b: 0 | 1, c: string }, k0: 'a', k1: 'a' | 'b', k2: 'a' | 'b' | 'c') {⟨U+000D⟩
        obj[k0] = 1;⟨U+000D⟩
        obj[k0] = 2;⟨U+000D⟩
        obj[k0] = 'x';  // Error
  2557. mean non-conventional identifier length 1.96 over 27 names (token pass, confidence 0.50)

  2558. mean non-conventional identifier length 1.68 over 189 names (token pass, confidence 0.50)

  2559. 17 of 35 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2560. 17 of 35 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2561. 25 of 60 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2562. 120 of 205 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  2563. 39 of 77 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2564. 20 of 48 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2565. 66 of 148 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2566. 242 of 533 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2567. 159 of 321 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2568. 17 of 32 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2569. 17 of 33 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  2570. 17 of 41 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2571. 41 of 90 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2572. 30 of 47 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  2573. 20 of 42 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2574. 77 of 167 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2575. 17 of 37 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2576. 28 of 65 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2577. 37 of 62 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  2578. 113 of 185 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  2579. 108 of 166 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  2580. 21 of 49 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2581. 31 of 56 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2582. 22 of 53 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2583. mean non-conventional identifier length 1.88 over 32 names (token pass, confidence 0.50)

  2584. 30 of 41 non-conventional identifiers are single-character (73%) (token pass, confidence 0.50)

  2585. 28 of 69 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2586. 20 of 50 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2587. 19 of 35 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  2588. 25 of 45 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2589. 20 of 45 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2590. 15 of 32 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2591. 23 of 53 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2592. 22 of 40 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2593. 22 of 49 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2594. 35 of 70 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2595. 51 of 92 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2596. 51 of 92 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2597. 35 of 70 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2598. 29 of 62 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2599. 29 of 62 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2600. 32 of 57 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2601. 17 of 38 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2602. mean non-conventional identifier length 1.91 over 22 names (token pass, confidence 0.50)

  2603. 13 of 30 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2604. 115 of 243 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2605. 16 of 33 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2606. file mixes tab and space indentation (8 tab-indented and 59 space-indented lines) (raw pass, confidence 0.40)

    class C {⟨U+000D⟩
        n: number;⟨U+000D⟩
        explicitThis(this: this, m: number): number {⟨U+000D⟩
            return this.n + m;
  2607. 36 of 79 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2608. 283 of 645 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2609. 39 of 77 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2610. 39 of 77 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2611. 70 of 144 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2612. 62 of 128 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2613. 46 of 105 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2614. 24 of 59 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2615. 30 of 55 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2616. 66 of 118 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2617. 115 of 236 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2618. 18 of 37 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2619. 28 of 41 non-conventional identifiers are single-character (68%) (token pass, confidence 0.50)

  2620. 50 of 103 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2621. 35 of 87 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2622. 54 of 113 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2623. 116 of 283 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2624. 71 of 169 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2625. mean non-conventional identifier length 1.36 over 33 names (token pass, confidence 0.50)

  2626. 184 of 364 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2627. 90 of 152 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  2628. 81 of 158 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2629. 81 of 158 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2630. 115 of 201 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  2631. 74 of 152 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2632. 130 of 277 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2633. 74 of 168 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2634. 74 of 138 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  2635. 60 of 113 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2636. 31 of 57 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  2637. mean non-conventional identifier length 1.98 over 174 names (token pass, confidence 0.50)

  2638. 34 of 55 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  2639. 59 of 134 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2640. 126 of 310 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2641. mean non-conventional identifier length 1.85 over 40 names (token pass, confidence 0.50)

  2642. 35 of 70 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2643. 22 of 45 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2644. 20 of 36 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2645. 214 of 489 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2646. 25 of 43 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  2647. 74 of 168 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2648. 236 of 521 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2649. 236 of 590 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2650. 15 of 30 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2651. 111 of 193 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  2652. 59 of 105 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2653. 122 of 232 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2654. 16 of 34 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2655. 20 of 47 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2656. 62 of 139 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2657. 130 of 234 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2658. 22 of 49 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2659. 148 of 264 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2660. 25 of 57 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2661. 16 of 35 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

Reproduce This Scan

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.

cargo install disclude --version 4.0.0
git clone https://github.com/microsoft/TypeScript TypeScript && cd TypeScript
git checkout 28534d7609062699a68b1b66e2367f8d95dbf290
disclude scan --severity info --diff 5237fd46890956e4bb8177a1a05dcd69e4166560 .