npm / typescript / 7.1.0-dev.20261018.1

typescript 7.1.0-dev.20261018.1

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

Signals

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

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

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

    A build script executes enum source text by importing it as a data: URI. This runs code from a string without disk writes, which is an unusual evaluation technique. The source is most likely the repository's own enum declarations, so the risk is a design smell rather than clear malice, but the script's inputs were not shown.

  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 Creative Commons license text with an unwrapped long line.
    Reasoning

    A 13,885-character line in a license text is typical of unwrapped legal prose. The raw pass flags length alone, which is a weak signal.

  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 Generated Unicode ESNext identifier-start range table.
    Reasoning

    The line is a generated Unicode identifier-range table of numeric code points, a standard pattern in TypeScript's scanner. The raw pass flags only its length.

  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 Generated Unicode ESNext identifier-part range table.
    Reasoning

    Same as the adjacent line: a generated table of Unicode identifier-part code point ranges, flagged only for length.

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

    The import specifier is a path resolved via require.resolve from the extension's own manifest package name and a fixed 'typescript/' prefix. This is a normal plugin-loading pattern, not attacker-controlled input.

  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.96 Vendored vscode-jsonrpc type re-export line.
    Reasoning

    A long re-export list in a vendored .d.ts declaration file. Length alone is not suspicious.

  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 Generator script dynamically imports Unicode code-point data from a fixed package.
    Reasoning

    The specifier is a template built from a fixed PACKAGE constant and a property name. This is a generator script loading Unicode data from a known npm package.

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

    Same pattern as the previous finding: a fixed package prefix with a property name, loading Unicode mapping data in a generator script.

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

    Same pattern again: a generator loads simple Unicode mapping data from a fixed package path.

  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);
    }
    likely benign LLM, confidence 0.92 Compiler test fixture exercising dynamic import with nested yield expressions.
    Reasoning

    This is a TypeScript compiler baseline test fixture for nested yield inside a dynamic import. The construct is deliberately unusual to test the compiler, and the file is test data.

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

    async function* foo() {
        import((await import(yield "foo")).default);
    }
    likely benign LLM, confidence 0.92 Compiler test fixture with a nested dynamic import expression.
    Reasoning

    The same compiler test fixture; the nested dynamic import is intentional test syntax, not a payload.

  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⟩
    }
    likely benign LLM, confidence 0.92 Compiled baseline output showing lowered dynamic import as require call.
    Reasoning

    This is compiled output from the TypeScript test baseline, showing the expected __importStar(require(s)) lowering of the test's dynamic import. It is generated test expectation code.

  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 inside a test baseline for async generators.
    Reasoning

    This is TypeScript compiler test baseline output for async import with yield; the require(s) is the emitted form of a dynamic import in a test fixture, not a malicious dropper. The non-literal specifier is inherent to the test's purpose.

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

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

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

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

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

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

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

    A long line of numeric addition is a deliberate stress test for the TypeScript binder; no obfuscation or malicious behavior 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.95 Second long arithmetic line in the same TypeScript stress-test baseline.
    Reasoning

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    //// [collisionCodeGenModuleWithUnicodeNames.ts]⟨U+000D⟩
    namespace 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 {
    likely benign LLM, confidence 0.95 Identifier mixing Han, Katakana, and Cyrillic in a TypeScript unicode-name test.
    Reasoning

    The file is a TypeScript test for unicode identifier handling in code generation; the mixed-script names are intentional test inputs, not a disguise technique.

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

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

    Intentional unicode identifier from a compiler test about name collisions; no malicious use.

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

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

    Intentional mixed-script identifier in a TypeScript compiler test fixture.

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

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

    Same intentional unicode identifier test pattern; the class name exercises codegen for non-ASCII names.

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

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

    Intentional mixed-script identifier in the compiler's unicode-name test baseline.

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

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

    Intentional unicode identifier in a compiler test baseline; no obfuscation intent.

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

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

    Constructor use of the same intentional unicode test identifier; 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.93 Unicode identifier mixing several scripts inside a TypeScript compiler test baseline file.
    Reasoning

    Raw-pass unicode-mixed-script flag on an identifier in a TypeScript compiler test baseline. The file is a compiler output fixture built to exercise unicode identifier handling in module code generation. Mixed scripts here are deliberate test input, not obfuscation, and the snippet contains no execution or encoding behavior.

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

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

    Same file and pattern as the other findings: a mixed-script identifier used in a call inside a compiler test baseline. The call is a plain identifier invocation with no dynamic execution or decoding. This is a legitimate unicode-identifier test case.

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

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

    Raw-pass flag on a mixed-script identifier in a compiler test baseline. The identifier is an ordinary property-access target, and the file's purpose is to test unicode name collisions in code generation.

  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.93 Mixed-script identifier in a compiler test baseline, used in a call.
    Reasoning

    Mixed-script identifier in a compiler test baseline file. Raw-pass unicode heuristics have a high false-positive rate, and this is a deliberate unicode fixture.

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

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

    Same mixed-script identifier pattern in the compiler test baseline. It is a plain call with no decoding or execution primitives, consistent with a legitimate unicode-name test.

  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.93 Strict-mode var declaration with a mixed-script identifier in a compiler baseline.
    Reasoning

    A 'use strict' directive followed by a var declaration of a mixed-script identifier. This is standard TypeScript emit output in a test baseline, and the identifier is a deliberate unicode-name fixture.

  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.93 Mixed-script variable declared in a compiler test baseline file.
    Reasoning

    Same var declaration pattern in the compiler test baseline. The mixed-script name is intentional test input for unicode identifier handling.

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

    Var declaration with a mixed-script identifier in a compiler test baseline. There is no execution, network, or encoding behavior, only expected emitted code for a unicode-name test.

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

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

    Function parameter using a mixed-script identifier, typical of TypeScript module-wrapper emit in a compiler test baseline. The identifier is deliberate unicode test input.

  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.93 Mixed-script function parameter in a compiler test baseline module wrapper.
    Reasoning

    Mixed-script identifier in the same module-wrapper function parameter list of a compiler test baseline. It is a unicode-name fixture, not a sign of obfuscation.

  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.93 Mixed-script function parameter in a compiler test baseline module wrapper.
    Reasoning

    Final mixed-script parameter in the module-wrapper function of a compiler test baseline. The file is generated expected-output for a unicode identifier test and contains no suspicious execution or decoding.

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

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

    This is a TypeScript compiler baseline file, a generated expected-output fixture for a test about code generation with unicode identifiers. The mixed-script identifier is the deliberate subject of the test, and the raw pass has a high false-positive rate on identifiers like this. No execution, encoding, or payload is present.

  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 second mixed-script identifier fragment from the same class declaration in the compiler test baseline.
    Reasoning

    The same class-name identifier in a compiler test baseline, flagged for mixing Other, Latin, Arabic, Han, Katakana and Cyrillic characters. This is intentional unicode coverage in the test corpus, not obfuscation.

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

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

    A suffix identifier of the same deliberately unicode-heavy test name. The file is a TypeScript compiler baseline, and the identifiers are only declared and referenced, with no runtime behavior that could hide malicious intent.

  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 mixed-script identifier used as a namespace/member reference in the compiler test baseline.
    Reasoning

    This is a module-level member access in the generated baseline, using the same unicode identifier set. The file exercises name-collision codegen with unicode names, so the mixed scripts are expected test input.

  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 mixed-script member identifier in the compiler baseline's module emit.
    Reasoning

    A property or member reference in the generated baseline composed of the same unicode test identifiers. Nothing in the snippet indicates dynamic execution or an encoded payload.

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

    ß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123_1.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123 = 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيوني
    likely benign LLM, confidence 0.93 A mixed-script identifier assigned within the compiler test's emitted module code.
    Reasoning

    A property reference in the same generated baseline, using the test's unicode identifier set. The identifier is part of a deliberate codegen test and does not involve an exfiltration or execution pattern.

  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 An assignment using mixed-script unicode identifiers in the compiler baseline.
    Reasoning

    A further identifier reference in the expected-output fixture. The line is a plain assignment of unicode-named values and shows no decoding or obfuscated execution.

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

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

    The same test identifier set appears in the expected emitted code. The file is a TypeScript test fixture, and the unicode names are the subject under test, not an attempt to disguise behavior.

  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 trailing mixed-script identifier assignment in the compiler baseline.
    Reasoning

    A final identifier reference in the same baseline file, with no execution or encoding. It is consistent with the test verifying unicode identifier emit, so the raw-pass flag is a false positive.

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

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

    Raw-pass unicode-mixed-script hit on a long identifier in a TypeScript compiler baseline file. The file path and the name itself (a deliberately mixed-script collision test) show this is compiler test output exercising Unicode identifier handling, not obfuscation.

  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.95 Mixed-script identifier in a TypeScript compiler test baseline for Unicode module names.
    Reasoning

    Same file and pattern as the other findings: a deliberately constructed Unicode identifier in a compiler conformance baseline. Raw-pass script-mixing heuristics fire on legitimate multilingual identifiers, so this is a false positive.

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

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

    Raw-pass unicode-mixed-script on an identifier inside a compiler test baseline. The code is a generated expected-output file for a Unicode name collision test, with no execution, decoding, or network behaviour.

  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.95 Mixed-script identifier used in an emitted namespace IIFE in a compiler test baseline.
    Reasoning

    Raw-pass hit on a mixed-script identifier used in a namespace IIFE within a compiler baseline. This is the expected emitted JavaScript for a Unicode module-name test, so the finding is a false positive.

  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.95 Mixed-script identifier in emitted namespace code within a compiler test baseline.
    Reasoning

    Mixed-script identifier in a compiler baseline. The surrounding code is a namespace-merging expression for a Unicode name test, which is plain generated JavaScript.

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

    Raw-pass unicode-mixed-script on a test-fixture identifier. The file is a TypeScript conformance baseline and the identifier pattern is intentional test input, not a hidden payload.

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

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

    Same pattern as the rest of the file: a Unicode identifier in a compiler test expectation. The raw heuristic flags script mixing, which is expected for this test's purpose.

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

    Raw-pass finding on a mixed-script identifier in a compiler baseline. It is the expected output of a Unicode identifier test and has no malicious indicators.

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

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

    Mixed-script identifier in a compiler conformance baseline. The raw-pass heuristic is firing on intentional Unicode test content, a known false-positive pattern for this pass.

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

    Mixed-script identifier used in a `new` expression within a compiler baseline. This is ordinary generated test code exercising Unicode identifiers, with no dynamic execution or dropper behaviour.

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

    w 才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüßAbcd123.才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄüß才能ソЫⅨ蒤郳र्क्ड्राüışğİliيونيكودöÄü
    likely benign LLM, confidence 0.88 A unicode-heavy identifier in a TypeScript compiler test baseline that mixes several scripts.
    Reasoning

    The file is a TypeScript compiler baseline for a test about code generation with unicode identifier names. The mixed-script identifier is a deliberate fixture exercising unicode handling, not an obfuscation attempt. The raw pass has a higher false-positive rate, and nothing here is executed in a dangerous way.

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

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

    Same compiler test baseline for unicode identifier collision codegen. The mixed-script identifier is a deliberate test input and is only called locally, which is consistent with a compiler fixture.

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

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

    Part of the same compiler test fixture for unicode module names. The identifier mixes scripts as a test input, with no sign of hidden behavior or evasion.

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

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

    The same deliberate unicode identifier fixture from a TypeScript compiler test. It is not used to hide a payload or to obscure a sensitive name.

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

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

    Compiler test fixture for unicode identifiers. The call to a mixed-script name is a local test expression, not an obfuscated dropper or evasion.

  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.85 A dynamic import with a variable specifier in a TypeScript compiler test baseline for extension mapping.
    Reasoning

    This is a TypeScript compiler baseline testing output extension rewriting for dynamic imports. The non-literal import is a deliberate test case of the emitter's behavior. It is not a payload loader; the specifier is a constant string in the fixture.

  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.85 A dynamic import wrapped in a rewrite helper in a TypeScript compiler test baseline.
    Reasoning

    Same compiler test baseline for content mapper output extensions. The rewritten dynamic import is the expected emitter output for a test case and does not show malicious use.

  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.85 A dynamic import using a function parameter in a TypeScript compiler test baseline.
    Reasoning

    A compiler test baseline for import helpers with commonjs output. The function takes a path parameter to exercise dynamic import emission. This is a test fixture for the compiler, not a runtime loader of attacker-controlled code.

  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.85 A require call using a function parameter in a TypeScript compiler test baseline.
    Reasoning

    Compiler test baseline exercising dynamic require emission for commonjs. The non-literal require is part of the test scenario and is not paired with any decode or fetch behavior.

  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.85 A require of a helper-rewritten specifier in a TypeScript compiler test baseline.
    Reasoning

    Compiler-emitted commonjs output for a test that verifies import helper rewriting. The require of a rewritten path is the expected emitted form for that scenario; the specifier is produced by a known tslib helper.

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

    Compiler test baseline for dynamic require with a rewrite helper. The code is expected transpiler output for testing extension rewriting, with no evidence of malicious intent.

  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.95 Compiler test baseline showing a dynamic import with a variable path, as part of rewriting-extension tests.
    Reasoning

    This file is a TypeScript compiler baseline (expected-output fixture) for testing import extension rewriting. The dynamic import with a variable specifier is a deliberate test case of the TypeScript feature, not an attack. The snippet is embedded test source, not a payload.

  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.95 Test fixture in TypeScript compiler baselines calling require with a parameter.
    Reasoning

    Compiler baseline test fixture; the require with a non-literal argument mirrors the tested pattern in a JSDoc-typed function. No malicious 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.95 Compiler baseline showing dynamic import wrapped in a tslib extension-rewrite helper.
    Reasoning

    Compiler test baseline using the tslib helper __rewriteRelativeImportExtension to rewrite specifiers. Legitimate test of TypeScript emit behavior.

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

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

    Compiler baseline test output; require wrapped in extension rewriting helper. Expected emit for the tested feature, no payload.

  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.95 Compiler test baseline with a dynamic import of a variable path.
    Reasoning

    TypeScript compiler baseline fixture for the import-helpers compatibility test. The variable-specifier import is intentional 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.95 Compiler baseline calling require on a function parameter.
    Reasoning

    Compiler baseline test fixture; require with a parameter is expected emit for the tested feature.

  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.95 Compiler baseline with tslib helper wrapping a dynamic require.
    Reasoning

    Compiler baseline showing tslib-based emit for dynamic import with extension rewriting. Standard TypeScript test output, 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.95 Compiler baseline wrapping a require call with an extension-rewrite helper.
    Reasoning

    Compiler baseline test output rewriting require specifiers via tslib helper. Benign test fixture.

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

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

    Compiler baseline test fixture for module=preserve; variable-specifier dynamic import is the tested 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.95 Compiler baseline calling require with a function parameter.
    Reasoning

    Compiler baseline fixture; require with a parameter argument is expected test emit.

  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.95 Compiler baseline with dynamic import passed through an extension-rewrite helper.
    Reasoning

    Compiler baseline showing dynamic import wrapped in tslib extension rewrite helper. Standard test output.

  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.95 Compiler baseline with require wrapped in an extension-rewrite helper.
    Reasoning

    Compiler baseline test output for require via tslib extension rewriting. Not malicious.

  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 with a dynamic import whose specifier is a function parameter.
    Reasoning

    This is a TypeScript compiler test baseline file. The dynamic import(path) is a normal parameterized import in a test fixture for module extension rewriting; no malicious payload is present.

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

    export function literal() { return import("./Widget.mjs"); }⟨U+000D⟩
    export function dynamic(path) { return import(__rewriteRelativeImportExtension(path, false, { ".identity.y.z": ".identity.y.z", ".unmapped.y.z": ".unmapped.y.z", ".y.z": ".mjs", ".z": ".js" })); }⟨U+000D⟩
    export const inferred = import("./Widget.mjs");
    likely benign LLM, confidence 0.90 Compiler-emitted dynamic import wrapped in an extension-rewrite helper.
    Reasoning

    Compiler baseline output showing rewritten dynamic import via a helper that maps file extensions. This is expected transpiler output, not obfuscation or malicious behavior.

  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.92 Generator yielding an arrow function in a compiler type-inference test.
    Reasoning

    This is a TypeScript test case checking contextual typing of yield expressions. Yielding a lambda is a legitimate pattern used to test inference; the state-machine label is a heuristic false positive here.

  651. info warn → info by review generator-yield-callable tsc/testdata/baselines/reference/compiler/contextualTypeOnYield1.js:13:5

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

    const f = function* () {⟨U+000D⟩
        yield (num) => console.log(num); // `num` should be inferred to have type `number`.⟨U+000D⟩
    };
    likely benign LLM, confidence 0.92 Generator yielding an arrow function in a TypeScript compiler test.
    Reasoning

    Same compiler test fixture for yield contextual typing; yielding a callable is benign in this context.

  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 Long single-line nested conditional type definition in a test baseline.
    Reasoning

    A very long line of nested conditional type declarations in a TypeScript compiler test baseline. Long lines are typical of generated or stress-test output and carry no obfuscation significance.

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

    Compiler test exercising evaluation order of import specifiers with side-effecting String(i++). The non-literal specifier is intentional test behavior, not malicious.

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

    import(String(i++));
    import(String(i++));
    
    const getPath = async () => {
    likely benign LLM, confidence 0.92 Second dynamic import with side-effecting specifier in a compiler test.
    Reasoning

    Same compiler test for import specifier evaluation order; benign test code.

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

    const getPath = async () => {
    	/* in reality this would do some async FS operation, or a web request */
    	return "/root/my/cool/path";
    };
  736. dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)

    const someFunction = async () => {
    	const result = await import(await getPath());
    };
    likely benign LLM, confidence 0.92 Async dynamic import with awaited specifier in a compiler test.
    Reasoning

    Awaited non-literal dynamic import in a compiler test fixture, consistent with testing async specifier evaluation.

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

    let i = 0;⟨U+000D⟩
    Promise.resolve(`${String(i++)}`).then(s => __importStar(require(s)));⟨U+000D⟩
    Promise.resolve(`${String(i++)}`).then(s => __importStar(require(s)));⟨U+000D⟩
    const getPath = async () => {
    likely benign LLM, confidence 0.90 Downleveled dynamic import calling require with a runtime specifier.
    Reasoning

    Emitted CommonJS interop helper calling require on a computed value, typical of TypeScript downlevel output for dynamic import in a test baseline.

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

    Promise.resolve(`${String(i++)}`).then(s => __importStar(require(s)));⟨U+000D⟩
    Promise.resolve(`${String(i++)}`).then(s => __importStar(require(s)));⟨U+000D⟩
    const getPath = async () => {⟨U+000D⟩
        /* in reality this would do some async FS operation, or a web request */
    likely benign LLM, confidence 0.90 Downleveled dynamic import calling require with a runtime specifier.
    Reasoning

    Same compiler-emitted require interop pattern in a test baseline; no malicious indicators.

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

    const someFunction = async () => {⟨U+000D⟩
        const result = await Promise.resolve(`${await getPath()}`).then(s => __importStar(require(s)));⟨U+000D⟩
    };
    likely benign LLM, confidence 0.90 Downleveled async dynamic import calling require with a computed path.
    Reasoning

    Compiler-emitted dynamic import downlevel in a test fixture; the require call is a normal translation of import().

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

    const path = './foo';
    import(path,);⟨U+000D⟩
    ⟨U+000D⟩
    //// [dynamicImportTrailingComma.js]
    likely benign LLM, confidence 0.92 Dynamic import with trailing comma in a compiler parser test.
    Reasoning

    Test case verifying parsing of a trailing comma in import(); the specifier is a local constant './foo' and nothing suspicious is present.

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

    const path = './foo';⟨U+000D⟩
    Promise.resolve(`${path}`).then(s => __importStar(require(s)));
    likely benign LLM, confidence 0.90 Downleveled dynamic import of a constant local path in a test baseline.
    Reasoning

    Compiler-emitted downlevel of dynamic import with a constant local path; benign test output.

  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.88 Function building a require path from a parameter, in a compiler test.
    Reasoning

    Simple test fixture concatenating a name into a require path. Dynamic require with user input can be a path traversal concern in real code, but this is a compiler test baseline with no real payload.

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

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

    function foo(name) {⟨U+000D⟩
        var s = require("t/" + name);⟨U+000D⟩
    }
    likely benign LLM, confidence 0.85 Test baseline function that requires a module whose name is concatenated with a parameter.
    Reasoning

    A require with a concatenated path built from a function parameter is a common legitimate pattern; in a TypeScript compiler test baseline it is test data, not an attack. Dynamic require is worth noting but not malicious here.

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

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

    //// [emitBOM.js]⟨U+000D⟩
    ⟨U+FEFF⟩"use strict";⟨U+000D⟩
    // JS and d.ts output should have a BOM but not the sourcemap⟨U+000D⟩
    var x;
    dismissed LLM, confidence 0.95 Compiler baseline containing a deliberate UTF-8 BOM in emitted JavaScript.
    Reasoning

    A byte order mark at the start of emitted output is intentional; the file is a compiler baseline testing BOM emission and the comment says the output should have a BOM.

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

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

    //// [emitBOM.d.ts]⟨U+000D⟩
    ⟨U+FEFF⟩declare var x: any;
    dismissed LLM, confidence 0.95 Compiler baseline containing a deliberate BOM in an emitted declaration file.
    Reasoning

    Same as the other BOM finding: the d.ts baseline intentionally includes a BOM to test emit behavior.

  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;
    dismissed LLM, confidence 0.95 Test file using astral-plane Unicode identifiers like _K_𝑚 to exercise compiler handling.
    Reasoning

    The file exists specifically to test extended Unicode identifiers (mathematical symbols). Mixed-script identifiers here are the test subject, not obfuscation.

  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;
    dismissed LLM, confidence 0.95 Test file using astral-plane Unicode identifier _K_𝑀 as part of an extended Unicode test.
    Reasoning

    Same test file; the Unicode identifier is intentional for conformance testing.

  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⟩
        }
    dismissed LLM, confidence 0.95 Private-field WeakMap usage with extended Unicode identifiers in a compiler test.
    Reasoning

    Same conformance test; the snippet itself comments on the purpose of the Unicode characters.

  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⟩
    }
    dismissed LLM, confidence 0.95 Second WeakMap assignment using extended Unicode identifiers in a compiler test.
    Reasoning

    Same conformance test file; the identifiers are deliberate test inputs.

  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;
    dismissed LLM, confidence 0.95 Test code with Unicode identifiers including a lookalike character, used to validate identifier handling.
    Reasoning

    The snippet comment states the test is about lookalike characters, which is the subject of the conformance test. Not malicious.

  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;
    dismissed LLM, confidence 0.95 Test code assigning a WeakMap to an extended Unicode identifier.
    Reasoning

    Same conformance test; the lookalike identifier is intentional.

  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.93 Ideographic space used as indentation in a TypeScript compiler baseline.
    Reasoning

    An ideographic space in indentation is a stray whitespace character in a compiler test baseline; it is harmless and not used to hide executable code.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    mapUrl: data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwMi5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHVCQUF1QjtBQUV2QixJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDVixPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUF
    dismissed LLM, confidence 0.93 Inline base64-encoded source map data URL in a compiler test baseline.
    Reasoning

    An inline base64 source map is a standard, documented output of the TypeScript compiler; the decoded content is a JSON source map.

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

    //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5saW5lU291cmNlTWFwMi5qcyIsInNvdXJjZVJvb3QiOiJmaWxlOi8vL2ZvbGRlci8iLCJzb3VyY2VzIjpbImlubGluZVNvdXJjZU1hcDIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHVCQUF1QjtBQUV2QixJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDVixPQUFPLENBQUMsR0FBRyxDQUFDLENBQU
    dismissed LLM, confidence 0.93 Inline base64 sourceMappingURL comment in a compiler test baseline.
    Reasoning

    Same standard inline source map; the sourceMappingURL comment is normal compiler output.

  891. 49 of 105 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

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

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

     
    	function inner(n) {
                    // this line should raise an error
                    // otherwise, there's a bug in overload resolution / partial typechecking
  894. file mixes tab and space indentation (44 tab-indented and 38 space-indented lines) (raw pass, confidence 0.40)

    interface Base {
    	foo: string|number;
    	optional?: number;
    }
  895. 25 of 32 non-conventional identifiers are single-character (78%) (token pass, confidence 0.50)

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

    export interface A<a> {
        value: a;
    }
  897. 68 of 112 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  898. 22 of 50 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  899. 22 of 50 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

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

    interface I1 {
        item:number;
        item:number;
    }
  901. file mixes tab and space indentation (2 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    namespace Foo {
        export interface I1 { item: string; }
        export class C1 { }
    }
  902. 31 of 71 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

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

    interface I1 {
        iObj:{ };
        iNum:number;
        iAny:any;
  904. file mixes tab and space indentation (2 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    interface I1 {
        i1P1: number;
        i1P2(): void;
    }
  905. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    export class MergedClass extends SomeBaseClass<any> {
    	public constructor() {
    		super();
    	}
  906. 32 of 54 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  907. 30 of 72 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

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

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

  910. 49 of 90 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  911. 49 of 86 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

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

  913. 40 of 76 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

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

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

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

  917. 15 of 36 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  918. 23 of 47 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  919. 25 of 61 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  920. 19 of 47 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

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

  922. 28 of 67 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

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

  924. 35 of 52 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

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

  926. 19 of 33 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  927. file mixes tab and space indentation (9 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    function f1(node: A | B) {
      if (node instanceof A || node instanceof A) {
        node;  // A
      }
  928. file mixes tab and space indentation (7 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    interface IDef {
    	p1: (e:string) => void;
    	p2: () => (n: number) => any;
    }
  929. compression ratio 0.822 is >2σ above file mean 0.566 (raw pass, confidence 0.50)

    a.ts(108,7): error TS2322: Type '({ a: number; } & { b?: string | undefined; c?: IteratorZipValue<Iterable<boolean> | undefined, "c", never, {}> | undefined; })[]' is not assignable to type '{ a: number; c: boolean; }[]'.
  930. compression ratio 0.822 is >2σ above file mean 0.566 (raw pass, confidence 0.50)

              ~~~⟨U+000D⟩
    !!! error TS2322: Type '({ a: number; } & { b?: string | undefined; c?: IteratorZipValue<Iterable<boolean> | undefined, "c", never, {}> | undefined; })[]' is not assignable to type '{ a: number; c: boolean; }[]'.
  931. line length 1027 characters (raw pass, confidence 0.50)

        }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN"
  932. line length 1119 characters (raw pass, confidence 0.50)

        }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) & object ? U : never : never : never) | (Partial<TPadding> extends infer T_2 ? T_2 extends Partial<TPadding> ? T_2 extends unknown ? T_2[(K extends n
  933. line length 1177 characters (raw pass, confidence 0.50)

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

        }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN"
  935. line length 1119 characters (raw pass, confidence 0.50)

        }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) & object ? U : never : never : never) | (Partial<TPadding> extends infer T_2 ? T_2 extends Partial<TPadding> ? T_2 extends unknown ? T_2[(K extends n
  936. line length 1163 characters (raw pass, confidence 0.50)

        }): IteratorObject<T extends Partial<Record<keyof T, undefined>> ? keyof T extends never ? Record<PropertyKey, unknown> : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable<infer U> | Iterator<infer U, any, any>) & object ? U 
  937. file mixes tab and space indentation (2 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    const SomeConstructor = function () {
    	this.x = 1;
    };
  938. file mixes tab and space indentation (2 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    const SomeConstructor = function Named() {
    	this.x = 1;
    };
  939. base64-like blob (124 bytes, compression ratio 1.00) (in comment) (raw pass, confidence 0.36)

    }⟨U+000D⟩
    //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYS5qcyIsInNvdXJjZXMiOlsiYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsTUFBTSxDQUFDO0NBQ04ifQ==
  940. file mixes tab and space indentation (10 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    function Color(obj) {
        this.example = true
    };
    Color.prototype = {
  941. file mixes tab and space indentation (9 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  942. file mixes tab and space indentation (9 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  943. file mixes tab and space indentation (9 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  944. file mixes tab and space indentation (9 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  945. file mixes tab and space indentation (9 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  946. file mixes tab and space indentation (9 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
        interface Element {
            name: string;
            isIntrinsic: boolean;
  947. 44 of 88 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

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

    declare module "Test" {
    	export default class Text { }
    }
  949. file mixes tab and space indentation (6 tab-indented and 52 space-indented lines) (raw pass, confidence 0.40)

    type Defaultize<Props, Defaults> =
    	// Distribute over unions
    	Props extends any // Make any properties included in Default optional
    		? Partial<Pick<Props, Extract<keyof Props, keyof Defaults>>> &
  950. file mixes tab and space indentation (6 tab-indented and 52 space-indented lines) (raw pass, confidence 0.40)

    type Defaultize<Props, Defaults> =
    	// Distribute over unions
    	Props extends any // Make any properties included in Default optional
    		? Partial<Pick<Props, Extract<keyof Props, keyof Defaults>>> &
  951. file mixes tab and space indentation (6 tab-indented and 50 space-indented lines) (raw pass, confidence 0.40)

    type Defaultize<Props, Defaults> =
    	// Distribute over unions
    	Props extends any // Make any properties included in Default optional
    		? Partial<Pick<Props, Extract<keyof Props, keyof Defaults>>> &
  952. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

    // corrupted to U+FFFD. "\uD800" is a lone high surrogate; "\uDC00" a lone low.⟨U+000D⟩
    const text = React.createElement("div", null, "\uD800a\uDC00");⟨U+000D⟩
    const attr = React.createElement("div", { title: "\uD800" });⟨U+000D⟩
    // A non-BMP code point reference is a single supplementary character.
  953. orphaned low surrogate \uDC00 (no preceding high surrogate) (token pass, confidence 0.65)

    // corrupted to U+FFFD. "\uD800" is a lone high surrogate; "\uDC00" a lone low.⟨U+000D⟩
    const text = React.createElement("div", null, "\uD800a\uDC00");⟨U+000D⟩
    const attr = React.createElement("div", { title: "\uD800" });⟨U+000D⟩
    // A non-BMP code point reference is a single supplementary character.
  954. orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)

    const text = React.createElement("div", null, "\uD800a\uDC00");⟨U+000D⟩
    const attr = React.createElement("div", { title: "\uD800" });⟨U+000D⟩
    // A non-BMP code point reference is a single supplementary character.⟨U+000D⟩
    const supplementary = React.createElement("div", null, "\uD83D\uDE00");
  955. surrogate pair \uD83D\uDE00 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    // A non-BMP code point reference is a single supplementary character.⟨U+000D⟩
    const supplementary = React.createElement("div", null, "\uD83D\uDE00");
  956. surrogate pair \uD83D\uDEA8 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

        // Test multiple unicode characters⟨U+000D⟩
        return (_jsx("div", { children: "\u26A0 \u26D4 \uD83D\uDEA8" }));⟨U+000D⟩
    };
  957. 26 of 53 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

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

    
    	 private _listeners: any[] = [];
    
    	 constructor () {
  959. 134 of 325 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

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

    {
    	for (let let of [1,2,3]) {}
    
    	for (const let of [1,2,3]) {}
  961. file mixes tab and space indentation (4 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    {
    	for (let let of [1,2,3]) {}
    
    	for (const let of [1,2,3]) {}
  962. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    	for (var let in [1,2,3]) {}
    }
  963. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    	for (var let in [1,2,3]) {}
    }
  964. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    	for (var let of [1,2,3]) {}
    }
  965. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    	for (var let of [1,2,3]) {}
    }
  966. 30 of 62 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

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

    
        export class Buffer {
        	lines: List<Line> = ListMakeHead<Line>();
            
  968. line length 817 characters (raw pass, confidence 0.50)

    !!! error TS2339: Property 'p38' does not exist on type 'merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<{ p1: number; }, { p2: number; }>, { p3: number; }>, { p4: number; }>, { p5: number
  969. line length 817 characters (raw pass, confidence 0.50)

    !!! error TS2339: Property 'p51' does not exist on type 'merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<{ p1: number; }, { p2: number; }>, { p3: number; }>, { p4: number; }>, { p5: number
  970. line length 787 characters (raw pass, confidence 0.50)

    !!! error TS2339: Property 'p38' does not exist on type 'merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<{ p1: 1; }, { p2: number; }>, { p3: number; }>, { p4: number; }>, { p5: number; }>, { p6:
  971. line length 787 characters (raw pass, confidence 0.50)

    !!! error TS2339: Property 'p50' does not exist on type 'merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<merge<{ p1: 1; }, { p2: number; }>, { p3: number; }>, { p4: number; }>, { p5: number; }>, { p6:
  972. line length 1375 characters (raw pass, confidence 0.50)

    !!! error TS2339: Property 'p38' does not exist on type 'Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<{ p1: number; } & { p2: number; }, "p2"> & { p2: number; p3: number; }, "p3"> & { p3: number; p4: number; }, "p4"> & {
  973. line length 1375 characters (raw pass, confidence 0.50)

    !!! error TS2339: Property 'p51' does not exist on type 'Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<Omit<{ p1: number; } & { p2: number; }, "p2"> & { p2: number; p3: number; }, "p3"> & { p3: number; p4: number; }, "p4"> & {
  974. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    interface ISomething {
       something: number;
    }
  975. 25 of 53 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  976. 19 of 47 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

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

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

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

    //// [tests/cases/compiler/mappedTypeWithAsClauseAndLateBoundProperty2.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [mappedTypeWithAsClauseAndLateBoundProperty2.ts]
  980. 20 of 50 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

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

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

  983. mean non-conventional identifier length 1.79 over 28 names (token pass, confidence 0.50)

  984. 31 of 61 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  985. 38 of 74 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  986. 32 of 71 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

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

    class A {
        public pb: number = 2;
        protected ptd: number = 1;
        private pvt: number = 0;
  988. file mixes tab and space indentation (4 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    let data = {
    	public foo: 'hey',
    	private bar: 'nay',
    	protected baz: 'oh my',
  989. 36 of 54 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  990. 39 of 58 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  991. 26 of 40 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  992. 47 of 70 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

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

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

    export class C1 {
    	public p1 = 0;
    	public p2() {}
    }
  995. file mixes tab and space indentation (10 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    export interface Bar {
    	_brand1: any;
    }
  996. file mixes tab and space indentation (3 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    export namespace TypeScript.Strasse.Street {
    	export class Rue {
    		public address:string;
    	}	
  997. 40 of 86 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

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

    namespace A.B.C {
    	import XYZ = X.Y.Z;
    	export function ping(x: number) {
    		if (x>0) XYZ.pong (x-1);
  999. 16 of 38 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

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

    namespace mod1 {
    	interface mInt {
    		new (bar:any):any;
            foo (bar:any):any;
  1001. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    namespace Foo {
    	1+1;
    }
  1002. file mixes tab and space indentation (2 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    export enum Animals {
    	Cat,
    	Dog
    };
  1003. 34 of 66 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1004. 38 of 68 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1005. 38 of 75 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1006. 35 of 68 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

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

  1008. 29 of 58 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

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

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

    namespace B {
    	export function f(): A.I { return null; }
    }
  1011. file mixes tab and space indentation (33 tab-indented and 42 space-indented lines) (raw pass, confidence 0.40)

    namespace OuterMod {
    	export function someExportedOuterFunc() { return -1; }
    
    	export namespace OuterInnerMod {
  1012. file mixes tab and space indentation (33 tab-indented and 42 space-indented lines) (raw pass, confidence 0.40)

    namespace OuterMod {
    	export function someExportedOuterFunc() { return -1; }
    
    	export namespace OuterInnerMod {
  1013. 20 of 50 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1014. 18 of 41 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

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

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

  1017. 29 of 43 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  1018. 48 of 119 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1019. 14 of 32 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

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

    function fx1(x: string | number | undefined) {
        if (isFalsy(x)) {
            x;  // "" | 0 | undefined
        }
  1021. 26 of 34 non-conventional identifiers are single-character (76%) (token pass, confidence 0.50)

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

  1023. file mixes tab and space indentation (9 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)

    namespace M {
    	class Foo {}
    	class Gar {
    		public fa: Foo[];
  1024. 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1025. 52 of 83 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  1026. 18 of 40 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

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

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

    function foo(...rest: number) { // error
    	var x: string = rest[0];
    	return x;
    }
  1029. 30 of 60 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

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

    interface Obj<T> {
    	ref: T;
    }
    interface Func<T> {
  1031. 29 of 65 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1032. 40 of 89 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1033. 36 of 48 non-conventional identifiers are single-character (75%) (token pass, confidence 0.50)

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

    function process( x: {a:number; b:string;}) {
    	return x.a;
    }
  1035. 20 of 40 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

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

  1037. line length 722 characters (raw pass, confidence 0.50)

    let _e = {}, { prop = Object.assign({}, obj) } = _e, _f = _e.more, more = _f === void 0 ? (_a = Object.assign({}, obj), obj = __rest(_a, []), _a) : _f, _g = '' + 'other', _h = _e[_g], other = _h === void 0 ? Object.assign({}, obj) : _h, _j = _e.yetAnother, _k = _j === void 0 ? Object.assign({}, obj) : _j, _l = _k.neste
  1038. 32 of 52 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

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

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

  1041. 15 of 33 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1042. 161 of 258 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  1043. 33 of 72 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

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

  1045. 75 of 132 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

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

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

    class C {
    	m1(), m1();
    	m2(), m2() {}
    	m3() {}, m3();
  1048. 17 of 34 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

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

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

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

    function attr(nameOrMap: any, value?: string): any {
        if (nameOrMap && typeof nameOrMap === "object") {
            // handle map case
            return new Accessor;
  1052. 23 of 34 non-conventional identifiers are single-character (68%) (token pass, confidence 0.50)

  1053. 16 of 36 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

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

    class C1 {
    	constructor(public p1:string); // ERROR
    	constructor(private p2:number); // ERROR
    	constructor(public p3:any) {} // OK
  1055. 58 of 90 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

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

    function f0<T extends typeof a>(a: T) {
    	a.b;
    }
  1057. 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

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

    try {
    	if (Math.random() > 0.5) {
    		foo = 1234;
    	}
  1059. file mixes tab and space indentation (5 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    function f() {
    	{
    		const x: string = 12;
    		const y: string = 12;
  1060. 28 of 56 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

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

  1062. 16 of 38 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1063. line length 709 characters (raw pass, confidence 0.50)

    exports.m3 = exports.glo_im2_public = exports.glo_im1_public = exports.glo_im4_private_v4_public = exports.glo_im4_private_v3_public = exports.glo_im4_private_v2_public = exports.glo_im4_private_v1_public = exports.glo_im3_private_v4_public = exports.glo_im3_private_v3_public = exports.glo_im3_private_v2_public = expor
  1064. line length 881 characters (raw pass, confidence 0.50)

    exports.publicUse_im_public_mu_public = exports.publicUse_im_public_mi_public = exports.publicUse_im_public_i_public = exports.publicUse_im_public_v_public = exports.publicUse_im_public_f_public = exports.publicUse_im_public_e_public = exports.publicUse_im_public_c_public = exports.im_public_mi_public = exports.im_publ
  1065. line length 598 characters (raw pass, confidence 0.50)

    exports.publicUse_im_private_mu_public = exports.publicUse_im_private_mi_public = exports.publicUse_im_private_i_public = exports.publicUse_im_private_v_public = exports.publicUse_im_private_f_public = exports.publicUse_im_private_e_public = exports.publicUse_im_private_c_public = exports.publicUse_im_private_mu_privat
  1066. file mixes tab and space indentation (4 tab-indented and 16 space-indented lines) (raw pass, confidence 0.40)

    class Foo {
    	public pubMeth() {this.privMeth();}
    	private privMeth() {}
    	public pubProp = 0;
  1067. file mixes tab and space indentation (5 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    class Foo {
    	private pvar = 0;
    	constructor() {
    	    var n = this.pvar;
  1068. 18 of 43 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1069. 22 of 51 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1070. 32 of 75 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1071. 58 of 112 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1072. line length 619 characters (raw pass, confidence 0.50)

        type KnownIterationMapKeys = '-40' | '-39' | '-38' | '-37' | '-36' | '-35' | '-34' | '-33' | '-32' | '-31' | '-30' | '-29' | '-28' | '-27' | '-26' | '-25' | '-24' | '-23' | '-22' | '-21' | '-20' | '-19' | '-18' | '-17' | '-16' | '-15' | '-14' | '-13' | '-12' | '-11' | '-10' | '-9' | '-8' | '-7' | '-6' | '-5' | '-4'
  1073. file mixes tab and space indentation (5 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    function foo(x: any) {
    	switch(x) {
    		case 1: return;
    		default:
  1074. 28 of 58 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

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

    class X {
    	method(readonly x: number) {}
    	set x(readonly value: number) {}
    }
  1076. 135 of 241 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

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

  1078. file mixes tab and space indentation (48 tab-indented and 72 space-indented lines) (raw pass, confidence 0.40)

    
    	export interface IWidget {
    		getDomNode(): any;
    		destroy();
  1079. 22 of 35 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

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

  1081. 21 of 30 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)

  1082. 28 of 38 non-conventional identifiers are single-character (74%) (token pass, confidence 0.50)

  1083. 18 of 33 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1084. file mixes tab and space indentation (13 tab-indented and 17 space-indented lines) (raw pass, confidence 0.40)

    export namespace Foo {
    	export class C {}
    }
  1085. file mixes tab and space indentation (13 tab-indented and 14 space-indented lines) (raw pass, confidence 0.40)

    	
    		if ( top && top.doScroll ) {
    			(function doScrollCheck() {
    				if ( false ) {
  1086. file mixes tab and space indentation (8 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    function R1() {
    	R1();
    	return;
    }
  1087. 23 of 49 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1088. 25 of 62 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

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

    interface Entity<T extends Entity<T>> {
       X: T;
       Y: T;
    }
  1090. 24 of 58 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1091. 36 of 86 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

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

    const regexes: RegExp[] = [
    	/[𝘈-𝘡][𝘡-𝘈]/,
    	/[𝘈-𝘡][𝘡-𝘈]/u,
    	/[𝘈-𝘡][𝘡-𝘈]/v,
  1093. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    const regexes: RegExp[] = [
    	/\u{10000}[\u{10000}]/,
    	/\u{10000}[\u{10000}]/u,
    	/\u{10000}[\u{10000}]/v,
  1094. file mixes tab and space indentation (6 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    const regexes: RegExp[] = [
    	/a{7,8}/,
    	/a{9223372036854775807,9223372036854775808}/,
    	/a{8,7}/,
  1095. 28 of 35 non-conventional identifiers are single-character (80%) (token pass, confidence 0.50)

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

    const regexes: RegExp[] = [
    	// Flags
    	/foo/visualstudiocode,
    	// Pattern modifiers
  1097. 28 of 35 non-conventional identifiers are single-character (80%) (token pass, confidence 0.50)

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

    const regexes: RegExp[] = [
    	// Flags
    	/foo/visualstudiocode,
    	// Pattern modifiers
  1099. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    const regexes: RegExp[] = [
    	/[?&]/v,
    	/[a&]/v,
    	/[&a]/v,
  1100. 28 of 42 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

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

    export namespace Models {
    	export class Person {
            constructor(name: string) { }
    	}
  1102. base64-like blob (72 bytes, compression ratio 1.15) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/requireOfJsonFileWithModuleNodeResolutionEmitEs2015.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [file1.ts]
  1103. 55 of 110 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1104. base64-like blob (68 bytes, compression ratio 1.06) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/resolveInterfaceNameWithSameLetDeclarationName1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [resolveInterfaceNameWithSameLetDeclarationName1.ts]
  1105. base64-like blob (68 bytes, compression ratio 1.07) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/resolveInterfaceNameWithSameLetDeclarationName2.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [resolveInterfaceNameWithSameLetDeclarationName2.ts]
  1106. base64-like blob (65 bytes, compression ratio 1.08) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/resolveModuleNameWithSameLetDeclarationName1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [resolveModuleNameWithSameLetDeclarationName1.ts]
  1107. base64-like blob (65 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/resolveModuleNameWithSameLetDeclarationName2.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [resolveModuleNameWithSameLetDeclarationName2.ts]
  1108. base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/resolveTypeAliasWithSameLetDeclarationName1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [resolveTypeAliasWithSameLetDeclarationName1.ts]
  1109. line length 564 characters (raw pass, confidence 0.50)

            solomonis() : panglima.abidi<quasiater.carolinensis, rendalli.crenulata<gabriellae.klossii<julianae.nudicaudus, dogramacii.aurata>, argurus.netscheri<minutus.inez<argurus.peninsulae, julianae.nudicaudus>, julianae.oralis<lavali.xanthognathus, argurus.oreas>>>> { var x : panglima.abidi<quasiater.carolinensis, re
  1110. line length 522 characters (raw pass, confidence 0.50)

            morrisi() : ruatanica.hector<trivirgatus.oconnelli, sagitta.cinereus<nigra.caucasica<julianae.sumatrana, trivirgatus.oconnelli>, quasiater.wattsi<julianae.galapagoensis, panamensis.linulus<lavali.xanthognathus, macrorhinos.konganensis>>>> { var x : ruatanica.hector<trivirgatus.oconnelli, sagitta.cinereus<nigra.
  1111. line length 509 characters (raw pass, confidence 0.50)

                flamarioni(): imperfecta.lasiurus<amphibius<patas.uralensis, gabriellae.klossii<julianae.nudicaudus, dogramacii.aurata>>, sagitta.leptoceros<lutreolus.punicus, daubentonii.arboreus<quasiater.carolinensis, rionegrensis.caniventer>>> { var x: imperfecta.lasiurus<amphibius<patas.uralensis, gabriellae.klossii<j
  1112. line length 524 characters (raw pass, confidence 0.50)

                simulator(): macrorhinos.marmosurus<Lanthanum.nitidus<dammermani.melanops, lavali.lepturus>, macrorhinos.marmosurus<rendalli.moojeni<panglima.amphibius<trivirgatus.falconeri, caurinus.psilurus>, gabriellae.echinatus>, sagitta.stolzmanni>> { var x: macrorhinos.marmosurus<Lanthanum.nitidus<dammermani.melanops
  1113. line length 594 characters (raw pass, confidence 0.50)

                beatrix(): imperfecta.ciliolabrum<provocax.melanoleuca, panglima.amphibius<minutus.inez<rendalli.moojeni<panglima.amphibius<trivirgatus.falconeri, caurinus.psilurus>, gabriellae.echinatus>, dogramacii.aurata>, imperfecta.ciliolabrum<quasiater.carolinensis, lavali.beisa>>> { var x: imperfecta.ciliolabrum<pro
  1114. line length 614 characters (raw pass, confidence 0.50)

                pilirostris(): argurus.wetmorei<imperfecta.lasiurus<panglima.amphibius<patas.uralensis, gabriellae.klossii<julianae.nudicaudus, dogramacii.aurata>>, sagitta.leptoceros<lutreolus.punicus, daubentonii.arboreus<quasiater.carolinensis, rionegrensis.caniventer>>>, macrorhinos.konganensis> { var x: argurus.wetmor
  1115. line length 586 characters (raw pass, confidence 0.50)

                palmeri(): panglima.amphibius<howi.coludo<macrorhinos.daphaenodon, panglima.amphibius<macrorhinos.daphaenodon, patas.uralensis>>, trivirgatus.mixtus<argurus.dauricus<dogramacii.aurata, dammermani.melanops>, panglima.amphibius<lavali.lepturus, quasiater.carolinensis>>> { var x: panglima.amphibius<howi.coludo
  1116. line length 559 characters (raw pass, confidence 0.50)

        solomonis() : panglima.abidi<quasiater.carolinensis, rendalli.crenulata<gabriellae.klossii<julianae.nudicaudus, dogramacii.aurata>, argurus.netscheri<minutus.inez<argurus.peninsulae, julianae.nudicaudus>, julianae.oralis<lavali.xanthognathus, argurus.oreas>>>> { var x : panglima.abidi<quasiater.carolinensis, rendal
  1117. line length 517 characters (raw pass, confidence 0.50)

        morrisi() : ruatanica.hector<trivirgatus.oconnelli, sagitta.cinereus<nigra.caucasica<julianae.sumatrana, trivirgatus.oconnelli>, quasiater.wattsi<julianae.galapagoensis, panamensis.linulus<lavali.xanthognathus, macrorhinos.konganensis>>>> { var x : ruatanica.hector<trivirgatus.oconnelli, sagitta.cinereus<nigra.cauc
  1118. line length 504 characters (raw pass, confidence 0.50)

            flamarioni(): imperfecta.lasiurus<amphibius<patas.uralensis, gabriellae.klossii<julianae.nudicaudus, dogramacii.aurata>>, sagitta.leptoceros<lutreolus.punicus, daubentonii.arboreus<quasiater.carolinensis, rionegrensis.caniventer>>> { var x: imperfecta.lasiurus<amphibius<patas.uralensis, gabriellae.klossii<julia
  1119. line length 519 characters (raw pass, confidence 0.50)

            simulator(): macrorhinos.marmosurus<Lanthanum.nitidus<dammermani.melanops, lavali.lepturus>, macrorhinos.marmosurus<rendalli.moojeni<panglima.amphibius<trivirgatus.falconeri, caurinus.psilurus>, gabriellae.echinatus>, sagitta.stolzmanni>> { var x: macrorhinos.marmosurus<Lanthanum.nitidus<dammermani.melanops, la
  1120. line length 589 characters (raw pass, confidence 0.50)

            beatrix(): imperfecta.ciliolabrum<provocax.melanoleuca, panglima.amphibius<minutus.inez<rendalli.moojeni<panglima.amphibius<trivirgatus.falconeri, caurinus.psilurus>, gabriellae.echinatus>, dogramacii.aurata>, imperfecta.ciliolabrum<quasiater.carolinensis, lavali.beisa>>> { var x: imperfecta.ciliolabrum<provoca
  1121. line length 609 characters (raw pass, confidence 0.50)

            pilirostris(): argurus.wetmorei<imperfecta.lasiurus<panglima.amphibius<patas.uralensis, gabriellae.klossii<julianae.nudicaudus, dogramacii.aurata>>, sagitta.leptoceros<lutreolus.punicus, daubentonii.arboreus<quasiater.carolinensis, rionegrensis.caniventer>>>, macrorhinos.konganensis> { var x: argurus.wetmorei<i
  1122. line length 581 characters (raw pass, confidence 0.50)

            palmeri(): panglima.amphibius<howi.coludo<macrorhinos.daphaenodon, panglima.amphibius<macrorhinos.daphaenodon, patas.uralensis>>, trivirgatus.mixtus<argurus.dauricus<dogramacii.aurata, dammermani.melanops>, panglima.amphibius<lavali.lepturus, quasiater.carolinensis>>> { var x: panglima.amphibius<howi.coludo<mac
  1123. 30 of 69 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1124. 52 of 122 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1125. 24 of 52 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1126. 17 of 30 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1127. 19 of 40 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

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

    try { } catch(ex1) { 
    	throw ex1;
    }
  1129. file mixes tab and space indentation (5 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    class C {
    	public p1 = 0;
    	public callback(cb:()=>void) {cb();}
    	public doit() {
  1130. file mixes tab and space indentation (8 tab-indented and 33 space-indented lines) (raw pass, confidence 0.40)

    interface MouseEvent {
        x: number;
        y: number;
    }
  1131. file mixes tab and space indentation (3 tab-indented and 23 space-indented lines) (raw pass, confidence 0.40)

    {
        export class Test
        {
          private name = "hello";
  1132. 28 of 50 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

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

    (function() {
    	var s0;
    	for ({ s0 = 5 } of [{ s0: 1 }]) {
    	}
  1134. file mixes tab and space indentation (49 tab-indented and 49 space-indented lines) (raw pass, confidence 0.40)

    (function() {
    	var s0;
    	for ({ s0 = 5 } of [{ s0: 1 }]) {
    	}
  1135. identifier `啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ` mixes scripts: Han + Other (in string/comment) (raw pass, confidence 0.40)

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

    ⟨U+000D⟩
    //// [①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].ts]⟨U+000D⟩
    var a = 1;
    var b = 2;
  1137. identifier `啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ` mixes scripts: Han + Other (in string/comment) (raw pass, confidence 0.40)

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

    ⟨U+000D⟩
    //// [①Ⅻㄨㄩ 啊阿鼾齄丂丄狚狛狜狝﨨﨩ˊˋ˙–⿻〇㐀㐁䶴䶵U1[⟨U+E025⟩⟨U+E026⟩⟨U+E027⟩⟨U+E038⟩⟨U+E039⟩]U2[⟨U+E25A⟩⟨U+E25B⟩⟨U+E26C⟩⟨U+E26D⟩]U3[⟨U+E4FE⟩⟨U+E4FF⟩⟨U+E500⟩⟨U+E50B⟩⟨U+E50C⟩].js]⟨U+000D⟩
    "use strict";⟨U+000D⟩
    var a = 1;
  1139. mean non-conventional identifier length 1.91 over 22 names (token pass, confidence 0.50)

  1140. 28 of 52 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

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

    function outer<T>(x: T) {
      class Inner {
        static y: T = x;
      }
  1142. file mixes tab and space indentation (4 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    class C {
    	static s;
    	public a() {
    		s = 1;
  1143. 56 of 84 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  1144. 21 of 40 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1145. 66 of 162 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

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

    class C {
    	constructor() {
    		static p1 = 0; // ERROR
    		static m1() {} // ERROR
  1147. 14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

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

    interface Lifecycle<Attrs, State> {
    	oninit?(vnode: Vnode<Attrs, State>): number;
    	[_: number]: any;
    }
  1149. file mixes tab and space indentation (10 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    interface Lifecycle<Attrs, State extends Lifecycle<Attrs, State>> {
    	oninit?(vnode: Vnode<Attrs, State>): number;
    	[_: number]: any;
    }
  1150. 22 of 48 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1151. base64-like blob (66 bytes, compression ratio 1.08) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallFromClassThatDerivesFromGenericType1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericType1.ts]
  1152. base64-like blob (66 bytes, compression ratio 1.08) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallFromClassThatDerivesFromGenericType2.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericType2.ts]
  1153. base64-like blob (103 bytes, compression ratio 0.93) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts]
  1154. base64-like blob (82 bytes, compression ratio 1.01) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts]⟨U+000D⟩
    class A<T1, T2> {
        constructor(private map: (value: T1) => T2) {
  1155. base64-like blob (82 bytes, compression ratio 1.01) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js]⟨U+000D⟩
    "use strict";⟨U+000D⟩
    class A {
  1156. base64-like blob (88 bytes, compression ratio 0.98) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts]
  1157. base64-like blob (67 bytes, compression ratio 1.07) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts]⟨U+000D⟩
    class A<T1, T2> {
        constructor(private map: (value: T1) => T2) {
  1158. base64-like blob (67 bytes, compression ratio 1.07) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js]⟨U+000D⟩
    "use strict";⟨U+000D⟩
    class A {
  1159. base64-like blob (85 bytes, compression ratio 0.99) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts]
  1160. base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts]⟨U+000D⟩
    class A {
        constructor(private map: (value: number) => string) {
  1161. base64-like blob (64 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js]⟨U+000D⟩
    "use strict";⟨U+000D⟩
    class A {
  1162. base64-like blob (65 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallInJSWithWrongBaseTypeArgumentCount1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [a.ts]
  1163. base64-like blob (65 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallInJSWithWrongBaseTypeArgumentCount1.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [a.ts]
  1164. base64-like blob (65 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallInJSWithWrongBaseTypeArgumentCount2.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [a.ts]
  1165. base64-like blob (65 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    //// [tests/cases/compiler/superCallInJSWithWrongBaseTypeArgumentCount2.ts] ////⟨U+000D⟩
    ⟨U+000D⟩
    //// [a.ts]
  1166. 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

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

    class A {
    	constructor(f: string) {
    	}
    	public blah(): string { return ""; }
  1168. 19 of 41 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

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

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

    function R1(index: number) {
        switch (index) {
            case 0:
            case 1:
  1171. file mixes tab and space indentation (1 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    {
      "name": "styled-components",
      "version": "3.3.3",
      "typings": "typings/styled-components.d.ts"
  1172. surrogate pair \uD83D\uDCA9 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    
    f `'\u{1f4a9}'${ " should be converted to " }'\uD83D\uDCA9'`;⟨U+000D⟩
    ⟨U+000D⟩
    //// [taggedTemplateStringsWithUnicodeEscapes.js]
  1173. surrogate pair \uD83D\uDCA9 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    }⟨U+000D⟩
    f `'\u{1f4a9}'${" should be converted to "}'\uD83D\uDCA9'`;
  1174. surrogate pair \uD83D\uDCA9 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    
    f `'\u{1f4a9}'${ " should be converted to " }'\uD83D\uDCA9'`;⟨U+000D⟩
    ⟨U+000D⟩
    //// [taggedTemplateStringsWithUnicodeEscapesES6.js]
  1175. surrogate pair \uD83D\uDCA9 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    }⟨U+000D⟩
    f `'\u{1f4a9}'${" should be converted to "}'\uD83D\uDCA9'`;
  1176. file mixes tab and space indentation (5 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    function suggest(){ 
    	var TypeScriptKeywords:string[];  
    	var result:any;	
    					
  1177. file mixes tab and space indentation (11 tab-indented and 32 space-indented lines) (raw pass, confidence 0.40)

    {
          constructor(x: number, y: number);
          public x: number;
          public y: number;
  1178. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function func2(stuff1:string, stuff2:number, stuff3:number) {
    	return func1([stuff1, stuff2, stuff3]);
    }
  1179. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function func2(stuff1:string, stuff2:number, stuff3:number) {
    	return func1([stuff1, stuff2, stuff3]);
    }
  1180. 27 of 44 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

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

    namespace M {
        export interface I {
    	z;
        }
  1182. 22 of 55 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

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

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

    interface IPoint {
        x:number;
        y:number;
    }
  1185. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    namespace M {
    	var f = () => {this.window;}
    }
  1186. line length 815 characters (raw pass, confidence 0.50)

    export enum SyntaxKind { Node0, Node1, Node2, Node3, Node4, Node5, Node6, Node7, Node8, Node9, Node10, Node11, Node12, Node13, Node14, Node15, Node16, Node17, Node18, Node19, Node20, Node21, Node22, Node23, Node24, Node25, Node26, Node27, Node28, Node29, Node30, Node31, Node32, Node33, Node34, Node35, Node36, Node37, N
  1187. line length 907 characters (raw pass, confidence 0.50)

    export type Node = Node0 | Node1 | Node2 | Node3 | Node4 | Node5 | Node6 | Node7 | Node8 | Node9 | Node10 | Node11 | Node12 | Node13 | Node14 | Node15 | Node16 | Node17 | Node18 | Node19 | Node20 | Node21 | Node22 | Node23 | Node24 | Node25 | Node26 | Node27 | Node28 | Node29 | Node30 | Node31 | Node32 | Node33 | Node3
  1188. line length 908 characters (raw pass, confidence 0.50)

    export type Node = Node0 | Node1 | Node2 | Node3 | Node4 | Node5 | Node6 | Node7 | Node8 | Node9 | Node10 | Node11 | Node12 | Node13 | Node14 | Node15 | Node16 | Node17 | Node18 | Node19 | Node20 | Node21 | Node22 | Node23 | Node24 | Node25 | Node26 | Node27 | Node28 | Node29 | Node30 | Node31 | Node32 | Node33 | Node3
  1189. 14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1190. 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

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

    interface I1<T, U> {
    	m(value: T): U;
    }
  1192. file mixes tab and space indentation (1 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    namespace JSX {
        export interface IntrinsicElements {
            span: {};
        }
  1193. 52 of 91 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

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

  1195. 19 of 39 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1196. 32 of 46 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)

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

    (foo: Foo) => {
    	bar[id]++;
    	const id = foo.bar;
    }
  1198. 21 of 35 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  1199. 19 of 33 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  1200. 38 of 89 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

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

    function f1() {
    	var a = { x: 1, y: 2 };
    	a = {}; // error
        a = { x: 1 }; // error
  1202. 27 of 53 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1203. 19 of 45 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

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

  1205. 48 of 71 non-conventional identifiers are single-character (68%) (token pass, confidence 0.50)

  1206. 32 of 49 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1207. 33 of 68 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

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

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

  1210. 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

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

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

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

  1214. mean non-conventional identifier length 1.29 over 56 names (token pass, confidence 0.50)

  1215. 22 of 39 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

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

    function p(undefined = "wat") {
    	return undefined;
    }
  1217. file mixes tab and space indentation (3 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    class undefined {
    	foo: string;
    }
    interface undefined {
  1218. 17 of 35 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

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

    namespace M{
    	class A{
    		constructor(val:string){}
    	}
  1220. U+00AD SOFT HYPHEN in source (in string/comment) (raw pass, confidence 0.45)

    //// [unicodeStringLiteral.ts]⟨U+000D⟩
    var ੳ = "Ü⟨U+00AD⟩ਲ⟨U+000E⟩ĭ";⟨U+000D⟩
    ⟨U+000D⟩
    //// [unicodeStringLiteral.js]
  1221. U+00AD SOFT HYPHEN in source (in string/comment) (raw pass, confidence 0.45)

    "use strict";⟨U+000D⟩
    var ੳ = "Ü⟨U+00AD⟩ਲ⟨U+000E⟩ĭ";
  1222. surrogate pair \uD83D\uDE03 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    // low-high surrogate pair - the "correct" case
    export const highLow = "\ud83d\ude03" as const;
    
    // high surrogate
  1223. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // high surrogate
    export const high = "\ud83d" as const;
    
    // low surrogate
  1224. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // low surrogate
    export const low = "\ude03" as const;
    
    // two high surrogates
  1225. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // two high surrogates
    export const highHigh = "\ud83d\ud83d" as const;
    
    // two low surrogates
  1226. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // two high surrogates
    export const highHigh = "\ud83d\ud83d" as const;
    
    // two low surrogates
  1227. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // two low surrogates
    export const lowLow = "\ude03\ude03" as const;
    
    // swapped expected order of surrogates
  1228. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // two low surrogates
    export const lowLow = "\ude03\ude03" as const;
    
    // swapped expected order of surrogates
  1229. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // swapped expected order of surrogates
    export const lowHigh = "\ude03\ud83d" as const;
  1230. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // swapped expected order of surrogates
    export const lowHigh = "\ude03\ud83d" as const;
  1231. surrogate pair \uD83D\uDE03 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)

    // low-high surrogate pair - the "correct" case⟨U+000D⟩
    export const highLow = "\ud83d\ude03";⟨U+000D⟩
    // high surrogate⟨U+000D⟩
    export const high = "\ud83d";
  1232. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // high surrogate⟨U+000D⟩
    export const high = "\ud83d";⟨U+000D⟩
    // low surrogate⟨U+000D⟩
    export const low = "\ude03";
  1233. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // low surrogate⟨U+000D⟩
    export const low = "\ude03";⟨U+000D⟩
    // two high surrogates⟨U+000D⟩
    export const highHigh = "\ud83d\ud83d";
  1234. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // two high surrogates⟨U+000D⟩
    export const highHigh = "\ud83d\ud83d";⟨U+000D⟩
    // two low surrogates⟨U+000D⟩
    export const lowLow = "\ude03\ude03";
  1235. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // two high surrogates⟨U+000D⟩
    export const highHigh = "\ud83d\ud83d";⟨U+000D⟩
    // two low surrogates⟨U+000D⟩
    export const lowLow = "\ude03\ude03";
  1236. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // two low surrogates⟨U+000D⟩
    export const lowLow = "\ude03\ude03";⟨U+000D⟩
    // swapped expected order of surrogates⟨U+000D⟩
    export const lowHigh = "\ude03\ud83d";
  1237. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // two low surrogates⟨U+000D⟩
    export const lowLow = "\ude03\ude03";⟨U+000D⟩
    // swapped expected order of surrogates⟨U+000D⟩
    export const lowHigh = "\ude03\ud83d";
  1238. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    // swapped expected order of surrogates⟨U+000D⟩
    export const lowHigh = "\ude03\ud83d";
  1239. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    // swapped expected order of surrogates⟨U+000D⟩
    export const lowHigh = "\ude03\ud83d";
  1240. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    export declare const highLow: "😃";⟨U+000D⟩
    export declare const high: "\uD83D";⟨U+000D⟩
    export declare const low: "\uDE03";⟨U+000D⟩
    export declare const highHigh: "\uD83D\uD83D";
  1241. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    export declare const high: "\uD83D";⟨U+000D⟩
    export declare const low: "\uDE03";⟨U+000D⟩
    export declare const highHigh: "\uD83D\uD83D";⟨U+000D⟩
    export declare const lowLow: "\uDE03\uDE03";
  1242. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    export declare const low: "\uDE03";⟨U+000D⟩
    export declare const highHigh: "\uD83D\uD83D";⟨U+000D⟩
    export declare const lowLow: "\uDE03\uDE03";⟨U+000D⟩
    export declare const lowHigh: "\uDE03\uD83D";
  1243. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    export declare const low: "\uDE03";⟨U+000D⟩
    export declare const highHigh: "\uD83D\uD83D";⟨U+000D⟩
    export declare const lowLow: "\uDE03\uDE03";⟨U+000D⟩
    export declare const lowHigh: "\uDE03\uD83D";
  1244. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    export declare const highHigh: "\uD83D\uD83D";⟨U+000D⟩
    export declare const lowLow: "\uDE03\uDE03";⟨U+000D⟩
    export declare const lowHigh: "\uDE03\uD83D";
  1245. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    export declare const highHigh: "\uD83D\uD83D";⟨U+000D⟩
    export declare const lowLow: "\uDE03\uDE03";⟨U+000D⟩
    export declare const lowHigh: "\uDE03\uD83D";
  1246. orphaned low surrogate \uDE03 (no preceding high surrogate) (token pass, confidence 0.65)

    export declare const lowLow: "\uDE03\uDE03";⟨U+000D⟩
    export declare const lowHigh: "\uDE03\uD83D";
  1247. orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)

    export declare const lowLow: "\uDE03\uDE03";⟨U+000D⟩
    export declare const lowHigh: "\uDE03\uD83D";
  1248. file mixes tab and space indentation (1 tab-indented and 28 space-indented lines) (raw pass, confidence 0.40)

    declare class Test<T> {
        obj: T;
        get<K extends keyof T>(k: K): T[K];
    }
  1249. file mixes tab and space indentation (2 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    interface Interface<T extends Enum> {
    	type: T;
    }
  1250. file mixes tab and space indentation (16 tab-indented and 94 space-indented lines) (raw pass, confidence 0.40)

    function func1() {
        aFunc();
    
        console.log(EnumA.Value);
  1251. file mixes tab and space indentation (16 tab-indented and 102 space-indented lines) (raw pass, confidence 0.40)

    function func1() {
        aFunc();
    
        console.log(EnumA.Value);
  1252. 45 of 62 non-conventional identifiers are single-character (73%) (token pass, confidence 0.50)

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

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

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

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

  1257. 36 of 63 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

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

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

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

    interface Controller<out T> {
    	createAnimal: () => T;
    	run: (animal: T) => void;
    }
  1261. 30 of 46 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

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

    {
    	"typeAcquisition": {
    		"enable": true,
    		"include": ["0.d.ts", "1.d.ts"],
  1263. file mixes tab and space indentation (5 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": true,
    		"include": ["0.d.ts", "1.d.ts"],
  1264. file mixes tab and space indentation (3 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enableAutoDiscovy": true,
    	},
  1265. file mixes tab and space indentation (3 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enableAutoDiscovy": true,
    	},
  1266. file mixes tab and space indentation (3 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enableAutoDiscovy": true,
    	}
  1267. file mixes tab and space indentation (3 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enableAutoDiscovy": true,
    	}
  1268. file mixes tab and space indentation (5 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": false,
    		"include": ["0.d.ts"],
  1269. file mixes tab and space indentation (5 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": false,
    		"include": ["0.d.ts"],
  1270. file mixes tab and space indentation (3 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": false,
    	},
  1271. file mixes tab and space indentation (3 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": false,
    	},
  1272. file mixes tab and space indentation (3 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": true,
    	},
  1273. file mixes tab and space indentation (3 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    {
    	"typeAcquisition": {
    		"enable": true,
    	},
  1274. file mixes tab and space indentation (4 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    {
    			    "compilerOptions": {
    					"types": []
    				}
  1275. file mixes tab and space indentation (4 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    {
    			    "compilerOptions": {
    					"types": []
    				}
  1276. file mixes tab and space indentation (2 tab-indented and 31 space-indented lines) (raw pass, confidence 0.40)

    {
      "compilerOptions": {
        "outDir": "./dist",
        "strict": true,
  1277. file mixes tab and space indentation (2 tab-indented and 31 space-indented lines) (raw pass, confidence 0.40)

    {
      "compilerOptions": {
        "outDir": "./dist",
        "strict": true,
  1278. file mixes tab and space indentation (2 tab-indented and 15 space-indented lines) (raw pass, confidence 0.40)

    {
      "compilerOptions": {
        "outFile": "${configDir}/outFile",
        "outDir": "${configDir}/outDir",
  1279. file mixes tab and space indentation (2 tab-indented and 15 space-indented lines) (raw pass, confidence 0.40)

    {
      "compilerOptions": {
        "outFile": "${configDir}/outFile",
        "outDir": "${configDir}/outDir",
  1280. file mixes tab and space indentation (6 tab-indented and 16 space-indented lines) (raw pass, confidence 0.40)

    {
    				"extends": "./tsconfigWithExtends.json",
    				"compilerOptions": {
    				    "outDir": "./dist",
  1281. file mixes tab and space indentation (6 tab-indented and 16 space-indented lines) (raw pass, confidence 0.40)

    {
    				"extends": "./tsconfigWithExtends.json",
    				"compilerOptions": {
    				    "outDir": "./dist",
  1282. file mixes tab and space indentation (13 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    			    "compilerOptions": {
    				"sourcemap": true,
    				"declarationmap": true,
  1283. file mixes tab and space indentation (13 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    {
    			    "compilerOptions": {
    				"sourcemap": true,
    				"declarationmap": true,
  1284. 56 of 140 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1285. 56 of 140 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1286. mean non-conventional identifier length 1.92 over 26 names (token pass, confidence 0.50)

  1287. mean non-conventional identifier length 1.83 over 24 names (token pass, confidence 0.50)

  1288. 39 of 97 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1289. 71 of 140 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1290. 54 of 114 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1291. 73 of 135 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

  1292. 14 of 32 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1293. 109 of 233 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

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

  1295. 95 of 223 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

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

  1297. 106 of 218 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1298. 91 of 175 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

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

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

  1301. 2181 of 4122 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  1302. 454 of 912 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

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

  1304. 54 of 116 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1305. 65 of 118 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

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

  1307. 59 of 125 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1308. 91 of 169 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)

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

  1310. 57 of 127 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1311. mean non-conventional identifier length 1.41 over 39 names (token pass, confidence 0.50)

  1312. 252 of 610 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1313. 164 of 244 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  1314. 135 of 242 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1315. 135 of 242 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1316. 28 of 70 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1317. 32 of 63 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

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

    let o = {
    	async m1() { },
    	async m2(): Promise<void> { },
    	async m3(): MyPromise<void> { }
  1319. file mixes tab and space indentation (10 tab-indented and 44 space-indented lines) (raw pass, confidence 0.40)

    let o = {
    	async m1() { },
    	async m2(): Promise<void> { },
    	async m3(): MyPromise<void> { }
  1320. file mixes tab and space indentation (10 tab-indented and 44 space-indented lines) (raw pass, confidence 0.40)

    let o = {
    	async m1() { },
    	async m2(): Promise<void> { },
    	async m3(): MyPromise<void> { }
  1321. file mixes tab and space indentation (10 tab-indented and 19 space-indented lines) (raw pass, confidence 0.40)

    let o = {
    	async m1() { },
    	async m2(): Promise<void> { },
    	async m3(): MyPromise<void> { }
  1322. file mixes tab and space indentation (10 tab-indented and 54 space-indented lines) (raw pass, confidence 0.40)

    let o = {
    	async m1() { },
    	async m2(): Promise<void> { },
    	async m3(): MyPromise<void> { }
  1323. file mixes tab and space indentation (10 tab-indented and 54 space-indented lines) (raw pass, confidence 0.40)

    let o = {
    	async m1() { },
    	async m2(): Promise<void> { },
    	async m3(): MyPromise<void> { }
  1324. line length 980 characters (raw pass, confidence 0.50)

    _a = C1, _C1_instances = new WeakSet(), _C1_a_accessor_storage = new WeakMap(), _C1_b_accessor_storage = new WeakMap(), _C1_a_get = function _C1_a_get() { return __classPrivateFieldGet(this, _C1_a_accessor_storage, "f"); }, _C1_a_set = function _C1_a_set(value) { __classPrivateFieldSet(this, _C1_a_accessor_storage, val
  1325. line length 520 characters (raw pass, confidence 0.50)

    _b = C2, _C2_instances = new WeakSet(), _C2_a_1_accessor_storage = new WeakMap(), _C2_a_get = function _C2_a_get() { return __classPrivateFieldGet(this, _C2_a_1_accessor_storage, "f"); }, _C2_a_set = function _C2_a_set(value) { __classPrivateFieldSet(this, _C2_a_1_accessor_storage, value, "f"); }, _C2_b_get = function 
  1326. file mixes tab and space indentation (5 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    async function f() {
    	let await_a = await a;
    	let await_b = await b;
    	let await_c = await c;
  1327. file mixes tab and space indentation (5 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)

    async function f() {
    	let await_a = await a;
    	let await_b = await b;
    	let await_c = await c;
  1328. 115 of 215 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

  1329. 74 of 166 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1330. 51 of 121 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1331. 18 of 41 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

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

  1333. 51 of 113 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

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

    declare namespace JSX {
    	interface Element { }
    	interface ElementAttributesProperty { props: {} }
    	interface IntrinsicElements { 
  1335. file mixes tab and space indentation (8 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface ElementAttributesProperty { props: {} }
    	interface IntrinsicElements { 
  1336. file mixes tab and space indentation (14 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    interface ButtonProp {
        a: number,
        b: string,
        children: Button;
  1337. file mixes tab and space indentation (4 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    interface ButtonProp {
        a: number,
        b: string,
        children: Button;
  1338. 20 of 32 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

  1339. 45 of 74 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

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

    export namespace M1 {
    	export class C1 {
    		m1: foo2.M1.C1;
    		x: number;
  1341. 18 of 44 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1342. 52 of 101 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

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

  1344. 25 of 41 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  1345. 39 of 71 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1346. 22 of 54 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1347. 17 of 40 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

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

    class A {
    	public constructor(a: boolean) // error
    	protected constructor(a: number) // error
    	private constructor(a: string)
  1349. 24 of 50 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

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

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

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

  1353. 31 of 76 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1354. 31 of 76 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1355. 32 of 69 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1356. 18 of 30 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

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

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

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

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

  1361. 24 of 57 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1362. 22 of 46 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1363. 22 of 46 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

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

  1365. 24 of 51 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1366. 50 of 117 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1367. 54 of 127 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1368. 50 of 117 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

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

    export class C1 {
    	m1 = 42;
    	static s1 = true;
    }
  1370. file mixes tab and space indentation (8 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    export class C1 {
    	m1 = 42;
    	static s1 = true;
    }
  1371. mean non-conventional identifier length 1.92 over 72 names (token pass, confidence 0.50)

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

  1373. 660 of 1317 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1374. 518 of 1025 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1375. mean non-conventional identifier length 1.92 over 443 names (token pass, confidence 0.50)

  1376. 75 of 148 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

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

  1378. 272 of 537 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

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

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

  1381. 18 of 40 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1382. 18 of 40 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

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

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

  1385. 20 of 34 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  1386. 20 of 34 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

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

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

  1389. 20 of 35 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1390. 20 of 35 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

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

    class C {
        ["hello"]() {
            debugger;
        }
  1392. file mixes tab and space indentation (4 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    class C {
        ["hello"]() {
            debugger;
    	}
  1393. file mixes tab and space indentation (3 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    var v = {
        ["hello"]() {
            debugger;
    	},
  1394. file mixes tab and space indentation (4 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    var v = {
        ["hello"]() {
            debugger;
    	},
  1395. file mixes tab and space indentation (8 tab-indented and 161 space-indented lines) (raw pass, confidence 0.40)

    interface Covariant<T> {
        foo: T extends string ? T : number;
    }
  1396. mean non-conventional identifier length 1.67 over 30 names (token pass, confidence 0.50)

  1397. 46 of 97 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1398. 31 of 61 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1399. 19 of 39 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1400. 130 of 291 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1401. 74 of 182 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1402. 35 of 83 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1403. 86 of 155 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1404. 52 of 110 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1405. 52 of 110 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

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

    namespace JSX {
        export interface IntrinsicElements {
            span: {};
        }
  1407. 26 of 40 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1408. 15 of 36 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

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

    class C1 {
        a!: number;
        b: string;  // Error
    }
  1410. 26 of 60 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1411. 26 of 63 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

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

  1413. 26 of 63 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1414. 52 of 64 non-conventional identifiers are single-character (81%) (token pass, confidence 0.50)

  1415. 22 of 44 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1416. 82 of 173 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1417. 44 of 94 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1418. mean non-conventional identifier length 1.50 over 24 names (token pass, confidence 0.50)

  1419. mean non-conventional identifier length 1.46 over 24 names (token pass, confidence 0.50)

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

    const { [a]: aVal, [b]: bVal } = (() => {
    	return { [a]: 1, [b]: 1 };
    })();
    console.log(aVal, bVal);
  1421. 25 of 44 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

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

    enum K {
        a = "a",
        b = "b"
    }
  1423. 22 of 40 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

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

    const K = {
        a: "a",
        b: "b"
    }
  1425. 26 of 50 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

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

    type Correct = {
    	code: string
    	property: true
    	err: undefined
  1427. file mixes tab and space indentation (4 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    namespace x {
    	export var x = 10;
    }
    class y {
  1428. `Function(...)` called with a non-literal body (ast pass, confidence 0.75)

    
    Function(import.defer);
    
    import.defer
    likely benign LLM, confidence 0.85 Conformance test exercising invalid import.defer usage passed to Function.
    Reasoning

    This is a conformance test for invalid import.defer syntax. The Function call appears because the test passes import.defer as an argument to check error reporting; the snippet is not an attack payload and there is no real dynamic execution of external data.

  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 Conformance test with invalid import.defer expressions in a standalone context.
    Reasoning

    Another invalid-syntax conformance test for import.defer; the Function invocation is a test construct, not a payload, and the file is a TypeScript test baseline.

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

    var a = () => {
        var arg = arguments[0];  // error
    }
  1431. file mixes tab and space indentation (6 tab-indented and 18 space-indented lines) (raw pass, confidence 0.40)

    var a = () => {
        var arg = arguments[0];  // error
    }
  1432. 19 of 40 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1433. 32 of 67 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

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

  1435. 138 of 244 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

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

    export enum Animals {
    	Cat = 1
    }
    export enum Animals {
  1437. 232 of 478 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1438. 40 of 90 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1439. 45 of 90 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

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

  1441. file mixes tab and space indentation (22 tab-indented and 54 space-indented lines) (raw pass, confidence 0.40)

    class B extends A {
    	public constructor() {
    		'inject';
    		super();
  1442. line length 746 characters (raw pass, confidence 0.50)

                __esDecorate(_a, _private_field1_descriptor = { get: __setFunctionName(function () { return __classPrivateFieldGet(this, _C_field1_accessor_storage, "f"); }, "#field1", "get"), set: __setFunctionName(function (value) { __classPrivateFieldSet(this, _C_field1_accessor_storage, value, "f"); }, "#field1", "set"
  1443. line length 560 characters (raw pass, confidence 0.50)

                __esDecorate(this, _private_field1_descriptor = { get: __setFunctionName(function () { return this.#field1_accessor_storage; }, "#field1", "get"), set: __setFunctionName(function (value) { this.#field1_accessor_storage = value; }, "#field1", "set") }, _private_field1_decorators, { kind: "accessor", name: "#
  1444. line length 747 characters (raw pass, confidence 0.50)

                __esDecorate(_a, _static_private_field1_descriptor = { get: __setFunctionName(function () { return __classPrivateFieldGet(_a, _a, "f", _C_field1_accessor_storage); }, "#field1", "get"), set: __setFunctionName(function (value) { __classPrivateFieldSet(_a, _a, value, "f", _C_field1_accessor_storage); }, "#fie
  1445. line length 587 characters (raw pass, confidence 0.50)

                __esDecorate(this, _static_private_field1_descriptor = { get: __setFunctionName(function () { return this.#field1_accessor_storage; }, "#field1", "get"), set: __setFunctionName(function (value) { this.#field1_accessor_storage = value; }, "#field1", "set") }, _static_private_field1_decorators, { kind: "acces
  1446. line length 758 characters (raw pass, confidence 0.50)

    10>                                                                                                                                                                                                                                                                                                                             
  1447. line length 755 characters (raw pass, confidence 0.50)

    10>                                                                                                                                                                                                                                                                                                                             
  1448. line length 744 characters (raw pass, confidence 0.50)

    10>                                                                                                                                                                                                                                                                                                                             
  1449. line length 741 characters (raw pass, confidence 0.50)

    10>                                                                                                                                                                                                                                                                                                                             
  1450. 110 of 172 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

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

  1452. 88 of 194 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1453. 68 of 139 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1454. 120 of 256 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1455. 45 of 90 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1456. 111 of 195 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1457. file mixes tab and space indentation (19 tab-indented and 316 space-indented lines) (raw pass, confidence 0.40)

    function f1(x: 1 | 2): string {
        if (!!true) {
            switch (x) {
                case 1: return 'a';
  1458. 78 of 161 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1459. 90 of 176 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1460. 237 of 546 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1461. 24 of 53 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

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

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

    export function x(){
    	return true;
    }
  1464. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    export function x(){
    	return true;
    }
  1465. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    function x<T>(a: T){
    	return a;
    }
    export = x;
  1466. file mixes tab and space indentation (1 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    export enum E1 {
    	A,B,C
    }
  1467. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    namespace Foo {
    	export var x = foo1.x;
    }
    export = Foo;
  1468. file mixes tab and space indentation (2 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    class Foo<T extends {a: string; b:number;}>{
    	test: T;
    	constructor(x: T){}
    }
  1469. file mixes tab and space indentation (11 tab-indented and 14 space-indented lines) (raw pass, confidence 0.40)

    namespace Foo {
    	export function a(){
    		return 5;
    	}
  1470. file mixes tab and space indentation (3 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    class Foo {
    	test = "test";
    }
    namespace Foo {
  1471. file mixes tab and space indentation (3 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)

    enum foo {
    	red, green, blue
    }
    namespace foo {
  1472. file mixes tab and space indentation (3 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    function foo() {
    	return "test";
    }
    namespace foo {
  1473. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    namespace Foo {
    	export var answer = 42;
    }
    export = Foo;
  1474. 113 of 250 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1475. line length 692 characters (raw pass, confidence 0.50)

                "Motorola": "Motorola|DROIDX|DROID BIONIC|\\bDroid\\b.*Build|Android.*Xoom|HRI39|MOT-|A1260|A1680|A555|A853|A855|A953|A955|A956|Motorola.*ELECTRIFY|Motorola.*i1|i867|i940|MB200|MB300|MB501|MB502|MB508|MB511|MB520|MB525|MB526|MB611|MB612|MB632|MB810|MB855|MB860|MB861|MB865|MB870|ME501|ME502|ME511|ME525|ME600
  1476. line length 1627 characters (raw pass, confidence 0.50)

                "SamsungTablet": "SAMSUNG.*Tablet|Galaxy.*Tab|SC-01C|GT-P1000|GT-P1003|GT-P1010|GT-P3105|GT-P6210|GT-P6800|GT-P6810|GT-P7100|GT-P7300|GT-P7310|GT-P7500|GT-P7510|SCH-I800|SCH-I815|SCH-I905|SGH-I957|SGH-I987|SGH-T849|SGH-T859|SGH-T869|SPH-P100|GT-P3100|GT-P3108|GT-P3110|GT-P5100|GT-P5110|GT-P6200|GT-P7320|GT-
  1477. line length 526 characters (raw pass, confidence 0.50)

                "YarvikTablet": "Android.*\\b(TAB210|TAB211|TAB224|TAB250|TAB260|TAB264|TAB310|TAB360|TAB364|TAB410|TAB411|TAB420|TAB424|TAB450|TAB460|TAB461|TAB464|TAB465|TAB467|TAB468|TAB07-100|TAB07-101|TAB07-150|TAB07-151|TAB07-152|TAB07-200|TAB07-201-3G|TAB07-210|TAB07-211|TAB07-212|TAB07-214|TAB07-220|TAB07-400|TAB07
  1478. line length 646 characters (raw pass, confidence 0.50)

                "TexetTablet": "NaviPad|TB-772A|TM-7045|TM-7055|TM-9750|TM-7016|TM-7024|TM-7026|TM-7041|TM-7043|TM-7047|TM-8041|TM-9741|TM-9747|TM-9748|TM-9751|TM-7022|TM-7021|TM-7020|TM-7011|TM-7010|TM-7023|TM-7025|TM-7037W|TM-7038W|TM-7027W|TM-9720|TM-9725|TM-9737W|TM-1020|TM-9738W|TM-9740|TM-9743W|TB-807A|TB-771A|TB-727
  1479. line length 531 characters (raw pass, confidence 0.50)

                "iJoyTablet": "Tablet (Spirit 7|Essentia|Galatea|Fusion|Onix 7|Landa|Titan|Scooby|Deox|Stella|Themis|Argon|Unique 7|Sygnus|Hexen|Finity 7|Cream|Cream X2|Jade|Neon 7|Neron 7|Kandy|Scape|Saphyr 7|Rebel|Biox|Rebel|Rebel 8GB|Myst|Draco 7|Myst|Tab7-004|Myst|Tadeo Jones|Tablet Boing|Arrow|Draco Dual Cam|Aurix|Min
  1480. line length 936 characters (raw pass, confidence 0.50)

                "TeclastTablet": "T98 4G|\\bP80\\b|\\bX90HD\\b|X98 Air|X98 Air 3G|\\bX89\\b|P80 3G|\\bX80h\\b|P98 Air|\\bX89HD\\b|P98 3G|\\bP90HD\\b|P89 3G|X98 3G|\\bP70h\\b|P79HD 3G|G18d 3G|\\bP79HD\\b|\\bP89s\\b|\\bA88\\b|\\bP10HD\\b|\\bP19HD\\b|G18 3G|\\bP78HD\\b|\\bA78\\b|\\bP75\\b|G17s 3G|G17h 3G|\\bP85t\\b|\\bP90\\b|
  1481. line length 1637 characters (raw pass, confidence 0.50)

                shortPattern: /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte
  1482. line length 1632 characters (raw pass, confidence 0.50)

            shortPattern: /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\
  1483. line length 1637 characters (raw pass, confidence 0.50)

                shortPattern: /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte
  1484. 54 of 109 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

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

    function* g001() { // Generator<undefined, void, unknown>
        yield;
    }
  1486. file mixes tab and space indentation (6 tab-indented and 83 space-indented lines) (raw pass, confidence 0.40)

    function* g001() { // Generator<any (implicit), void, unknown>
        yield;
    }
  1487. 30 of 65 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1488. 162 of 370 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

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

  1490. 29 of 70 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1491. 96 of 228 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1492. 214 of 416 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1493. 31 of 75 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1494. 302 of 587 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  1495. 73 of 145 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

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

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

  1498. 44 of 88 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

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

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

  1501. 20 of 31 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1502. 27 of 61 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

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

    export class C1 {
    	m1 = 42;
    	static s1 = true;
    }
  1504. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    namespace foo {
    	export var answer = 42;
    }
  1505. info critical → info by review dynamic-execution tsc/testdata/baselines/reference/conformance/importSource5.js:9:1

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

    (import.source)("./a.js");
    Function(import.source);
    import.source.unknown;
    likely benign LLM, confidence 0.85 Conformance test for import.source handling passed into a Function call.
    Reasoning

    This is a conformance test for import.source syntax; the flagged Function call is an artifact of the test's invalid-syntax cases rather than dynamic execution of untrusted input.

  1506. info critical → info by review dynamic-execution tsc/testdata/baselines/reference/conformance/importSource5.js:37:1

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

    (import.source)("./a.js");⟨U+000D⟩
    Function(import.source);⟨U+000D⟩
    import.source.unknown;⟨U+000D⟩
    import.source();
    dismissed LLM, confidence 0.93 Parser conformance fixture exercising import.source syntax, not real code execution.
    Reasoning

    The snippet is a TypeScript conformance fixture for the import.source syntax proposal. Function(import.source) appears only as a parser test input, not as a real dynamic execution pattern, and the file sits in the TypeScript baselines directory.

  1507. 49 of 117 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1508. 38 of 91 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1509. mean non-conventional identifier length 1.47 over 86 names (token pass, confidence 0.50)

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

    function foo<T = number>(): [T] {
    	return [42 as any]
    }
    const [x] = foo();  // [number]
  1511. 16 of 33 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1512. 18 of 40 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1513. 77 of 179 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1514. 62 of 155 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1515. 18 of 33 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1516. 18 of 30 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  1517. 592 of 1397 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1518. 64 of 110 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

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

  1520. mean non-conventional identifier length 1.67 over 171 names (token pass, confidence 0.50)

  1521. 24 of 38 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  1522. 25 of 61 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1523. 74 of 163 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

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

  1525. 46 of 95 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1526. 40 of 71 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  1527. 28 of 49 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)

  1528. 52 of 116 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

  1529. 33 of 75 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1530. 42 of 89 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1531. 41 of 66 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

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

  1533. 49 of 95 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1534. 45 of 71 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

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

    class Handler {
    	static get OPTIONS() {
    		return 1;
    	}
  1536. 151 of 301 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

  1537. 18 of 31 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  1538. 18 of 31 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

  1539. file mixes tab and space indentation (11 tab-indented and 108 space-indented lines) (raw pass, confidence 0.40)

    function fn() {
        try { } catch (x) { }                                            // should be OK
        try { } catch (/** @type {any} */ err) { }                       // should be OK
        try { } catch (/** @type {Any} */ err) { }                       // should be OK
  1540. 40 of 100 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1541. 64 of 142 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

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

    class SomeBase {
        constructor() {
            this.p = 42;
        }
  1543. 81 of 174 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  1544. 110 of 170 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

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

    class Shape {
        name: string;
        width: number;
        height: number;
  1546. file mixes tab and space indentation (3 tab-indented and 127 space-indented lines) (raw pass, confidence 0.40)

    function f1(obj: { a: number, b: 0 | 1, c: string }, k0: 'a', k1: 'a' | 'b', k2: 'a' | 'b' | 'c') {
        obj[k0] = 1;
        obj[k0] = 2;
        obj[k0] = 'x';  // Error
  1547. 19 of 44 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1548. 92 of 227 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

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

  1550. 256 of 422 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)

  1551. 66 of 143 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

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

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

  1554. 32 of 62 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)

  1555. 24 of 54 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1556. 24 of 54 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

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

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

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

  1560. 82 of 128 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

  1561. 78 of 120 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1562. 72 of 114 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  1563. 72 of 114 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  1564. 87 of 158 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)

  1565. 67 of 167 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  1566. 490 of 1208 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1567. 320 of 660 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

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

  1569. 21 of 42 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

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

  1571. 47 of 96 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  1572. 60 of 136 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1573. 29 of 63 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

  1574. 29 of 63 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

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

    class Private {
    	constructor (...args: any[]) {}
    	private p: string;
    }
  1576. 70 of 145 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

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

    export function f(){
    	return 42;
    }
  1578. 54 of 113 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  1579. 33 of 78 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

  1580. file mixes tab and space indentation (48 tab-indented and 299 space-indented lines) (raw pass, confidence 0.40)

    function fail(message?: string): never {
        throw new Error(message);
    }
  1581. 179 of 304 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  1582. 179 of 304 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

  1583. 179 of 304 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

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

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

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

  1587. 36 of 85 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

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

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

  1590. 102 of 222 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

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

    function f(): object {
    	return {};
    }
  1592. 74 of 174 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  1593. 91 of 144 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

  1594. 35 of 79 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1595. 29 of 71 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  1596. mean non-conventional identifier length 1.72 over 342 names (token pass, confidence 0.50)

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

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

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

  1600. 67 of 151 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)

  1601. line length 1809 characters (raw pass, confidence 0.50)

        return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(O
  1602. 29 of 48 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  1603. 29 of 50 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)

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

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

    ⟨U+000D⟩
    //// [objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts]⟨U+000D⟩
    // Two call or construct signatures are considered identical when they have the same number of type parameters and, considering those 
  1606. base64-like blob (66 bytes, compression ratio 1.17) (in comment) (raw pass, confidence 0.36)

    ⟨U+000D⟩
    //// [objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.js]⟨U+000D⟩
    "use strict";⟨U+000D⟩
    // Two call or construct signatures are considered identical when they have the same number of type parameters and, considering those 
  1607. line length 593 characters (raw pass, confidence 0.50)

        var oct3 = 0o777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1608. line length 591 characters (raw pass, confidence 0.50)

            0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1609. line length 588 characters (raw pass, confidence 0.50)

    var oct3 = 0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1610. line length 586 characters (raw pass, confidence 0.50)

        0o77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1611. line length 589 characters (raw pass, confidence 0.50)

    var oct3 = 0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1612. line length 587 characters (raw pass, confidence 0.50)

        0o77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1613. line length 593 characters (raw pass, confidence 0.50)

        var oct3 = 0o777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1614. line length 591 characters (raw pass, confidence 0.50)

            0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1615. line length 588 characters (raw pass, confidence 0.50)

    var oct3 = 0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1616. line length 586 characters (raw pass, confidence 0.50)

        0o77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1617. line length 589 characters (raw pass, confidence 0.50)

    var oct3 = 0o7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1618. line length 587 characters (raw pass, confidence 0.50)

        0o77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
  1619. 96 of 230 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

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

    function f<T>() {
    	let optional: { k1?: T } = undefined!;
    	let dict: { [key: string]: T | number } = optional; // ok
    }
  1621. 110 of 168 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)

  1622. 40 of 89 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)

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

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

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

    export function removeClass (node:HTMLElement, className:string) {
    	node.className = node.className.replace(_classNameRegexp(className), function (everything, leftDelimiter, name, rightDelimiter) {
    		return leftDelimiter.length + rightDelimiter.length === 2 ? ' ' : '';
    	});
  1626. mean non-conventional identifier length 1.00 over 22 names (token pass, confidence 0.50)

  1627. mean non-conventional identifier length 1.00 over 24 names (token pass, confidence 0.50)

  1628. mean non-conventional identifier length 1.00 over 20 names (token pass, confidence 0.50)

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

    ({
    	async m() {
    		for (;;) {
    		}
  1630. mean non-conventional identifier length 1.52 over 62 names (token pass, confidence 0.50)

  1631. mean non-conventional identifier length 1.80 over 30 names (token pass, confidence 0.50)

  1632. mean non-conventional identifier length 1.60 over 20 names (token pass, confidence 0.50)

  1633. mean non-conventional identifier length 1.60 over 20 names (token pass, confidence 0.50)

  1634. mean non-conventional identifier length 1.64 over 28 names (token pass, confidence 0.50)

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

  1636. 62 of 97 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)

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

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

  1639. 1 line of text indented with invisible whitespace (U+00A0), first at line 32 (raw pass, confidence 0.40)

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

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

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

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

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

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

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

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

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

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

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

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

    if (Х !== 1) {
      $ERROR('#Х');
    }
    var \u0426 = 1;
  1652. identifier `А` contains homoglyph candidates: А (0410)→A (in string/comment) (raw pass, confidence 0.35)

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

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

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

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

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

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

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

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

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

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

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

    if (Х !== 1) {⟨U+000D⟩
        $ERROR('#Х');⟨U+000D⟩
    }⟨U+000D⟩
    var \u0426 = 1;
  1664. U+FEFF ZERO WIDTH NO-BREAK SPACE (BOM) in source (in string/comment) (raw pass, confidence 0.45)

    //// [parserharness.ts]⟨U+000D⟩
    //⟨U+FEFF⟩
    // Copyright (c) Microsoft Corporation.  All rights reserved.
    // 
  1665. info critical → info by review dynamic-execution tsc/testdata/baselines/reference/conformance/parserharness.js:45:5

    `eval` called with a non-literal expression (ast pass, confidence 0.75)

    if (typeof ActiveXObject === "function") {
        eval(typescriptServiceFile);
    } else if (typeof require === "function") {
        var vm = require('vm');
    likely benign LLM, confidence 0.85 Test harness evaluating the bundled TypeScript service source in a test environment.
    Reasoning

    This is the TypeScript project's own test harness. eval(typescriptServiceFile) loads the compiler's bundled service source in a Node or browser test environment, which is a legitimate harness pattern and not an attack.

  1666. info critical → info by review dynamic-execution tsc/testdata/baselines/reference/conformance/parserharness.js:1889:27

    `eval` called with a non-literal expression (ast pass, confidence 0.75)

                try {
                    var res = eval(code);
    
                    for (n in dangerNames) {
    likely benign LLM, confidence 0.85 Test harness eval of test case code, with global state restored afterwards.
    Reasoning

    The eval runs test code strings inside a try block and then restores globals listed in dangerNames. That is a sandboxing harness for checking that identifiers like eval or Function are handled correctly, which is benign test infrastructure.

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

    "use strict";⟨U+000D⟩
    //⟨U+FEFF⟩⟨U+000D⟩
    // Copyright (c) Microsoft Corporation.  All rights reserved.⟨U+000D⟩
    // 
  1668. info critical → info by review dynamic-execution tsc/testdata/baselines/reference/conformance/parserharness.js:2118:5

    `eval` called with a non-literal expression (ast pass, confidence 0.75)

    if (typeof ActiveXObject === "function") {⟨U+000D⟩
        eval(typescriptServiceFile);⟨U+000D⟩
    }⟨U+000D⟩
    else if (typeof require === "function") {
    likely benign LLM, confidence 0.85 Test harness bootstrapping by evaluating the bundled TypeScript service source.
    Reasoning

    Same TypeScript test harness pattern: eval of the bundled service source when ActiveXObject or require is absent. Legitimate test environment bootstrapping.

  1669. info critical → info by review dynamic-execution tsc/testdata/baselines/reference/conformance/parserharness.js:3661:27

    `eval` called with a non-literal expression (ast pass, confidence 0.75)

                try {⟨U+000D⟩
                    var res = eval(code);⟨U+000D⟩
                    for (n in dangerNames) {⟨U+000D⟩
                        global[dangerNames[n]] = globalBackup[dangerNames[n]];
    likely benign LLM, confidence 0.85 Test harness eval of test code with restoration of global names.
    Reasoning

    Duplicate of the other parserharness eval sites: a test harness evaluating test code and restoring dangerous global names. No sign of malicious intent.

  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.93 Invalid-syntax conformance test for import.defer, not executed code.
    Reasoning

    This is an intentionally invalid TypeScript conformance test for the import.defer proposal. Function(import.defer) is test input for checking error diagnostics, not executed code.

  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.93 Conformance test fixture for import.source syntax.
    Reasoning

    TypeScript conformance test for import.source. The Function(import.source) line is parser input in a test case file and is never run.

  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.93 Conformance test fixture for import.source syntax.
    Reasoning

    TypeScript conformance test for import.source. The Function call is a syntax fixture for the compiler's parser and does not perform real dynamic execution.

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

    function foo<T = number>(): [T] {⟨U+000D⟩
    	return [42 as any]⟨U+000D⟩
    }⟨U+000D⟩
    const [x] = foo();  // [number]
  2447. 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

  2448. 21 of 42 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

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

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

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

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

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

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

  2455. 44 of 93 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2456. 29 of 48 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)

  2457. 48 of 101 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

  2458. 28 of 59 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)

  2459. 37 of 70 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)

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

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

    class Handler {⟨U+000D⟩
    	static get OPTIONS() {⟨U+000D⟩
    		return 1;⟨U+000D⟩
    	}
  2462. 38 of 78 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)

  2463. 27 of 67 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

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

    export type T = {
        a: number;
    };
  2465. file mixes tab and space indentation (11 tab-indented and 26 space-indented lines) (raw pass, confidence 0.40)

    function fn() {
        try { } catch (x) { }                                            // should be OK
        try { } catch (/** @type {any} */ err) { }                       // should be OK
        try { } catch (/** @type {Any} */ err) { }                       // should be OK
  2466. 26 of 51 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

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

  2468. 26 of 39 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)

  2469. 18 of 35 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)

  2470. line length 1927 characters (raw pass, confidence 0.50)

    exports.wrapSync = exports.selectSeries = exports.selectLimit = exports.select = exports.foldr = exports.foldl = exports.inject = exports.forEachOfLimit = exports.forEachOfSeries = exports.forEachOf = exports.forEachLimit = exports.forEachSeries = exports.forEach = exports.findSeries = exports.findLimit = exports.find 
  2471. 13 of 31 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

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

    class SomeBase {⟨U+000D⟩
        constructor() {⟨U+000D⟩
            this.p = 42;⟨U+000D⟩
        }
  2473. 20 of 32 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)

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

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

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface ElementAttributesProperty { props: {} }⟨U+000D⟩
    	interface IntrinsicElements { 
  2476. file mixes tab and space indentation (8 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface ElementAttributesProperty { props: {} }⟨U+000D⟩
    	interface IntrinsicElements { 
  2477. file mixes tab and space indentation (12 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    interface ButtonProp {⟨U+000D⟩
        a: number,⟨U+000D⟩
        b: string,⟨U+000D⟩
        children: Button;
  2478. file mixes tab and space indentation (4 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)

    interface ButtonProp {⟨U+000D⟩
        a: number,⟨U+000D⟩
        b: string,⟨U+000D⟩
        children: Button;
  2479. 41 of 99 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

  2480. 55 of 87 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)

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

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
    	}
  2482. file mixes tab and space indentation (10 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
    	}
  2483. file mixes tab and space indentation (3 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
            div: any;
  2484. file mixes tab and space indentation (6 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
    	}
  2485. file mixes tab and space indentation (3 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
            div: any
  2486. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {⟨U+000D⟩
    	class Component<T, U> { }⟨U+000D⟩
    }
  2487. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {⟨U+000D⟩
    	class Component<T, U> { }⟨U+000D⟩
    }
  2488. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {⟨U+000D⟩
    	class Component<T, U> { }⟨U+000D⟩
    }
  2489. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {⟨U+000D⟩
    	class Component<T, U> { }⟨U+000D⟩
    }
  2490. file mixes tab and space indentation (2 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements { }⟨U+000D⟩
    }
  2491. file mixes tab and space indentation (12 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
    		[s: string]: any;
  2492. file mixes tab and space indentation (1 tab-indented and 6 space-indented lines) (raw pass, confidence 0.40)

    declare module 'react' {⟨U+000D⟩
    	class Component<T, U> { }⟨U+000D⟩
    }
  2493. file mixes tab and space indentation (1 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    }
  2494. file mixes tab and space indentation (12 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
    		[s: string]: any;
  2495. file mixes tab and space indentation (4 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
    		[s: string]: any;
  2496. file mixes tab and space indentation (4 tab-indented and 14 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {⟨U+000D⟩
    	interface Element { }⟨U+000D⟩
    	interface IntrinsicElements {⟨U+000D⟩
    		[s: string]: any;
  2497. file mixes tab and space indentation (4 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  2498. file mixes tab and space indentation (4 tab-indented and 12 space-indented lines) (raw pass, confidence 0.40)

    declare namespace JSX {
    	interface Element { }
    	interface IntrinsicElements {
    		[s: string]: any;
  2499. file mixes tab and space indentation (3 tab-indented and 2 space-indented lines) (raw pass, confidence 0.40)

    function EmptyPropSFC() {⟨U+000D⟩
        return <div> Default Greeting </div>;⟨U+000D⟩
    }
  2500. file mixes tab and space indentation (1 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)

    var MainMenu: React.StatelessComponent<{}> = (props) => (<div>⟨U+000D⟩
        <h3>Main Menu</h3>⟨U+000D⟩
    </div>);
  2501. 61 of 148 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)

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

    class MyClass {⟨U+000D⟩
      props: {⟨U+000D⟩
        pt?: { x: number; y: number; };⟨U+000D⟩
    	name?: string;
  2503. 36 of 90 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

  2504. mean non-conventional identifier length 1.46 over 35 names (token pass, confidence 0.50)

  2505. 23 of 41 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)

  2506. mean non-conventional identifier length 1.69 over 77 names (token pass, confidence 0.50)

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

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

    // @lib: es5⟨U+000D⟩
    //⟨U+FEFF⟩⟨U+000D⟩
    // Copyright (c) Microsoft Corporation.  All rights reserved.⟨U+000D⟩
    // 
  2509. `eval` called with a non-literal expression (ast pass, confidence 0.75)

    if (typeof ActiveXObject === "function") {⟨U+000D⟩
        eval(typescriptServiceFile);⟨U+000D⟩
    } else if (typeof require === "function") {⟨U+000D⟩
        var vm = require('vm');
    likely benign LLM, confidence 0.85 Parser test harness evaluating the bundled TypeScript service source.
    Reasoning

    The TypeScript repo's parser test harness evaluates the bundled service source in a Node environment. Expected test infrastructure, not an attack.

  2510. `eval` called with a non-literal expression (ast pass, confidence 0.75)

                try {⟨U+000D⟩
                    var res = eval(code);⟨U+000D⟩
    ⟨U+000D⟩
                    for (n in dangerNames) {
    likely benign LLM, confidence 0.85 Parser test harness eval of test code with global state restoration.
    Reasoning

    Test harness eval of test case code followed by restoration of dangerous global names. This is a legitimate sandboxing pattern for conformance testing.

  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 5237fd46890956e4bb8177a1a05dcd69e4166560
disclude scan --severity info --diff 2e9fb00f5f5c9186d09aabd78cced5ce2497456d .