npm / typescript / 7.1.0-dev.20261017.1

typescript 7.1.0-dev.20261017.1

Source
https://github.com/microsoft/TypeScript
Commit scanned
2e9fb00f5f5c (recorded by npm)
Compared with
abcbb2e69d2a (0 signals introduced since)
Files
34514 scanned, 33358 skipped (binary, oversized, or unrecognised)
Signals
1 critical · 428 warn · 2232 info
Scan time
109.4 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 14:03

Signals

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

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

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

    The data: URI import executes source text in memory, which is an unusual evaluation technique and is worth noting. Here it appears to be a build-time script that evaluates enum declarations from the TypeScript source, so the source is likely trusted. Nothing in the snippet shows attacker-controlled input or a network fetch, so the leaning is benign, but the pattern deserves a check of where enumSource comes from.

  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 text with a very long line.
    Reasoning

    Long line in a plain-text license file is ordinary prose from the Creative Commons license. Raw long-line findings on text and data files have a high false-positive rate.

  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.96 A long generated array of Unicode identifier-start code points.
    Reasoning

    This is a large numeric table of Unicode identifier code-point ranges, a standard generated data structure in TypeScript's scanner. The length comes from data, not 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.96 A long generated array of Unicode identifier-part code points.
    Reasoning

    Same pattern as the adjacent line: a generated Unicode identifier-part code-point table in the TypeScript scanner.

  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 loads a TypeScript module by resolving a path from its manifest and importing it as a file URL.
    Reasoning

    The specifier is resolved with require.resolve from the extension's own manifest name and export path, then loaded via a file URL. This is a normal plugin or module-loading pattern in a VS Code extension, not an attacker-controlled 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 file that re-exports many JSON-RPC type names on one line.
    Reasoning

    This is a vendored TypeScript declaration file with a long re-export list. It is a declaration-only file and contains no executable logic.

  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.85 A generator script dynamically imports Unicode code-point data for a property from a fixed package.
    Reasoning

    The specifier is a fixed package name plus a Unicode property name, used by a code-generation script. This is ordinary dynamic loading of a known dependency's data.

  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.85 A generator script dynamically imports Unicode mapping data from a fixed package.
    Reasoning

    Same pattern as the sibling loader: a fixed package path with a property name, used at generation time to load mapping data.

  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.85 A generator script dynamically imports simple Unicode mapping data from a fixed package.
    Reasoning

    Same pattern as the other loaders in this script: a fixed package path with a property name, used to load simple case-mapping data at generation time.

  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 compiler test fixture that exercises import() with a yield-based specifier inside an async generator.
    Reasoning

    This is a TypeScript compiler test baseline checking how nested yield and await expressions inside import() are emitted. The non-literal specifier is intentional test input, not a payload.

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

    async function* foo() {
        import((await import(yield "foo")).default);
    }
    dismissed LLM, confidence 0.92 A compiler test fixture with a nested import() whose specifier comes from a yield.
    Reasoning

    Same compiler test fixture; the second flagged import() is part of the nested-yield test case and is not a real dynamic load.

  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 A compiled test baseline that rewrites a dynamic import into a non-literal require inside an async generator.
    Reasoning

    This is compiler-emitted output from a TypeScript test baseline, showing downlevel async generator and import rewriting to require. The non-literal require is an artifact of the test case being compiled.

  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 transpiled to require inside a test baseline for async generator yield handling.
    Reasoning

    This is TypeScript compiler test baseline output for async generators with nested yield and dynamic import. The require with a non-literal specifier is a direct consequence of the test's dynamic import() being transpiled; it is the test subject, not a dropper.

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

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

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

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

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

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

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

    A long line of literal arithmetic addition is a deliberate stress test for the TypeScript binder's handling of deep binary expressions. No obfuscation or payload is present.

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

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

    Same generated stress-test expression as the other finding in this file; plain numeric additions with no executable risk.

  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 {
    dismissed LLM, confidence 0.96 Mixed-script Unicode identifier used as a namespace name in a TypeScript compiler collision test.
    Reasoning

    The file is a TypeScript compiler test deliberately exercising Unicode identifiers across many scripts to check code generation collisions. Mixed-script identifiers here are intentional test input, not disguised names.

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

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

    Same intentional Unicode identifier stress test in a compiler baseline; the mixed scripts reflect deliberate coverage of the identifier grammar.

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

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

    Part of the deliberate Unicode identifier test in a TypeScript compiler baseline; no execution or deception beyond testing the parser.

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

        export class 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 {
        }
    }
    dismissed LLM, confidence 0.96 Mixed-script exported class name in the TypeScript Unicode collision baseline.
    Reasoning

    Class name using the same deliberate multi-script identifier from the compiler test; expected for this test file.

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

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

    Repeated deliberate 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 {
        }
    }
    dismissed LLM, confidence 0.96 Mixed-script identifier fragment in the exported class of the Unicode test baseline.
    Reasoning

    Same intentional Unicode identifier test pattern in a TypeScript baseline; no malicious indicators.

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

    var x = new 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيك
    dismissed LLM, confidence 0.96 Object construction referencing the mixed-script Unicode class in the compiler test baseline.
    Reasoning

    Instantiation using the same deliberate Unicode identifier from the TypeScript compiler test; benign test content.

  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 Mixed-script unicode identifier inside a tsc compiler test baseline.
    Reasoning

    The file is a TypeScript compiler test baseline (collisionCodeGenModuleWithUnicodeNames) that deliberately exercises unicode identifiers. The mixed-script identifiers are test fixtures, not obfuscation of a payload.

  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 Mixed-script unicode identifier used in a call within a tsc test baseline.
    Reasoning

    Same compiler test baseline file; the identifier is a deliberately constructed unicode test name used in a function call, consistent with compiler conformance testing.

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

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

    Part of the deliberately unicode-heavy compiler test fixture; the identifier serves as a property access target in a test baseline.

  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 unicode identifier in a tsc conformance baseline.
    Reasoning

    Compiler conformance baseline testing unicode identifier emission; no execution, encoding, or exfiltration behavior is present.

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

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

    Compiler test baseline; the unicode identifier is a test input exercising name handling, not malicious obfuscation.

  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 tsc emitted baseline.
    Reasoning

    The file name and 'use strict' module wrapper show a TypeScript-emitted baseline for a unicode-names collision test, a standard compiler artifact.

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

    Compiler-emitted test baseline; the unicode variable is part of a deliberate collision/naming test.

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

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

    Compiler test baseline output with a unicode variable name; no malicious behavior present.

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

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

    The IIFE parameter with a unicode name is the emitted module pattern from TypeScript's namespace/module codegen, as the file name indicates.

  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 unicode IIFE parameter in a tsc test baseline.
    Reasoning

    Standard emitted module wrapper in a compiler test baseline; the unicode parameter name is the test subject.

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

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

    Same emitted IIFE parameter pattern in a compiler baseline file; no 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⟩
        }
    likely benign LLM, confidence 0.93 A unicode-named empty class declaration in a TypeScript compiler test baseline.
    Reasoning

    This is a TypeScript compiler baseline file from a test named collisionCodeGenModuleWithUnicodeNames. The identifier deliberately mixes Han, Katakana, Cyrillic and Latin characters to test unicode identifier handling in code generation. The raw-pass unicode-mixed-script signal fires on exactly this kind of intentional test input, and nothing in the snippet suggests obfuscation or malicious behaviour.

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

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

    Same file and test as the other findings. The identifier is a long multi-script name in the compiler's unicode-identifier test corpus. It is a legitimate test fixture, not an attack payload.

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

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

    Same compiler baseline fixture. The identifier is a unicode-named class exercising identifier-name emission. The mixed-script signal is a raw-pass false positive on deliberate test data.

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

        才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123_1.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودö
    likely benign LLM, confidence 0.93 A member access on unicode-named identifiers in a compiler collision test baseline.
    Reasoning

    Line 20 of the same baseline is a module-style property access on unicode-named identifiers, consistent with testing name collision in generated code. The mixed scripts are intentional test input, with no dynamic execution or encoded payload present.

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

      才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123_1.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄ
    likely benign LLM, confidence 0.93 A unicode-named property in a compiler test baseline assignment.
    Reasoning

    The identifier is part of a dotted unicode-name assignment in the compiler test baseline. Raw-pass mixed-script detection on deliberately constructed test identifiers is a known false-positive pattern.

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

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

    Same baseline file. The identifier is a unicode-named member in a chained assignment that tests generated-name collisions. The content is ordinary compiler test output.

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

    şğİliيونيكودöÄüßAbcd123_1.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड… (340 bytes total)
    likely benign LLM, confidence 0.93 A unicode-named identifier chain in a TypeScript compiler test baseline.
    Reasoning

    Same compiler baseline. The snippet is a deliberately constructed multi-script identifier chain from a TypeScript test named for unicode names and code-generation collisions. Nothing indicates obfuscation.

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

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

    Same file. The identifier is part of a long unicode assignment expression in a compiler test baseline. Mixed scripts here reflect the test's purpose, not an attempt to hide code.

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

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

    Same baseline file. The snippet is a unicode-named variable assignment in compiler test output. It is a raw-pass mixed-script false positive, with no execution, shell, or encoding behaviour.

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

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

    Raw-pass unicode-mixed-script flag on an identifier in a TypeScript compiler test baseline. The file name and the deliberately mixed identifiers indicate a test of unicode identifier handling in code generation, not obfuscation. Raw findings have a high false-positive rate.

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

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

    Same file and pattern as the other findings: a mixed-script identifier inside a generated compiler test baseline designed to exercise unicode names. No execution, encoding, or malicious behavior is present.

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

    ß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123;⟨U+000D⟩
    dismissed LLM, confidence 0.93 Mixed-script unicode identifier in a tsc collision codegen baseline file.
    Reasoning

    Raw unicode-mixed-script flag on a test-fixture identifier in a TypeScript baseline. The context is a compiler test for unicode name handling, so this is a legitimate coding pattern.

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

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

    Raw unicode-mixed-script flag in a generated TypeScript test baseline that tests unicode module names. The snippet shows an ordinary IIFE namespace pattern with unicode identifiers, which is expected test input.

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

    )(才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 || (才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودö
    dismissed LLM, confidence 0.93 Mixed-script unicode identifier in a tsc codegen baseline file.
    Reasoning

    Raw-pass unicode identifier flag in a TypeScript compiler baseline file. The mixed scripts come from a deliberate unicode-name test case, not from obfuscation.

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

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

    Raw unicode-mixed-script flag on a test-baseline identifier. The file is a TypeScript compiler test expecting such names, and the snippet is benign assignment code.

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

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

    Raw-pass flag on a unicode identifier inside a compiler baseline test for unicode names. Nothing in the snippet suggests malicious or hidden behavior.

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

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

    Raw unicode-mixed-script finding in a generated TypeScript test baseline. The identifiers are test inputs for unicode name handling, which is a legitimate use.

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

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

    Raw-pass unicode identifier flag inside a tsc compiler test baseline. The code is a simple assignment in a deliberate unicode-name test, not obfuscation.

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

    var x = new 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيك
    dismissed LLM, confidence 0.93 Mixed-script unicode identifier used in a new-expression within a tsc test baseline.
    Reasoning

    Raw unicode-mixed-script flag on a constructor call in a TypeScript compiler baseline. The file exists to test unicode identifier emit, so the mixed-script names are expected and benign.

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

    w 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄü
    dismissed LLM, confidence 0.93 A deliberately constructed unicode identifier mixing several scripts, in a compiler test baseline.
    Reasoning

    The file is a TypeScript compiler test baseline for unicode identifier handling. The mixed-script identifier is deliberate test input exercising unicode names, not an obfuscation technique in shipped code.

  604. 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 mixed-script unicode identifier used in a call inside a compiler test baseline.
    Reasoning

    Same TypeScript compiler unicode-names test baseline. The identifier is a test fixture covering unicode name emission, and the call is ordinary test code.

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

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

    This is part of the TypeScript compiler's unicode identifier test corpus. The mixed scripts reflect the test's purpose and do not hide executable behavior.

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

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

    Same compiler test baseline for unicode names. The raw-pass mixed-script signal is a known false positive for this kind of fixture.

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

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

    Compiler test fixture exercising unicode identifiers. The call is trivial and the identifier is test input, so this is a benign raw-pass false positive.

  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 .astro module in a compiler test baseline for extension rewriting.
    Reasoning

    This is a TypeScript compiler baseline for an import-extension rewriting feature. The path is a constant string assigned locally, and the import is a test of module resolution, not hidden code loading.

  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 whose specifier is passed through an extension-rewrite helper in a compiler baseline.
    Reasoning

    The import specifier is wrapped in the compiler's rewrite helper, which is the feature under test. The path is a constant and the surrounding code is typical test output.

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

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

    This is an exported helper in a TypeScript compiler test baseline demonstrating dynamic import emission. A parameterized import is expected in this test and does not indicate malicious loading.

  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 require call on a parameter in a CommonJS compiler test baseline.
    Reasoning

    The baseline shows how TypeScript emits dynamic import as require in CommonJS. The variable require here is test code, with no encoded payload or shell involvement.

  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 compiler-emitted require of a rewritten specifier inside a test baseline.
    Reasoning

    Emitted CommonJS output from the TypeScript compiler for dynamic import with extension rewriting. The non-literal require is the expected test behavior, and the tslib helper is standard.

  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 require of a rewritten path in a TypeScript compiler test baseline.
    Reasoning

    Another compiler-emitted CommonJS fixture covering import rewriting with tslib. The require target is produced by the test helper, which is consistent with a legitimate compiler test.

  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 showing a dynamic import(path) call alongside a literal import.
    Reasoning

    This is a TypeScript compiler baseline file (expected-output fixture) for testing import extension rewriting. The dynamic import with a variable path is the intended test subject of a TypeScript compiler feature; it is not a dropper or obfuscation.

  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 containing require(path) with a non-literal argument inside a TypeScript baseline.
    Reasoning

    Compiler baseline fixture for TypeScript's module handling; the require(path) call is a deliberate test case in a generated expected-output file, with no network, shell, or decoding behavior.

  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.92 Expected output showing rewritten dynamic import specifier via tslib helper.
    Reasoning

    Compiler test baseline using tslib's __rewriteRelativeImportExtension helper to rewrite a path before a dynamic import; this is the feature under test and is legitimate.

  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 Expected output with require over a rewritten non-literal specifier.
    Reasoning

    Same compiler baseline pattern: require wrapped in the import-extension rewrite helper, which is the tested behavior in a generated fixture.

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

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

    TypeScript compiler baseline fixture for the import-extension feature; the variable-specifier dynamic import is a deliberate test input.

  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 Baseline fixture with require(path) for a commonjs compatibility test.
    Reasoning

    Compiler test expected output; require(path) is a standard test case of a non-literal module specifier in TypeScript's baseline suite.

  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.93 Expected commonjs output using tslib helpers around a dynamic require.
    Reasoning

    Generated compiler output that uses tslib's __importStar and the extension rewrite helper around a dynamic require; this is the tested transform and not malicious.

  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 Baseline fixture requiring a helper-rewritten specifier in commonjs mode.
    Reasoning

    Compiler baseline with require wrapped by the rewrite helper; a deliberate test of TypeScript's emit behavior.

  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 Preserve-mode baseline containing dynamic import(path).
    Reasoning

    TypeScript compiler baseline for preserve module mode; the dynamic import with a variable is the test input.

  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 Preserve-mode baseline with require(path).
    Reasoning

    Expected compiler output with a require over a variable path, part of TypeScript's test corpus rather than shipped runtime code.

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

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

    Compiler baseline using the tslib extension-rewrite helper in a dynamic import; intended test behavior.

  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 Preserve-mode baseline with require over a rewritten specifier.
    Reasoning

    Compiler baseline fixture for require with a rewritten specifier; part of the expected-output test corpus.

  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 Test baseline containing a dynamic import of a caller-supplied path.
    Reasoning

    This is a TypeScript compiler baseline file exercising dynamic import with a variable path; the flagged import(path) is a normal test construct, and the module path is a local relative file.

  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 Compiler-generated dynamic import with extension-rewrite helper in a test baseline.
    Reasoning

    Compiler baseline output showing the rewriteRelativeImportExtension helper wrapping a dynamic import; this is generated test output of TypeScript's extension rewriting, not malicious.

  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.85 Generator yielding an arrow function in a compiler test for contextual typing.
    Reasoning

    This is a TypeScript test for contextual typing on yield; yielding an arrow function is a deliberate language-feature test, not a state-machine payload or dropper.

  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.85 Generator yielding an arrow function in a compiler test for contextual typing.
    Reasoning

    Same compiler test as the previous finding, with the same benign yield-of-arrow-function pattern in a JS baseline.

  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.95 Very long line containing a nested conditional type definition in a test baseline.
    Reasoning

    Long line is a deeply nested TypeScript conditional type in a compiler test; long generated type expressions are expected and not obfuscation.

  706. 60 of 132 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

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

    class C {
    	fun(a: string);
    	fun(a = 3);
    	fun(a = null) { }
  708. 14 of 35 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

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

    class Foo {
    	public v = "Yo";
    }
  710. file mixes tab and space indentation (1 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    class Foo {
    	public v = "Yo";
    }
  711. 19 of 39 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  712. 65 of 129 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  713. 65 of 129 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  714. 102 of 190 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  715. 102 of 190 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  716. 19 of 35 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

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

  718. 22 of 30 non-conventional identifiers are single-character (73%) (token pass, confidence 0.50)

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

    if (null as any) {
        ({ exportedFoo, nonexportedFoo } = null as any);
    }
    else if (null as any) {
  720. 28 of 58 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  721. base64-like blob (65 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/doYouNeedToChangeYourTargetLibraryES2016Plus.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [doYouNeedToChangeYourTargetLibraryES2016Plus.ts]
  722. 86 of 124 non-conventional identifiers are single-character (69%) (token pass, confidence 0.50)

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

    namespace M {
        export namespace N {
    	export function f(x:number)=>2*x;
    	export namespace X.Y.Z {
  724. 55 of 103 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  725. 52 of 88 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  726. 52 of 88 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  727. 32 of 68 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  728. 36 of 72 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  729. 91 of 164 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  730. mean non-conventional identifier length 1.95 over 21 names (token pass, confidence 0.50)

  731. 18 of 37 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  732. 69 of 167 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

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

    
    import(String(i++));
    import(String(i++));
    likely benign LLM, confidence 0.85 Dynamic import with a side-effecting specifier expression in a compiler test.
    Reasoning

    Test case evaluating the specifier expression of import() for side effects; a standard compiler test of dynamic import semantics.

  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.85 Dynamic import with a side-effecting specifier expression in a compiler test.
    Reasoning

    Duplicate of the same compiler test pattern evaluating import() specifier side effects.

  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.85 Dynamic import of an awaited path inside an async test function.
    Reasoning

    Compiler test calling import() on an awaited path from an async helper; benign test scaffolding.

  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.85 Compiler-emitted dynamic require wrapper in a test baseline.
    Reasoning

    Compiler-emitted CommonJS interop of dynamic import (__importStar(require(s))) in a test baseline; the require is test scaffolding, not a payload.

  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.85 Compiler-emitted dynamic require wrapper in a test baseline.
    Reasoning

    Same compiler-emitted dynamic require interop pattern as the neighboring finding, benign 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.85 Dynamic require of an awaited path in a compiler test baseline.
    Reasoning

    Compiler test emitting a dynamic require via __importStar for an awaited path; benign test code.

  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.85 Dynamic import with a trailing comma in a compiler syntax test.
    Reasoning

    Compiler test checking that import() accepts a trailing comma; the variable path is a local constant './foo', benign.

  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.85 Compiler-emitted dynamic require of a local constant in a test baseline.
    Reasoning

    Compiler-emitted dynamic require of a local constant path in a test baseline; no malicious behavior.

  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.80 Dynamic require of a path built from a function argument in a compiler test.
    Reasoning

    Require with a concatenated name fragment ('t/' + name) is a generic dynamic require; in a compiler test it is a benign feature test, though the pattern would warrant review in production code.

  743. info warn → info by review dynamic-import tsc/testdata/baselines/reference/compiler/dynamicRequire.js:12:13

    `require` called with a non-literal specifier (ast pass, confidence 0.80)

    function foo(name) {⟨U+000D⟩
        var s = require("t/" + name);⟨U+000D⟩
    }
    likely benign LLM, confidence 0.90 A function builds a require path from a parameter.
    Reasoning

    Non-literal require specifier in a test baseline; a common legitimate pattern for dynamic module loading, with the path prefix constrained.

  744. info warn → info by review unicode-zero-width tsc/testdata/baselines/reference/compiler/emitBOM.js:8:1

    U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (raw pass, confidence 0.75)

    //// [emitBOM.js]⟨U+000D⟩
    ⟨U+FEFF⟩"use strict";⟨U+000D⟩
    // JS and d.ts output should have a BOM but not the sourcemap⟨U+000D⟩
    var x;
    likely benign LLM, confidence 0.95 Byte order mark in a TypeScript compiler test baseline file.
    Reasoning

    A BOM at the start of compiler baseline output is intentional: the test checks that tsc emits a BOM. It is not hidden code.

  745. info warn → info by review unicode-zero-width tsc/testdata/baselines/reference/compiler/emitBOM.js:14:1

    U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (raw pass, confidence 0.75)

    //// [emitBOM.d.ts]⟨U+000D⟩
    ⟨U+FEFF⟩declare var x: any;
    likely benign LLM, confidence 0.95 Byte order mark in a declaration baseline file.
    Reasoning

    Same as the sibling finding: the BOM in the emitted .d.ts baseline is the expected output of the emitBOM 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.92 Mathematical italic letter identifier in a Unicode identifier test.
    Reasoning

    This is a TypeScript conformance baseline testing astral-plane Unicode identifiers (math script letters). Mixing scripts in identifiers is the point of the test, not an attack.

  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.92 Mathematical letter identifier in a Unicode identifier test.
    Reasoning

    Same test fixture; the mixed-script identifier is deliberate coverage of extended Unicode identifiers.

  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.92 Usage of a Unicode-identifier WeakMap in a test baseline.
    Reasoning

    Usage of the same deliberate Unicode identifiers in a compiled private-field WeakMap pattern from the test baseline.

  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.92 Usage of a Unicode-identifier WeakMap in a test baseline.
    Reasoning

    Same fixture; the identifier usage is part of the conformance test for Unicode names.

  794. identifier `_K_𝑚` mixes scripts: Latin + Other (raw pass, confidence 0.80)

    }⟨U+000D⟩
    _K_𝑚 = new WeakMap(), _K_𝑀 = new WeakMap();⟨U+000D⟩
    // lower 8 bits look like 'a'⟨U+000D⟩
    const ၡ = 6;
    likely benign LLM, confidence 0.90 Confusable Unicode identifier in a compiler test baseline.
    Reasoning

    The comment in the snippet ('lower 8 bits look like a') shows the test is intentionally exercising confusable-looking identifiers for compiler correctness.

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

    Same test fixture with deliberate confusable identifiers, as the comment indicates.

  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 character in indentation of a test baseline.
    Reasoning

    An ideographic space in indentation within a TypeScript test baseline is probably a stray character from the source test, not a payload. It is low risk but odd.

  838. 37 of 72 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  839. 32 of 56 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  840. 45 of 95 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  841. 18 of 34 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

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

    interface I {
    	f: (a: { a: number }) => void
    }
    class X<T extends { a: string }> implements I {
  843. 30 of 65 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  844. 31 of 73 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  845. 50 of 93 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  846. 32 of 78 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  847. 52 of 103 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  848. 32 of 54 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  849. 28 of 50 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  850. mean non-conventional identifier length 1.44 over 82 names (token pass, confidence 0.50)

  851. line length 501 characters (raw pass, confidence 0.50)

    function Foo(x1, y1, z1, a1, b1, c1, x2, y2, z2, a2, b2, c2, x3, y3, z3, a3, b3, c3, x4, y4, z4, a4, b4, c4, x5, y5, z5, a5, b5, c5, x6, y6, z6, a6, b6, c6, x7, y7, z7, a7, b7, c7, x8, y8, z8, a8, b8, c8, x9, y9, z9, a9, b9, c9, x10, y12, z10, a10, b10, c10, x11, y13, z11, a11, b11, c11, x12, y14, z12, a12, b12, c12, x
  852. 56 of 90 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  853. 46 of 104 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  854. 22 of 49 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  855. 20 of 49 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

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

    class C99 {
    	private get Baz():number { return 0; }
    	public set Baz(n:number) {} // error - accessors do not agree in visibility
    }
  857. 38 of 54 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)

  858. 21 of 41 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

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

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

  861. 79 of 115 non-conventional identifiers are single-character (69%) (token pass, confidence 0.50)

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

  863. mean non-conventional identifier length 1.96 over 79 names (token pass, confidence 0.50)

  864. 34 of 56 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  865. 19 of 44 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  866. file mixes tab and space indentation (15 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    interface I {
        ({descendants, read}?: {
            descendants?: boolean;
            read?: any;
  867. 28 of 46 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

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

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

    interface Red {
    	[n:number]; // ok
    	[s:string]; // ok
    }
  870. 42 of 76 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  871. 22 of 36 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  872. 36 of 78 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  873. mean non-conventional identifier length 1.78 over 41 names (token pass, confidence 0.50)

  874. 33 of 62 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  875. 59 of 133 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  876. file mixes tab and space indentation (16 tab-indented and 118 space-indented lines) (raw pass, confidence 0.40)

    function truePromise(): Promise<true> {
        return Promise.resolve(true);
    }
  877. 28 of 56 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

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

    const evenSquaresInline: number[] =  // should error
        [1, 2, 3, 4]
            .map(x => x % 2 === 0 ? x * x : null)
            .filter(x => !!x); // tests truthiness, not non-nullishness
  879. 95 of 199 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

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

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

    export type inferPipe<t, pipe> =
        pipe extends (In: t) => unknown ? (In: t) => ReturnType<pipe> : never
    
    interface Type<t> {
  882. 19 of 30 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  883. 16 of 39 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  884. 25 of 39 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

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

    interface A {
      (key:string):void;
    }
  886. 20 of 33 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

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

  888. base64-like blob (288 bytes, compression ratio 0.74) (in comment) (raw pass, confidence 0.36)

    //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwMi5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHVCQUF1QjtBQUV2QixJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDVixPQUFPLENBQUMsR0FBRyxDQUFDLENBQU
  889. base64-like blob (288 bytes, compression ratio 0.74) (raw pass, confidence 0.60)

    mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwMi5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHVCQUF1QjtBQUV2QixJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDVixPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUF
    likely benign LLM, confidence 0.90 Base64-encoded inline source map in a compiler test output.
    Reasoning

    This is a standard inline source map data URL with a JSON payload that decodes to version 3 mappings. It is a normal compiler artifact.

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

    //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwMi5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHVCQUF1QjtBQUV2QixJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDVixPQUFPLENBQUMsR0FBRyxDQUFDLENBQU
    likely benign LLM, confidence 0.90 Base64 inline source map reference in a compiler test output.
    Reasoning

    Same inline source map sourceMappingURL, a normal tsc artifact encoding ordinary mappings.

  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 Function constructor call with import.defer in a conformance test for invalid syntax.
    Reasoning

    This is a conformance test for the import.defer syntax, which is intentionally invalid. Passing import.defer to the Function constructor is a test input, not runtime execution of attacker code. The AST flag is a false positive from the test context.

  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 Function call on import.defer in a conformance test for invalid syntax.
    Reasoning

    Same conformance test for invalid import.defer usage; the snippet is test input exercising parser errors.

  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 Function call on import.source in a conformance test.
    Reasoning

    Conformance test for import.source syntax; the Function(import.source) call is test input for a parser/checker case, not a dropper.

  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.90 Test fixture calling Function with an import.source expression to check parser output.
    Reasoning

    This is a TypeScript compiler conformance baseline exercising the import.source syntax. Function(import.source) is an intentional syntax test on a non-literal, not a dynamic payload, and the file is a test fixture.

  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 Test harness evaluating the bundled TypeScript service source in a JS environment.
    Reasoning

    This is the TypeScript parser test harness. The eval of typescriptServiceFile loads the compiler's own service source in a Node vm or ActiveX environment, which is a standard bootstrapping pattern for a test harness rather than obfuscated or malicious execution.

  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 Harness evaluates test code inside a try block and restores global names afterward.
    Reasoning

    In the parser harness, eval(code) runs test case code to check behavior, and the loop over dangerNames restores globals afterward. This is ordinary test-harness logic in the TypeScript repo.

  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 Parser harness loading the TypeScript service source via eval in a test environment.
    Reasoning

    This is the same environment-bootstrap eval of the TypeScript service source as the other parser harness finding. It is a legitimate test-infrastructure pattern in a compiler repository.

  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 Harness evaluates test code and restores dangerous global names afterward.
    Reasoning

    This is another copy of the harness eval(code) test runner with global-name restoration, typical for the TypeScript conformance test suite.

  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.90 Conformance test using Function with an import.defer expression to check an error case.
    Reasoning

    This is a TypeScript conformance test for import defer and deliberately includes invalid standalone usage to check diagnostics. Function(import.defer) is a test input, not a payload.

  2444. info critical → info by review dynamic-execution tsc/testdata/tests/cases/conformance/importSource/importSource11.ts:25:1

    `Function(...)` called with a non-literal body (ast pass, confidence 0.75)

    (import.source)("./a.js");
    Function(import.source);
    import.source.unknown;
    dismissed LLM, confidence 0.90 Conformance test using Function with an import.source expression.
    Reasoning

    This is a TypeScript conformance test for import source syntax. Function(import.source) is an intentional syntax case in a compiler test file.

  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.90 Conformance test with Function applied to an import.source expression.
    Reasoning

    This is a TypeScript conformance test for import source syntax, with the same test-input pattern as the other importSource fixtures, not a malicious payload.

  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 TypeScript-source parser harness that evaluates the TypeScript service file.
    Reasoning

    This is the TypeScript source of the parser harness, which evals the bundled TypeScript service in a Node or ActiveX environment. It is a standard bootstrapping pattern in the compiler's own test suite.

  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 Parser harness runs test code via eval and restores globals.
    Reasoning

    This is the TypeScript-source version of the harness eval(code) test runner with global restoration, a normal conformance-test pattern.

  2511. U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (in string/comment) (raw pass, confidence 0.45)

    ⟨U+FEFF⟩// @target: es2015⟨U+000D⟩
    //⟨U+FEFF⟩⟨U+000D⟩
    // Copyright (c) Microsoft Corporation.  All rights reserved.⟨U+000D⟩
    // 
  2512. 15 of 35 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2513. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

    
    //CHECK#А-Я
    var \u0410 = 1;
    if (А !== 1) {
  2514. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

    if (А !== 1) {
      $ERROR('#А');
    }
    var \u0411 = 1;
  2515. identifier `В` contains homoglyph candidates: В (0412)→B (in string/comment) (raw pass, confidence 0.35)

    if (В !== 1) {
      $ERROR('#В');
    }
    var \u0413 = 1;
  2516. identifier `Е` contains homoglyph candidates: Е (0415)→E (in string/comment) (raw pass, confidence 0.35)

    if (Е !== 1) {
      $ERROR('#Е');
    }
    var \u0416 = 1;
  2517. identifier `К` contains homoglyph candidates: К (041A)→K (in string/comment) (raw pass, confidence 0.35)

    if (К !== 1) {
      $ERROR('#К');
    }
    var \u041B = 1;
  2518. identifier `М` contains homoglyph candidates: М (041C)→M (in string/comment) (raw pass, confidence 0.35)

    if (М !== 1) {
      $ERROR('#М');
    }
    var \u041D = 1;
  2519. identifier `Н` contains homoglyph candidates: Н (041D)→H (in string/comment) (raw pass, confidence 0.35)

    if (Н !== 1) {
      $ERROR('#Н');
    }
    var \u041E = 1;
  2520. identifier `О` contains homoglyph candidates: О (041E)→O (in string/comment) (raw pass, confidence 0.35)

    if (О !== 1) {
      $ERROR('#О');
    }
    var \u041F = 1;
  2521. identifier `Р` contains homoglyph candidates: Р (0420)→P (in string/comment) (raw pass, confidence 0.35)

    if (Р !== 1) {
      $ERROR('#Р');
    }
    var \u0421 = 1;
  2522. identifier `С` contains homoglyph candidates: С (0421)→C (in string/comment) (raw pass, confidence 0.35)

    if (С !== 1) {
      $ERROR('#С');
    }
    var \u0422 = 1;
  2523. identifier `Т` contains homoglyph candidates: Т (0422)→T (in string/comment) (raw pass, confidence 0.35)

    if (Т !== 1) {
      $ERROR('#Т');
    }
    var \u0423 = 1;
  2524. identifier `Х` contains homoglyph candidates: Х (0425)→X (in string/comment) (raw pass, confidence 0.35)

    if (Х !== 1) {
      $ERROR('#Х');
    }
    var \u0426 = 1;
  2525. 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2526. 137 of 255 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  2527. 56 of 131 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2528. 43 of 96 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2529. 37 of 92 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2530. 59 of 99 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  2531. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

    
    //CHECK#А-Я
    var \u0410 = 1;
    if (А !== 1) {
  2532. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

    if (А !== 1) {
      $ERROR('#А');
    }
    var \u0411 = 1;
  2533. identifier `В` contains homoglyph candidates: В (0412)→B (in string/comment) (raw pass, confidence 0.35)

    if (В !== 1) {
      $ERROR('#В');
    }
    var \u0413 = 1;
  2534. identifier `Е` contains homoglyph candidates: Е (0415)→E (in string/comment) (raw pass, confidence 0.35)

    if (Е !== 1) {
      $ERROR('#Е');
    }
    var \u0416 = 1;
  2535. identifier `К` contains homoglyph candidates: К (041A)→K (in string/comment) (raw pass, confidence 0.35)

    if (К !== 1) {
      $ERROR('#К');
    }
    var \u041B = 1;
  2536. identifier `М` contains homoglyph candidates: М (041C)→M (in string/comment) (raw pass, confidence 0.35)

    if (М !== 1) {
      $ERROR('#М');
    }
    var \u041D = 1;
  2537. identifier `Н` contains homoglyph candidates: Н (041D)→H (in string/comment) (raw pass, confidence 0.35)

    if (Н !== 1) {
      $ERROR('#Н');
    }
    var \u041E = 1;
  2538. identifier `О` contains homoglyph candidates: О (041E)→O (in string/comment) (raw pass, confidence 0.35)

    if (О !== 1) {
      $ERROR('#О');
    }
    var \u041F = 1;
  2539. identifier `Р` contains homoglyph candidates: Р (0420)→P (in string/comment) (raw pass, confidence 0.35)

    if (Р !== 1) {
      $ERROR('#Р');
    }
    var \u0421 = 1;
  2540. identifier `С` contains homoglyph candidates: С (0421)→C (in string/comment) (raw pass, confidence 0.35)

    if (С !== 1) {
      $ERROR('#С');
    }
    var \u0422 = 1;
  2541. identifier `Т` contains homoglyph candidates: Т (0422)→T (in string/comment) (raw pass, confidence 0.35)

    if (Т !== 1) {
      $ERROR('#Т');
    }
    var \u0423 = 1;
  2542. identifier `Х` contains homoglyph candidates: Х (0425)→X (in string/comment) (raw pass, confidence 0.35)

    if (Х !== 1) {
      $ERROR('#Х');
    }
    var \u0426 = 1;
  2543. 27 of 64 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2544. 34 of 65 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

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

    interface Covariant<T> {⟨U+000D⟩
        foo: T extends string ? T : number;⟨U+000D⟩
    }
  2546. 16 of 33 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

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

    namespace JSX {⟨U+000D⟩
        export interface IntrinsicElements {⟨U+000D⟩
            span: {};⟨U+000D⟩
        }
  2548. 36 of 78 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2549. 15 of 34 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2550. mean non-conventional identifier length 1.45 over 135 names (token pass, confidence 0.50)

  2551. 16 of 30 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2552. 25 of 48 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  2553. 31 of 63 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2554. 54 of 118 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

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

    class Shape {⟨U+000D⟩
        name: string;⟨U+000D⟩
        width: number;⟨U+000D⟩
        height: number;
  2556. file mixes tab and space indentation (3 tab-indented and 65 space-indented lines) (raw pass, confidence 0.40)

    function f1(obj: { a: number, b: 0 | 1, c: string }, k0: 'a', k1: 'a' | 'b', k2: 'a' | 'b' | 'c') {⟨U+000D⟩
        obj[k0] = 1;⟨U+000D⟩
        obj[k0] = 2;⟨U+000D⟩
        obj[k0] = 'x';  // Error
  2557. mean non-conventional identifier length 1.96 over 27 names (token pass, confidence 0.50)

  2558. mean non-conventional identifier length 1.68 over 189 names (token pass, confidence 0.50)

  2559. 17 of 35 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2560. 17 of 35 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2561. 25 of 60 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2562. 120 of 205 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  2563. 39 of 77 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2564. 20 of 48 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2565. 66 of 148 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2566. 242 of 533 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2567. 159 of 321 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2568. 17 of 32 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2569. 17 of 33 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  2570. 17 of 41 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2571. 41 of 90 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

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

  2573. 20 of 42 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2574. 77 of 167 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2575. 17 of 37 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2576. 28 of 65 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2577. 37 of 62 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  2578. 113 of 185 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  2579. 108 of 166 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

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

  2581. 31 of 56 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2582. 22 of 53 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2583. mean non-conventional identifier length 1.88 over 32 names (token pass, confidence 0.50)

  2584. 30 of 41 non-conventional identifiers are single-character (73%) (token pass, confidence 0.50)

  2585. 28 of 69 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

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

  2587. 19 of 35 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  2588. 25 of 45 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

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

  2590. 15 of 32 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2591. 23 of 53 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

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

  2593. 22 of 49 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2594. 35 of 70 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2595. 51 of 92 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2596. 51 of 92 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2597. 35 of 70 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2598. 29 of 62 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2599. 29 of 62 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2600. 32 of 57 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2601. 17 of 38 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2602. mean non-conventional identifier length 1.91 over 22 names (token pass, confidence 0.50)

  2603. 13 of 30 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2604. 115 of 243 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2605. 16 of 33 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

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

    class C {⟨U+000D⟩
        n: number;⟨U+000D⟩
        explicitThis(this: this, m: number): number {⟨U+000D⟩
            return this.n + m;
  2607. 36 of 79 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  2608. 283 of 645 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2609. 39 of 77 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2610. 39 of 77 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2611. 70 of 144 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2612. 62 of 128 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2613. 46 of 105 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

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

  2615. 30 of 55 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  2616. 66 of 118 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2617. 115 of 236 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2618. 18 of 37 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2619. 28 of 41 non-conventional identifiers are single-character (68%) (token pass, confidence 0.50)

  2620. 50 of 103 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2621. 35 of 87 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

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

  2623. 116 of 283 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2624. 71 of 169 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  2625. mean non-conventional identifier length 1.36 over 33 names (token pass, confidence 0.50)

  2626. 184 of 364 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2627. 90 of 152 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  2628. 81 of 158 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2629. 81 of 158 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2630. 115 of 201 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

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

  2632. 130 of 277 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2633. 74 of 168 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2634. 74 of 138 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  2635. 60 of 113 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2636. 31 of 57 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  2637. mean non-conventional identifier length 1.98 over 174 names (token pass, confidence 0.50)

  2638. 34 of 55 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  2639. 59 of 134 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2640. 126 of 310 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2641. mean non-conventional identifier length 1.85 over 40 names (token pass, confidence 0.50)

  2642. 35 of 70 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  2643. 22 of 45 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2644. 20 of 36 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2645. 214 of 489 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2646. 25 of 43 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  2647. 74 of 168 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

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

  2649. 236 of 590 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

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

  2651. 111 of 193 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  2652. 59 of 105 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2653. 122 of 232 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  2654. 16 of 34 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2655. 20 of 47 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2656. 62 of 139 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2657. 130 of 234 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2658. 22 of 49 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  2659. 148 of 264 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2660. 25 of 57 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  2661. 16 of 35 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.0.0
git clone https://github.com/microsoft/TypeScript TypeScript && cd TypeScript
git checkout 2e9fb00f5f5c9186d09aabd78cced5ce2497456d
disclude scan --severity info --diff abcbb2e69d2a86d9ffee66582a0dd0339b674733 .