npm / typescript / 7.1.0-dev.20261016.1

typescript 7.1.0-dev.20261016.1

Source
https://github.com/microsoft/TypeScript
Commit scanned
abcbb2e69d2a (recorded by npm)
Compared with
257e87406c6a (0 signals introduced since)
Files
34293 scanned, 33126 skipped (binary, oversized, or unrecognised)
Signals
1 critical · 428 warn · 2232 info
Scan time
108.6 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-17 13:59

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.65 A build script that evaluates TypeScript enum source via a data: URI dynamic import to extract enum values.
    Reasoning

    A build-time script imports a data: URI containing enum source text, which is a code-execution technique. The input is enum source read from the repository during generation, not remote or attacker-supplied input, so it reads as a legitimate evaluation trick. The residual doubt is that the input is not verified.

  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 A Creative Commons license paragraph stored as one long line in NOTICE.txt.
    Reasoning

    The flagged line is a long paragraph of Creative Commons license text in a NOTICE file. Long prose lines are normal and carry no code-level risk.

  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 A generated array of Unicode identifier-start code points in the TypeScript scanner.
    Reasoning

    The line is a large numeric array of Unicode identifier code-point ranges, typical of generated character tables in a TypeScript scanner. It is data, not executable obfuscation.

  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 A generated array of Unicode identifier-part code points in the TypeScript scanner.
    Reasoning

    Same pattern as the neighbouring finding: a generated numeric table of Unicode identifier-part ranges. Long lines from generated data tables are benign.

  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 A VS Code extension loader that dynamically imports a TypeScript module resolved from its own package.
    Reasoning

    The import specifier is derived from require.resolve over the extension's own manifest name and an export path. This is a plugin loader resolving a local module, not an attacker-controlled URL or payload.

  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.95 A vendored .d.ts re-export list from vscode-jsonrpc.
    Reasoning

    This is a vendored TypeScript declaration file with a long re-export statement. Declaration files commonly have long export lists and contain no executable code.

  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 A generator script dynamically importing Unicode code-point data modules.
    Reasoning

    A generator script loads Unicode code-point data from a fixed package name with a property path. The specifier is built from constants and a local property name, which is an ordinary data-loading pattern in a build 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 A generator script dynamically importing Unicode mapping data modules.
    Reasoning

    Same generator pattern as the previous finding: a dynamic import of a Unicode mapping module from a fixed package, used 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 A generator script dynamically importing simple case-mapping data modules.
    Reasoning

    Same generator pattern: a dynamic import of simple-mapping data from a fixed package in a build-time script.

  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.92 A TypeScript compiler test fixture that nests yield inside a dynamic import.
    Reasoning

    This is a TypeScript compiler test fixture exercising nested yield inside a dynamic import expression. The non-literal specifier is intentional test input, not a malicious 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.92 A TypeScript compiler test fixture testing nested yield in dynamic import.
    Reasoning

    Same compiler test fixture; the second dynamic import marks the same intentional nested-yield syntax being tested.

  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 Compiled TypeScript baseline output using require with a computed specifier for a dynamic import.
    Reasoning

    This is compiled emit output in a TypeScript test baseline, where require is produced by the transpiler for the dynamic import downlevel. It is expected compiler output with no payload.

  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 Compiler-emitted dynamic import helper inside an async generator test baseline.
    Reasoning

    This is TypeScript compiler test baseline output for async import with yield. The require(s) with a non-literal specifier is an artifact of testing dynamic import emit, not a dropper. No encoded payload or shell execution is present.

  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.95 Very long line of numeric addition in a TypeScript binder stress test.
    Reasoning

    A long line of literal arithmetic expression, a stress test for the binder in the TypeScript test suite. Length alone is not malicious.

  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.95 Long numeric addition expression in a TypeScript binder stress test.
    Reasoning

    Same benign stress-test arithmetic line as the other finding in this file.

  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.93 Unicode identifier mixing scripts in a TypeScript codegen test fixture.
    Reasoning

    The identifier is deliberately mixed-script in a TypeScript compiler test about unicode name collision codegen. It is a test fixture, not a homoglyph attack on a real dependency.

  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.93 Mixed-script unicode identifier in a TypeScript compiler test namespace.
    Reasoning

    Same deliberate mixed-script unicode identifier in the compiler test fixture; no malicious use.

  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.93 Mixed-script unicode identifier fragment in a TypeScript compiler test fixture.
    Reasoning

    Same deliberate unicode identifier from the TypeScript test suite; benign.

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

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

    Same unicode identifier used as a class name in the compiler test baseline; benign.

  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.93 Mixed-script unicode identifier in a TypeScript compiler test baseline.
    Reasoning

    Same unicode identifier from the compiler test fixture; benign.

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

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

    Same unicode identifier fragment in the compiler test baseline; 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.93 Mixed-script unicode identifier used in a new expression in a compiler test baseline.
    Reasoning

    Same deliberate mixed-script identifier used in a constructor expression in the test baseline; benign.

  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.95 Test-fixture identifier mixing Unicode scripts in a TypeScript compiler baseline.
    Reasoning

    This is a TypeScript compiler test baseline file exercising unicode identifiers in module code generation. The mixed-script identifiers are deliberate test inputs for the compiler's unicode handling, not obfuscation or malicious payloads.

  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 Unicode-named function call in a TypeScript compiler test baseline.
    Reasoning

    Same compiler test baseline; the identifier is a deliberately constructed unicode name used to verify emitted code for module names with unicode characters.

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

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

    Part of the same generated test baseline for unicode identifier code generation; no execution, network, or encoded payload is present.

  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 Mixed-script identifier in a compiler-generated test baseline.
    Reasoning

    Compiler test baseline using a long mixed-script identifier to exercise emitter behavior; the raw pass flags unicode diversity, which is expected here.

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

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

    Same TypeScript baseline file for unicode name collision testing; the call target is a test identifier with no malicious behavior.

  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 Variable declaration with mixed-script unicode name in a compiler test baseline.
    Reasoning

    Generated compiler baseline declaring a variable with a unicode name to test collision handling. Raw pass unicode flag is a known false-positive pattern for such fixtures.

  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 variable name in a TypeScript compiler test baseline.
    Reasoning

    Same declaration in the compiler test baseline; the identifier is intentionally unusual to exercise the emitter.

  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 Unicode variable declaration in a compiler test baseline.
    Reasoning

    Compiler baseline fixture; the variable name is a deliberate unicode test case with no execution or payload behavior.

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

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

    Parameter of an IIFE in a generated TypeScript test baseline for module code generation with unicode names; benign test artifact.

  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 in the compiler baseline; the mixed-script name is an intentional test input.

  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 Unicode parameter identifier in a compiler test baseline.
    Reasoning

    Parameter identifier within the TypeScript compiler's expected-output baseline; no dynamic execution or encoded payload is present.

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

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

    This is a TypeScript compiler baseline file in testdata, generated to test code generation with unicode identifiers. The mixed-script class name is deliberate test input, and the raw pass has a high false-positive rate. Nothing indicates obfuscation or malicious behavior.

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

        class 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 {⟨U+000D⟩
        }
    dismissed LLM, confidence 0.93 A second mixed-script identifier fragment from the same compiler test baseline class declaration.
    Reasoning

    Same fixture as the other findings in this file: a deliberately unicode-heavy identifier in a compiler test baseline. The mixed scripts reflect the test's purpose, not concealment.

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

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

    The identifier is part of the same generated unicode-names test fixture from the TypeScript compiler. It is a raw byte-pattern hit on legitimate, intentionally varied identifiers.

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

        才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123_1.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودö
    dismissed LLM, confidence 0.93 A mixed-script identifier used as a member access in the compiler test baseline output.
    Reasoning

    The line is generated test output for a namespace/property collision case using unicode identifiers. It is consistent with compiler baseline content and shows no execution or hidden payload.

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

      才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123_1.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄ
    dismissed LLM, confidence 0.93 A mixed-script identifier in an assignment within the compiler test baseline.
    Reasoning

    This is an identifier within the same compiler baseline assignment expression. The mixed-script naming is a deliberate property of the unicode test, and the file is a fixture.

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

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

    The identifier appears in the generated compiler fixture's assignment statement. It is an expected artifact of testing unicode identifier emission, not obfuscation.

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

    şğİliيونيكودöÄüßAbcd123_1.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड… (340 bytes total)
    dismissed LLM, confidence 0.93 A mixed-script identifier in a long generated compiler test line.
    Reasoning

    The finding comes from a long generated line in a TypeScript compiler test baseline that exercises unicode name collisions. Mixed scripts are the test subject, and the context shows no dynamic execution or encoded payload.

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

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

    This is one more identifier from the same compiler test baseline file. Its unicode mix is intentional test content, and the raw pass flags it only because it contains mixed scripts.

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

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

    The final flagged identifier is in the same TypeScript compiler fixture, which exists to test unicode identifier handling. There is 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⟩
    likely benign LLM, confidence 0.93 Mixed-script Unicode identifier in a TypeScript compiler test baseline.
    Reasoning

    The file is a TypeScript compiler baseline (testdata/baselines/reference) for a codegen collision test using Unicode identifiers. The mixed-script identifier is the deliberate subject of the test, not an attack, and the raw pass is prone to false positives on such identifiers.

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

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

    Same compiler test baseline for Unicode identifier collision codegen. The flagged identifier is a deliberately constructed test name with no execution or payload behaviour.

  595. 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 Unicode identifier in a TypeScript compiler test baseline.
    Reasoning

    Same compiler test baseline. The identifier is an assignment target in a test of Unicode name handling, consistent with legitimate test coverage.

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

    })(才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 || (才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكود… (340 bytes total)
    likely benign LLM, confidence 0.93 Mixed-script Unicode identifier used in generated module wrapper in a TypeScript test baseline.
    Reasoning

    Same compiler test baseline. The identifier appears inside an IIFE-style module pattern generated by tsc for a namespace named with Unicode characters, which is expected compiler output.

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

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

    Same compiler test baseline. The identifier is part of the generated module pattern exercising Unicode names; there is no decoding, dynamic execution, or encoded payload.

  598. 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 in generated namespace code of a TypeScript test baseline.
    Reasoning

    Same compiler test baseline. The identifier is a name in a namespace-merge assignment, expected in tsc output for this test case.

  599. 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 Mixed-script Unicode identifier in generated namespace code of a TypeScript test baseline.
    Reasoning

    Same compiler test baseline. The identifier is used in standard generated namespace-initialisation code, with no obfuscation or malicious behaviour.

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

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

    Same compiler test baseline. The flagged identifier is a standard generated name in a test of Unicode module names, consistent with tsc output.

  601. 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 Unicode identifier in generated namespace code of a TypeScript test baseline.
    Reasoning

    Same compiler test baseline. The identifier is an ordinary assignment in generated test output with no execution or encoding involved.

  602. 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.93 Mixed-script Unicode identifier in a TypeScript compiler test baseline.
    Reasoning

    Same compiler test baseline. The identifier is used in a constructor call in a test exercising Unicode identifiers, with no sign of malicious intent.

  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.88 A generated test-fixture identifier that mixes Unicode scripts, as expected in a compiler's Unicode name test.
    Reasoning

    This is a TypeScript compiler test baseline for Unicode identifier handling. The identifier is a deliberately constructed mix of scripts, which is the purpose of a collision/unicode-name test. The raw pass has a higher false-positive rate, and nothing here indicates an attack.

  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.88 Another mixed-script identifier in the same generated Unicode-names test fixture.
    Reasoning

    Same compiler test baseline. The mixed-script identifier is an intentional test input for Unicode name emission, and the surrounding code is ordinary generated JavaScript.

  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.88 A mixed-script identifier used as a Unicode name test case in a TypeScript compiler baseline.
    Reasoning

    Same compiler test baseline. The Han/Katakana/Cyrillic identifier is an intentional Unicode-name test case, not obfuscation.

  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.88 A mixed-script identifier in the Unicode names compiler test fixture.
    Reasoning

    Same compiler test baseline. The mixed-script identifier is an intentional Unicode name exercising the emitter, and the code is plain generated output.

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

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

    Same compiler test baseline. The identifier is a deliberate Unicode test input for name collision handling, with no execution, network, or encoding behaviour.

  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.90 A dynamic import of a local module path in a compiler test baseline for output extension mapping.
    Reasoning

    This is a TypeScript compiler baseline testing import-extension rewriting for .astro files. The variable-specifier import is a deliberate test of dynamic import handling, and the module paths are local test fixtures, not payloads.

  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.90 A dynamic import using a rewrite helper for relative module paths in a compiler test fixture.
    Reasoning

    Same compiler baseline. The dynamic import is wrapped in a rewrite helper and targets local relative paths, consistent with testing extension rewriting rather than malicious loading.

  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.90 A test-fixture function performing dynamic import of a caller-supplied path, next to a literal import.
    Reasoning

    This is a compiler test baseline. The function takes a path parameter and calls import(), which is a typical test of dynamic import emission alongside a literal case for comparison. No remote or encoded source is involved.

  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 A test-fixture dynamicRequire helper calling require with a parameter, in a CommonJS emit baseline.
    Reasoning

    Compiler baseline for CommonJS emit of dynamic require. The non-literal require is part of the test scenario and is confined to local module paths.

  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 A generated require call on a rewritten path inside a compiler test's CommonJS output.
    Reasoning

    Generated CommonJS output from the TypeScript compiler test suite. The require call is the expected emit for a dynamic import under the commonjs target with the import-helpers rewrite, not a dropper.

  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 A dynamicRequire helper in generated CommonJS test output that wraps the path with a rewrite helper.
    Reasoning

    Compiler baseline for dynamic require with a rewrite helper. The pattern matches expected emit testing extension rewriting and does not fetch or execute external content.

  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"); }
    likely benign LLM, confidence 0.93 Compiler test baseline containing a dynamic import with a variable specifier.
    Reasoning

    This is a TypeScript compiler baseline file (reference output for a test). The dynamic import(path) sits inside a test fixture exercising module extension rewriting; the non-literal specifier is the intended subject of the test, not a dropper.

  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]
    likely benign LLM, confidence 0.93 Test fixture with a dynamic require using a parameter as specifier.
    Reasoning

    Part of a tsc test baseline; require(path) is a deliberate fixture for dynamic require handling in a compiler test, not attacker-controlled execution.

  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]
    likely benign LLM, confidence 0.93 Baseline output showing import rewritten through a tslib helper, in a test fixture.
    Reasoning

    Compiler baseline for __rewriteRelativeImportExtension behavior; the non-literal import is the tested construct within a fixture file.

  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" })); }
    likely benign LLM, confidence 0.93 Fixture require call wrapped in the extension-rewrite helper.
    Reasoning

    Test baseline for import extension rewriting; the require call is part of expected compiler output, not malicious.

  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"); }
    likely benign LLM, confidence 0.93 Test baseline with a dynamic import(path) in a commonjs compatibility fixture.
    Reasoning

    Compiler test baseline in the TypeScript repo; dynamic import of a parameter is the tested feature.

  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]
    likely benign LLM, confidence 0.93 Fixture dynamic require with a parameter specifier.
    Reasoning

    Expected compiler output for a dynamic require fixture; no malicious indicators.

  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"))); }
    likely benign LLM, confidence 0.92 Compiled commonjs dynamic import wrapper using tslib __importStar in a test baseline.
    Reasoning

    Compiled commonjs output of the tsc test for import rewriting via tslib helpers; the require(s) is generated from the source fixture.

  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" })); }
    likely benign LLM, confidence 0.93 Fixture require using the extension-rewrite helper.
    Reasoning

    Test fixture baseline; the require call wraps the rewrite helper as expected compiler output.

  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"); }
    likely benign LLM, confidence 0.93 Test baseline with dynamic import of a variable path.
    Reasoning

    TypeScript compiler baseline for a module-preserve test; dynamic import is the tested construct.

  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]
    likely benign LLM, confidence 0.93 Fixture dynamic require with parameter specifier.
    Reasoning

    Compiler test fixture output; dynamic require is expected behavior being tested.

  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]
    likely benign LLM, confidence 0.93 Fixture dynamic import through the tslib rewrite helper.
    Reasoning

    Baseline of compiler output for import extension rewriting; no payload or obfuscation, just a tested construct.

  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" })); }
    likely benign LLM, confidence 0.93 Fixture require wrapped in the extension-rewrite helper.
    Reasoning

    Test baseline fixture; the require is part of expected compiler output for extension rewriting.

  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 of a caller-supplied path in a compiler test baseline.
    Reasoning

    This is TypeScript compiler test baseline output; the dynamic import takes a parameter, a normal pattern for a module loader. No obfuscation or payload is present.

  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 helper that rewrites extensions.
    Reasoning

    Compiler-generated rewrite of a relative import extension in a test baseline. The mapping is a plain object of extension rewrites, not an attack.

  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.93 Generator yielding a lambda in a TypeScript typing test.
    Reasoning

    A generator yielding an arrow function is a standard TypeScript contextual typing test. The 'state-machine' signal is a heuristic false positive here.

  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.93 Generator yielding a lambda in a TypeScript typing test.
    Reasoning

    Same test case as the prior finding, a generator yielding a typed arrow function. Legitimate test code.

  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
    likely benign LLM, confidence 0.97 Long single-line nested TypeScript conditional type.
    Reasoning

    A very long line of nested conditional type declarations in a compiler test. Length alone is not obfuscation, and the raw pass is high false-positive.

  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.93 Dynamic import with an evaluated side-effecting specifier in a test.
    Reasoning

    Compiler test exercising evaluation order of dynamic import specifiers. The side-effecting counter is intentional test design.

  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.93 Dynamic import with an evaluated specifier in a test.
    Reasoning

    Same compiler evaluation-order test as the prior finding.

  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.92 Awaited dynamic import of a computed path in a test.
    Reasoning

    Awaited dynamic import of a path from an async helper, a normal test pattern with no hidden payload.

  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.92 Downleveled dynamic import using require with a computed specifier.
    Reasoning

    Compiler downlevel output converting dynamic import to require with a string specifier. Standard transpilation artifact.

  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.92 Downleveled dynamic import using require with a computed specifier.
    Reasoning

    Same downleveled dynamic import pattern as the prior finding 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.92 Downleveled dynamic import using require in an async function.
    Reasoning

    Compiler-emitted downlevel of dynamic import in a test file, with no encoding or shell use.

  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.92 Dynamic import with a trailing comma in a parser test.
    Reasoning

    Test for parsing a trailing comma in import(). The path is a local constant, so this is a parser test.

  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.92 Downleveled dynamic import using require in a parser test.
    Reasoning

    Downleveled form of the same trailing-comma test, using a local constant path.

  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.90 require with a concatenated parameter in a test fixture.
    Reasoning

    Require with string concatenation of a parameter is a common dynamic-loading pattern. Here it is a small compiler test; the only risk would be a user-controlled path, which the snippet does not show being attacker-controlled.

  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 Function requires a module whose path is built from a parameter.
    Reasoning

    A require with a concatenated path built from a function parameter is a common, legitimate dynamic-loading pattern; it is a test fixture from the TypeScript compiler. Only a mild warning is warranted.

  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;
    dismissed LLM, confidence 0.95 Byte order mark at the start of an emitted JS baseline file.
    Reasoning

    The BOM is intentional in a TypeScript emit-BOM test fixture, documenting expected output. A leading BOM at the start of a file is standard and harmless.

  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;
    dismissed LLM, confidence 0.95 Byte order mark in an emitted .d.ts baseline file.
    Reasoning

    Same as the other BOM finding: an intentional BOM in a declaration-file baseline for a compiler test.

  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.93 Identifier using mathematical italic letters mixed with Latin, from a Unicode identifier test.
    Reasoning

    The file is a compiler test deliberately exercising Unicode identifiers from the Mathematical Alphanumeric block. The mixed-script names are intended test content, not disguise for malicious code.

  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.93 Second mixed-script identifier from the Unicode identifier test.
    Reasoning

    Same deliberate Unicode identifier test fixture; the mixed-script name is the subject 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.93 Use of the mixed-script identifier in a WeakMap-based class emulation.
    Reasoning

    Repeated use of the same deliberate Unicode identifiers in the compiler test, including private-field WeakMap emulation. Benign test content.

  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.93 Second mixed-script identifier use in the Unicode identifier test.
    Reasoning

    Same deliberate Unicode identifier test fixture; no malicious behavior is present.

  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.93 Assignment using mixed-script identifiers, with comments describing the test intent.
    Reasoning

    The file's comments show it intentionally tests identifiers that look visually similar ('lower 8 bits look like a'). This is a compiler test for Unicode identifier handling, not an attack.

  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 Unicode lookalike test assignment.
    Reasoning

    Same intentional Unicode identifier test; the lookalike identifier is the subject of the test.

  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 on a line in a TypeScript test baseline.
    Reasoning

    An ideographic space in indentation is a stray character from a test fixture for error reporting. It is harmless and has no code-execution effect, though it is a minor formatting oddity.

  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
    dismissed LLM, confidence 0.90 Base64-encoded inline source map embedded as a data URL.
    Reasoning

    This is a standard inline source map data URL in a compiler baseline. The base64 decodes to ordinary JSON source map data, so it is not a payload.

  890. base64-like blob (288 bytes, compression ratio 0.74) (raw pass, confidence 0.60)

    //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwMi5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHVCQUF1QjtBQUV2QixJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDVixPQUFPLENBQUMsR0FBRyxDQUFDLENBQU
    dismissed LLM, confidence 0.90 Inline source map sourceMappingURL comment with base64 data.
    Reasoning

    The same inline source map appears as a sourceMappingURL comment. Standard tooling output, not an obfuscated payload.

  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 Test input calling Function with an import.defer expression for a parser conformance case.
    Reasoning

    This is a conformance test for import.defer syntax errors. The Function(import.defer) call is a parser test input meant to be invalid, not executed malicious code. The flagged pattern is an artifact of the test's syntax.

  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 Test input using import.defer in an invalid standalone form.
    Reasoning

    Another parser conformance test for invalid import.defer usage; the snippet is syntax-error test input rather than a dropper.

  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 Test input using import.source with a Function call for a conformance case.
    Reasoning

    A TypeScript conformance test for import source syntax. The Function(import.source) form is parser test input, not a real dynamic-execution 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();
    dismissed LLM, confidence 0.93 Test fixture exercising import.source syntax, including a Function() call passed an expression.
    Reasoning

    The snippet is a conformance test fixture for import.source syntax. Function(import.source) is a deliberate parser test case inside the TypeScript repository, not a dropper or runtime code-injection path.

  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');
    dismissed LLM, confidence 0.90 Compiled test harness baseline that evals the bundled TypeScript service file.
    Reasoning

    This is the compiled JavaScript baseline of the TypeScript parser test harness. It performs the same benign eval of the bundled service file as the source test, so it is a legitimate test-infrastructure pattern.

  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) {
    dismissed LLM, confidence 0.90 Test harness eval of a test code string, followed by restoration of dangerous global names.
    Reasoning

    The eval runs test code inside a harness that checks for dangerous global names and restores globals afterward. This is a sandboxed test-runner mechanism in the TypeScript repository, and the surrounding code shows no malicious intent.

  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") {
    dismissed LLM, confidence 0.90 Compiled test harness baseline that evals the bundled TypeScript service file in a non-ActiveX environment.
    Reasoning

    Same benign test-harness pattern as the other eval of the bundled service file in the compiled baseline. It is part of the TypeScript repository's test infrastructure.

  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]];
    dismissed LLM, confidence 0.90 Test harness eval of test code with global-name save and restore in a compiled baseline.
    Reasoning

    This is another instance of the test harness's sandboxed eval with global-name save and restore. It is a legitimate TypeScript test-runner technique with no sign of malicious behavior.

  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
    dismissed LLM, confidence 0.92 Invalid-usage test fixture for import.defer that passes it into Function().
    Reasoning

    This is a TypeScript conformance test for invalid import.defer usage. Function(import.defer) is a deliberate error-case fixture that tests the compiler's diagnostics, not a real execution path.

  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;
    dismissed LLM, confidence 0.92 Test fixture for import.source syntax with a Function() call on the import expression.
    Reasoning

    This is a TypeScript conformance test fixture for import.source syntax. The Function() call is a parser test input, not runtime code execution.

  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;
    dismissed LLM, confidence 0.92 Test fixture for import.source syntax with a Function() call on the import expression.
    Reasoning

    This is a TypeScript conformance test fixture for import.source syntax, sharing the same content as the JavaScript baseline. It is a benign compiler test input.

  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');
    dismissed LLM, confidence 0.90 Test harness code that evals the bundled TypeScript service file when running under a legacy or Node environment.
    Reasoning

    This is the TypeScript parser test harness, which evaluates its own bundled service script in Node's vm or in an ActiveX-guarded branch. The eval is a deliberate, benign feature of the test harness, and the code is part of the TypeScript repository.

  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) {
    dismissed LLM, confidence 0.90 Test harness eval of test code with global-name save and restore.
    Reasoning

    The eval is part of the TypeScript parser test harness, which runs test code in a controlled way and restores globals afterward. It is a legitimate test-runner pattern in the TypeScript repository.

  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 abcbb2e69d2a86d9ffee66582a0dd0339b674733
disclude scan --severity info --diff 257e87406c6a8be277cb8cd5ef8d7b458a650390 .