Upload folder using huggingface_hub (part 23)

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-inferrable-types.d.ts

@@ -0,0 +1,11 @@
+export type Options = [
+    {
+        ignoreParameters?: boolean;
+        ignoreProperties?: boolean;
+    }
+];
+export type MessageIds = 'noInferrableType';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInferrableType", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-inferrable-types.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-inferrable-types',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean',
+            recommended: 'stylistic',
+        },
+        fixable: 'code',
+        messages: {
+            noInferrableType: 'Type {{type}} trivially inferred from a {{type}} literal, remove type annotation.',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    ignoreParameters: {
+                        type: 'boolean',
+                        description: 'Whether to ignore function parameters.',
+                    },
+                    ignoreProperties: {
+                        type: 'boolean',
+                        description: 'Whether to ignore class properties.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            ignoreParameters: false,
+            ignoreProperties: false,
+        },
+    ],
+    create(context, [{ ignoreParameters, ignoreProperties }]) {
+        function isFunctionCall(init, callName) {
+            const node = (0, util_1.skipChainExpression)(init);
+            return (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.callee.name === callName);
+        }
+        function isLiteral(init, typeName) {
+            return (init.type === utils_1.AST_NODE_TYPES.Literal && typeof init.value === typeName);
+        }
+        function isIdentifier(init, ...names) {
+            return (init.type === utils_1.AST_NODE_TYPES.Identifier && names.includes(init.name));
+        }
+        function hasUnaryPrefix(init, ...operators) {
+            return (init.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                operators.includes(init.operator));
+        }
+        const keywordMap = {
+            [utils_1.AST_NODE_TYPES.TSBigIntKeyword]: 'bigint',
+            [utils_1.AST_NODE_TYPES.TSBooleanKeyword]: 'boolean',
+            [utils_1.AST_NODE_TYPES.TSNullKeyword]: 'null',
+            [utils_1.AST_NODE_TYPES.TSNumberKeyword]: 'number',
+            [utils_1.AST_NODE_TYPES.TSStringKeyword]: 'string',
+            [utils_1.AST_NODE_TYPES.TSSymbolKeyword]: 'symbol',
+            [utils_1.AST_NODE_TYPES.TSUndefinedKeyword]: 'undefined',
+        };
+        /**
+         * Returns whether a node has an inferrable value or not
+         */
+        function isInferrable(annotation, init) {
+            switch (annotation.type) {
+                case utils_1.AST_NODE_TYPES.TSBigIntKeyword: {
+                    // note that bigint cannot have + prefixed to it
+                    const unwrappedInit = hasUnaryPrefix(init, '-')
+                        ? init.argument
+                        : init;
+                    return (isFunctionCall(unwrappedInit, 'BigInt') ||
+                        unwrappedInit.type === utils_1.AST_NODE_TYPES.Literal);
+                }
+                case utils_1.AST_NODE_TYPES.TSBooleanKeyword:
+                    return (hasUnaryPrefix(init, '!') ||
+                        isFunctionCall(init, 'Boolean') ||
+                        isLiteral(init, 'boolean'));
+                case utils_1.AST_NODE_TYPES.TSNumberKeyword: {
+                    const unwrappedInit = hasUnaryPrefix(init, '+', '-')
+                        ? init.argument
+                        : init;
+                    return (isIdentifier(unwrappedInit, 'Infinity', 'NaN') ||
+                        isFunctionCall(unwrappedInit, 'Number') ||
+                        isLiteral(unwrappedInit, 'number'));
+                }
+                case utils_1.AST_NODE_TYPES.TSNullKeyword:
+                    return init.type === utils_1.AST_NODE_TYPES.Literal && init.value == null;
+                case utils_1.AST_NODE_TYPES.TSStringKeyword:
+                    return (isFunctionCall(init, 'String') ||
+                        isLiteral(init, 'string') ||
+                        init.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
+                case utils_1.AST_NODE_TYPES.TSSymbolKeyword:
+                    return isFunctionCall(init, 'Symbol');
+                case utils_1.AST_NODE_TYPES.TSTypeReference: {
+                    if (annotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        annotation.typeName.name === 'RegExp') {
+                        const isRegExpLiteral = init.type === utils_1.AST_NODE_TYPES.Literal &&
+                            init.value instanceof RegExp;
+                        const isRegExpNewCall = init.type === utils_1.AST_NODE_TYPES.NewExpression &&
+                            init.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            init.callee.name === 'RegExp';
+                        const isRegExpCall = isFunctionCall(init, 'RegExp');
+                        return isRegExpLiteral || isRegExpCall || isRegExpNewCall;
+                    }
+                    return false;
+                }
+                case utils_1.AST_NODE_TYPES.TSUndefinedKeyword:
+                    return (hasUnaryPrefix(init, 'void') || isIdentifier(init, 'undefined'));
+            }
+            return false;
+        }
+        /**
+         * Reports an inferrable type declaration, if any
+         */
+        function reportInferrableType(node, typeNode, initNode) {
+            if (!typeNode || !initNode) {
+                return;
+            }
+            if (!isInferrable(typeNode.typeAnnotation, initNode)) {
+                return;
+            }
+            const type = typeNode.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference
+                ? // TODO - if we add more references
+                    'RegExp'
+                : keywordMap[typeNode.typeAnnotation.type];
+            context.report({
+                node,
+                messageId: 'noInferrableType',
+                data: {
+                    type,
+                },
+                *fix(fixer) {
+                    if ((node.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+                        node.left.optional) ||
+                        (node.type === utils_1.AST_NODE_TYPES.PropertyDefinition && node.definite)) {
+                        yield fixer.remove((0, util_1.nullThrows)(context.sourceCode.getTokenBefore(typeNode), util_1.NullThrowsReasons.MissingToken('token before', 'type node')));
+                    }
+                    yield fixer.remove(typeNode);
+                },
+            });
+        }
+        function inferrableVariableVisitor(node) {
+            reportInferrableType(node, node.id.typeAnnotation, node.init);
+        }
+        function inferrableParameterVisitor(node) {
+            if (ignoreParameters) {
+                return;
+            }
+            node.params.forEach(param => {
+                if (param.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
+                    param = param.parameter;
+                }
+                if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                    reportInferrableType(param, param.left.typeAnnotation, param.right);
+                }
+            });
+        }
+        function inferrablePropertyVisitor(node) {
+            // We ignore `readonly` because of Microsoft/TypeScript#14416
+            // Essentially a readonly property without a type
+            // will result in its value being the type, leading to
+            // compile errors if the type is stripped.
+            if (ignoreProperties || node.readonly || node.optional) {
+                return;
+            }
+            reportInferrableType(node, node.typeAnnotation, node.value);
+        }
+        return {
+            AccessorProperty: inferrablePropertyVisitor,
+            ArrowFunctionExpression: inferrableParameterVisitor,
+            FunctionDeclaration: inferrableParameterVisitor,
+            FunctionExpression: inferrableParameterVisitor,
+            PropertyDefinition: inferrablePropertyVisitor,
+            VariableDeclarator: inferrableVariableVisitor,
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-this.d.ts

@@ -0,0 +1,15 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util';
+declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpectedThis", [({
+    capIsConstructor?: boolean;
+} | undefined)?], unknown, {
+    ThisExpression(node: TSESTree.ThisExpression): void;
+}>;
+export type Options = InferOptionsTypeFromRule<typeof baseRule>;
+export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpectedThis", [({
+    capIsConstructor?: boolean;
+} | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-this.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+const getESLintCoreRule_1 = require("../util/getESLintCoreRule");
+const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-invalid-this');
+const defaultOptions = [{ capIsConstructor: true }];
+exports.default = (0, util_1.createRule)({
+    name: 'no-invalid-this',
+    meta: {
+        type: 'suggestion',
+        defaultOptions,
+        docs: {
+            description: 'Disallow `this` keywords outside of classes or class-like objects',
+            extendsBaseRule: true,
+        },
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        messages: baseRule.meta.messages,
+        schema: baseRule.meta.schema,
+    },
+    defaultOptions,
+    create(context) {
+        const rules = baseRule.create(context);
+        /**
+         * Since function definitions can be nested we use a stack storing if "this" is valid in the current context.
+         *
+         * Example:
+         *
+         * function a(this: number) { // valid "this"
+         *     function b() {
+         *         console.log(this); // invalid "this"
+         *     }
+         * }
+         *
+         * When parsing the function declaration of "a" the stack will be: [true]
+         * When parsing the function declaration of "b" the stack will be: [true, false]
+         */
+        const thisIsValidStack = [];
+        return {
+            ...rules,
+            AccessorProperty() {
+                thisIsValidStack.push(true);
+            },
+            'AccessorProperty:exit'() {
+                thisIsValidStack.pop();
+            },
+            FunctionDeclaration(node) {
+                thisIsValidStack.push(node.params.some(param => param.type === utils_1.AST_NODE_TYPES.Identifier && param.name === 'this'));
+            },
+            'FunctionDeclaration:exit'() {
+                thisIsValidStack.pop();
+            },
+            FunctionExpression(node) {
+                thisIsValidStack.push(node.params.some(param => param.type === utils_1.AST_NODE_TYPES.Identifier && param.name === 'this'));
+            },
+            'FunctionExpression:exit'() {
+                thisIsValidStack.pop();
+            },
+            PropertyDefinition() {
+                thisIsValidStack.push(true);
+            },
+            'PropertyDefinition:exit'() {
+                thisIsValidStack.pop();
+            },
+            ThisExpression(node) {
+                const thisIsValidHere = thisIsValidStack[thisIsValidStack.length - 1];
+                if (thisIsValidHere) {
+                    return;
+                }
+                // baseRule's work
+                rules.ThisExpression(node);
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-void-type.d.ts

@@ -0,0 +1,9 @@
+export interface Options {
+    allowAsThisParameter?: boolean;
+    allowInGenericTypeArguments?: boolean | [string, ...string[]];
+}
+export type MessageIds = 'invalidVoidForGeneric' | 'invalidVoidNotReturn' | 'invalidVoidNotReturnOrGeneric' | 'invalidVoidNotReturnOrThisParam' | 'invalidVoidNotReturnOrThisParamOrGeneric' | 'invalidVoidUnionConstituent';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [Options], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-invalid-void-type.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-invalid-void-type',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow `void` type outside of generic or return types',
+            recommended: 'strict',
+        },
+        messages: {
+            invalidVoidForGeneric: '{{ generic }} may not have void as a type argument.',
+            invalidVoidNotReturn: 'void is only valid as a return type.',
+            invalidVoidNotReturnOrGeneric: 'void is only valid as a return type or generic type argument.',
+            invalidVoidNotReturnOrThisParam: 'void is only valid as return type or type of `this` parameter.',
+            invalidVoidNotReturnOrThisParamOrGeneric: 'void is only valid as a return type or generic type argument or the type of a `this` parameter.',
+            invalidVoidUnionConstituent: 'void is not valid as a constituent in a union type',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allowAsThisParameter: {
+                        type: 'boolean',
+                        description: 'Whether a `this` parameter of a function may be `void`.',
+                    },
+                    allowInGenericTypeArguments: {
+                        description: 'Whether `void` can be used as a valid value for generic type parameters.',
+                        oneOf: [
+                            {
+                                type: 'boolean',
+                                description: 'Whether `void` can be used as a valid value for all generic type parameters.',
+                            },
+                            {
+                                type: 'array',
+                                description: 'Allowlist of types that may accept `void` as a generic type parameter.',
+                                items: { type: 'string' },
+                                minItems: 1,
+                            },
+                        ],
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        { allowAsThisParameter: false, allowInGenericTypeArguments: true },
+    ],
+    create(context, [{ allowAsThisParameter, allowInGenericTypeArguments }]) {
+        const validParents = [
+            utils_1.AST_NODE_TYPES.TSTypeAnnotation, //
+        ];
+        const invalidGrandParents = [
+            utils_1.AST_NODE_TYPES.TSPropertySignature,
+            utils_1.AST_NODE_TYPES.CallExpression,
+            utils_1.AST_NODE_TYPES.PropertyDefinition,
+            utils_1.AST_NODE_TYPES.AccessorProperty,
+            utils_1.AST_NODE_TYPES.Identifier,
+        ];
+        const validUnionMembers = [
+            utils_1.AST_NODE_TYPES.TSVoidKeyword,
+            utils_1.AST_NODE_TYPES.TSNeverKeyword,
+        ];
+        if (allowInGenericTypeArguments === true) {
+            validParents.push(utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation);
+        }
+        /**
+         * @brief check if the given void keyword is used as a valid generic type
+         *
+         * reports if the type parametrized by void is not in the allowlist, or
+         * allowInGenericTypeArguments is false.
+         * no-op if the given void keyword is not used as generic type
+         */
+        function checkGenericTypeArgument(node) {
+            // only matches T<..., void, ...>
+            // extra check for precaution
+            /* istanbul ignore next */
+            if (node.parent.type !== utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation ||
+                node.parent.parent.type !== utils_1.AST_NODE_TYPES.TSTypeReference) {
+                return;
+            }
+            // check allowlist
+            if (Array.isArray(allowInGenericTypeArguments)) {
+                const fullyQualifiedName = context.sourceCode
+                    .getText(node.parent.parent.typeName)
+                    .replaceAll(' ', '');
+                if (!allowInGenericTypeArguments
+                    .map(s => s.replaceAll(' ', ''))
+                    .includes(fullyQualifiedName)) {
+                    context.report({
+                        node,
+                        messageId: 'invalidVoidForGeneric',
+                        data: { generic: fullyQualifiedName },
+                    });
+                }
+                return;
+            }
+            if (!allowInGenericTypeArguments) {
+                context.report({
+                    node,
+                    messageId: allowAsThisParameter
+                        ? 'invalidVoidNotReturnOrThisParam'
+                        : 'invalidVoidNotReturn',
+                });
+            }
+        }
+        /**
+         * @brief checks if the generic type parameter defaults to void
+         */
+        function checkDefaultVoid(node, parentNode) {
+            if (parentNode.default !== node) {
+                context.report({
+                    node,
+                    messageId: getNotReturnOrGenericMessageId(node),
+                });
+            }
+        }
+        /**
+         * @brief checks that a union containing void is valid
+         * @return true if every member of the union is specified as a valid type in
+         * validUnionMembers, or is a valid generic type parametrized by void
+         */
+        function isValidUnionType(node) {
+            return node.types.every(member => validUnionMembers.includes(member.type) ||
+                // allows any T<..., void, ...> here, checked by checkGenericTypeArgument
+                (member.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                    member.typeArguments?.type ===
+                        utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation &&
+                    member.typeArguments.params
+                        .map(param => param.type)
+                        .includes(utils_1.AST_NODE_TYPES.TSVoidKeyword)));
+        }
+        return {
+            TSVoidKeyword(node) {
+                // checks T<..., void, ...> against specification of allowInGenericArguments option
+                if (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation &&
+                    node.parent.parent.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                    checkGenericTypeArgument(node);
+                    return;
+                }
+                // allow <T = void> if allowInGenericTypeArguments is specified, and report if the generic type parameter extends void
+                if (allowInGenericTypeArguments &&
+                    node.parent.type === utils_1.AST_NODE_TYPES.TSTypeParameter &&
+                    node.parent.default?.type === utils_1.AST_NODE_TYPES.TSVoidKeyword) {
+                    checkDefaultVoid(node, node.parent);
+                    return;
+                }
+                // union w/ void must contain types from validUnionMembers, or a valid generic void type
+                if (node.parent.type === utils_1.AST_NODE_TYPES.TSUnionType &&
+                    isValidUnionType(node.parent)) {
+                    return;
+                }
+                // using `void` as part of the return type of function overloading implementation
+                if (node.parent.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+                    const declaringFunction = getParentFunctionDeclarationNode(node.parent);
+                    if (declaringFunction &&
+                        (0, util_1.hasOverloadSignatures)(declaringFunction, context)) {
+                        return;
+                    }
+                }
+                // this parameter is ok to be void.
+                if (allowAsThisParameter &&
+                    node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
+                    node.parent.parent.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.parent.parent.name === 'this') {
+                    return;
+                }
+                // default cases
+                if (validParents.includes(node.parent.type) &&
+                    // https://github.com/typescript-eslint/typescript-eslint/issues/6225
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    !invalidGrandParents.includes(node.parent.parent.type)) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: allowInGenericTypeArguments && allowAsThisParameter
+                        ? 'invalidVoidNotReturnOrThisParamOrGeneric'
+                        : allowInGenericTypeArguments
+                            ? getNotReturnOrGenericMessageId(node)
+                            : allowAsThisParameter
+                                ? 'invalidVoidNotReturnOrThisParam'
+                                : 'invalidVoidNotReturn',
+                });
+            },
+        };
+    },
+});
+function getNotReturnOrGenericMessageId(node) {
+    return node.parent.type === utils_1.AST_NODE_TYPES.TSUnionType
+        ? 'invalidVoidUnionConstituent'
+        : 'invalidVoidNotReturnOrGeneric';
+}
+function getParentFunctionDeclarationNode(node) {
+    let current = node.parent;
+    while (current) {
+        if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+            return current;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.MethodDefinition &&
+            current.value.body != null) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return null;
+}

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loop-func.d.ts

@@ -0,0 +1,13 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util';
+declare const baseRule: TSESLint.RuleModule<"unsafeRefs", [], unknown, {
+    ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression): void;
+    FunctionDeclaration(node: TSESTree.FunctionDeclaration): void;
+    FunctionExpression(node: TSESTree.FunctionExpression): void;
+}>;
+export type Options = InferOptionsTypeFromRule<typeof baseRule>;
+export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
+declare const _default: TSESLint.RuleModule<"unsafeRefs", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loop-func.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+const getESLintCoreRule_1 = require("../util/getESLintCoreRule");
+const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-loop-func');
+exports.default = (0, util_1.createRule)({
+    name: 'no-loop-func',
+    meta: {
+        type: 'suggestion',
+        // defaultOptions, -- base rule does not use defaultOptions
+        docs: {
+            description: 'Disallow function declarations that contain unsafe references inside loop statements',
+            extendsBaseRule: true,
+        },
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        messages: baseRule.meta.messages,
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const SKIPPED_IIFE_NODES = new Set();
+        /**
+         * Gets the containing loop node of a specified node.
+         *
+         * We don't need to check nested functions, so this ignores those.
+         * `Scope.through` contains references of nested functions.
+         *
+         * @param node An AST node to get.
+         * @returns The containing loop node of the specified node, or `null`.
+         */
+        function getContainingLoopNode(node) {
+            for (let currentNode = node; currentNode.parent; currentNode = currentNode.parent) {
+                const parent = currentNode.parent;
+                switch (parent.type) {
+                    case utils_1.AST_NODE_TYPES.WhileStatement:
+                    case utils_1.AST_NODE_TYPES.DoWhileStatement:
+                        return parent;
+                    case utils_1.AST_NODE_TYPES.ForStatement:
+                        // `init` is outside of the loop.
+                        if (parent.init !== currentNode) {
+                            return parent;
+                        }
+                        break;
+                    case utils_1.AST_NODE_TYPES.ForInStatement:
+                    case utils_1.AST_NODE_TYPES.ForOfStatement:
+                        // `right` is outside of the loop.
+                        if (parent.right !== currentNode) {
+                            return parent;
+                        }
+                        break;
+                    case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+                    case utils_1.AST_NODE_TYPES.FunctionExpression:
+                    case utils_1.AST_NODE_TYPES.FunctionDeclaration:
+                        // We don't need to check nested functions.
+                        // We need to check nested functions only in case of IIFE.
+                        if (SKIPPED_IIFE_NODES.has(parent)) {
+                            break;
+                        }
+                        return null;
+                    default:
+                        break;
+                }
+            }
+            return null;
+        }
+        /**
+         * Gets the containing loop node of a given node.
+         * If the loop was nested, this returns the most outer loop.
+         * @param node A node to get. This is a loop node.
+         * @param excludedNode A node that the result node should not include.
+         * @returns The most outer loop node.
+         */
+        function getTopLoopNode(node, excludedNode) {
+            const border = excludedNode ? excludedNode.range[1] : 0;
+            let retv = node;
+            let containingLoopNode = node;
+            while (containingLoopNode && containingLoopNode.range[0] >= border) {
+                retv = containingLoopNode;
+                containingLoopNode = getContainingLoopNode(containingLoopNode);
+            }
+            return retv;
+        }
+        /**
+         * Checks whether a given reference which refers to an upper scope's variable is
+         * safe or not.
+         * @param loopNode A containing loop node.
+         * @param reference A reference to check.
+         * @returns `true` if the reference is safe or not.
+         */
+        function isSafe(loopNode, reference) {
+            const variable = reference.resolved;
+            const definition = variable?.defs[0];
+            const declaration = definition?.parent;
+            const kind = declaration?.type === utils_1.AST_NODE_TYPES.VariableDeclaration
+                ? declaration.kind
+                : '';
+            // type references are all safe
+            // this only really matters for global types that haven't been configured
+            if (reference.isTypeReference) {
+                return true;
+            }
+            // Variables which are declared by `const` is safe.
+            if (kind === 'const') {
+                return true;
+            }
+            /*
+             * Variables which are declared by `let` in the loop is safe.
+             * It's a different instance from the next loop step's.
+             */
+            if (kind === 'let' &&
+                declaration &&
+                declaration.range[0] > loopNode.range[0] &&
+                declaration.range[1] < loopNode.range[1]) {
+                return true;
+            }
+            /*
+             * WriteReferences which exist after this border are unsafe because those
+             * can modify the variable.
+             */
+            const border = getTopLoopNode(loopNode, kind === 'let' ? declaration : null).range[0];
+            /**
+             * Checks whether a given reference is safe or not.
+             * The reference is every reference of the upper scope's variable we are
+             * looking now.
+             *
+             * It's safe if the reference matches one of the following condition.
+             * - is readonly.
+             * - doesn't exist inside a local function and after the border.
+             *
+             * @param upperRef A reference to check.
+             * @returns `true` if the reference is safe.
+             */
+            function isSafeReference(upperRef) {
+                const id = upperRef.identifier;
+                return (!upperRef.isWrite() ||
+                    (variable?.scope.variableScope === upperRef.from.variableScope &&
+                        id.range[0] < border));
+            }
+            return variable?.references.every(isSafeReference) ?? false;
+        }
+        /**
+         * Reports functions which match the following condition:
+         * - has a loop node in ancestors.
+         * - has any references which refers to an unsafe variable.
+         *
+         * @param node The AST node to check.
+         */
+        function checkForLoops(node) {
+            const loopNode = getContainingLoopNode(node);
+            if (!loopNode) {
+                return;
+            }
+            const references = context.sourceCode.getScope(node).through;
+            if (!(node.async || node.generator) && isIIFE(node)) {
+                const isFunctionExpression = node.type === utils_1.AST_NODE_TYPES.FunctionExpression;
+                // Check if the function is referenced elsewhere in the code
+                const isFunctionReferenced = isFunctionExpression && node.id
+                    ? references.some(r => r.identifier.name === node.id?.name)
+                    : false;
+                if (!isFunctionReferenced) {
+                    SKIPPED_IIFE_NODES.add(node);
+                    return;
+                }
+            }
+            const unsafeRefs = references
+                .filter(r => r.resolved && !isSafe(loopNode, r))
+                .map(r => r.identifier.name);
+            if (unsafeRefs.length > 0) {
+                context.report({
+                    node,
+                    messageId: 'unsafeRefs',
+                    data: { varNames: `'${unsafeRefs.join("', '")}'` },
+                });
+            }
+        }
+        return {
+            ArrowFunctionExpression: checkForLoops,
+            FunctionDeclaration: checkForLoops,
+            FunctionExpression: checkForLoops,
+        };
+    },
+});
+function isIIFE(node) {
+    return (node.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        node.parent.callee === node);
+}

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loss-of-precision.d.ts

@@ -0,0 +1,9 @@
+import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util';
+import { getESLintCoreRule } from '../util/getESLintCoreRule';
+declare const baseRule: ReturnType<typeof getESLintCoreRule>;
+export type Options = InferOptionsTypeFromRule<NonNullable<typeof baseRule>>;
+export type MessageIds = InferMessageIdsTypeFromRule<NonNullable<typeof baseRule>>;
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noLossOfPrecision", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-loss-of-precision.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const getESLintCoreRule_1 = require("../util/getESLintCoreRule");
+const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-loss-of-precision');
+exports.default = (0, util_1.createRule)({
+    name: 'no-loss-of-precision',
+    meta: {
+        type: 'problem',
+        // defaultOptions, -- base rule does not use defaultOptions
+        deprecated: {
+            deprecatedSince: '8.0.0',
+            replacedBy: [
+                {
+                    rule: {
+                        name: 'no-loss-of-precision',
+                        url: 'https://eslint.org/docs/latest/rules/no-loss-of-precision',
+                    },
+                },
+            ],
+            url: 'https://github.com/typescript-eslint/typescript-eslint/pull/8832',
+        },
+        docs: {
+            description: 'Disallow literal numbers that lose precision',
+            extendsBaseRule: true,
+        },
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        messages: baseRule.meta.messages,
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return baseRule.create(context);
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-magic-numbers.d.ts

@@ -0,0 +1,29 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util';
+declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMagic", [{
+    detectObjects?: boolean;
+    enforceConst?: boolean;
+    ignore?: (number | string)[];
+    ignoreArrayIndexes?: boolean;
+    ignoreEnums?: boolean;
+    ignoreNumericLiteralTypes?: boolean;
+    ignoreReadonlyClassProperties?: boolean;
+    ignoreTypeIndexes?: boolean;
+}], unknown, {
+    Literal(node: TSESTree.Literal): void;
+}>;
+export type Options = InferOptionsTypeFromRule<typeof baseRule>;
+export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMagic", [{
+    detectObjects?: boolean;
+    enforceConst?: boolean;
+    ignore?: (number | string)[];
+    ignoreArrayIndexes?: boolean;
+    ignoreEnums?: boolean;
+    ignoreNumericLiteralTypes?: boolean;
+    ignoreReadonlyClassProperties?: boolean;
+    ignoreTypeIndexes?: boolean;
+}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-magic-numbers.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+const getESLintCoreRule_1 = require("../util/getESLintCoreRule");
+const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-magic-numbers');
+// Extend base schema with additional property to ignore TS numeric literal types
+const schema = (0, util_1.deepMerge)(
+// eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- https://github.com/microsoft/TypeScript/issues/17002
+Array.isArray(baseRule.meta.schema)
+    ? baseRule.meta.schema[0]
+    : baseRule.meta.schema, {
+    properties: {
+        ignoreEnums: {
+            type: 'boolean',
+            description: 'Whether enums used in TypeScript are considered okay.',
+        },
+        ignoreNumericLiteralTypes: {
+            type: 'boolean',
+            description: 'Whether numbers used in TypeScript numeric literal types are considered okay.',
+        },
+        ignoreReadonlyClassProperties: {
+            type: 'boolean',
+            description: 'Whether `readonly` class properties are considered okay.',
+        },
+        ignoreTypeIndexes: {
+            type: 'boolean',
+            description: 'Whether numbers used to index types are okay.',
+        },
+    },
+});
+const defaultOptions = [
+    {
+        detectObjects: false,
+        enforceConst: false,
+        ignore: [],
+        ignoreArrayIndexes: false,
+        ignoreEnums: false,
+        ignoreNumericLiteralTypes: false,
+        ignoreReadonlyClassProperties: false,
+        ignoreTypeIndexes: false,
+    },
+];
+exports.default = (0, util_1.createRule)({
+    name: 'no-magic-numbers',
+    meta: {
+        type: 'suggestion',
+        defaultOptions,
+        docs: {
+            description: 'Disallow magic numbers',
+            extendsBaseRule: true,
+            frozen: true,
+        },
+        messages: baseRule.meta.messages,
+        schema: [schema],
+    },
+    defaultOptions,
+    create(context, [options]) {
+        const rules = baseRule.create(context);
+        const ignored = new Set((options.ignore ?? []).map(normalizeIgnoreValue));
+        return {
+            Literal(node) {
+                // If it’s not a numeric literal we’re not interested
+                if (typeof node.value !== 'number' && typeof node.value !== 'bigint') {
+                    return;
+                }
+                // This will be `true` if we’re configured to ignore this case (eg. it’s
+                // an enum and `ignoreEnums` is `true`). It will be `false` if we’re not
+                // configured to ignore this case. It will remain `undefined` if this is
+                // not one of our exception cases, and we’ll fall back to the base rule.
+                let isAllowed;
+                // Check if the node is ignored
+                if (ignored.has(normalizeLiteralValue(node, node.value))) {
+                    isAllowed = true;
+                }
+                // Check if the node is a TypeScript enum declaration
+                else if (isParentTSEnumDeclaration(node)) {
+                    isAllowed = options.ignoreEnums === true;
+                }
+                // Check TypeScript specific nodes for Numeric Literal
+                else if (isTSNumericLiteralType(node)) {
+                    isAllowed = options.ignoreNumericLiteralTypes === true;
+                }
+                // Check if the node is a type index
+                else if (isAncestorTSIndexedAccessType(node)) {
+                    isAllowed = options.ignoreTypeIndexes === true;
+                }
+                // Check if the node is a readonly class property
+                else if (isParentTSReadonlyPropertyDefinition(node)) {
+                    isAllowed = options.ignoreReadonlyClassProperties === true;
+                }
+                // If we’ve hit a case where the ignore option is true we can return now
+                if (isAllowed === true) {
+                    return;
+                }
+                // If the ignore option is *not* set we can report it now
+                if (isAllowed === false) {
+                    let fullNumberNode = node;
+                    let raw = node.raw;
+                    if (node.parent.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                        // the base rule only shows the operator for negative numbers
+                        // https://github.com/eslint/eslint/blob/9dfc8501fb1956c90dc11e6377b4cb38a6bea65d/lib/rules/no-magic-numbers.js#L126
+                        node.parent.operator === '-') {
+                        fullNumberNode = node.parent;
+                        raw = `${node.parent.operator}${node.raw}`;
+                    }
+                    context.report({
+                        node: fullNumberNode,
+                        messageId: 'noMagic',
+                        data: { raw },
+                    });
+                    return;
+                }
+                // Let the base rule deal with the rest
+                rules.Literal(node);
+            },
+        };
+    },
+});
+/**
+ * Convert the value to bigint if it's a string. Otherwise, return the value as-is.
+ * @param value The value to normalize.
+ * @returns The normalized value.
+ */
+function normalizeIgnoreValue(value) {
+    if (typeof value === 'string') {
+        return BigInt(value.slice(0, -1));
+    }
+    return value;
+}
+/**
+ * Converts the node to its numeric value, handling prefixed numbers (-1 / +1)
+ * @param node the node to normalize.
+ * @param value the node's value.
+ */
+function normalizeLiteralValue(node, value) {
+    if (node.parent.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+        ['-', '+'].includes(node.parent.operator) &&
+        node.parent.operator === '-') {
+        return -value;
+    }
+    return value;
+}
+/**
+ * Gets the true parent of the literal, handling prefixed numbers (-1 / +1)
+ */
+function getLiteralParent(node) {
+    if (node.parent.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+        ['-', '+'].includes(node.parent.operator)) {
+        return node.parent.parent;
+    }
+    return node.parent;
+}
+/**
+ * Checks if the node grandparent is a Typescript type alias declaration
+ * @param node the node to be validated.
+ * @returns true if the node grandparent is a Typescript type alias declaration
+ * @private
+ */
+function isGrandparentTSTypeAliasDeclaration(node) {
+    return node.parent?.parent?.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration;
+}
+/**
+ * Checks if the node grandparent is a Typescript union type and its parent is a type alias declaration
+ * @param node the node to be validated.
+ * @returns true if the node grandparent is a Typescript union type and its parent is a type alias declaration
+ * @private
+ */
+function isGrandparentTSUnionType(node) {
+    if (node.parent?.parent?.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+        return isGrandparentTSTypeAliasDeclaration(node.parent);
+    }
+    return false;
+}
+/**
+ * Checks if the node parent is a Typescript enum member
+ * @param node the node to be validated.
+ * @returns true if the node parent is a Typescript enum member
+ * @private
+ */
+function isParentTSEnumDeclaration(node) {
+    const parent = getLiteralParent(node);
+    return parent?.type === utils_1.AST_NODE_TYPES.TSEnumMember;
+}
+/**
+ * Checks if the node parent is a Typescript literal type
+ * @param node the node to be validated.
+ * @returns true if the node parent is a Typescript literal type
+ * @private
+ */
+function isParentTSLiteralType(node) {
+    return node.parent?.type === utils_1.AST_NODE_TYPES.TSLiteralType;
+}
+/**
+ * Checks if the node is a valid TypeScript numeric literal type.
+ * @param node the node to be validated.
+ * @returns true if the node is a TypeScript numeric literal type.
+ * @private
+ */
+function isTSNumericLiteralType(node) {
+    // For negative numbers, use the parent node
+    if (node.parent?.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+        node.parent.operator === '-') {
+        node = node.parent;
+    }
+    // If the parent node is not a TSLiteralType, early return
+    if (!isParentTSLiteralType(node)) {
+        return false;
+    }
+    // If the grandparent is a TSTypeAliasDeclaration, ignore
+    if (isGrandparentTSTypeAliasDeclaration(node)) {
+        return true;
+    }
+    // If the grandparent is a TSUnionType and it's parent is a TSTypeAliasDeclaration, ignore
+    if (isGrandparentTSUnionType(node)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Checks if the node parent is a readonly class property
+ * @param node the node to be validated.
+ * @returns true if the node parent is a readonly class property
+ * @private
+ */
+function isParentTSReadonlyPropertyDefinition(node) {
+    const parent = getLiteralParent(node);
+    if (parent?.type === utils_1.AST_NODE_TYPES.PropertyDefinition && parent.readonly) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Checks if the node is part of a type indexed access (eg. Foo[4])
+ * @param node the node to be validated.
+ * @returns true if the node is part of an indexed access
+ * @private
+ */
+function isAncestorTSIndexedAccessType(node) {
+    // Handle unary expressions (eg. -4)
+    let ancestor = getLiteralParent(node);
+    // Go up another level while we’re part of a type union (eg. 1 | 2) or
+    // intersection (eg. 1 & 2)
+    while (ancestor?.parent?.type === utils_1.AST_NODE_TYPES.TSUnionType ||
+        ancestor?.parent?.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+        ancestor = ancestor.parent;
+    }
+    return ancestor?.parent?.type === utils_1.AST_NODE_TYPES.TSIndexedAccessType;
+}

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-meaningless-void-operator.d.ts

@@ -0,0 +1,10 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type Options = [
+    {
+        checkNever: boolean;
+    }
+];
+declare const _default: TSESLint.RuleModule<"meaninglessVoidOperator" | "removeVoid", Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-meaningless-void-operator.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-meaningless-void-operator',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow the `void` operator except when used to discard a value',
+            recommended: 'strict',
+            requiresTypeChecking: true,
+        },
+        fixable: 'code',
+        hasSuggestions: true,
+        messages: {
+            meaninglessVoidOperator: "void operator shouldn't be used on {{type}}; it should convey that a return value is being ignored",
+            removeVoid: "Remove 'void'",
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    checkNever: {
+                        type: 'boolean',
+                        description: 'Whether to suggest removing `void` when the argument has type `never`.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [{ checkNever: false }],
+    create(context, [{ checkNever }]) {
+        const services = utils_1.ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        return {
+            'UnaryExpression[operator="void"]'(node) {
+                const fix = (fixer) => {
+                    return fixer.removeRange([
+                        context.sourceCode.getTokens(node)[0].range[0],
+                        context.sourceCode.getTokens(node)[1].range[0],
+                    ]);
+                };
+                const argType = services.getTypeAtLocation(node.argument);
+                const unionParts = tsutils.unionConstituents(argType);
+                if (unionParts.every(part => tsutils.isTypeFlagSet(part, ts.TypeFlags.Void | ts.TypeFlags.Undefined))) {
+                    context.report({
+                        node,
+                        messageId: 'meaninglessVoidOperator',
+                        data: { type: checker.typeToString(argType) },
+                        fix,
+                    });
+                }
+                else if (checkNever &&
+                    unionParts.every(part => tsutils.isTypeFlagSet(part, ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.Never))) {
+                    context.report({
+                        node,
+                        messageId: 'meaninglessVoidOperator',
+                        data: { type: checker.typeToString(argType) },
+                        suggest: [{ messageId: 'removeVoid', fix }],
+                    });
+                }
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-new.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"errorMessageClass" | "errorMessageInterface", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-new.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-misused-new',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce valid definition of `new` and `constructor`',
+            recommended: 'recommended',
+        },
+        messages: {
+            errorMessageClass: 'Class cannot have method named `new`.',
+            errorMessageInterface: 'Interfaces cannot be constructed, only classes.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        /**
+         * @param node type to be inspected.
+         * @returns name of simple type or null
+         */
+        function getTypeReferenceName(node) {
+            if (node) {
+                switch (node.type) {
+                    case utils_1.AST_NODE_TYPES.TSTypeAnnotation:
+                        return getTypeReferenceName(node.typeAnnotation);
+                    case utils_1.AST_NODE_TYPES.TSTypeReference:
+                        return getTypeReferenceName(node.typeName);
+                    case utils_1.AST_NODE_TYPES.Identifier:
+                        return node.name;
+                    default:
+                        break;
+                }
+            }
+            return null;
+        }
+        /**
+         * @param parent parent node.
+         * @param returnType type to be compared
+         */
+        function isMatchingParentType(parent, returnType) {
+            if (parent &&
+                (parent.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+                    parent.type === utils_1.AST_NODE_TYPES.ClassExpression ||
+                    parent.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) &&
+                parent.id) {
+                return getTypeReferenceName(returnType) === parent.id.name;
+            }
+            return false;
+        }
+        return {
+            "ClassBody > MethodDefinition[key.name='new']"(node) {
+                if (node.value.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression &&
+                    isMatchingParentType(node.parent.parent, node.value.returnType)) {
+                    context.report({
+                        node,
+                        messageId: 'errorMessageClass',
+                    });
+                }
+            },
+            'TSInterfaceBody > TSConstructSignatureDeclaration'(node) {
+                if (isMatchingParentType(node.parent.parent, node.returnType)) {
+                    // constructor
+                    context.report({
+                        node,
+                        messageId: 'errorMessageInterface',
+                    });
+                }
+            },
+            "TSMethodSignature[key.name='constructor']"(node) {
+                context.report({
+                    node,
+                    messageId: 'errorMessageInterface',
+                });
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-promises.d.ts

@@ -0,0 +1,21 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type Options = [
+    {
+        checksConditionals?: boolean;
+        checksSpreads?: boolean;
+        checksVoidReturn?: boolean | ChecksVoidReturnOptions;
+    }
+];
+export interface ChecksVoidReturnOptions {
+    arguments?: boolean;
+    attributes?: boolean;
+    inheritedMethods?: boolean;
+    properties?: boolean;
+    returns?: boolean;
+    variables?: boolean;
+}
+export type MessageId = 'conditional' | 'predicate' | 'spread' | 'voidReturnArgument' | 'voidReturnAttribute' | 'voidReturnInheritedMethod' | 'voidReturnProperty' | 'voidReturnReturnValue' | 'voidReturnVariable';
+declare const _default: TSESLint.RuleModule<MessageId, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-promises.js

@@ -0,0 +1,765 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+const promiseUtils_1 = require("../util/promiseUtils");
+function parseChecksVoidReturn(checksVoidReturn) {
+    switch (checksVoidReturn) {
+        case false:
+            return false;
+        case true:
+        case undefined:
+            return {
+                arguments: true,
+                attributes: true,
+                inheritedMethods: true,
+                properties: true,
+                returns: true,
+                variables: true,
+            };
+        default:
+            return {
+                arguments: checksVoidReturn.arguments ?? true,
+                attributes: checksVoidReturn.attributes ?? true,
+                inheritedMethods: checksVoidReturn.inheritedMethods ?? true,
+                properties: checksVoidReturn.properties ?? true,
+                returns: checksVoidReturn.returns ?? true,
+                variables: checksVoidReturn.variables ?? true,
+            };
+    }
+}
+exports.default = (0, util_1.createRule)({
+    name: 'no-misused-promises',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow Promises in places not designed to handle them',
+            recommended: 'recommended',
+            requiresTypeChecking: true,
+        },
+        messages: {
+            conditional: 'Expected non-Promise value in a boolean conditional.',
+            predicate: 'Expected a non-Promise value to be returned.',
+            spread: 'Expected a non-Promise value to be spread in an object.',
+            voidReturnArgument: 'Promise returned in function argument where a void return was expected.',
+            voidReturnAttribute: 'Promise-returning function provided to attribute where a void return was expected.',
+            voidReturnInheritedMethod: "Promise-returning method provided where a void return was expected by extended/implemented type '{{ heritageTypeName }}'.",
+            voidReturnProperty: 'Promise-returning function provided to property where a void return was expected.',
+            voidReturnReturnValue: 'Promise-returning function provided to return value where a void return was expected.',
+            voidReturnVariable: 'Promise-returning function provided to variable where a void return was expected.',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    checksConditionals: {
+                        type: 'boolean',
+                        description: 'Whether to warn when a Promise is provided to conditional statements.',
+                    },
+                    checksSpreads: {
+                        type: 'boolean',
+                        description: 'Whether to warn when `...` spreading a `Promise`.',
+                    },
+                    checksVoidReturn: {
+                        description: 'Whether to warn when a Promise is returned from a function typed as returning `void`.',
+                        oneOf: [
+                            {
+                                type: 'boolean',
+                                description: 'Whether to disable checking all asynchronous functions.',
+                            },
+                            {
+                                type: 'object',
+                                additionalProperties: false,
+                                description: 'Which forms of functions may have checking disabled.',
+                                properties: {
+                                    arguments: {
+                                        type: 'boolean',
+                                        description: 'Disables checking an asynchronous function passed as argument where the parameter type expects a function that returns `void`.',
+                                    },
+                                    attributes: {
+                                        type: 'boolean',
+                                        description: 'Disables checking an asynchronous function passed as a JSX attribute expected to be a function that returns `void`.',
+                                    },
+                                    inheritedMethods: {
+                                        type: 'boolean',
+                                        description: 'Disables checking an asynchronous method in a type that extends or implements another type expecting that method to return `void`.',
+                                    },
+                                    properties: {
+                                        type: 'boolean',
+                                        description: 'Disables checking an asynchronous function passed as an object property expected to be a function that returns `void`.',
+                                    },
+                                    returns: {
+                                        type: 'boolean',
+                                        description: 'Disables checking an asynchronous function returned in a function whose return type is a function that returns `void`.',
+                                    },
+                                    variables: {
+                                        type: 'boolean',
+                                        description: 'Disables checking an asynchronous function used as a variable whose return type is a function that returns `void`.',
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            checksConditionals: true,
+            checksSpreads: true,
+            checksVoidReturn: true,
+        },
+    ],
+    create(context, [{ checksConditionals, checksSpreads, checksVoidReturn }]) {
+        const services = (0, util_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        const checkedNodes = new Set();
+        const conditionalChecks = {
+            'CallExpression > MemberExpression': checkArrayPredicates,
+            ConditionalExpression: checkTestConditional,
+            DoWhileStatement: checkTestConditional,
+            ForStatement: checkTestConditional,
+            IfStatement: checkTestConditional,
+            LogicalExpression: checkConditional,
+            'UnaryExpression[operator="!"]'(node) {
+                checkConditional(node.argument, true);
+            },
+            WhileStatement: checkTestConditional,
+        };
+        checksVoidReturn = parseChecksVoidReturn(checksVoidReturn);
+        const voidReturnChecks = checksVoidReturn
+            ? {
+                ...(checksVoidReturn.arguments && {
+                    CallExpression: checkArguments,
+                    NewExpression: checkArguments,
+                }),
+                ...(checksVoidReturn.attributes && {
+                    JSXAttribute: checkJSXAttribute,
+                }),
+                ...(checksVoidReturn.inheritedMethods && {
+                    ClassDeclaration: checkClassLikeOrInterfaceNode,
+                    ClassExpression: checkClassLikeOrInterfaceNode,
+                    TSInterfaceDeclaration: checkClassLikeOrInterfaceNode,
+                }),
+                ...(checksVoidReturn.properties && {
+                    Property: checkProperty,
+                }),
+                ...(checksVoidReturn.returns && {
+                    ReturnStatement: checkReturnStatement,
+                }),
+                ...(checksVoidReturn.variables && {
+                    AssignmentExpression: checkAssignment,
+                    VariableDeclarator: checkVariableDeclaration,
+                }),
+            }
+            : {};
+        const spreadChecks = {
+            SpreadElement: checkSpread,
+        };
+        /**
+         * A syntactic check to see if an annotated type is maybe a function type.
+         * This is a perf optimization to help avoid requesting types where possible
+         */
+        function isPossiblyFunctionType(node) {
+            switch (node.typeAnnotation.type) {
+                case utils_1.AST_NODE_TYPES.TSConditionalType:
+                case utils_1.AST_NODE_TYPES.TSConstructorType:
+                case utils_1.AST_NODE_TYPES.TSFunctionType:
+                case utils_1.AST_NODE_TYPES.TSImportType:
+                case utils_1.AST_NODE_TYPES.TSIndexedAccessType:
+                case utils_1.AST_NODE_TYPES.TSInferType:
+                case utils_1.AST_NODE_TYPES.TSIntersectionType:
+                case utils_1.AST_NODE_TYPES.TSQualifiedName:
+                case utils_1.AST_NODE_TYPES.TSThisType:
+                case utils_1.AST_NODE_TYPES.TSTypeOperator:
+                case utils_1.AST_NODE_TYPES.TSTypeQuery:
+                case utils_1.AST_NODE_TYPES.TSTypeReference:
+                case utils_1.AST_NODE_TYPES.TSUnionType:
+                    return true;
+                case utils_1.AST_NODE_TYPES.TSTypeLiteral:
+                    return node.typeAnnotation.members.some(member => member.type === utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration ||
+                        member.type === utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration);
+                case utils_1.AST_NODE_TYPES.TSAbstractKeyword:
+                case utils_1.AST_NODE_TYPES.TSAnyKeyword:
+                case utils_1.AST_NODE_TYPES.TSArrayType:
+                case utils_1.AST_NODE_TYPES.TSAsyncKeyword:
+                case utils_1.AST_NODE_TYPES.TSBigIntKeyword:
+                case utils_1.AST_NODE_TYPES.TSBooleanKeyword:
+                case utils_1.AST_NODE_TYPES.TSDeclareKeyword:
+                case utils_1.AST_NODE_TYPES.TSExportKeyword:
+                case utils_1.AST_NODE_TYPES.TSIntrinsicKeyword:
+                case utils_1.AST_NODE_TYPES.TSLiteralType:
+                case utils_1.AST_NODE_TYPES.TSMappedType:
+                case utils_1.AST_NODE_TYPES.TSNamedTupleMember:
+                case utils_1.AST_NODE_TYPES.TSNeverKeyword:
+                case utils_1.AST_NODE_TYPES.TSNullKeyword:
+                case utils_1.AST_NODE_TYPES.TSNumberKeyword:
+                case utils_1.AST_NODE_TYPES.TSObjectKeyword:
+                case utils_1.AST_NODE_TYPES.TSOptionalType:
+                case utils_1.AST_NODE_TYPES.TSPrivateKeyword:
+                case utils_1.AST_NODE_TYPES.TSProtectedKeyword:
+                case utils_1.AST_NODE_TYPES.TSPublicKeyword:
+                case utils_1.AST_NODE_TYPES.TSReadonlyKeyword:
+                case utils_1.AST_NODE_TYPES.TSRestType:
+                case utils_1.AST_NODE_TYPES.TSStaticKeyword:
+                case utils_1.AST_NODE_TYPES.TSStringKeyword:
+                case utils_1.AST_NODE_TYPES.TSSymbolKeyword:
+                case utils_1.AST_NODE_TYPES.TSTemplateLiteralType:
+                case utils_1.AST_NODE_TYPES.TSTupleType:
+                case utils_1.AST_NODE_TYPES.TSTypePredicate:
+                case utils_1.AST_NODE_TYPES.TSUndefinedKeyword:
+                case utils_1.AST_NODE_TYPES.TSUnknownKeyword:
+                case utils_1.AST_NODE_TYPES.TSVoidKeyword:
+                    return false;
+            }
+        }
+        function checkTestConditional(node) {
+            if (node.test) {
+                checkConditional(node.test, true);
+            }
+        }
+        /**
+         * This function analyzes the type of a node and checks if it is a Promise in a boolean conditional.
+         * It uses recursion when checking nested logical operators.
+         * @param node The AST node to check.
+         * @param isTestExpr Whether the node is a descendant of a test expression.
+         */
+        function checkConditional(node, isTestExpr = false) {
+            // prevent checking the same node multiple times
+            if (checkedNodes.has(node)) {
+                return;
+            }
+            checkedNodes.add(node);
+            if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+                // ignore the left operand for nullish coalescing expressions not in a context of a test expression
+                if (node.operator !== '??' || isTestExpr) {
+                    checkConditional(node.left, isTestExpr);
+                }
+                // we ignore the right operand when not in a context of a test expression
+                if (isTestExpr) {
+                    checkConditional(node.right, isTestExpr);
+                }
+                return;
+            }
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+            if (isAlwaysThenable(checker, tsNode)) {
+                context.report({
+                    node,
+                    messageId: 'conditional',
+                });
+            }
+        }
+        function checkArrayPredicates(node) {
+            const parent = node.parent;
+            if (parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                const callback = parent.arguments.at(0);
+                if (callback &&
+                    (0, util_1.isArrayMethodCallWithPredicate)(context, services, parent)) {
+                    const type = services.esTreeNodeToTSNodeMap.get(callback);
+                    if (returnsThenable(checker, type)) {
+                        context.report({
+                            node: callback,
+                            messageId: 'predicate',
+                        });
+                    }
+                }
+            }
+        }
+        function checkArguments(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                isPromiseFinallyMethod(node)) {
+                return;
+            }
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+            const voidArgs = voidFunctionArguments(checker, tsNode);
+            if (voidArgs.size === 0) {
+                return;
+            }
+            for (const [index, argument] of node.arguments.entries()) {
+                if (!voidArgs.has(index)) {
+                    continue;
+                }
+                const tsNode = services.esTreeNodeToTSNodeMap.get(argument);
+                if (returnsThenable(checker, tsNode)) {
+                    context.report({
+                        node: argument,
+                        messageId: 'voidReturnArgument',
+                    });
+                }
+            }
+        }
+        function checkAssignment(node) {
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+            const varType = services.getTypeAtLocation(node.left);
+            if (!isVoidReturningFunctionType(checker, tsNode.left, varType)) {
+                return;
+            }
+            if (returnsThenable(checker, tsNode.right)) {
+                context.report({
+                    node: node.right,
+                    messageId: 'voidReturnVariable',
+                });
+            }
+        }
+        function checkVariableDeclaration(node) {
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+            if (tsNode.initializer == null ||
+                node.init == null ||
+                node.id.typeAnnotation == null) {
+                return;
+            }
+            // syntactically ignore some known-good cases to avoid touching type info
+            if (!isPossiblyFunctionType(node.id.typeAnnotation)) {
+                return;
+            }
+            const varType = services.getTypeAtLocation(node.id);
+            if (!isVoidReturningFunctionType(checker, tsNode.initializer, varType)) {
+                return;
+            }
+            if (returnsThenable(checker, tsNode.initializer)) {
+                context.report({
+                    node: node.init,
+                    messageId: 'voidReturnVariable',
+                });
+            }
+        }
+        function checkProperty(node) {
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+            if (ts.isPropertyAssignment(tsNode)) {
+                const contextualType = checker.getContextualType(tsNode.initializer);
+                if (contextualType != null &&
+                    isVoidReturningFunctionType(checker, tsNode.initializer, contextualType) &&
+                    returnsThenable(checker, tsNode.initializer)) {
+                    if ((0, util_1.isFunction)(node.value)) {
+                        const functionNode = node.value;
+                        if (functionNode.returnType) {
+                            context.report({
+                                node: functionNode.returnType.typeAnnotation,
+                                messageId: 'voidReturnProperty',
+                            });
+                        }
+                        else {
+                            context.report({
+                                loc: (0, util_1.getFunctionHeadLoc)(functionNode, context.sourceCode),
+                                messageId: 'voidReturnProperty',
+                            });
+                        }
+                    }
+                    else {
+                        context.report({
+                            node: node.value,
+                            messageId: 'voidReturnProperty',
+                        });
+                    }
+                }
+            }
+            else if (ts.isShorthandPropertyAssignment(tsNode)) {
+                const contextualType = checker.getContextualType(tsNode.name);
+                if (contextualType != null &&
+                    isVoidReturningFunctionType(checker, tsNode.name, contextualType) &&
+                    returnsThenable(checker, tsNode.name)) {
+                    context.report({
+                        node: node.value,
+                        messageId: 'voidReturnProperty',
+                    });
+                }
+            }
+            else if (ts.isMethodDeclaration(tsNode)) {
+                if (ts.isComputedPropertyName(tsNode.name)) {
+                    return;
+                }
+                const obj = tsNode.parent;
+                // Below condition isn't satisfied unless something goes wrong,
+                // but is needed for type checking.
+                // 'node' does not include class method declaration so 'obj' is
+                // always an object literal expression, but after converting 'node'
+                // to TypeScript AST, its type includes MethodDeclaration which
+                // does include the case of class method declaration.
+                if (!ts.isObjectLiteralExpression(obj)) {
+                    return;
+                }
+                if (!returnsThenable(checker, tsNode)) {
+                    return;
+                }
+                const objType = checker.getContextualType(obj);
+                if (objType == null) {
+                    return;
+                }
+                const propertySymbol = tsutils
+                    .unionConstituents(objType)
+                    .map(t => checker.getPropertyOfType(t, tsNode.name.getText()))
+                    .find(p => p);
+                if (propertySymbol == null) {
+                    return;
+                }
+                const contextualType = checker.getTypeOfSymbolAtLocation(propertySymbol, tsNode.name);
+                if (isVoidReturningFunctionType(checker, tsNode.name, contextualType)) {
+                    const functionNode = node.value;
+                    if (functionNode.returnType) {
+                        context.report({
+                            node: functionNode.returnType.typeAnnotation,
+                            messageId: 'voidReturnProperty',
+                        });
+                    }
+                    else {
+                        context.report({
+                            loc: (0, util_1.getFunctionHeadLoc)(functionNode, context.sourceCode),
+                            messageId: 'voidReturnProperty',
+                        });
+                    }
+                }
+                return;
+            }
+        }
+        function checkReturnStatement(node) {
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+            if (tsNode.expression == null || node.argument == null) {
+                return;
+            }
+            // syntactically ignore some known-good cases to avoid touching type info
+            const functionNode = (() => {
+                let current = node.parent;
+                while (current && !(0, util_1.isFunction)(current)) {
+                    current = current.parent;
+                }
+                return (0, util_1.nullThrows)(current, util_1.NullThrowsReasons.MissingParent);
+            })();
+            if (functionNode.returnType &&
+                !isPossiblyFunctionType(functionNode.returnType)) {
+                return;
+            }
+            const contextualType = checker.getContextualType(tsNode.expression);
+            if (contextualType != null &&
+                isVoidReturningFunctionType(checker, tsNode.expression, contextualType) &&
+                returnsThenable(checker, tsNode.expression)) {
+                context.report({
+                    node: node.argument,
+                    messageId: 'voidReturnReturnValue',
+                });
+            }
+        }
+        function isPromiseFinallyMethod(node) {
+            const promiseFinallyCall = (0, promiseUtils_1.parseFinallyCall)(node, context);
+            return (promiseFinallyCall != null &&
+                (0, util_1.isPromiseLike)(services.program, (0, util_1.getConstrainedTypeAtLocation)(services, promiseFinallyCall.object)));
+        }
+        function checkClassLikeOrInterfaceNode(node) {
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+            const heritageTypes = getHeritageTypes(checker, tsNode);
+            if (!heritageTypes?.length) {
+                return;
+            }
+            for (const nodeMember of tsNode.members) {
+                const memberName = nodeMember.name?.getText();
+                if (memberName == null) {
+                    // Call/construct/index signatures don't have names. TS allows call signatures to mismatch,
+                    // and construct signatures can't be async.
+                    // TODO - Once we're able to use `checker.isTypeAssignableTo` (v8), we can check an index
+                    // signature here against its compatible index signatures in `heritageTypes`
+                    continue;
+                }
+                if (!returnsThenable(checker, nodeMember)) {
+                    continue;
+                }
+                const node = services.tsNodeToESTreeNodeMap.get(nodeMember);
+                if (isStaticMember(node)) {
+                    continue;
+                }
+                for (const heritageType of heritageTypes) {
+                    checkHeritageTypeForMemberReturningVoid(nodeMember, heritageType, memberName);
+                }
+            }
+        }
+        /**
+         * Checks `heritageType` for a member named `memberName` that returns void; reports the
+         * 'voidReturnInheritedMethod' message if found.
+         * @param nodeMember Node member that returns a Promise
+         * @param heritageType Heritage type to check against
+         * @param memberName Name of the member to check for
+         */
+        function checkHeritageTypeForMemberReturningVoid(nodeMember, heritageType, memberName) {
+            const heritageMember = getMemberIfExists(heritageType, memberName);
+            if (heritageMember == null) {
+                return;
+            }
+            const memberType = checker.getTypeOfSymbolAtLocation(heritageMember, nodeMember);
+            if (!isVoidReturningFunctionType(checker, nodeMember, memberType)) {
+                return;
+            }
+            context.report({
+                node: services.tsNodeToESTreeNodeMap.get(nodeMember),
+                messageId: 'voidReturnInheritedMethod',
+                data: { heritageTypeName: checker.typeToString(heritageType) },
+            });
+        }
+        function checkJSXAttribute(node) {
+            if (node.value?.type !== utils_1.AST_NODE_TYPES.JSXExpressionContainer) {
+                return;
+            }
+            const expressionContainer = services.esTreeNodeToTSNodeMap.get(node.value);
+            const expression = services.esTreeNodeToTSNodeMap.get(node.value.expression);
+            const contextualType = checker.getContextualType(expressionContainer);
+            if (contextualType != null &&
+                isVoidReturningFunctionType(checker, expressionContainer, contextualType) &&
+                returnsThenable(checker, expression)) {
+                context.report({
+                    node: node.value,
+                    messageId: 'voidReturnAttribute',
+                });
+            }
+        }
+        function checkSpread(node) {
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+            if (isSometimesThenable(checker, tsNode.expression)) {
+                context.report({
+                    node: node.argument,
+                    messageId: 'spread',
+                });
+            }
+        }
+        return {
+            ...(checksConditionals ? conditionalChecks : {}),
+            ...(checksVoidReturn ? voidReturnChecks : {}),
+            ...(checksSpreads ? spreadChecks : {}),
+        };
+    },
+});
+function isSometimesThenable(checker, node) {
+    const type = checker.getTypeAtLocation(node);
+    for (const subType of tsutils.unionConstituents(checker.getApparentType(type))) {
+        if (tsutils.isThenableType(checker, node, subType)) {
+            return true;
+        }
+    }
+    return false;
+}
+// Variation on the thenable check which requires all forms of the type (read:
+// alternates in a union) to be thenable. Otherwise, you might be trying to
+// check if something is defined or undefined and get caught because one of the
+// branches is thenable.
+function isAlwaysThenable(checker, node) {
+    const type = checker.getTypeAtLocation(node);
+    for (const subType of tsutils.unionConstituents(checker.getApparentType(type))) {
+        const thenProp = subType.getProperty('then');
+        // If one of the alternates has no then property, it is not thenable in all
+        // cases.
+        if (thenProp == null) {
+            return false;
+        }
+        // We walk through each variation of the then property. Since we know it
+        // exists at this point, we just need at least one of the alternates to
+        // be of the right form to consider it thenable.
+        const thenType = checker.getTypeOfSymbolAtLocation(thenProp, node);
+        let hasThenableSignature = false;
+        for (const subType of tsutils.unionConstituents(thenType)) {
+            for (const signature of subType.getCallSignatures()) {
+                if (signature.parameters.length !== 0 &&
+                    isFunctionParam(checker, signature.parameters[0], node)) {
+                    hasThenableSignature = true;
+                    break;
+                }
+            }
+            // We only need to find one variant of the then property that has a
+            // function signature for it to be thenable.
+            if (hasThenableSignature) {
+                break;
+            }
+        }
+        // If no flavors of the then property are thenable, we don't consider the
+        // overall type to be thenable
+        if (!hasThenableSignature) {
+            return false;
+        }
+    }
+    // If all variants are considered thenable (i.e. haven't returned false), we
+    // consider the overall type thenable
+    return true;
+}
+function isFunctionParam(checker, param, node) {
+    const type = checker.getApparentType(checker.getTypeOfSymbolAtLocation(param, node));
+    for (const subType of tsutils.unionConstituents(type)) {
+        if (subType.getCallSignatures().length !== 0) {
+            return true;
+        }
+    }
+    return false;
+}
+function checkThenableOrVoidArgument(checker, node, type, index, thenableReturnIndices, voidReturnIndices) {
+    if (isThenableReturningFunctionType(checker, node.expression, type)) {
+        thenableReturnIndices.add(index);
+    }
+    else if (isVoidReturningFunctionType(checker, node.expression, type) &&
+        // If a certain argument accepts both thenable and void returns,
+        // a promise-returning function is valid
+        !thenableReturnIndices.has(index)) {
+        voidReturnIndices.add(index);
+    }
+    const contextualType = checker.getContextualTypeForArgumentAtIndex(node, index);
+    if (contextualType !== type) {
+        checkThenableOrVoidArgument(checker, node, contextualType, index, thenableReturnIndices, voidReturnIndices);
+    }
+}
+// Get the positions of arguments which are void functions (and not also
+// thenable functions). These are the candidates for the void-return check at
+// the current call site.
+// If the function parameters end with a 'rest' parameter, then we consider
+// the array type parameter (e.g. '...args:Array<SomeType>') when determining
+// if trailing arguments are candidates.
+function voidFunctionArguments(checker, node) {
+    // 'new' can be used without any arguments, as in 'let b = new Object;'
+    // In this case, there are no argument positions to check, so return early.
+    if (!node.arguments) {
+        return new Set();
+    }
+    const thenableReturnIndices = new Set();
+    const voidReturnIndices = new Set();
+    const type = checker.getTypeAtLocation(node.expression);
+    // We can't use checker.getResolvedSignature because it prefers an early '() => void' over a later '() => Promise<void>'
+    // See https://github.com/microsoft/TypeScript/issues/48077
+    for (const subType of tsutils.unionConstituents(type)) {
+        // Standard function calls and `new` have two different types of signatures
+        const signatures = ts.isCallExpression(node)
+            ? subType.getCallSignatures()
+            : subType.getConstructSignatures();
+        for (const signature of signatures) {
+            for (const [index, parameter] of signature.parameters.entries()) {
+                const decl = parameter.valueDeclaration;
+                let type = checker.getTypeOfSymbolAtLocation(parameter, node.expression);
+                // If this is a array 'rest' parameter, check all of the argument indices
+                // from the current argument to the end.
+                if (decl && (0, util_1.isRestParameterDeclaration)(decl)) {
+                    if (checker.isArrayType(type)) {
+                        // Unwrap 'Array<MaybeVoidFunction>' to 'MaybeVoidFunction',
+                        // so that we'll handle it in the same way as a non-rest
+                        // 'param: MaybeVoidFunction'
+                        type = checker.getTypeArguments(type)[0];
+                        for (let i = index; i < node.arguments.length; i++) {
+                            checkThenableOrVoidArgument(checker, node, type, i, thenableReturnIndices, voidReturnIndices);
+                        }
+                    }
+                    else if (checker.isTupleType(type)) {
+                        // Check each type in the tuple - for example, [boolean, () => void] would
+                        // add the index of the second tuple parameter to 'voidReturnIndices'
+                        const typeArgs = checker.getTypeArguments(type);
+                        for (let i = index; i < node.arguments.length && i - index < typeArgs.length; i++) {
+                            checkThenableOrVoidArgument(checker, node, typeArgs[i - index], i, thenableReturnIndices, voidReturnIndices);
+                        }
+                    }
+                }
+                else {
+                    checkThenableOrVoidArgument(checker, node, type, index, thenableReturnIndices, voidReturnIndices);
+                }
+            }
+        }
+    }
+    for (const index of thenableReturnIndices) {
+        voidReturnIndices.delete(index);
+    }
+    return voidReturnIndices;
+}
+/**
+ * @returns Whether any call signature of the type has a thenable return type.
+ */
+function anySignatureIsThenableType(checker, node, type) {
+    for (const signature of type.getCallSignatures()) {
+        const returnType = signature.getReturnType();
+        if (tsutils.isThenableType(checker, node, returnType)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * @returns Whether type is a thenable-returning function.
+ */
+function isThenableReturningFunctionType(checker, node, type) {
+    for (const subType of tsutils.unionConstituents(type)) {
+        if (anySignatureIsThenableType(checker, node, subType)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * @returns Whether type is a void-returning function.
+ */
+function isVoidReturningFunctionType(checker, node, type) {
+    let hadVoidReturn = false;
+    for (const subType of tsutils.unionConstituents(type)) {
+        for (const signature of subType.getCallSignatures()) {
+            const returnType = signature.getReturnType();
+            // If a certain positional argument accepts both thenable and void returns,
+            // a promise-returning function is valid
+            if (tsutils.isThenableType(checker, node, returnType)) {
+                return false;
+            }
+            hadVoidReturn ||= tsutils.isTypeFlagSet(returnType, ts.TypeFlags.Void);
+        }
+    }
+    return hadVoidReturn;
+}
+/**
+ * @returns Whether expression is a function that returns a thenable.
+ */
+function returnsThenable(checker, node) {
+    const type = checker.getApparentType(checker.getTypeAtLocation(node));
+    return tsutils
+        .unionConstituents(type)
+        .some(t => anySignatureIsThenableType(checker, node, t));
+}
+function getHeritageTypes(checker, tsNode) {
+    return tsNode.heritageClauses
+        ?.flatMap(clause => clause.types)
+        .map(typeExpression => checker.getTypeAtLocation(typeExpression));
+}
+/**
+ * @returns The member with the given name in `type`, if it exists.
+ */
+function getMemberIfExists(type, memberName) {
+    const escapedMemberName = ts.escapeLeadingUnderscores(memberName);
+    const symbolMemberMatch = type.getSymbol()?.members?.get(escapedMemberName);
+    return (symbolMemberMatch ?? tsutils.getPropertyOfType(type, escapedMemberName));
+}
+function isStaticMember(node) {
+    return ((node.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
+        node.type === utils_1.AST_NODE_TYPES.PropertyDefinition ||
+        node.type === utils_1.AST_NODE_TYPES.AccessorProperty) &&
+        node.static);
+}

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-spread.d.ts

@@ -0,0 +1,12 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+import type { TypeOrValueSpecifier } from '../util';
+type Options = [
+    {
+        allow?: TypeOrValueSpecifier[];
+    }
+];
+type MessageIds = 'addAwait' | 'noArraySpreadInObject' | 'noClassDeclarationSpreadInObject' | 'noClassInstanceSpreadInObject' | 'noFunctionSpreadInObject' | 'noIterableSpreadInObject' | 'noMapSpreadInObject' | 'noPromiseSpreadInObject' | 'noStringSpread' | 'replaceMapSpreadInObject';
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-spread.js

@@ -0,0 +1,260 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-misused-spread',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow using the spread operator when it might cause unexpected behavior',
+            recommended: 'strict',
+            requiresTypeChecking: true,
+        },
+        hasSuggestions: true,
+        messages: {
+            addAwait: 'Add await operator.',
+            noArraySpreadInObject: 'Using the spread operator on an array in an object will result in a list of indices.',
+            noClassDeclarationSpreadInObject: 'Using the spread operator on class declarations will spread only their static properties, and will lose their class prototype.',
+            noClassInstanceSpreadInObject: 'Using the spread operator on class instances will lose their class prototype.',
+            noFunctionSpreadInObject: 'Using the spread operator on a function without additional properties can cause unexpected behavior. Did you forget to call the function?',
+            noIterableSpreadInObject: 'Using the spread operator on an Iterable in an object can cause unexpected behavior.',
+            noMapSpreadInObject: 'Using the spread operator on a Map in an object will result in an empty object. Did you mean to use `Object.fromEntries(map)` instead?',
+            noPromiseSpreadInObject: 'Using the spread operator on Promise in an object can cause unexpected behavior. Did you forget to await the promise?',
+            noStringSpread: [
+                'Using the spread operator on a string can mishandle special characters, as can `.split("")`.',
+                '- `...` produces Unicode code points, which will decompose complex emojis into individual emojis',
+                '- .split("") produces UTF-16 code units, which breaks rich characters in many languages',
+                'Consider using `Intl.Segmenter` for locale-aware string decomposition.',
+                "Otherwise, if you don't need to preserve emojis or other non-Ascii characters, disable this lint rule on this line or configure the 'allow' rule option.",
+            ].join('\n'),
+            replaceMapSpreadInObject: 'Replace map spread in object with `Object.fromEntries()`',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allow: {
+                        ...util_1.readonlynessOptionsSchema.properties.allow,
+                        description: 'An array of type specifiers that are known to be safe to spread.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allow: [],
+        },
+    ],
+    create(context, [options]) {
+        const services = (0, util_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        function checkArrayOrCallSpread(node) {
+            const type = (0, util_1.getConstrainedTypeAtLocation)(services, node.argument);
+            if (!(0, util_1.typeMatchesSomeSpecifier)(type, options.allow, services.program) &&
+                isString(type)) {
+                context.report({
+                    node,
+                    messageId: 'noStringSpread',
+                });
+            }
+        }
+        function getMapSpreadSuggestions(node, type) {
+            const types = tsutils.unionConstituents(type);
+            if (types.some(t => !isMap(services.program, t))) {
+                return null;
+            }
+            if (node.parent.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                node.parent.properties.length === 1) {
+                return [
+                    {
+                        messageId: 'replaceMapSpreadInObject',
+                        fix: (0, util_1.getWrappingFixer)({
+                            node: node.parent,
+                            innerNode: node.argument,
+                            sourceCode: context.sourceCode,
+                            wrap: code => `Object.fromEntries(${code})`,
+                        }),
+                    },
+                ];
+            }
+            return [
+                {
+                    messageId: 'replaceMapSpreadInObject',
+                    fix: (0, util_1.getWrappingFixer)({
+                        node: node.argument,
+                        sourceCode: context.sourceCode,
+                        wrap: code => `Object.fromEntries(${code})`,
+                    }),
+                },
+            ];
+        }
+        function getPromiseSpreadSuggestions(node) {
+            const isHighPrecedence = (0, util_1.isHigherPrecedenceThanAwait)(services.esTreeNodeToTSNodeMap.get(node));
+            return [
+                {
+                    messageId: 'addAwait',
+                    fix: fixer => isHighPrecedence
+                        ? fixer.insertTextBefore(node, 'await ')
+                        : [
+                            fixer.insertTextBefore(node, 'await ('),
+                            fixer.insertTextAfter(node, ')'),
+                        ],
+                },
+            ];
+        }
+        function checkObjectSpread(node) {
+            const type = (0, util_1.getConstrainedTypeAtLocation)(services, node.argument);
+            if ((0, util_1.typeMatchesSomeSpecifier)(type, options.allow, services.program)) {
+                return;
+            }
+            if (isPromise(services.program, type)) {
+                context.report({
+                    node,
+                    messageId: 'noPromiseSpreadInObject',
+                    suggest: getPromiseSpreadSuggestions(node.argument),
+                });
+                return;
+            }
+            if (isFunctionWithoutProps(type)) {
+                context.report({
+                    node,
+                    messageId: 'noFunctionSpreadInObject',
+                });
+                return;
+            }
+            if (isMap(services.program, type)) {
+                context.report({
+                    node,
+                    messageId: 'noMapSpreadInObject',
+                    suggest: getMapSpreadSuggestions(node, type),
+                });
+                return;
+            }
+            if (isArray(checker, type)) {
+                context.report({
+                    node,
+                    messageId: 'noArraySpreadInObject',
+                });
+                return;
+            }
+            if (isIterable(type, checker) &&
+                // Don't report when the type is string, since TS will flag it already
+                !isString(type)) {
+                context.report({
+                    node,
+                    messageId: 'noIterableSpreadInObject',
+                });
+                return;
+            }
+            if (isClassInstance(checker, type)) {
+                context.report({
+                    node,
+                    messageId: 'noClassInstanceSpreadInObject',
+                });
+                return;
+            }
+            if (isClassDeclaration(type)) {
+                context.report({
+                    node,
+                    messageId: 'noClassDeclarationSpreadInObject',
+                });
+            }
+        }
+        return {
+            'ArrayExpression > SpreadElement': checkArrayOrCallSpread,
+            'CallExpression > SpreadElement': checkArrayOrCallSpread,
+            JSXSpreadAttribute: checkObjectSpread,
+            'ObjectExpression > SpreadElement': checkObjectSpread,
+        };
+    },
+});
+function isIterable(type, checker) {
+    return tsutils
+        .typeConstituents(type)
+        .some(t => !!tsutils.getWellKnownSymbolPropertyOfType(t, 'iterator', checker));
+}
+function isArray(checker, type) {
+    return isTypeRecurser(type, t => checker.isArrayType(t) || checker.isTupleType(t));
+}
+function isString(type) {
+    return isTypeRecurser(type, t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.StringLike));
+}
+function isFunctionWithoutProps(type) {
+    return isTypeRecurser(type, t => t.getCallSignatures().length > 0 && t.getProperties().length === 0);
+}
+function isPromise(program, type) {
+    return isTypeRecurser(type, t => (0, util_1.isPromiseLike)(program, t));
+}
+function isClassInstance(checker, type) {
+    return isTypeRecurser(type, t => {
+        // If the type itself has a construct signature, it's a class(-like)
+        if (t.getConstructSignatures().length) {
+            return false;
+        }
+        const symbol = t.getSymbol();
+        // If the type's symbol has a construct signature, the type is an instance
+        return !!symbol
+            ?.getDeclarations()
+            ?.some(declaration => checker
+            .getTypeOfSymbolAtLocation(symbol, declaration)
+            .getConstructSignatures().length);
+    });
+}
+function isClassDeclaration(type) {
+    return isTypeRecurser(type, t => {
+        if (tsutils.isObjectType(t) &&
+            tsutils.isObjectFlagSet(t, ts.ObjectFlags.InstantiationExpressionType)) {
+            return true;
+        }
+        const kind = t.getSymbol()?.valueDeclaration?.kind;
+        return (kind === ts.SyntaxKind.ClassDeclaration ||
+            kind === ts.SyntaxKind.ClassExpression);
+    });
+}
+function isMap(program, type) {
+    return isTypeRecurser(type, t => (0, util_1.isBuiltinSymbolLike)(program, t, ['Map', 'ReadonlyMap', 'WeakMap']));
+}
+function isTypeRecurser(type, predicate) {
+    if (type.isUnionOrIntersection()) {
+        return type.types.some(t => isTypeRecurser(t, predicate));
+    }
+    return predicate(type);
+}

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-mixed-enums.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"mixed", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-mixed-enums.js

@@ -0,0 +1,200 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const scope_manager_1 = require("@typescript-eslint/scope-manager");
+const utils_1 = require("@typescript-eslint/utils");
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+var AllowedType;
+(function (AllowedType) {
+    AllowedType[AllowedType["Number"] = 0] = "Number";
+    AllowedType[AllowedType["String"] = 1] = "String";
+    AllowedType[AllowedType["Unknown"] = 2] = "Unknown";
+})(AllowedType || (AllowedType = {}));
+exports.default = (0, util_1.createRule)({
+    name: 'no-mixed-enums',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow enums from having both number and string members',
+            recommended: 'strict',
+            requiresTypeChecking: true,
+        },
+        messages: {
+            mixed: `Mixing number and string enums can be confusing.`,
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = (0, util_1.getParserServices)(context);
+        const typeChecker = parserServices.program.getTypeChecker();
+        function collectNodeDefinitions(node) {
+            const { name } = node.id;
+            const found = {
+                imports: [],
+                previousSibling: undefined,
+            };
+            let scope = context.sourceCode.getScope(node);
+            for (const definition of scope.upper?.set.get(name)?.defs ?? []) {
+                if (definition.node.type === utils_1.AST_NODE_TYPES.TSEnumDeclaration &&
+                    definition.node.range[0] < node.range[0] &&
+                    definition.node.body.members.length > 0) {
+                    found.previousSibling = definition.node;
+                    break;
+                }
+            }
+            while (scope) {
+                scope.set.get(name)?.defs.forEach(definition => {
+                    if (definition.type === scope_manager_1.DefinitionType.ImportBinding) {
+                        found.imports.push(definition.node);
+                    }
+                });
+                scope = scope.upper;
+            }
+            return found;
+        }
+        function getAllowedTypeForNode(node) {
+            return tsutils.isTypeFlagSet(typeChecker.getTypeAtLocation(node), ts.TypeFlags.StringLike)
+                ? AllowedType.String
+                : AllowedType.Number;
+        }
+        function getTypeFromImported(imported) {
+            const type = typeChecker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(imported));
+            const valueDeclaration = type.getSymbol()?.valueDeclaration;
+            if (!valueDeclaration ||
+                !ts.isEnumDeclaration(valueDeclaration) ||
+                valueDeclaration.members.length === 0) {
+                return undefined;
+            }
+            return getAllowedTypeForNode(valueDeclaration.members[0]);
+        }
+        function getMemberType(member) {
+            if (!member.initializer) {
+                return AllowedType.Number;
+            }
+            switch (member.initializer.type) {
+                case utils_1.AST_NODE_TYPES.Literal:
+                    switch (typeof member.initializer.value) {
+                        case 'number':
+                            return AllowedType.Number;
+                        case 'string':
+                            return AllowedType.String;
+                        default:
+                            return AllowedType.Unknown;
+                    }
+                case utils_1.AST_NODE_TYPES.TemplateLiteral:
+                    return AllowedType.String;
+                default:
+                    return getAllowedTypeForNode(parserServices.esTreeNodeToTSNodeMap.get(member.initializer));
+            }
+        }
+        function getDesiredTypeForDefinition(node) {
+            const { imports, previousSibling } = collectNodeDefinitions(node);
+            // Case: Merged ambiently via module augmentation
+            // import { MyEnum } from 'other-module';
+            // declare module 'other-module' {
+            //   enum MyEnum { A }
+            // }
+            for (const imported of imports) {
+                const typeFromImported = getTypeFromImported(imported);
+                if (typeFromImported != null) {
+                    return typeFromImported;
+                }
+            }
+            // Case: Multiple enum declarations in the same file
+            // enum MyEnum { A }
+            // enum MyEnum { B }
+            if (previousSibling) {
+                return getMemberType(previousSibling.body.members[0]);
+            }
+            // Case: Namespace declaration merging
+            // namespace MyNamespace {
+            //   export enum MyEnum { A }
+            // }
+            // namespace MyNamespace {
+            //   export enum MyEnum { B }
+            // }
+            if (node.parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
+                node.parent.parent.type === utils_1.AST_NODE_TYPES.TSModuleBlock) {
+                // https://github.com/typescript-eslint/typescript-eslint/issues/8352
+                // TODO: We don't need to dip into the TypeScript type checker here!
+                // Merged namespaces must all exist in the same file.
+                // We could instead compare this file's nodes to find the merges.
+                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node.id);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const declarations = typeChecker
+                    .getSymbolAtLocation(tsNode)
+                    .getDeclarations();
+                const [{ initializer }] = declarations[0]
+                    .members;
+                return initializer &&
+                    tsutils.isTypeFlagSet(typeChecker.getTypeAtLocation(initializer), ts.TypeFlags.StringLike)
+                    ? AllowedType.String
+                    : AllowedType.Number;
+            }
+            // Finally, we default to the type of the first enum member
+            return getMemberType(node.body.members[0]);
+        }
+        return {
+            TSEnumDeclaration(node) {
+                if (!node.body.members.length) {
+                    return;
+                }
+                let desiredType = getDesiredTypeForDefinition(node);
+                if (desiredType === ts.TypeFlags.Unknown) {
+                    return;
+                }
+                for (const member of node.body.members) {
+                    const currentType = getMemberType(member);
+                    if (currentType === AllowedType.Unknown) {
+                        return;
+                    }
+                    if (currentType === AllowedType.Number) {
+                        desiredType ??= currentType;
+                    }
+                    if (currentType !== desiredType) {
+                        context.report({
+                            node: member.initializer ?? member,
+                            messageId: 'mixed',
+                        });
+                        return;
+                    }
+                }
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-namespace.d.ts

@@ -0,0 +1,11 @@
+export type Options = [
+    {
+        allowDeclarations?: boolean;
+        allowDefinitionFiles?: boolean;
+    }
+];
+export type MessageIds = 'moduleSyntaxIsPreferred';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"moduleSyntaxIsPreferred", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-namespace.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-namespace',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow TypeScript namespaces',
+            recommended: 'recommended',
+        },
+        messages: {
+            moduleSyntaxIsPreferred: 'ES2015 module syntax is preferred over namespaces.',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allowDeclarations: {
+                        type: 'boolean',
+                        description: 'Whether to allow `declare` with custom TypeScript namespaces.',
+                    },
+                    allowDefinitionFiles: {
+                        type: 'boolean',
+                        description: 'Whether to allow `declare` with custom TypeScript namespaces inside definition files.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowDeclarations: false,
+            allowDefinitionFiles: true,
+        },
+    ],
+    create(context, [{ allowDeclarations, allowDefinitionFiles }]) {
+        function isDeclaration(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration && node.declare) {
+                return true;
+            }
+            return node.parent != null && isDeclaration(node.parent);
+        }
+        return {
+            "TSModuleDeclaration[global!=true][id.type!='Literal']"(node) {
+                if (node.parent.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration ||
+                    (allowDefinitionFiles && (0, util_1.isDefinitionFile)(context.filename)) ||
+                    (allowDeclarations && isDeclaration(node))) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'moduleSyntaxIsPreferred',
+                });
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-nullish-coalescing.d.ts

@@ -0,0 +1,5 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const _default: TSESLint.RuleModule<"noNonNullAssertedNullishCoalescing" | "suggestRemovingNonNull", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-nullish-coalescing.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scope_manager_1 = require("@typescript-eslint/scope-manager");
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+function hasAssignmentBeforeNode(variable, node) {
+    return (variable.references.some(ref => ref.isWrite() && ref.identifier.range[1] < node.range[1]) ||
+        variable.defs.some(def => isDefinitionWithAssignment(def) && def.node.range[1] < node.range[1]));
+}
+function isDefinitionWithAssignment(definition) {
+    if (definition.type !== scope_manager_1.DefinitionType.Variable) {
+        return false;
+    }
+    const variableDeclarator = definition.node;
+    return variableDeclarator.definite || variableDeclarator.init != null;
+}
+exports.default = (0, util_1.createRule)({
+    name: 'no-non-null-asserted-nullish-coalescing',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow non-null assertions in the left operand of a nullish coalescing operator',
+            recommended: 'strict',
+        },
+        hasSuggestions: true,
+        messages: {
+            noNonNullAssertedNullishCoalescing: 'The nullish coalescing operator is designed to handle undefined and null - using a non-null assertion is not needed.',
+            suggestRemovingNonNull: 'Remove the non-null assertion.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            'LogicalExpression[operator = "??"] > TSNonNullExpression.left'(node) {
+                if (node.expression.type === utils_1.TSESTree.AST_NODE_TYPES.Identifier) {
+                    const scope = context.sourceCode.getScope(node);
+                    const identifier = node.expression;
+                    const variable = utils_1.ASTUtils.findVariable(scope, identifier.name);
+                    if (variable && !hasAssignmentBeforeNode(variable, node)) {
+                        return;
+                    }
+                }
+                context.report({
+                    node,
+                    messageId: 'noNonNullAssertedNullishCoalescing',
+                    /*
+                    Use a suggestion instead of a fixer, because this can break type checks.
+                    The resulting type of the nullish coalesce is only influenced by the right operand if the left operand can be `null` or `undefined`.
+                    After removing the non-null assertion the type of the left operand might contain `null` or `undefined` and then the type of the right operand
+                    might change the resulting type of the nullish coalesce.
+                    See the following example:
+          
+                    function test(x?: string): string {
+                      const bar = x! ?? false; // type analysis reports `bar` has type `string`
+                      //          x  ?? false; // type analysis reports `bar` has type `string | false`
+                      return bar;
+                    }
+                    */
+                    suggest: [
+                        {
+                            messageId: 'suggestRemovingNonNull',
+                            fix(fixer) {
+                                const exclamationMark = (0, util_1.nullThrows)(context.sourceCode.getLastToken(node, utils_1.ASTUtils.isNonNullAssertionPunctuator), util_1.NullThrowsReasons.MissingToken('!', 'Non-null Assertion'));
+                                return fixer.remove(exclamationMark);
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-optional-chain.d.ts

@@ -0,0 +1,5 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const _default: TSESLint.RuleModule<"suggestRemovingNonNull" | "noNonNullOptionalChain", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-asserted-optional-chain.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-non-null-asserted-optional-chain',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow non-null assertions after an optional chain expression',
+            recommended: 'recommended',
+        },
+        hasSuggestions: true,
+        messages: {
+            noNonNullOptionalChain: 'Optional chain expressions can return undefined by design - using a non-null assertion is unsafe and wrong.',
+            suggestRemovingNonNull: 'You should remove the non-null assertion.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            // non-nulling a wrapped chain will scrub all nulls introduced by the chain
+            // (x?.y)!
+            // (x?.())!
+            'TSNonNullExpression > ChainExpression'(node) {
+                // selector guarantees this assertion
+                const parent = node.parent;
+                context.report({
+                    node,
+                    messageId: 'noNonNullOptionalChain',
+                    // use a suggestion instead of a fixer, because this can obviously break type checks
+                    suggest: [
+                        {
+                            messageId: 'suggestRemovingNonNull',
+                            fix(fixer) {
+                                return fixer.removeRange([
+                                    parent.range[1] - 1,
+                                    parent.range[1],
+                                ]);
+                            },
+                        },
+                    ],
+                });
+            },
+            // non-nulling at the end of a chain will scrub all nulls introduced by the chain
+            // x?.y!
+            // x?.()!
+            'ChainExpression > TSNonNullExpression'(node) {
+                context.report({
+                    node,
+                    messageId: 'noNonNullOptionalChain',
+                    // use a suggestion instead of a fixer, because this can obviously break type checks
+                    suggest: [
+                        {
+                            messageId: 'suggestRemovingNonNull',
+                            fix(fixer) {
+                                return fixer.removeRange([node.range[1] - 1, node.range[1]]);
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-assertion.d.ts

@@ -0,0 +1,6 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type MessageIds = 'noNonNull' | 'suggestOptionalChain';
+declare const _default: TSESLint.RuleModule<MessageIds, [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-non-null-assertion.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-non-null-assertion',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow non-null assertions using the `!` postfix operator',
+            recommended: 'strict',
+        },
+        hasSuggestions: true,
+        messages: {
+            noNonNull: 'Forbidden non-null assertion.',
+            suggestOptionalChain: 'Consider using the optional chain operator `?.` instead. This operator includes runtime checks, so it is safer than the compile-only non-null assertion operator.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            TSNonNullExpression(node) {
+                const suggest = [];
+                // it always exists in non-null assertion
+                const nonNullOperator = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.expression, util_1.isNonNullAssertionPunctuator), util_1.NullThrowsReasons.MissingToken('!', 'expression'));
+                function replaceTokenWithOptional() {
+                    return fixer => fixer.replaceText(nonNullOperator, '?.');
+                }
+                function removeToken() {
+                    return fixer => fixer.remove(nonNullOperator);
+                }
+                if (node.parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.parent.object === node &&
+                    !(0, util_1.isAssignee)(node.parent)) {
+                    if (!node.parent.optional) {
+                        if (node.parent.computed) {
+                            // it is x![y]?.z
+                            suggest.push({
+                                messageId: 'suggestOptionalChain',
+                                fix: replaceTokenWithOptional(),
+                            });
+                        }
+                        else {
+                            // it is x!.y?.z
+                            suggest.push({
+                                messageId: 'suggestOptionalChain',
+                                fix(fixer) {
+                                    // x!.y?.z
+                                    //   ^ punctuator
+                                    const punctuator = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(nonNullOperator), util_1.NullThrowsReasons.MissingToken('.', '!'));
+                                    return [
+                                        fixer.remove(nonNullOperator),
+                                        fixer.insertTextBefore(punctuator, '?'),
+                                    ];
+                                },
+                            });
+                        }
+                    }
+                    else {
+                        // it is x!?.[y].z or  x!?.y.z
+                        suggest.push({
+                            messageId: 'suggestOptionalChain',
+                            fix: removeToken(),
+                        });
+                    }
+                }
+                else if (node.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    node.parent.callee === node) {
+                    if (!node.parent.optional) {
+                        // it is x.y?.z!()
+                        suggest.push({
+                            messageId: 'suggestOptionalChain',
+                            fix: replaceTokenWithOptional(),
+                        });
+                    }
+                    else {
+                        // it is x.y.z!?.()
+                        suggest.push({
+                            messageId: 'suggestOptionalChain',
+                            fix: removeToken(),
+                        });
+                    }
+                }
+                context.report({
+                    node,
+                    messageId: 'noNonNull',
+                    suggest,
+                });
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redeclare.d.ts

@@ -0,0 +1,12 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type MessageIds = 'redeclared' | 'redeclaredAsBuiltin' | 'redeclaredBySyntax';
+export type Options = [
+    {
+        builtinGlobals?: boolean;
+        ignoreDeclarationMerge?: boolean;
+    }
+];
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redeclare.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scope_manager_1 = require("@typescript-eslint/scope-manager");
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-redeclare',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow variable redeclaration',
+            extendsBaseRule: true,
+        },
+        messages: {
+            redeclared: "'{{id}}' is already defined.",
+            redeclaredAsBuiltin: "'{{id}}' is already defined as a built-in global variable.",
+            redeclaredBySyntax: "'{{id}}' is already defined by a variable declaration.",
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    builtinGlobals: {
+                        type: 'boolean',
+                        description: 'Whether to report shadowing of built-in global variables.',
+                    },
+                    ignoreDeclarationMerge: {
+                        type: 'boolean',
+                        description: 'Whether to ignore declaration merges between certain TypeScript declaration types.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            builtinGlobals: true,
+            ignoreDeclarationMerge: true,
+        },
+    ],
+    create(context, [options]) {
+        const CLASS_DECLARATION_MERGE_NODES = new Set([
+            utils_1.AST_NODE_TYPES.ClassDeclaration,
+            utils_1.AST_NODE_TYPES.TSInterfaceDeclaration,
+            utils_1.AST_NODE_TYPES.TSModuleDeclaration,
+        ]);
+        const FUNCTION_DECLARATION_MERGE_NODES = new Set([
+            utils_1.AST_NODE_TYPES.FunctionDeclaration,
+            utils_1.AST_NODE_TYPES.TSModuleDeclaration,
+        ]);
+        const ENUM_DECLARATION_MERGE_NODES = new Set([
+            utils_1.AST_NODE_TYPES.TSEnumDeclaration,
+            utils_1.AST_NODE_TYPES.TSModuleDeclaration,
+        ]);
+        function* iterateDeclarations(variable) {
+            if (options.builtinGlobals &&
+                'eslintImplicitGlobalSetting' in variable &&
+                (variable.eslintImplicitGlobalSetting === 'readonly' ||
+                    variable.eslintImplicitGlobalSetting === 'writable')) {
+                yield { type: 'builtin' };
+            }
+            if ('eslintExplicitGlobalComments' in variable &&
+                variable.eslintExplicitGlobalComments) {
+                for (const comment of variable.eslintExplicitGlobalComments) {
+                    yield {
+                        loc: (0, util_1.getNameLocationInGlobalDirectiveComment)(context.sourceCode, comment, variable.name),
+                        node: comment,
+                        type: 'comment',
+                    };
+                }
+            }
+            const identifiers = variable.identifiers
+                .map(id => ({
+                identifier: id,
+                parent: id.parent,
+            }))
+                // ignore function declarations because TS will treat them as an overload
+                .filter(({ parent }) => parent.type !== utils_1.AST_NODE_TYPES.TSDeclareFunction);
+            if (options.ignoreDeclarationMerge && identifiers.length > 1) {
+                if (
+                // interfaces merging
+                identifiers.every(({ parent }) => parent.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration)) {
+                    return;
+                }
+                if (
+                // namespace/module merging
+                identifiers.every(({ parent }) => parent.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration)) {
+                    return;
+                }
+                if (
+                // class + interface/namespace merging
+                identifiers.every(({ parent }) => CLASS_DECLARATION_MERGE_NODES.has(parent.type))) {
+                    const classDecls = identifiers.filter(({ parent }) => parent.type === utils_1.AST_NODE_TYPES.ClassDeclaration);
+                    if (classDecls.length === 1) {
+                        // safe declaration merging
+                        return;
+                    }
+                    // there's more than one class declaration, which needs to be reported
+                    for (const { identifier } of classDecls) {
+                        yield { loc: identifier.loc, node: identifier, type: 'syntax' };
+                    }
+                    return;
+                }
+                if (
+                // class + interface/namespace merging
+                identifiers.every(({ parent }) => FUNCTION_DECLARATION_MERGE_NODES.has(parent.type))) {
+                    const functionDecls = identifiers.filter(({ parent }) => parent.type === utils_1.AST_NODE_TYPES.FunctionDeclaration);
+                    if (functionDecls.length === 1) {
+                        // safe declaration merging
+                        return;
+                    }
+                    // there's more than one function declaration, which needs to be reported
+                    for (const { identifier } of functionDecls) {
+                        yield { loc: identifier.loc, node: identifier, type: 'syntax' };
+                    }
+                    return;
+                }
+                if (
+                // enum + namespace merging
+                identifiers.every(({ parent }) => ENUM_DECLARATION_MERGE_NODES.has(parent.type))) {
+                    const enumDecls = identifiers.filter(({ parent }) => parent.type === utils_1.AST_NODE_TYPES.TSEnumDeclaration);
+                    if (enumDecls.length === 1) {
+                        // safe declaration merging
+                        return;
+                    }
+                    // there's more than one enum declaration, which needs to be reported
+                    for (const { identifier } of enumDecls) {
+                        yield { loc: identifier.loc, node: identifier, type: 'syntax' };
+                    }
+                    return;
+                }
+            }
+            for (const { identifier } of identifiers) {
+                yield { loc: identifier.loc, node: identifier, type: 'syntax' };
+            }
+        }
+        function findVariablesInScope(scope) {
+            for (const variable of scope.variables) {
+                const [declaration, ...extraDeclarations] = iterateDeclarations(variable);
+                if (extraDeclarations.length === 0) {
+                    continue;
+                }
+                /*
+                 * If the type of a declaration is different from the type of
+                 * the first declaration, it shows the location of the first
+                 * declaration.
+                 */
+                const detailMessageId = declaration.type === 'builtin'
+                    ? 'redeclaredAsBuiltin'
+                    : 'redeclaredBySyntax';
+                const data = { id: variable.name };
+                // Report extra declarations.
+                for (const { loc, node, type } of extraDeclarations) {
+                    const messageId = type === declaration.type ? 'redeclared' : detailMessageId;
+                    if (node) {
+                        context.report({ loc, node, messageId, data });
+                    }
+                    else if (loc) {
+                        context.report({ loc, messageId, data });
+                    }
+                }
+            }
+        }
+        /**
+         * Find variables in the current scope.
+         */
+        function checkForBlock(node) {
+            const scope = context.sourceCode.getScope(node);
+            /*
+             * In ES5, some node type such as `BlockStatement` doesn't have that scope.
+             * `scope.block` is a different node in such a case.
+             */
+            if (scope.block === node) {
+                findVariablesInScope(scope);
+            }
+        }
+        return {
+            ArrowFunctionExpression: checkForBlock,
+            BlockStatement: checkForBlock,
+            ForInStatement: checkForBlock,
+            ForOfStatement: checkForBlock,
+            ForStatement: checkForBlock,
+            FunctionDeclaration: checkForBlock,
+            FunctionExpression: checkForBlock,
+            Program(node) {
+                const scope = context.sourceCode.getScope(node);
+                findVariablesInScope(scope);
+                // Node.js or ES modules has a special scope.
+                if (scope.type === scope_manager_1.ScopeType.global &&
+                    // The special scope's block is the Program node.
+                    scope.block === scope.childScopes[0]?.block) {
+                    findVariablesInScope(scope.childScopes[0]);
+                }
+            },
+            SwitchStatement: checkForBlock,
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redundant-type-constituents.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"overrides" | "errorTypeOverrides" | "literalOverridden" | "overridden" | "primitiveOverridden", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redundant-type-constituents.js

@@ -0,0 +1,431 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+const literalToPrimitiveTypeFlags = {
+    [ts.TypeFlags.BigIntLiteral]: ts.TypeFlags.BigInt,
+    [ts.TypeFlags.BooleanLiteral]: ts.TypeFlags.Boolean,
+    [ts.TypeFlags.NumberLiteral]: ts.TypeFlags.Number,
+    [ts.TypeFlags.StringLiteral]: ts.TypeFlags.String,
+    [ts.TypeFlags.TemplateLiteral]: ts.TypeFlags.String,
+};
+const literalTypeFlags = [
+    ts.TypeFlags.BigIntLiteral,
+    ts.TypeFlags.BooleanLiteral,
+    ts.TypeFlags.NumberLiteral,
+    ts.TypeFlags.StringLiteral,
+    ts.TypeFlags.TemplateLiteral,
+];
+const primitiveTypeFlags = [
+    ts.TypeFlags.BigInt,
+    ts.TypeFlags.Boolean,
+    ts.TypeFlags.Number,
+    ts.TypeFlags.String,
+];
+const primitiveTypeFlagNames = {
+    [ts.TypeFlags.BigInt]: 'bigint',
+    [ts.TypeFlags.Boolean]: 'boolean',
+    [ts.TypeFlags.Number]: 'number',
+    [ts.TypeFlags.String]: 'string',
+};
+const primitiveTypeFlagTypes = {
+    bigint: ts.TypeFlags.BigIntLiteral,
+    boolean: ts.TypeFlags.BooleanLiteral,
+    number: ts.TypeFlags.NumberLiteral,
+    string: ts.TypeFlags.StringLiteral,
+};
+const keywordNodeTypesToTsTypes = new Map([
+    [utils_1.TSESTree.AST_NODE_TYPES.TSAnyKeyword, ts.TypeFlags.Any],
+    [utils_1.TSESTree.AST_NODE_TYPES.TSBigIntKeyword, ts.TypeFlags.BigInt],
+    [utils_1.TSESTree.AST_NODE_TYPES.TSBooleanKeyword, ts.TypeFlags.Boolean],
+    [utils_1.TSESTree.AST_NODE_TYPES.TSNeverKeyword, ts.TypeFlags.Never],
+    [utils_1.TSESTree.AST_NODE_TYPES.TSNumberKeyword, ts.TypeFlags.Number],
+    [utils_1.TSESTree.AST_NODE_TYPES.TSStringKeyword, ts.TypeFlags.String],
+    [utils_1.TSESTree.AST_NODE_TYPES.TSUnknownKeyword, ts.TypeFlags.Unknown],
+]);
+function addToMapGroup(map, key, value) {
+    const existing = map.get(key);
+    if (existing) {
+        existing.push(value);
+    }
+    else {
+        map.set(key, [value]);
+    }
+}
+function describeLiteralType(type) {
+    if (type.isStringLiteral()) {
+        return JSON.stringify(type.value);
+    }
+    if ((0, util_1.isTypeBigIntLiteralType)(type)) {
+        return `${type.value.negative ? '-' : ''}${type.value.base10Value}n`;
+    }
+    if (type.isLiteral()) {
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        return type.value.toString();
+    }
+    if (tsutils.isIntrinsicErrorType(type) && type.aliasSymbol) {
+        return type.aliasSymbol.escapedName.toString();
+    }
+    if ((0, util_1.isTypeAnyType)(type)) {
+        return 'any';
+    }
+    if ((0, util_1.isTypeNeverType)(type)) {
+        return 'never';
+    }
+    if ((0, util_1.isTypeUnknownType)(type)) {
+        return 'unknown';
+    }
+    if ((0, util_1.isTypeTemplateLiteralType)(type)) {
+        return 'template literal type';
+    }
+    if ((0, util_1.isTypeBigIntLiteralType)(type)) {
+        return `${type.value.negative ? '-' : ''}${type.value.base10Value}n`;
+    }
+    if (tsutils.isTrueLiteralType(type)) {
+        return 'true';
+    }
+    if (tsutils.isFalseLiteralType(type)) {
+        return 'false';
+    }
+    return 'literal type';
+}
+function describeLiteralTypeNode(typeNode) {
+    switch (typeNode.type) {
+        case utils_1.AST_NODE_TYPES.TSAnyKeyword:
+            return 'any';
+        case utils_1.AST_NODE_TYPES.TSBooleanKeyword:
+            return 'boolean';
+        case utils_1.AST_NODE_TYPES.TSNeverKeyword:
+            return 'never';
+        case utils_1.AST_NODE_TYPES.TSNumberKeyword:
+            return 'number';
+        case utils_1.AST_NODE_TYPES.TSStringKeyword:
+            return 'string';
+        case utils_1.AST_NODE_TYPES.TSUnknownKeyword:
+            return 'unknown';
+        case utils_1.AST_NODE_TYPES.TSLiteralType:
+            switch (typeNode.literal.type) {
+                case utils_1.TSESTree.AST_NODE_TYPES.Literal:
+                    switch (typeof typeNode.literal.value) {
+                        case 'bigint':
+                            return `${typeNode.literal.value < 0 ? '-' : ''}${typeNode.literal.value}n`;
+                        case 'string':
+                            return JSON.stringify(typeNode.literal.value);
+                        default:
+                            return `${typeNode.literal.value}`;
+                    }
+                case utils_1.TSESTree.AST_NODE_TYPES.TemplateLiteral:
+                    return 'template literal type';
+            }
+    }
+    return 'literal type';
+}
+function isNodeInsideReturnType(node) {
+    return (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
+        (0, util_1.isFunctionOrFunctionType)(node.parent.parent));
+}
+/**
+ * @remarks TypeScript stores boolean types as the union false | true, always.
+ */
+function unionTypePartsUnlessBoolean(type) {
+    return type.isUnion() &&
+        type.types.length === 2 &&
+        tsutils.isFalseLiteralType(type.types[0]) &&
+        tsutils.isTrueLiteralType(type.types[1])
+        ? [type]
+        : tsutils.unionConstituents(type);
+}
+exports.default = (0, util_1.createRule)({
+    name: 'no-redundant-type-constituents',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow members of unions and intersections that do nothing or override type information',
+            recommended: 'recommended',
+            requiresTypeChecking: true,
+        },
+        messages: {
+            errorTypeOverrides: `'{{typeName}}' is an 'error' type that acts as 'any' and overrides all other types in this {{container}} type.`,
+            literalOverridden: `{{literal}} is overridden by {{primitive}} in this union type.`,
+            overridden: `'{{typeName}}' is overridden by other types in this {{container}} type.`,
+            overrides: `'{{typeName}}' overrides all other types in this {{container}} type.`,
+            primitiveOverridden: `{{primitive}} is overridden by the {{literal}} in this intersection type.`,
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = (0, util_1.getParserServices)(context);
+        const typesCache = new Map();
+        function getTypeNodeTypePartFlags(typeNode) {
+            const keywordTypeFlags = keywordNodeTypesToTsTypes.get(typeNode.type);
+            if (keywordTypeFlags) {
+                return [
+                    {
+                        typeFlags: keywordTypeFlags,
+                        typeName: describeLiteralTypeNode(typeNode),
+                    },
+                ];
+            }
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
+                typeNode.literal.type === utils_1.AST_NODE_TYPES.Literal) {
+                return [
+                    {
+                        typeFlags: primitiveTypeFlagTypes[typeof typeNode.literal
+                            .value],
+                        typeName: describeLiteralTypeNode(typeNode),
+                    },
+                ];
+            }
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+                return typeNode.types.flatMap(getTypeNodeTypePartFlags);
+            }
+            const nodeType = services.getTypeAtLocation(typeNode);
+            const typeParts = unionTypePartsUnlessBoolean(nodeType);
+            return typeParts.map(typePart => ({
+                typeFlags: typePart.flags,
+                typeName: describeLiteralType(typePart),
+            }));
+        }
+        function getTypeNodeTypePartFlagsCached(typeNode) {
+            const existing = typesCache.get(typeNode);
+            if (existing) {
+                return existing;
+            }
+            const created = getTypeNodeTypePartFlags(typeNode);
+            typesCache.set(typeNode, created);
+            return created;
+        }
+        return {
+            'TSIntersectionType:exit'(node) {
+                const seenLiteralTypes = new Map();
+                const seenPrimitiveTypes = new Map();
+                const seenUnionTypes = new Map();
+                function checkIntersectionBottomAndTopTypes({ typeFlags, typeName }, typeNode) {
+                    for (const [messageId, checkFlag] of [
+                        ['overrides', ts.TypeFlags.Any],
+                        ['overrides', ts.TypeFlags.Never],
+                        ['overridden', ts.TypeFlags.Unknown],
+                    ]) {
+                        if (typeFlags === checkFlag) {
+                            context.report({
+                                node: typeNode,
+                                messageId: typeFlags === ts.TypeFlags.Any && typeName !== 'any'
+                                    ? 'errorTypeOverrides'
+                                    : messageId,
+                                data: {
+                                    container: 'intersection',
+                                    typeName,
+                                },
+                            });
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+                for (const typeNode of node.types) {
+                    const typePartFlags = getTypeNodeTypePartFlagsCached(typeNode);
+                    for (const typePart of typePartFlags) {
+                        if (checkIntersectionBottomAndTopTypes(typePart, typeNode)) {
+                            continue;
+                        }
+                        for (const literalTypeFlag of literalTypeFlags) {
+                            if (typePart.typeFlags === literalTypeFlag) {
+                                addToMapGroup(seenLiteralTypes, literalToPrimitiveTypeFlags[literalTypeFlag], typePart.typeName);
+                                break;
+                            }
+                        }
+                        for (const primitiveTypeFlag of primitiveTypeFlags) {
+                            if (typePart.typeFlags === primitiveTypeFlag) {
+                                addToMapGroup(seenPrimitiveTypes, primitiveTypeFlag, typeNode);
+                            }
+                        }
+                    }
+                    // if any typeNode is TSTypeReference and typePartFlags have more than 1 element, than the referenced type is definitely a union.
+                    if (typePartFlags.length >= 2) {
+                        seenUnionTypes.set(typeNode, typePartFlags);
+                    }
+                }
+                /**
+                 * @example
+                 * ```ts
+                 * type F = "a"|2|"b";
+                 * type I = F & string;
+                 * ```
+                 * This function checks if all the union members of `F` are assignable to the other member of `I`. If every member is assignable, then its reported else not.
+                 */
+                const checkIfUnionsAreAssignable = () => {
+                    for (const [typeRef, typeValues] of seenUnionTypes) {
+                        let primitive = undefined;
+                        for (const { typeFlags } of typeValues) {
+                            if (seenPrimitiveTypes.has(literalToPrimitiveTypeFlags[typeFlags])) {
+                                primitive =
+                                    literalToPrimitiveTypeFlags[typeFlags];
+                            }
+                            else {
+                                primitive = undefined;
+                                break;
+                            }
+                        }
+                        if (Number.isInteger(primitive)) {
+                            context.report({
+                                node: typeRef,
+                                messageId: 'primitiveOverridden',
+                                data: {
+                                    literal: typeValues.map(name => name.typeName).join(' | '),
+                                    primitive: primitiveTypeFlagNames[primitive],
+                                },
+                            });
+                        }
+                    }
+                };
+                if (seenUnionTypes.size > 0) {
+                    checkIfUnionsAreAssignable();
+                    return;
+                }
+                // For each primitive type of all the seen primitive types,
+                // if there was a literal type seen that overrides it,
+                // report each of the primitive type's type nodes
+                for (const [primitiveTypeFlag, typeNodes] of seenPrimitiveTypes) {
+                    const matchedLiteralTypes = seenLiteralTypes.get(primitiveTypeFlag);
+                    if (matchedLiteralTypes) {
+                        for (const typeNode of typeNodes) {
+                            context.report({
+                                node: typeNode,
+                                messageId: 'primitiveOverridden',
+                                data: {
+                                    literal: matchedLiteralTypes.join(' | '),
+                                    primitive: primitiveTypeFlagNames[primitiveTypeFlag],
+                                },
+                            });
+                        }
+                    }
+                }
+            },
+            'TSUnionType:exit'(node) {
+                const seenLiteralTypes = new Map();
+                const seenPrimitiveTypes = new Set();
+                function checkUnionBottomAndTopTypes({ typeFlags, typeName }, typeNode) {
+                    for (const checkFlag of [
+                        ts.TypeFlags.Any,
+                        ts.TypeFlags.Unknown,
+                    ]) {
+                        if (typeFlags === checkFlag) {
+                            context.report({
+                                node: typeNode,
+                                messageId: typeFlags === ts.TypeFlags.Any && typeName !== 'any'
+                                    ? 'errorTypeOverrides'
+                                    : 'overrides',
+                                data: {
+                                    container: 'union',
+                                    typeName,
+                                },
+                            });
+                            return true;
+                        }
+                    }
+                    if (typeFlags === ts.TypeFlags.Never &&
+                        !isNodeInsideReturnType(node)) {
+                        context.report({
+                            node: typeNode,
+                            messageId: 'overridden',
+                            data: {
+                                container: 'union',
+                                typeName: 'never',
+                            },
+                        });
+                        return true;
+                    }
+                    return false;
+                }
+                for (const typeNode of node.types) {
+                    const typePartFlags = getTypeNodeTypePartFlagsCached(typeNode);
+                    for (const typePart of typePartFlags) {
+                        if (checkUnionBottomAndTopTypes(typePart, typeNode)) {
+                            continue;
+                        }
+                        for (const literalTypeFlag of literalTypeFlags) {
+                            if (typePart.typeFlags === literalTypeFlag) {
+                                addToMapGroup(seenLiteralTypes, literalToPrimitiveTypeFlags[literalTypeFlag], {
+                                    literalValue: typePart.typeName,
+                                    typeNode,
+                                });
+                                break;
+                            }
+                        }
+                        for (const primitiveTypeFlag of primitiveTypeFlags) {
+                            if ((typePart.typeFlags & primitiveTypeFlag) !== 0) {
+                                seenPrimitiveTypes.add(primitiveTypeFlag);
+                            }
+                        }
+                    }
+                }
+                const overriddenTypeNodes = new Map();
+                // For each primitive type of all the seen literal types,
+                // if there was a primitive type seen that overrides it,
+                // upsert the literal text and primitive type under the backing type node
+                for (const [primitiveTypeFlag, typeNodesWithText] of seenLiteralTypes) {
+                    if (seenPrimitiveTypes.has(primitiveTypeFlag)) {
+                        for (const { literalValue, typeNode } of typeNodesWithText) {
+                            addToMapGroup(overriddenTypeNodes, typeNode, {
+                                literalValue,
+                                primitiveTypeFlag,
+                            });
+                        }
+                    }
+                }
+                // For each type node that had at least one overridden literal,
+                // group those literals by their primitive type,
+                // then report each primitive type with all its literals
+                for (const [typeNode, typeFlagsWithText] of overriddenTypeNodes) {
+                    const grouped = (0, util_1.arrayGroupByToMap)(typeFlagsWithText, pair => pair.primitiveTypeFlag);
+                    for (const [primitiveTypeFlag, pairs] of grouped) {
+                        context.report({
+                            node: typeNode,
+                            messageId: 'literalOverridden',
+                            data: {
+                                literal: pairs.map(pair => pair.literalValue).join(' | '),
+                                primitive: primitiveTypeFlagNames[primitiveTypeFlag],
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-require-imports.d.ts

@@ -0,0 +1,11 @@
+export type Options = [
+    {
+        allow?: string[];
+        allowAsImport?: boolean;
+    }
+];
+export type MessageIds = 'noRequireImports';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRequireImports", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-require-imports.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'no-require-imports',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow invocation of `require()`',
+            recommended: 'recommended',
+        },
+        messages: {
+            noRequireImports: 'A `require()` style import is forbidden.',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allow: {
+                        type: 'array',
+                        description: 'Patterns of import paths to allow requiring from.',
+                        items: { type: 'string' },
+                    },
+                    allowAsImport: {
+                        type: 'boolean',
+                        description: 'Allows `require` statements in import declarations.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [{ allow: [], allowAsImport: false }],
+    create(context, options) {
+        const allowAsImport = options[0].allowAsImport;
+        const allowPatterns = options[0].allow?.map(pattern => new RegExp(pattern, 'u'));
+        function isImportPathAllowed(importPath) {
+            return allowPatterns?.some(pattern => importPath.match(pattern));
+        }
+        function isStringOrTemplateLiteral(node) {
+            return ((node.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.value === 'string') ||
+                node.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
+        }
+        return {
+            'CallExpression[callee.name="require"]'(node) {
+                if (node.arguments[0] && isStringOrTemplateLiteral(node.arguments[0])) {
+                    const argValue = util.getStaticStringValue(node.arguments[0]);
+                    if (typeof argValue === 'string' && isImportPathAllowed(argValue)) {
+                        return;
+                    }
+                }
+                const variable = utils_1.ASTUtils.findVariable(context.sourceCode.getScope(node), 'require');
+                // ignore non-global require usage as it's something user-land custom instead
+                // of the commonjs standard
+                if (!variable?.identifiers.length) {
+                    context.report({
+                        node,
+                        messageId: 'noRequireImports',
+                    });
+                }
+            },
+            TSExternalModuleReference(node) {
+                if (isStringOrTemplateLiteral(node.expression)) {
+                    const argValue = util.getStaticStringValue(node.expression);
+                    if (typeof argValue === 'string' && isImportPathAllowed(argValue)) {
+                        return;
+                    }
+                }
+                if (allowAsImport &&
+                    node.parent.type === utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'noRequireImports',
+                });
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-imports.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayOfStringOrObject, RuleListener } from 'eslint/lib/rules/no-restricted-imports';
+import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util';
+declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patterns" | "patternWithCustomMessage", [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns] | ArrayOfStringOrObject, unknown, RuleListener>;
+export type Options = InferOptionsTypeFromRule<typeof baseRule>;
+export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patterns" | "patternWithCustomMessage", [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns] | ArrayOfStringOrObject, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-imports.js

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const ignore_1 = __importDefault(require("ignore"));
+const util_1 = require("../util");
+const getESLintCoreRule_1 = require("../util/getESLintCoreRule");
+const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('no-restricted-imports');
+// In some versions of eslint, the base rule has a completely incompatible schema
+// This helper function is to safely try to get parts of the schema. If it's not
+// possible, we'll fallback to less strict checks.
+const tryAccess = (getter, fallback) => {
+    try {
+        return getter();
+    }
+    catch {
+        return fallback;
+    }
+};
+const baseSchema = baseRule.meta.schema;
+const allowTypeImportsOptionSchema = {
+    allowTypeImports: {
+        type: 'boolean',
+        description: 'Whether to allow type-only imports for a path.',
+    },
+};
+const arrayOfStringsOrObjects = {
+    type: 'array',
+    items: {
+        anyOf: [
+            { type: 'string' },
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    ...tryAccess(() => baseSchema.anyOf[1].items[0].properties.paths.items.anyOf[1]
+                        .properties, undefined),
+                    ...allowTypeImportsOptionSchema,
+                },
+                required: tryAccess(() => baseSchema.anyOf[1].items[0].properties.paths.items.anyOf[1]
+                    .required, undefined),
+            },
+        ],
+    },
+    uniqueItems: true,
+};
+const arrayOfStringsOrObjectPatterns = {
+    anyOf: [
+        {
+            type: 'array',
+            items: {
+                type: 'string',
+            },
+            uniqueItems: true,
+        },
+        {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    ...tryAccess(() => baseSchema.anyOf[1].items[0].properties.patterns.anyOf[1].items
+                        .properties, undefined),
+                    ...allowTypeImportsOptionSchema,
+                },
+                required: tryAccess(() => baseSchema.anyOf[1].items[0].properties.patterns.anyOf[1].items
+                    .required, []),
+            },
+            uniqueItems: true,
+        },
+    ],
+};
+const schema = {
+    anyOf: [
+        arrayOfStringsOrObjects,
+        {
+            type: 'array',
+            additionalItems: false,
+            items: [
+                {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        paths: arrayOfStringsOrObjects,
+                        patterns: arrayOfStringsOrObjectPatterns,
+                    },
+                },
+            ],
+        },
+    ],
+};
+function isObjectOfPaths(obj) {
+    return !!obj && Object.hasOwn(obj, 'paths');
+}
+function isObjectOfPatterns(obj) {
+    return !!obj && Object.hasOwn(obj, 'patterns');
+}
+function isOptionsArrayOfStringOrObject(options) {
+    if (isObjectOfPaths(options[0])) {
+        return false;
+    }
+    if (isObjectOfPatterns(options[0])) {
+        return false;
+    }
+    return true;
+}
+function getRestrictedPaths(options) {
+    if (isOptionsArrayOfStringOrObject(options)) {
+        return options;
+    }
+    if (isObjectOfPaths(options[0])) {
+        return options[0].paths;
+    }
+    return [];
+}
+function getRestrictedPatterns(options) {
+    if (isObjectOfPatterns(options[0])) {
+        return options[0].patterns;
+    }
+    return [];
+}
+function shouldCreateRule(baseRules, options) {
+    if (Object.keys(baseRules).length === 0 || options.length === 0) {
+        return false;
+    }
+    if (!isOptionsArrayOfStringOrObject(options)) {
+        return !!(options[0].paths?.length || options[0].patterns?.length);
+    }
+    return true;
+}
+exports.default = (0, util_1.createRule)({
+    name: 'no-restricted-imports',
+    meta: {
+        type: 'suggestion',
+        // defaultOptions, -- base rule does not use defaultOptions
+        docs: {
+            description: 'Disallow specified modules when loaded by `import`',
+            extendsBaseRule: true,
+        },
+        fixable: baseRule.meta.fixable,
+        messages: baseRule.meta.messages,
+        schema,
+    },
+    defaultOptions: [],
+    create(context) {
+        const rules = baseRule.create(context);
+        const { options } = context;
+        if (!shouldCreateRule(rules, options)) {
+            return {};
+        }
+        const restrictedPaths = getRestrictedPaths(options);
+        const allowedTypeImportPathNameSet = new Set();
+        for (const restrictedPath of restrictedPaths) {
+            if (typeof restrictedPath === 'object' &&
+                restrictedPath.allowTypeImports) {
+                allowedTypeImportPathNameSet.add(restrictedPath.name);
+            }
+        }
+        function isAllowedTypeImportPath(importSource) {
+            return allowedTypeImportPathNameSet.has(importSource);
+        }
+        const restrictedPatterns = getRestrictedPatterns(options);
+        const allowedImportTypeMatchers = [];
+        const allowedImportTypeRegexMatchers = [];
+        for (const restrictedPattern of restrictedPatterns) {
+            if (typeof restrictedPattern === 'object' &&
+                restrictedPattern.allowTypeImports) {
+                // Following how ignore is configured in the base rule
+                if (restrictedPattern.group) {
+                    allowedImportTypeMatchers.push((0, ignore_1.default)({
+                        allowRelativePaths: true,
+                        ignoreCase: !restrictedPattern.caseSensitive,
+                    }).add(restrictedPattern.group));
+                }
+                if (restrictedPattern.regex) {
+                    allowedImportTypeRegexMatchers.push(new RegExp(restrictedPattern.regex, restrictedPattern.caseSensitive ? 'u' : 'iu'));
+                }
+            }
+        }
+        function isAllowedTypeImportPattern(importSource) {
+            return (
+            // As long as there's one matching pattern that allows type import
+            allowedImportTypeMatchers.some(matcher => matcher.ignores(importSource)) ||
+                allowedImportTypeRegexMatchers.some(regex => regex.test(importSource)));
+        }
+        function checkImportNode(node) {
+            if (node.importKind === 'type' ||
+                (node.specifiers.length > 0 &&
+                    node.specifiers.every(specifier => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        specifier.importKind === 'type'))) {
+                const importSource = node.source.value.trim();
+                if (!isAllowedTypeImportPath(importSource) &&
+                    !isAllowedTypeImportPattern(importSource)) {
+                    return rules.ImportDeclaration(node);
+                }
+            }
+            else {
+                return rules.ImportDeclaration(node);
+            }
+        }
+        return {
+            ExportAllDeclaration: rules.ExportAllDeclaration,
+            'ExportNamedDeclaration[source]'(node) {
+                if (node.exportKind === 'type' ||
+                    (node.specifiers.length > 0 &&
+                        node.specifiers.every(specifier => specifier.exportKind === 'type'))) {
+                    const importSource = node.source.value.trim();
+                    if (!isAllowedTypeImportPath(importSource) &&
+                        !isAllowedTypeImportPattern(importSource)) {
+                        return rules.ExportNamedDeclaration(node);
+                    }
+                }
+                else {
+                    return rules.ExportNamedDeclaration(node);
+                }
+            },
+            ImportDeclaration: checkImportNode,
+            TSImportEqualsDeclaration(node) {
+                if (node.moduleReference.type === utils_1.AST_NODE_TYPES.TSExternalModuleReference) {
+                    const synthesizedImport = {
+                        ...node,
+                        type: utils_1.AST_NODE_TYPES.ImportDeclaration,
+                        assertions: [],
+                        attributes: [],
+                        source: node.moduleReference.expression,
+                        specifiers: [
+                            {
+                                ...node.id,
+                                type: utils_1.AST_NODE_TYPES.ImportDefaultSpecifier,
+                                local: node.id,
+                                // @ts-expect-error -- parent types are incompatible but it's fine for the purposes of this extension
+                                parent: node.id.parent,
+                            },
+                        ],
+                    };
+                    return checkImportNode(synthesizedImport);
+                }
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-types.d.ts

@@ -0,0 +1,16 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+type Types = Record<string, boolean | string | {
+    fixWith?: string;
+    message: string;
+    suggest?: readonly string[];
+} | null>;
+export type Options = [
+    {
+        types?: Types;
+    }
+];
+export type MessageIds = 'bannedTypeMessage' | 'bannedTypeReplacement';
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-restricted-types.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+function removeSpaces(str) {
+    return str.replaceAll(/\s/g, '');
+}
+function stringifyNode(node, sourceCode) {
+    return removeSpaces(sourceCode.getText(node));
+}
+function getCustomMessage(bannedType) {
+    if (!bannedType || bannedType === true) {
+        return '';
+    }
+    if (typeof bannedType === 'string') {
+        return ` ${bannedType}`;
+    }
+    if (bannedType.message) {
+        return ` ${bannedType.message}`;
+    }
+    return '';
+}
+const TYPE_KEYWORDS = {
+    bigint: utils_1.AST_NODE_TYPES.TSBigIntKeyword,
+    boolean: utils_1.AST_NODE_TYPES.TSBooleanKeyword,
+    never: utils_1.AST_NODE_TYPES.TSNeverKeyword,
+    null: utils_1.AST_NODE_TYPES.TSNullKeyword,
+    number: utils_1.AST_NODE_TYPES.TSNumberKeyword,
+    object: utils_1.AST_NODE_TYPES.TSObjectKeyword,
+    string: utils_1.AST_NODE_TYPES.TSStringKeyword,
+    symbol: utils_1.AST_NODE_TYPES.TSSymbolKeyword,
+    undefined: utils_1.AST_NODE_TYPES.TSUndefinedKeyword,
+    unknown: utils_1.AST_NODE_TYPES.TSUnknownKeyword,
+    void: utils_1.AST_NODE_TYPES.TSVoidKeyword,
+};
+exports.default = (0, util_1.createRule)({
+    name: 'no-restricted-types',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow certain types',
+        },
+        fixable: 'code',
+        hasSuggestions: true,
+        messages: {
+            bannedTypeMessage: "Don't use `{{name}}` as a type.{{customMessage}}",
+            bannedTypeReplacement: 'Replace `{{name}}` with `{{replacement}}`.',
+        },
+        schema: [
+            {
+                type: 'object',
+                $defs: {
+                    banConfig: {
+                        oneOf: [
+                            {
+                                type: 'boolean',
+                                description: 'Bans the type with the default message.',
+                                enum: [true],
+                            },
+                            {
+                                type: 'string',
+                                description: 'Bans the type with a custom message.',
+                            },
+                            {
+                                type: 'object',
+                                additionalProperties: false,
+                                description: 'Bans a type.',
+                                properties: {
+                                    fixWith: {
+                                        type: 'string',
+                                        description: 'Type to autofix replace with. Note that autofixers can be applied automatically - so you need to be careful with this option.',
+                                    },
+                                    message: {
+                                        type: 'string',
+                                        description: 'Custom error message.',
+                                    },
+                                    suggest: {
+                                        type: 'array',
+                                        description: 'Types to suggest replacing with.',
+                                        items: { type: 'string' },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+                additionalProperties: false,
+                properties: {
+                    types: {
+                        type: 'object',
+                        additionalProperties: {
+                            $ref: '#/items/0/$defs/banConfig',
+                        },
+                        description: 'An object whose keys are the types you want to ban, and the values are error messages.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [{}],
+    create(context, [{ types = {} }]) {
+        const bannedTypes = new Map(Object.entries(types).map(([type, data]) => [removeSpaces(type), data]));
+        function checkBannedTypes(typeNode, name = stringifyNode(typeNode, context.sourceCode)) {
+            const bannedType = bannedTypes.get(name);
+            if (bannedType == null || bannedType === false) {
+                return;
+            }
+            const customMessage = getCustomMessage(bannedType);
+            const fixWith = bannedType && typeof bannedType === 'object' && bannedType.fixWith;
+            const suggest = bannedType && typeof bannedType === 'object'
+                ? bannedType.suggest
+                : undefined;
+            context.report({
+                node: typeNode,
+                messageId: 'bannedTypeMessage',
+                data: {
+                    name,
+                    customMessage,
+                },
+                fix: fixWith
+                    ? (fixer) => fixer.replaceText(typeNode, fixWith)
+                    : null,
+                suggest: suggest?.map(replacement => ({
+                    messageId: 'bannedTypeReplacement',
+                    data: {
+                        name,
+                        replacement,
+                    },
+                    fix: (fixer) => fixer.replaceText(typeNode, replacement),
+                })),
+            });
+        }
+        const keywordSelectors = (0, util_1.objectReduceKey)(TYPE_KEYWORDS, (acc, keyword) => {
+            if (bannedTypes.has(keyword)) {
+                acc[TYPE_KEYWORDS[keyword]] = (node) => checkBannedTypes(node, keyword);
+            }
+            return acc;
+        }, {});
+        return {
+            ...keywordSelectors,
+            TSClassImplements(node) {
+                checkBannedTypes(node.expression);
+                if (node.typeArguments) {
+                    checkBannedTypes(node);
+                }
+            },
+            TSInterfaceHeritage(node) {
+                checkBannedTypes(node.expression);
+                if (node.typeArguments) {
+                    checkBannedTypes(node);
+                }
+            },
+            TSTupleType(node) {
+                if (!node.elementTypes.length) {
+                    checkBannedTypes(node);
+                }
+            },
+            TSTypeLiteral(node) {
+                if (!node.members.length) {
+                    checkBannedTypes(node);
+                }
+            },
+            TSTypeReference(node) {
+                checkBannedTypes(node.typeName);
+                if (node.typeArguments) {
+                    checkBannedTypes(node);
+                }
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-shadow.d.ts

@@ -0,0 +1,16 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type MessageIds = 'noShadow' | 'noShadowGlobal';
+export type Options = [
+    {
+        allow?: string[];
+        builtinGlobals?: boolean;
+        hoist?: 'all' | 'functions' | 'functions-and-types' | 'never' | 'types';
+        ignoreFunctionTypeParameterNameValueShadow?: boolean;
+        ignoreOnInitialization?: boolean;
+        ignoreTypeValueShadow?: boolean;
+    }
+];
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-shadow.js

@@ -0,0 +1,551 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scope_manager_1 = require("@typescript-eslint/scope-manager");
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+const isTypeImport_1 = require("../util/isTypeImport");
+const allowedFunctionVariableDefTypes = new Set([
+    utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration,
+    utils_1.AST_NODE_TYPES.TSFunctionType,
+    utils_1.AST_NODE_TYPES.TSMethodSignature,
+    utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression,
+    utils_1.AST_NODE_TYPES.TSDeclareFunction,
+    utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration,
+    utils_1.AST_NODE_TYPES.TSConstructorType,
+]);
+const functionsHoistedNodes = new Set([utils_1.AST_NODE_TYPES.FunctionDeclaration]);
+const typesHoistedNodes = new Set([
+    utils_1.AST_NODE_TYPES.TSInterfaceDeclaration,
+    utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration,
+]);
+exports.default = (0, util_1.createRule)({
+    name: 'no-shadow',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow variable declarations from shadowing variables declared in the outer scope',
+            extendsBaseRule: true,
+        },
+        messages: {
+            noShadow: "'{{name}}' is already declared in the upper scope on line {{shadowedLine}} column {{shadowedColumn}}.",
+            noShadowGlobal: "'{{name}}' is already a global variable.",
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allow: {
+                        type: 'array',
+                        description: 'Identifier names for which shadowing is allowed.',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                    builtinGlobals: {
+                        type: 'boolean',
+                        description: 'Whether to report shadowing of built-in global variables.',
+                    },
+                    hoist: {
+                        type: 'string',
+                        description: 'Whether to report shadowing before outer functions or variables are defined.',
+                        enum: ['all', 'functions', 'functions-and-types', 'never', 'types'],
+                    },
+                    ignoreFunctionTypeParameterNameValueShadow: {
+                        type: 'boolean',
+                        description: 'Whether to ignore function parameters named the same as a variable.',
+                    },
+                    ignoreOnInitialization: {
+                        type: 'boolean',
+                        description: 'Whether to ignore the variable initializers when the shadowed variable is presumably still unitialized.',
+                    },
+                    ignoreTypeValueShadow: {
+                        type: 'boolean',
+                        description: 'Whether to ignore types named the same as a variable.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allow: [],
+            builtinGlobals: false,
+            hoist: 'functions-and-types',
+            ignoreFunctionTypeParameterNameValueShadow: true,
+            ignoreOnInitialization: false,
+            ignoreTypeValueShadow: true,
+        },
+    ],
+    create(context, [options]) {
+        /**
+         * Check if a scope is a TypeScript module augmenting the global namespace.
+         */
+        function isGlobalAugmentation(scope) {
+            return ((scope.type === scope_manager_1.ScopeType.tsModule && scope.block.kind === 'global') ||
+                (!!scope.upper && isGlobalAugmentation(scope.upper)));
+        }
+        /**
+         * Check if variable is a `this` parameter.
+         */
+        function isThisParam(variable) {
+            return (variable.defs[0].type === scope_manager_1.DefinitionType.Parameter &&
+                variable.name === 'this');
+        }
+        function isTypeValueShadow(variable, shadowed) {
+            if (options.ignoreTypeValueShadow !== true) {
+                return false;
+            }
+            if (!('isValueVariable' in variable)) {
+                // this shouldn't happen...
+                return false;
+            }
+            const firstDefinition = shadowed.defs.at(0);
+            const isShadowedValue = !('isValueVariable' in shadowed) ||
+                !firstDefinition ||
+                (!(0, isTypeImport_1.isTypeImport)(firstDefinition) && shadowed.isValueVariable);
+            return variable.isValueVariable !== isShadowedValue;
+        }
+        function isFunctionTypeParameterNameValueShadow(variable, shadowed) {
+            if (options.ignoreFunctionTypeParameterNameValueShadow !== true) {
+                return false;
+            }
+            if (!('isValueVariable' in variable)) {
+                // this shouldn't happen...
+                return false;
+            }
+            const isShadowedValue = 'isValueVariable' in shadowed ? shadowed.isValueVariable : true;
+            if (!isShadowedValue) {
+                return false;
+            }
+            return variable.defs.every(def => allowedFunctionVariableDefTypes.has(def.node.type));
+        }
+        function isGenericOfStaticMethod(variable) {
+            if (!('isTypeVariable' in variable)) {
+                // this shouldn't happen...
+                return false;
+            }
+            if (!variable.isTypeVariable) {
+                return false;
+            }
+            if (variable.identifiers.length === 0) {
+                return false;
+            }
+            const typeParameter = variable.identifiers[0].parent;
+            if (typeParameter.type !== utils_1.AST_NODE_TYPES.TSTypeParameter) {
+                return false;
+            }
+            const typeParameterDecl = typeParameter.parent;
+            if (typeParameterDecl.type !== utils_1.AST_NODE_TYPES.TSTypeParameterDeclaration) {
+                return false;
+            }
+            const functionExpr = typeParameterDecl.parent;
+            if (functionExpr.type !== utils_1.AST_NODE_TYPES.FunctionExpression &&
+                functionExpr.type !== utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) {
+                return false;
+            }
+            const methodDefinition = functionExpr.parent;
+            if (methodDefinition.type !== utils_1.AST_NODE_TYPES.MethodDefinition) {
+                return false;
+            }
+            return methodDefinition.static;
+        }
+        function isGenericOfClass(variable) {
+            if (!('isTypeVariable' in variable)) {
+                // this shouldn't happen...
+                return false;
+            }
+            if (!variable.isTypeVariable) {
+                return false;
+            }
+            if (variable.identifiers.length === 0) {
+                return false;
+            }
+            const typeParameter = variable.identifiers[0].parent;
+            if (typeParameter.type !== utils_1.AST_NODE_TYPES.TSTypeParameter) {
+                return false;
+            }
+            const typeParameterDecl = typeParameter.parent;
+            if (typeParameterDecl.type !== utils_1.AST_NODE_TYPES.TSTypeParameterDeclaration) {
+                return false;
+            }
+            const classDecl = typeParameterDecl.parent;
+            return (classDecl.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+                classDecl.type === utils_1.AST_NODE_TYPES.ClassExpression);
+        }
+        function isGenericOfAStaticMethodShadow(variable, shadowed) {
+            return isGenericOfStaticMethod(variable) && isGenericOfClass(shadowed);
+        }
+        function isImportDeclaration(definition) {
+            return definition.type === utils_1.AST_NODE_TYPES.ImportDeclaration;
+        }
+        function isExternalModuleDeclarationWithName(scope, name) {
+            return (scope.type === scope_manager_1.ScopeType.tsModule &&
+                scope.block.id.type === utils_1.AST_NODE_TYPES.Literal &&
+                scope.block.id.value === name);
+        }
+        function isExternalDeclarationMerging(scope, variable, shadowed) {
+            const [firstDefinition] = shadowed.defs;
+            const [secondDefinition] = variable.defs;
+            return ((0, isTypeImport_1.isTypeImport)(firstDefinition) &&
+                isImportDeclaration(firstDefinition.parent) &&
+                isExternalModuleDeclarationWithName(scope, firstDefinition.parent.source.value) &&
+                (secondDefinition.node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration ||
+                    secondDefinition.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration));
+        }
+        /**
+         * Check if variable name is allowed.
+         * @param variable The variable to check.
+         * @returns Whether or not the variable name is allowed.
+         */
+        function isAllowed(variable) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            return options.allow.includes(variable.name);
+        }
+        /**
+         * Checks if a variable of the class name in the class scope of ClassDeclaration.
+         *
+         * ClassDeclaration creates two variables of its name into its outer scope and its class scope.
+         * So we should ignore the variable in the class scope.
+         * @param variable The variable to check.
+         * @returns Whether or not the variable of the class name in the class scope of ClassDeclaration.
+         */
+        function isDuplicatedClassNameVariable(variable) {
+            const block = variable.scope.block;
+            return (block.type === utils_1.AST_NODE_TYPES.ClassDeclaration &&
+                block.id === variable.identifiers[0]);
+        }
+        /**
+         * Checks if a variable of the class name in the class scope of TSEnumDeclaration.
+         *
+         * TSEnumDeclaration creates two variables of its name into its outer scope and its class scope.
+         * So we should ignore the variable in the class scope.
+         * @param variable The variable to check.
+         * @returns Whether or not the variable of the class name in the class scope of TSEnumDeclaration.
+         */
+        function isDuplicatedEnumNameVariable(variable) {
+            const block = variable.scope.block;
+            return (block.type === utils_1.AST_NODE_TYPES.TSEnumDeclaration &&
+                block.id === variable.identifiers[0]);
+        }
+        /**
+         * Checks whether or not a given location is inside of the range of a given node.
+         * @param node An node to check.
+         * @param location A location to check.
+         * @returns `true` if the location is inside of the range of the node.
+         */
+        function isInRange(node, location) {
+            return node && node.range[0] <= location && location <= node.range[1];
+        }
+        /**
+         * Searches from the current node through its ancestry to find a matching node.
+         * @param node a node to get.
+         * @param match a callback that checks whether or not the node verifies its condition or not.
+         * @returns the matching node.
+         */
+        function findSelfOrAncestor(node, match) {
+            let currentNode = node;
+            while (currentNode && !match(currentNode)) {
+                currentNode = currentNode.parent;
+            }
+            return currentNode;
+        }
+        /**
+         * Finds function's outer scope.
+         * @param scope Function's own scope.
+         * @returns Function's outer scope.
+         */
+        function getOuterScope(scope) {
+            const upper = scope.upper;
+            if (upper?.type === scope_manager_1.ScopeType.functionExpressionName) {
+                return upper.upper;
+            }
+            return upper;
+        }
+        /**
+         * Checks if a variable and a shadowedVariable have the same init pattern ancestor.
+         * @param variable a variable to check.
+         * @param shadowedVariable a shadowedVariable to check.
+         * @returns Whether or not the variable and the shadowedVariable have the same init pattern ancestor.
+         */
+        function isInitPatternNode(variable, shadowedVariable) {
+            const outerDef = shadowedVariable.defs.at(0);
+            if (!outerDef) {
+                return false;
+            }
+            const { variableScope } = variable.scope;
+            if (!((variableScope.block.type ===
+                utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                variableScope.block.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+                getOuterScope(variableScope) === shadowedVariable.scope)) {
+                return false;
+            }
+            const fun = variableScope.block;
+            const { parent } = fun;
+            const callExpression = findSelfOrAncestor(parent, node => node.type === utils_1.AST_NODE_TYPES.CallExpression);
+            if (!callExpression) {
+                return false;
+            }
+            let node = outerDef.name;
+            const location = callExpression.range[1];
+            while (node) {
+                if (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                    if (isInRange(node.init, location)) {
+                        return true;
+                    }
+                    if ((node.parent.parent.type === utils_1.AST_NODE_TYPES.ForInStatement ||
+                        node.parent.parent.type === utils_1.AST_NODE_TYPES.ForOfStatement) &&
+                        isInRange(node.parent.parent.right, location)) {
+                        return true;
+                    }
+                    break;
+                }
+                else if (node.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                    if (isInRange(node.right, location)) {
+                        return true;
+                    }
+                }
+                else if ([
+                    utils_1.AST_NODE_TYPES.ArrowFunctionExpression,
+                    utils_1.AST_NODE_TYPES.CatchClause,
+                    utils_1.AST_NODE_TYPES.ClassDeclaration,
+                    utils_1.AST_NODE_TYPES.ClassExpression,
+                    utils_1.AST_NODE_TYPES.ExportNamedDeclaration,
+                    utils_1.AST_NODE_TYPES.FunctionDeclaration,
+                    utils_1.AST_NODE_TYPES.FunctionExpression,
+                    utils_1.AST_NODE_TYPES.ImportDeclaration,
+                ].includes(node.type)) {
+                    break;
+                }
+                node = node.parent;
+            }
+            return false;
+        }
+        /**
+         * Finds the uppermost expression node that can evaluate to the given one,
+         * unwrapping through LogicalExpression and non-test ConditionalExpression branches.
+         * @param node The node to unwrap.
+         * @returns The topmost unwrapped node.
+         */
+        function unwrapExpression(node) {
+            const { parent } = node;
+            if (parent?.type === utils_1.AST_NODE_TYPES.LogicalExpression ||
+                (parent?.type === utils_1.AST_NODE_TYPES.ConditionalExpression &&
+                    parent.test !== node)) {
+                return unwrapExpression(parent);
+            }
+            return node;
+        }
+        /**
+         * Checks if a variable is the name of a function or class expression that is
+         * directly assigned (or transparently through `||`/`?:`) as the initializer
+         * of scopeVar.
+         *
+         * Allows `var a = function a() {}` but reports `var a = wrap(function a() {})`.
+         * @param variable The variable to check.
+         * @param scopeVar The scope variable to look for.
+         * @returns Whether or not the variable is the direct initializer name of scopeVar.
+         */
+        function isOnInitializer(variable, scopeVar) {
+            const outerDef = scopeVar.defs.at(0);
+            const innerDef = variable.defs.at(0);
+            if (!outerDef || !innerDef) {
+                return false;
+            }
+            if (!((innerDef.type === scope_manager_1.DefinitionType.FunctionName &&
+                innerDef.node.type === utils_1.AST_NODE_TYPES.FunctionExpression) ||
+                (innerDef.type === scope_manager_1.DefinitionType.ClassName &&
+                    innerDef.node.type === utils_1.AST_NODE_TYPES.ClassExpression))) {
+                return false;
+            }
+            const outerIdentifier = outerDef.name;
+            let initializerNode;
+            if (outerIdentifier.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                initializerNode = outerIdentifier.parent.init;
+            }
+            else if (outerIdentifier.parent.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                initializerNode = outerIdentifier.parent.right;
+            }
+            if (!initializerNode) {
+                return false;
+            }
+            const nodeToCheck = innerDef.node;
+            if (!(initializerNode.range[0] <= nodeToCheck.range[0] &&
+                nodeToCheck.range[1] <= initializerNode.range[1])) {
+                return false;
+            }
+            return initializerNode === unwrapExpression(nodeToCheck);
+        }
+        /**
+         * Get a range of a variable's identifier node.
+         * @param variable The variable to get.
+         * @returns The range of the variable's identifier node.
+         */
+        function getNameRange(variable) {
+            const def = variable.defs.at(0);
+            return def?.name.range;
+        }
+        /**
+         * Checks if a variable is in TDZ of scopeVar.
+         * @param variable The variable to check.
+         * @param scopeVar The variable of TDZ.
+         * @returns Whether or not the variable is in TDZ of scopeVar.
+         */
+        function isInTdz(variable, scopeVar) {
+            const outerDef = scopeVar.defs.at(0);
+            const inner = getNameRange(variable);
+            const outer = getNameRange(scopeVar);
+            if (!inner || !outer || inner[1] >= outer[0]) {
+                return false;
+            }
+            if (!outerDef) {
+                return true;
+            }
+            if (options.hoist === 'functions') {
+                return !functionsHoistedNodes.has(outerDef.node.type);
+            }
+            if (options.hoist === 'types') {
+                return !typesHoistedNodes.has(outerDef.node.type);
+            }
+            if (options.hoist === 'functions-and-types') {
+                return (!functionsHoistedNodes.has(outerDef.node.type) &&
+                    !typesHoistedNodes.has(outerDef.node.type));
+            }
+            return true;
+        }
+        /**
+         * Get declared line and column of a variable.
+         * @param  variable The variable to get.
+         * @returns The declared line and column of the variable.
+         */
+        function getDeclaredLocation(variable) {
+            const identifier = variable.identifiers.at(0);
+            if (identifier) {
+                return {
+                    column: identifier.loc.start.column + 1,
+                    global: false,
+                    line: identifier.loc.start.line,
+                };
+            }
+            return {
+                global: true,
+            };
+        }
+        /**
+         * Checks if the initialization of a variable has the declare modifier in a
+         * definition file.
+         */
+        function isDeclareInDTSFile(variable) {
+            const fileName = context.filename;
+            if (!(0, util_1.isDefinitionFile)(fileName)) {
+                return false;
+            }
+            return variable.defs.some(def => {
+                return ((def.type === scope_manager_1.DefinitionType.Variable && def.parent.declare) ||
+                    (def.type === scope_manager_1.DefinitionType.ClassName && def.node.declare) ||
+                    (def.type === scope_manager_1.DefinitionType.TSEnumName && def.node.declare) ||
+                    (def.type === scope_manager_1.DefinitionType.TSModuleName && def.node.declare));
+            });
+        }
+        /**
+         * Checks the current context for shadowed variables.
+         * @param scope Fixme
+         */
+        function checkForShadows(scope) {
+            // ignore global augmentation
+            if (isGlobalAugmentation(scope)) {
+                return;
+            }
+            const variables = scope.variables;
+            for (const variable of variables) {
+                // ignore "arguments"
+                if (variable.identifiers.length === 0) {
+                    continue;
+                }
+                // this params are pseudo-params that cannot be shadowed
+                if (isThisParam(variable)) {
+                    continue;
+                }
+                // ignore variables of a class name in the class scope of ClassDeclaration
+                if (isDuplicatedClassNameVariable(variable)) {
+                    continue;
+                }
+                // ignore variables of a class name in the class scope of ClassDeclaration
+                if (isDuplicatedEnumNameVariable(variable)) {
+                    continue;
+                }
+                // ignore configured allowed names
+                if (isAllowed(variable)) {
+                    continue;
+                }
+                // ignore variables with the declare keyword in .d.ts files
+                if (isDeclareInDTSFile(variable)) {
+                    continue;
+                }
+                // Gets shadowed variable.
+                const shadowed = scope.upper
+                    ? utils_1.ASTUtils.findVariable(scope.upper, variable.name)
+                    : null;
+                if (!shadowed) {
+                    continue;
+                }
+                // ignore type value variable shadowing if configured
+                if (isTypeValueShadow(variable, shadowed)) {
+                    continue;
+                }
+                // ignore function type parameter name shadowing if configured
+                if (isFunctionTypeParameterNameValueShadow(variable, shadowed)) {
+                    continue;
+                }
+                // ignore static class method generic shadowing class generic
+                // this is impossible for the scope analyser to understand
+                // so we have to handle this manually in this rule
+                if (isGenericOfAStaticMethodShadow(variable, shadowed)) {
+                    continue;
+                }
+                if (isExternalDeclarationMerging(scope, variable, shadowed)) {
+                    continue;
+                }
+                const isESLintGlobal = 'writeable' in shadowed;
+                if ((shadowed.identifiers.length > 0 ||
+                    (options.builtinGlobals && isESLintGlobal)) &&
+                    !isOnInitializer(variable, shadowed) &&
+                    !(options.ignoreOnInitialization &&
+                        isInitPatternNode(variable, shadowed)) &&
+                    !(options.hoist !== 'all' && isInTdz(variable, shadowed))) {
+                    const location = getDeclaredLocation(shadowed);
+                    context.report({
+                        node: variable.identifiers[0],
+                        ...(location.global
+                            ? {
+                                messageId: 'noShadowGlobal',
+                                data: {
+                                    name: variable.name,
+                                },
+                            }
+                            : {
+                                messageId: 'noShadow',
+                                data: {
+                                    name: variable.name,
+                                    shadowedColumn: location.column,
+                                    shadowedLine: location.line,
+                                },
+                            }),
+                    });
+                }
+            }
+        }
+        return {
+            'Program:exit'(node) {
+                const globalScope = context.sourceCode.getScope(node);
+                const stack = [...globalScope.childScopes];
+                while (stack.length) {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    const scope = stack.pop();
+                    stack.push(...scope.childScopes);
+                    checkForShadows(scope);
+                }
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-this-alias.d.ts

@@ -0,0 +1,11 @@
+export type Options = [
+    {
+        allowDestructuring?: boolean;
+        allowedNames?: string[];
+    }
+];
+export type MessageIds = 'thisAssignment' | 'thisDestructure';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-this-alias.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-this-alias',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow aliasing `this`',
+            recommended: 'recommended',
+        },
+        messages: {
+            thisAssignment: "Unexpected aliasing of 'this' to local variable.",
+            thisDestructure: "Unexpected aliasing of members of 'this' to local variables.",
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allowDestructuring: {
+                        type: 'boolean',
+                        description: 'Whether to ignore destructurings, such as `const { props, state } = this`.',
+                    },
+                    allowedNames: {
+                        type: 'array',
+                        description: 'Names to ignore, such as ["self"] for `const self = this;`.',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowDestructuring: true,
+            allowedNames: [],
+        },
+    ],
+    create(context, [{ allowDestructuring, allowedNames }]) {
+        return {
+            "VariableDeclarator[init.type='ThisExpression'], AssignmentExpression[right.type='ThisExpression']"(node) {
+                const id = node.type === utils_1.AST_NODE_TYPES.VariableDeclarator ? node.id : node.left;
+                if (allowDestructuring && id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                const hasAllowedName = id.type === utils_1.AST_NODE_TYPES.Identifier
+                    ? // https://github.com/typescript-eslint/typescript-eslint/issues/5439
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        allowedNames.includes(id.name)
+                    : false;
+                if (!hasAllowedName) {
+                    context.report({
+                        node: id,
+                        messageId: id.type === utils_1.AST_NODE_TYPES.Identifier
+                            ? 'thisAssignment'
+                            : 'thisDestructure',
+                    });
+                }
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-type-alias.d.ts

@@ -0,0 +1,18 @@
+type Values = 'always' | 'in-intersections' | 'in-unions' | 'in-unions-and-intersections' | 'never';
+export type Options = [
+    {
+        allowAliases?: Values;
+        allowCallbacks?: 'always' | 'never';
+        allowConditionalTypes?: 'always' | 'never';
+        allowConstructors?: 'always' | 'never';
+        allowGenerics?: 'always' | 'never';
+        allowLiterals?: Values;
+        allowMappedTypes?: Values;
+        allowTupleTypes?: Values;
+    }
+];
+export type MessageIds = 'noCompositionAlias' | 'noTypeAlias';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-type-alias.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-type-alias',
+    meta: {
+        type: 'suggestion',
+        deprecated: {
+            deprecatedSince: '6.0.0',
+            replacedBy: [
+                {
+                    rule: {
+                        name: '@typescript-eslint/consistent-type-definitions',
+                        url: 'https://typescript-eslint.io/rules/consistent-type-definitions',
+                    },
+                },
+            ],
+            url: 'https://github.com/typescript-eslint/typescript-eslint/pull/6229',
+        },
+        docs: {
+            description: 'Disallow type aliases',
+            // too opinionated to be recommended
+        },
+        messages: {
+            noCompositionAlias: '{{typeName}} in {{compositionType}} types are not allowed.',
+            noTypeAlias: 'Type {{alias}} are not allowed.',
+        },
+        schema: [
+            {
+                type: 'object',
+                $defs: {
+                    expandedOptions: {
+                        type: 'string',
+                        enum: [
+                            'always',
+                            'never',
+                            'in-unions',
+                            'in-intersections',
+                            'in-unions-and-intersections',
+                        ],
+                    },
+                    simpleOptions: {
+                        type: 'string',
+                        enum: ['always', 'never'],
+                    },
+                },
+                additionalProperties: false,
+                properties: {
+                    allowAliases: {
+                        $ref: '#/items/0/$defs/expandedOptions',
+                        description: 'Whether to allow direct one-to-one type aliases.',
+                    },
+                    allowCallbacks: {
+                        $ref: '#/items/0/$defs/simpleOptions',
+                        description: 'Whether to allow type aliases for callbacks.',
+                    },
+                    allowConditionalTypes: {
+                        $ref: '#/items/0/$defs/simpleOptions',
+                        description: 'Whether to allow type aliases for conditional types.',
+                    },
+                    allowConstructors: {
+                        $ref: '#/items/0/$defs/simpleOptions',
+                        description: 'Whether to allow type aliases with constructors.',
+                    },
+                    allowGenerics: {
+                        $ref: '#/items/0/$defs/simpleOptions',
+                        description: 'Whether to allow type aliases with generic types.',
+                    },
+                    allowLiterals: {
+                        $ref: '#/items/0/$defs/expandedOptions',
+                        description: 'Whether to allow type aliases with object literal types.',
+                    },
+                    allowMappedTypes: {
+                        $ref: '#/items/0/$defs/expandedOptions',
+                        description: 'Whether to allow type aliases with mapped types.',
+                    },
+                    allowTupleTypes: {
+                        $ref: '#/items/0/$defs/expandedOptions',
+                        description: 'Whether to allow type aliases with tuple types.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowAliases: 'never',
+            allowCallbacks: 'never',
+            allowConditionalTypes: 'never',
+            allowConstructors: 'never',
+            allowGenerics: 'never',
+            allowLiterals: 'never',
+            allowMappedTypes: 'never',
+            allowTupleTypes: 'never',
+        },
+    ],
+    create(context, [{ allowAliases, allowCallbacks, allowConditionalTypes, allowConstructors, allowGenerics, allowLiterals, allowMappedTypes, allowTupleTypes, },]) {
+        const unions = ['always', 'in-unions', 'in-unions-and-intersections'];
+        const intersections = [
+            'always',
+            'in-intersections',
+            'in-unions-and-intersections',
+        ];
+        const compositions = [
+            'in-unions',
+            'in-intersections',
+            'in-unions-and-intersections',
+        ];
+        const aliasTypes = new Set([
+            utils_1.AST_NODE_TYPES.TSArrayType,
+            utils_1.AST_NODE_TYPES.TSImportType,
+            utils_1.AST_NODE_TYPES.TSIndexedAccessType,
+            utils_1.AST_NODE_TYPES.TSLiteralType,
+            utils_1.AST_NODE_TYPES.TSTemplateLiteralType,
+            utils_1.AST_NODE_TYPES.TSTypeQuery,
+            utils_1.AST_NODE_TYPES.TSTypeReference,
+        ]);
+        /**
+         * Determines if the composition type is supported by the allowed flags.
+         * @param isTopLevel a flag indicating this is the top level node.
+         * @param compositionType the composition type (either TSUnionType or TSIntersectionType)
+         * @param allowed the currently allowed flags.
+         */
+        function isSupportedComposition(isTopLevel, compositionType, allowed) {
+            return (!compositions.includes(allowed) ||
+                (!isTopLevel &&
+                    ((compositionType === utils_1.AST_NODE_TYPES.TSUnionType &&
+                        unions.includes(allowed)) ||
+                        (compositionType === utils_1.AST_NODE_TYPES.TSIntersectionType &&
+                            intersections.includes(allowed)))));
+        }
+        /**
+         * Gets the message to be displayed based on the node type and whether the node is a top level declaration.
+         * @param node the location
+         * @param compositionType the type of composition this alias is part of (undefined if not
+         *                                  part of a composition)
+         * @param isRoot a flag indicating we are dealing with the top level declaration.
+         * @param type the kind of type alias being validated.
+         */
+        function reportError(node, compositionType, isRoot, type) {
+            if (isRoot) {
+                return context.report({
+                    node,
+                    messageId: 'noTypeAlias',
+                    data: {
+                        alias: type.toLowerCase(),
+                    },
+                });
+            }
+            return context.report({
+                node,
+                messageId: 'noCompositionAlias',
+                data: {
+                    compositionType: compositionType === utils_1.AST_NODE_TYPES.TSUnionType
+                        ? 'union'
+                        : 'intersection',
+                    typeName: type,
+                },
+            });
+        }
+        const isValidTupleType = (type) => {
+            if (type.node.type === utils_1.AST_NODE_TYPES.TSTupleType) {
+                return true;
+            }
+            if (type.node.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
+                ['keyof', 'readonly'].includes(type.node.operator) &&
+                type.node.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTupleType) {
+                return true;
+            }
+            return false;
+        };
+        const isValidGeneric = (type) => {
+            return (type.node.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                type.node.typeArguments != null);
+        };
+        const checkAndReport = (optionValue, isTopLevel, type, label) => {
+            if (optionValue === 'never' ||
+                !isSupportedComposition(isTopLevel, type.compositionType, optionValue)) {
+                reportError(type.node, type.compositionType, isTopLevel, label);
+            }
+        };
+        /**
+         * Validates the node looking for aliases, callbacks and literals.
+         * @param type the type of composition this alias is part of (null if not
+         *                                  part of a composition)
+         * @param isTopLevel a flag indicating this is the top level node.
+         */
+        function validateTypeAliases(type, isTopLevel = false) {
+            // https://github.com/typescript-eslint/typescript-eslint/issues/5439
+            /* eslint-disable @typescript-eslint/no-non-null-assertion */
+            if (type.node.type === utils_1.AST_NODE_TYPES.TSFunctionType) {
+                // callback
+                if (allowCallbacks === 'never') {
+                    reportError(type.node, type.compositionType, isTopLevel, 'Callbacks');
+                }
+            }
+            else if (type.node.type === utils_1.AST_NODE_TYPES.TSConditionalType) {
+                // conditional type
+                if (allowConditionalTypes === 'never') {
+                    reportError(type.node, type.compositionType, isTopLevel, 'Conditional types');
+                }
+            }
+            else if (type.node.type === utils_1.AST_NODE_TYPES.TSConstructorType) {
+                if (allowConstructors === 'never') {
+                    reportError(type.node, type.compositionType, isTopLevel, 'Constructors');
+                }
+            }
+            else if (type.node.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                // literal object type
+                checkAndReport(allowLiterals, isTopLevel, type, 'Literals');
+            }
+            else if (type.node.type === utils_1.AST_NODE_TYPES.TSMappedType) {
+                // mapped type
+                checkAndReport(allowMappedTypes, isTopLevel, type, 'Mapped types');
+            }
+            else if (isValidTupleType(type)) {
+                // tuple types
+                checkAndReport(allowTupleTypes, isTopLevel, type, 'Tuple Types');
+            }
+            else if (isValidGeneric(type)) {
+                if (allowGenerics === 'never') {
+                    reportError(type.node, type.compositionType, isTopLevel, 'Generics');
+                }
+            }
+            else if (type.node.type.endsWith(utils_1.AST_TOKEN_TYPES.Keyword) ||
+                aliasTypes.has(type.node.type) ||
+                (type.node.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
+                    (type.node.operator === 'keyof' ||
+                        (type.node.operator === 'readonly' &&
+                            type.node.typeAnnotation &&
+                            aliasTypes.has(type.node.typeAnnotation.type))))) {
+                // alias / keyword
+                checkAndReport(allowAliases, isTopLevel, type, 'Aliases');
+            }
+            else {
+                // unhandled type - shouldn't happen
+                reportError(type.node, type.compositionType, isTopLevel, 'Unhandled');
+            }
+            /* eslint-enable @typescript-eslint/no-non-null-assertion */
+        }
+        /**
+         * Flatten the given type into an array of its dependencies
+         */
+        function getTypes(node, compositionType = null) {
+            if (node.type === utils_1.AST_NODE_TYPES.TSUnionType ||
+                node.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                return node.types.flatMap(type => getTypes(type, node.type));
+            }
+            return [{ node, compositionType }];
+        }
+        return {
+            TSTypeAliasDeclaration(node) {
+                const types = getTypes(node.typeAnnotation);
+                if (types.length === 1) {
+                    // is a top level type annotation
+                    validateTypeAliases(types[0], true);
+                }
+                else {
+                    // is a composition type
+                    types.forEach(type => {
+                        validateTypeAliases(type);
+                    });
+                }
+            },
+        };
+    },
+});

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-boolean-literal-compare.d.ts

@@ -0,0 +1,12 @@
+export type MessageIds = 'comparingNullableToFalse' | 'comparingNullableToTrueDirect' | 'comparingNullableToTrueNegated' | 'direct' | 'negated' | 'noStrictNullCheck';
+export type Options = [
+    {
+        allowComparingNullableBooleansToFalse?: boolean;
+        allowComparingNullableBooleansToTrue?: boolean;
+        allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
+    }
+];
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-boolean-literal-compare.js

@@ -0,0 +1,263 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-unnecessary-boolean-literal-compare',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow unnecessary equality comparisons against boolean literals',
+            recommended: 'strict',
+            requiresTypeChecking: true,
+        },
+        fixable: 'code',
+        messages: {
+            comparingNullableToFalse: 'This expression unnecessarily compares a nullable boolean value to false instead of using the ?? operator to provide a default.',
+            comparingNullableToTrueDirect: 'This expression unnecessarily compares a nullable boolean value to true instead of using it directly.',
+            comparingNullableToTrueNegated: 'This expression unnecessarily compares a nullable boolean value to true instead of negating it.',
+            direct: 'This expression unnecessarily compares a boolean value to a boolean instead of using it directly.',
+            negated: 'This expression unnecessarily compares a boolean value to a boolean instead of negating it.',
+            noStrictNullCheck: 'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allowComparingNullableBooleansToFalse: {
+                        type: 'boolean',
+                        description: 'Whether to allow comparisons between nullable boolean variables and `false`.',
+                    },
+                    allowComparingNullableBooleansToTrue: {
+                        type: 'boolean',
+                        description: 'Whether to allow comparisons between nullable boolean variables and `true`.',
+                    },
+                    allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
+                        type: 'boolean',
+                        description: 'Unless this is set to `true`, the rule will error on every file whose `tsconfig.json` does _not_ have the `strictNullChecks` compiler option (or `strict`) set to `true`.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowComparingNullableBooleansToFalse: true,
+            allowComparingNullableBooleansToTrue: true,
+            allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+        },
+    ],
+    create(context, [options]) {
+        const services = (0, util_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        const compilerOptions = services.program.getCompilerOptions();
+        const isStrictNullChecks = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'strictNullChecks');
+        if (!isStrictNullChecks &&
+            options.allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing !== true) {
+            context.report({
+                loc: {
+                    start: { column: 0, line: 0 },
+                    end: { column: 0, line: 0 },
+                },
+                messageId: 'noStrictNullCheck',
+            });
+        }
+        function getBooleanComparison(node) {
+            const comparison = deconstructComparison(node);
+            if (!comparison) {
+                return undefined;
+            }
+            const { constraintType, isTypeParameter } = (0, util_1.getConstraintInfo)(checker, services.getTypeAtLocation(comparison.expression));
+            if (isTypeParameter && constraintType == null) {
+                return undefined;
+            }
+            if (isBooleanType(constraintType)) {
+                return {
+                    ...comparison,
+                    expressionIsNullableBoolean: false,
+                };
+            }
+            if (isNullableBoolean(constraintType)) {
+                return {
+                    ...comparison,
+                    expressionIsNullableBoolean: true,
+                };
+            }
+            return undefined;
+        }
+        function isBooleanType(expressionType) {
+            return tsutils.isTypeFlagSet(expressionType, ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral);
+        }
+        /**
+         * checks if the expressionType is a union that
+         *   1) contains at least one nullish type (null or undefined)
+         *   2) contains at least once boolean type (true or false or boolean)
+         *   3) does not contain any types besides nullish and boolean types
+         */
+        function isNullableBoolean(expressionType) {
+            if (!expressionType.isUnion()) {
+                return false;
+            }
+            const { types } = expressionType;
+            const nonNullishTypes = types.filter(type => !tsutils.isTypeFlagSet(type, ts.TypeFlags.Undefined | ts.TypeFlags.Null));
+            const hasNonNullishType = nonNullishTypes.length > 0;
+            if (!hasNonNullishType) {
+                return false;
+            }
+            const hasNullableType = nonNullishTypes.length < types.length;
+            if (!hasNullableType) {
+                return false;
+            }
+            const allNonNullishTypesAreBoolean = nonNullishTypes.every(isBooleanType);
+            if (!allNonNullishTypesAreBoolean) {
+                return false;
+            }
+            return true;
+        }
+        function deconstructComparison(node) {
+            const comparisonType = getEqualsKind(node.operator);
+            if (!comparisonType) {
+                return undefined;
+            }
+            for (const [against, expression] of [
+                [node.right, node.left],
+                [node.left, node.right],
+            ]) {
+                if (against.type !== utils_1.AST_NODE_TYPES.Literal ||
+                    typeof against.value !== 'boolean') {
+                    continue;
+                }
+                const { value: literalBooleanInComparison } = against;
+                const negated = !comparisonType.isPositive;
+                return {
+                    expression,
+                    literalBooleanInComparison,
+                    negated,
+                };
+            }
+            return undefined;
+        }
+        function nodeIsUnaryNegation(node) {
+            return (node.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                node.prefix &&
+                node.operator === '!');
+        }
+        return {
+            BinaryExpression(node) {
+                const comparison = getBooleanComparison(node);
+                if (comparison == null) {
+                    return;
+                }
+                if (comparison.expressionIsNullableBoolean) {
+                    if (comparison.literalBooleanInComparison &&
+                        options.allowComparingNullableBooleansToTrue) {
+                        return;
+                    }
+                    if (!comparison.literalBooleanInComparison &&
+                        options.allowComparingNullableBooleansToFalse) {
+                        return;
+                    }
+                }
+                context.report({
+                    node,
+                    messageId: comparison.expressionIsNullableBoolean
+                        ? comparison.literalBooleanInComparison
+                            ? comparison.negated
+                                ? 'comparingNullableToTrueNegated'
+                                : 'comparingNullableToTrueDirect'
+                            : 'comparingNullableToFalse'
+                        : comparison.negated
+                            ? 'negated'
+                            : 'direct',
+                    *fix(fixer) {
+                        // 1. isUnaryNegation - parent negation
+                        // 2. literalBooleanInComparison - is compared to literal boolean
+                        // 3. negated - is expression negated
+                        const isUnaryNegation = nodeIsUnaryNegation(node.parent);
+                        const shouldNegate = comparison.negated !== comparison.literalBooleanInComparison;
+                        const mutatedNode = isUnaryNegation ? node.parent : node;
+                        yield fixer.replaceText(mutatedNode, context.sourceCode.getText(comparison.expression));
+                        // if `isUnaryNegation === literalBooleanInComparison === !negated` is true - negate the expression
+                        if (shouldNegate === isUnaryNegation) {
+                            yield fixer.insertTextBefore(mutatedNode, '!');
+                            // if the expression `exp` is not a strong precedence node, wrap it in parentheses
+                            if (!(0, util_1.isStrongPrecedenceNode)(comparison.expression)) {
+                                yield fixer.insertTextBefore(mutatedNode, '(');
+                                yield fixer.insertTextAfter(mutatedNode, ')');
+                            }
+                        }
+                        // if the expression `exp` is nullable, and we're not comparing to `true`, insert `?? true`
+                        if (comparison.expressionIsNullableBoolean &&
+                            !comparison.literalBooleanInComparison) {
+                            // provide the default `true`
+                            yield fixer.insertTextBefore(mutatedNode, '(');
+                            yield fixer.insertTextAfter(mutatedNode, ' ?? true)');
+                        }
+                    },
+                });
+            },
+        };
+    },
+});
+function getEqualsKind(operator) {
+    switch (operator) {
+        case '!=':
+            return {
+                isPositive: false,
+                isStrict: false,
+            };
+        case '!==':
+            return {
+                isPositive: false,
+                isStrict: true,
+            };
+        case '==':
+            return {
+                isPositive: true,
+                isStrict: false,
+            };
+        case '===':
+            return {
+                isPositive: true,
+                isStrict: true,
+            };
+        default:
+            return undefined;
+    }
+}

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-condition.d.ts

@@ -0,0 +1,14 @@
+type LegacyAllowConstantLoopConditions = boolean;
+type AllowConstantLoopConditions = 'always' | 'never' | 'only-allowed-literals';
+export type Options = [
+    {
+        allowConstantLoopConditions?: AllowConstantLoopConditions | LegacyAllowConstantLoopConditions;
+        allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
+        checkTypePredicates?: boolean;
+    }
+];
+export type MessageId = 'alwaysFalsy' | 'alwaysFalsyFunc' | 'alwaysNullish' | 'alwaysTruthy' | 'alwaysTruthyFunc' | 'comparisonBetweenLiteralTypes' | 'never' | 'neverNullish' | 'neverOptionalChain' | 'noOverlapBooleanExpression' | 'noStrictNullCheck' | 'suggestRemoveOptionalChain' | 'typeGuardAlreadyIsType';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageId, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

tools/ui/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-condition.js

@@ -0,0 +1,689 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+const assertionFunctionUtils_1 = require("../util/assertionFunctionUtils");
+// #region
+const nullishFlag = ts.TypeFlags.Undefined | ts.TypeFlags.Null;
+function isNullishType(type) {
+    return tsutils.isTypeFlagSet(type, nullishFlag);
+}
+function isAlwaysNullish(type) {
+    return tsutils.unionConstituents(type).every(isNullishType);
+}
+/**
+ * Note that this differs from {@link isNullableType} in that it doesn't consider
+ * `any` or `unknown` to be nullable.
+ */
+function isPossiblyNullish(type) {
+    return tsutils
+        .unionConstituents(type)
+        .some(t => isNullishType(t) || (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Void));
+}
+function toStaticValue(type) {
+    // type.isLiteral() only covers numbers/bigints and strings, hence the rest of the branches.
+    if (tsutils.isBooleanLiteralType(type)) {
+        return { value: tsutils.isTrueLiteralType(type) };
+    }
+    if (type.flags === ts.TypeFlags.Undefined) {
+        return { value: undefined };
+    }
+    if (type.flags === ts.TypeFlags.Null) {
+        return { value: null };
+    }
+    if (type.isLiteral()) {
+        return { value: (0, util_1.getValueOfLiteralType)(type) };
+    }
+    return undefined;
+}
+const BOOL_OPERATORS = new Set([
+    '<',
+    '>',
+    '<=',
+    '>=',
+    '==',
+    '===',
+    '!=',
+    '!==',
+]);
+function isBoolOperator(operator) {
+    return BOOL_OPERATORS.has(operator);
+}
+function booleanComparison(left, operator, right) {
+    switch (operator) {
+        case '!=':
+            // eslint-disable-next-line eqeqeq -- intentionally comparing with loose equality
+            return left != right;
+        case '!==':
+            return left !== right;
+        case '<':
+            // @ts-expect-error: we don't care if the comparison seems unintentional.
+            return left < right;
+        case '<=':
+            // @ts-expect-error: we don't care if the comparison seems unintentional.
+            return left <= right;
+        case '==':
+            // eslint-disable-next-line eqeqeq -- intentionally comparing with loose equality
+            return left == right;
+        case '===':
+            return left === right;
+        case '>':
+            // @ts-expect-error: we don't care if the comparison seems unintentional.
+            return left > right;
+        case '>=':
+            // @ts-expect-error: we don't care if the comparison seems unintentional.
+            return left >= right;
+    }
+}
+const constantLoopConditionsAllowedLiterals = new Set([
+    true,
+    false,
+    1,
+    0,
+]);
+exports.default = (0, util_1.createRule)({
+    name: 'no-unnecessary-condition',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow conditionals where the type is always truthy or always falsy',
+            recommended: 'strict',
+            requiresTypeChecking: true,
+        },
+        hasSuggestions: true,
+        messages: {
+            alwaysFalsy: 'Unnecessary conditional, value is always falsy.',
+            alwaysFalsyFunc: 'This callback should return a conditional, but return is always falsy.',
+            alwaysNullish: 'Unnecessary conditional, left-hand side of `??` operator is always `null` or `undefined`.',
+            alwaysTruthy: 'Unnecessary conditional, value is always truthy.',
+            alwaysTruthyFunc: 'This callback should return a conditional, but return is always truthy.',
+            comparisonBetweenLiteralTypes: 'Unnecessary conditional, comparison is always {{trueOrFalse}}, since `{{left}} {{operator}} {{right}}` is {{trueOrFalse}}.',
+            never: 'Unnecessary conditional, value is `never`.',
+            neverNullish: 'Unnecessary conditional, expected left-hand side of `??` operator to be possibly null or undefined.',
+            neverOptionalChain: 'Unnecessary optional chain on a non-nullish value.',
+            noOverlapBooleanExpression: 'Unnecessary conditional, the types have no overlap.',
+            noStrictNullCheck: 'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
+            suggestRemoveOptionalChain: 'Remove unnecessary optional chain',
+            typeGuardAlreadyIsType: 'Unnecessary conditional, expression already has the type being checked by the {{typeGuardOrAssertionFunction}}.',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allowConstantLoopConditions: {
+                        description: 'Whether to ignore constant loop conditions, such as `while (true)`.',
+                        oneOf: [
+                            {
+                                type: 'boolean',
+                                description: 'Always ignore or not ignore the loop conditions',
+                            },
+                            {
+                                type: 'string',
+                                description: 'Which situations to ignore constant conditions in.',
+                                enum: ['always', 'never', 'only-allowed-literals'],
+                            },
+                        ],
+                    },
+                    allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
+                        type: 'boolean',
+                        description: 'Whether to not error when running with a tsconfig that has strictNullChecks turned.',
+                    },
+                    checkTypePredicates: {
+                        type: 'boolean',
+                        description: 'Whether to check the asserted argument of a type predicate function for unnecessary conditions',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowConstantLoopConditions: 'never',
+            allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+            checkTypePredicates: false,
+        },
+    ],
+    create(context, [{ allowConstantLoopConditions, allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing, checkTypePredicates, },]) {
+        const services = (0, util_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        const compilerOptions = services.program.getCompilerOptions();
+        const isStrictNullChecks = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'strictNullChecks');
+        const isNoUncheckedIndexedAccess = tsutils.isCompilerOptionEnabled(compilerOptions, 'noUncheckedIndexedAccess');
+        const allowConstantLoopConditionsOption = normalizeAllowConstantLoopConditions(
+        // https://github.com/typescript-eslint/typescript-eslint/issues/5439
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        allowConstantLoopConditions);
+        if (!isStrictNullChecks &&
+            allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing !== true) {
+            context.report({
+                loc: {
+                    start: { column: 0, line: 0 },
+                    end: { column: 0, line: 0 },
+                },
+                messageId: 'noStrictNullCheck',
+            });
+        }
+        function nodeIsArrayType(node) {
+            const nodeType = (0, util_1.getConstrainedTypeAtLocation)(services, node);
+            return tsutils
+                .unionConstituents(nodeType)
+                .some(part => checker.isArrayType(part));
+        }
+        function nodeIsTupleType(node) {
+            const nodeType = (0, util_1.getConstrainedTypeAtLocation)(services, node);
+            return tsutils
+                .unionConstituents(nodeType)
+                .some(part => checker.isTupleType(part));
+        }
+        function isArrayIndexExpression(node) {
+            return (
+            // Is an index signature
+            node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.computed &&
+                // ...into an array type
+                (nodeIsArrayType(node.object) ||
+                    // ... or a tuple type
+                    (nodeIsTupleType(node.object) &&
+                        // Exception: literal index into a tuple - will have a sound type
+                        node.property.type !== utils_1.AST_NODE_TYPES.Literal)));
+        }
+        // Conditional is always necessary if it involves:
+        //    `any` or `unknown` or a naked type variable
+        function isConditionalAlwaysNecessary(type) {
+            return tsutils
+                .unionConstituents(type)
+                .some(part => (0, util_1.isTypeAnyType)(part) ||
+                (0, util_1.isTypeUnknownType)(part) ||
+                (0, util_1.isTypeFlagSet)(part, ts.TypeFlags.TypeVariable));
+        }
+        function isNullableMemberExpression(node) {
+            const objectType = services.getTypeAtLocation(node.object);
+            if (node.computed) {
+                const propertyType = services.getTypeAtLocation(node.property);
+                return isNullablePropertyType(objectType, propertyType);
+            }
+            const property = node.property;
+            // Get the actual property name, to account for private properties (this.#prop).
+            const propertyName = context.sourceCode.getText(property);
+            const propertyType = objectType
+                .getProperties()
+                .find(prop => prop.name === propertyName);
+            if (propertyType &&
+                tsutils.isSymbolFlagSet(propertyType, ts.SymbolFlags.Optional)) {
+                return true;
+            }
+            return false;
+        }
+        /**
+         * Checks if a conditional node is necessary:
+         * if the type of the node is always true or always false, it's not necessary.
+         */
+        function checkNode(expression, isUnaryNotArgument = false, node = expression) {
+            // Check if the node is Unary Negation expression and handle it
+            if (expression.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                expression.operator === '!') {
+                return checkNode(expression.argument, !isUnaryNotArgument, node);
+            }
+            // Since typescript array index signature types don't represent the
+            //  possibility of out-of-bounds access, if we're indexing into an array
+            //  just skip the check, to avoid false positives
+            if (!isNoUncheckedIndexedAccess && isArrayIndexExpression(expression)) {
+                return;
+            }
+            // When checking logical expressions, only check the right side
+            //  as the left side has been checked by checkLogicalExpressionForUnnecessaryConditionals
+            //
+            // Unless the node is nullish coalescing, as it's common to use patterns like `nullBool ?? true` to to strict
+            //  boolean checks if we inspect the right here, it'll usually be a constant condition on purpose.
+            // In this case it's better to inspect the type of the expression as a whole.
+            if (expression.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
+                expression.operator !== '??') {
+                return checkNode(expression.right);
+            }
+            const type = (0, util_1.getConstrainedTypeAtLocation)(services, expression);
+            if (isConditionalAlwaysNecessary(type)) {
+                return;
+            }
+            let messageId = null;
+            if ((0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Never)) {
+                messageId = 'never';
+            }
+            else if (!(0, util_1.isPossiblyTruthy)(type)) {
+                messageId = !isUnaryNotArgument ? 'alwaysFalsy' : 'alwaysTruthy';
+            }
+            else if (!(0, util_1.isPossiblyFalsy)(type)) {
+                messageId = !isUnaryNotArgument ? 'alwaysTruthy' : 'alwaysFalsy';
+            }
+            if (messageId) {
+                context.report({ node, messageId });
+            }
+        }
+        function checkNodeForNullish(node) {
+            const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
+            // Conditional is always necessary if it involves `any`, `unknown` or a naked type parameter
+            if ((0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Any |
+                ts.TypeFlags.Unknown |
+                ts.TypeFlags.TypeParameter |
+                ts.TypeFlags.TypeVariable)) {
+                return;
+            }
+            let messageId = null;
+            if ((0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Never)) {
+                messageId = 'never';
+            }
+            else if (!isPossiblyNullish(type) &&
+                !(node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    isNullableMemberExpression(node))) {
+                // Since typescript array index signature types don't represent the
+                //  possibility of out-of-bounds access, if we're indexing into an array
+                //  just skip the check, to avoid false positives
+                if (isNoUncheckedIndexedAccess ||
+                    (!isArrayIndexExpression(node) &&
+                        !(node.type === utils_1.AST_NODE_TYPES.ChainExpression &&
+                            node.expression.type !== utils_1.AST_NODE_TYPES.TSNonNullExpression &&
+                            optionChainContainsOptionArrayIndex(node.expression)))) {
+                    messageId = 'neverNullish';
+                }
+            }
+            else if (isAlwaysNullish(type)) {
+                messageId = 'alwaysNullish';
+            }
+            if (messageId) {
+                context.report({ node, messageId });
+            }
+        }
+        /**
+         * Checks that a binary expression is necessarily conditional, reports otherwise.
+         * If both sides of the binary expression are literal values, it's not a necessary condition.
+         *
+         * NOTE: It's also unnecessary if the types that don't overlap at all
+         *    but that case is handled by the Typescript compiler itself.
+         *    Known exceptions:
+         *      - https://github.com/microsoft/TypeScript/issues/32627
+         *      - https://github.com/microsoft/TypeScript/issues/37160 (handled)
+         */
+        function checkIfBoolExpressionIsNecessaryConditional(node, left, right, operator) {
+            const leftType = (0, util_1.getConstrainedTypeAtLocation)(services, left);
+            const rightType = (0, util_1.getConstrainedTypeAtLocation)(services, right);
+            const leftStaticValue = toStaticValue(leftType);
+            const rightStaticValue = toStaticValue(rightType);
+            if (leftStaticValue != null && rightStaticValue != null) {
+                const conditionIsTrue = booleanComparison(leftStaticValue.value, operator, rightStaticValue.value);
+                context.report({
+                    node,
+                    messageId: 'comparisonBetweenLiteralTypes',
+                    data: {
+                        left: checker.typeToString(leftType),
+                        operator,
+                        right: checker.typeToString(rightType),
+                        trueOrFalse: conditionIsTrue ? 'true' : 'false',
+                    },
+                });
+                return;
+            }
+            // Workaround for https://github.com/microsoft/TypeScript/issues/37160
+            if (isStrictNullChecks) {
+                const UNDEFINED = ts.TypeFlags.Undefined;
+                const NULL = ts.TypeFlags.Null;
+                const VOID = ts.TypeFlags.Void;
+                const isComparable = (type, flag) => {
+                    // Allow comparison to `any`, `unknown` or a naked type parameter.
+                    flag |=
+                        ts.TypeFlags.Any |
+                            ts.TypeFlags.Unknown |
+                            ts.TypeFlags.TypeParameter |
+                            ts.TypeFlags.TypeVariable;
+                    // Allow loose comparison to nullish values.
+                    if (operator === '==' || operator === '!=') {
+                        flag |= NULL | UNDEFINED | VOID;
+                    }
+                    return (0, util_1.isTypeFlagSet)(type, flag);
+                };
+                if ((leftType.flags === UNDEFINED &&
+                    !isComparable(rightType, UNDEFINED | VOID)) ||
+                    (rightType.flags === UNDEFINED &&
+                        !isComparable(leftType, UNDEFINED | VOID)) ||
+                    (leftType.flags === NULL && !isComparable(rightType, NULL)) ||
+                    (rightType.flags === NULL && !isComparable(leftType, NULL))) {
+                    context.report({ node, messageId: 'noOverlapBooleanExpression' });
+                    return;
+                }
+            }
+        }
+        /**
+         * Checks that a logical expression contains a boolean, reports otherwise.
+         */
+        function checkLogicalExpressionForUnnecessaryConditionals(node) {
+            if (node.operator === '??') {
+                checkNodeForNullish(node.left);
+                return;
+            }
+            // Only checks the left side, since the right side might not be "conditional" at all.
+            // The right side will be checked if the LogicalExpression is used in a conditional context
+            checkNode(node.left);
+        }
+        /**
+         * Checks that a testable expression of a loop is necessarily conditional, reports otherwise.
+         */
+        function checkIfLoopIsNecessaryConditional(node) {
+            if (node.test == null) {
+                // e.g. `for(;;)`
+                return;
+            }
+            if (allowConstantLoopConditionsOption === 'only-allowed-literals' &&
+                node.test.type === utils_1.AST_NODE_TYPES.Literal &&
+                constantLoopConditionsAllowedLiterals.has(node.test.value)) {
+                return;
+            }
+            if (allowConstantLoopConditionsOption === 'always' &&
+                tsutils.isTrueLiteralType((0, util_1.getConstrainedTypeAtLocation)(services, node.test))) {
+                return;
+            }
+            checkNode(node.test);
+        }
+        function checkCallExpression(node) {
+            if (checkTypePredicates) {
+                const truthinessAssertedArgument = (0, assertionFunctionUtils_1.findTruthinessAssertedArgument)(services, node);
+                if (truthinessAssertedArgument != null) {
+                    checkNode(truthinessAssertedArgument);
+                }
+                const typeGuardAssertedArgument = (0, assertionFunctionUtils_1.findTypeGuardAssertedArgument)(services, node);
+                if (typeGuardAssertedArgument != null) {
+                    const typeOfArgument = (0, util_1.getConstrainedTypeAtLocation)(services, typeGuardAssertedArgument.argument);
+                    if (
+                    // Skip `any` — it is assignable to everything, producing
+                    // false positives for meaningful runtime type guards.
+                    !tsutils.isTypeFlagSet(typeOfArgument, ts.TypeFlags.Any | ts.TypeFlags.Unknown) &&
+                        checker.isTypeAssignableTo(typeOfArgument, typeGuardAssertedArgument.type) &&
+                        // Only flag if the types are mutually assignable (i.e. equivalent,
+                        // like Narrower ↔ Wider with optional props) or the predicate type
+                        // is a union that the argument is a strict subtype of.  This avoids
+                        // false positives with structural subtypes whose extra members are
+                        // all optional in the *predicate* type (e.g. custom MappedType
+                        // interfaces extending ts.Type).
+                        (checker.isTypeAssignableTo(typeGuardAssertedArgument.type, typeOfArgument) ||
+                            typeGuardAssertedArgument.type.isUnion())) {
+                        context.report({
+                            node: typeGuardAssertedArgument.argument,
+                            messageId: 'typeGuardAlreadyIsType',
+                            data: {
+                                typeGuardOrAssertionFunction: typeGuardAssertedArgument.asserts
+                                    ? 'assertion function'
+                                    : 'type guard',
+                            },
+                        });
+                    }
+                }
+            }
+            // If this is something like arr.filter(x => /*condition*/), check `condition`
+            if ((0, util_1.isArrayMethodCallWithPredicate)(context, services, node) &&
+                node.arguments.length) {
+                const callback = node.arguments[0];
+                // Inline defined functions
+                if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                    // Two special cases, where we can directly check the node that's returned:
+                    // () => something
+                    if (callback.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                        return checkNode(callback.body);
+                    }
+                    // () => { return something; }
+                    const callbackBody = callback.body.body;
+                    if (callbackBody.length === 1 &&
+                        callbackBody[0].type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                        callbackBody[0].argument) {
+                        return checkNode(callbackBody[0].argument);
+                    }
+                    // Potential enhancement: could use code-path analysis to check
+                    //   any function with a single return statement
+                    // (Value to complexity ratio is dubious however)
+                }
+                // Otherwise just do type analysis on the function as a whole.
+                const returnTypes = tsutils
+                    .getCallSignaturesOfType((0, util_1.getConstrainedTypeAtLocation)(services, callback))
+                    .map(sig => sig.getReturnType());
+                if (returnTypes.length === 0) {
+                    // Not a callable function, e.g. `any`
+                    return;
+                }
+                let hasFalsyReturnTypes = false;
+                let hasTruthyReturnTypes = false;
+                for (const type of returnTypes) {
+                    const { constraintType } = (0, util_1.getConstraintInfo)(checker, type);
+                    // Predicate is always necessary if it involves `any` or `unknown`
+                    if (!constraintType ||
+                        (0, util_1.isTypeAnyType)(constraintType) ||
+                        (0, util_1.isTypeUnknownType)(constraintType)) {
+                        return;
+                    }
+                    if ((0, util_1.isPossiblyFalsy)(constraintType)) {
+                        hasFalsyReturnTypes = true;
+                    }
+                    if ((0, util_1.isPossiblyTruthy)(constraintType)) {
+                        hasTruthyReturnTypes = true;
+                    }
+                    // bail early if both a possibly-truthy and a possibly-falsy have been detected
+                    if (hasFalsyReturnTypes && hasTruthyReturnTypes) {
+                        return;
+                    }
+                }
+                if (!hasFalsyReturnTypes) {
+                    return context.report({
+                        node: callback,
+                        messageId: 'alwaysTruthyFunc',
+                    });
+                }
+                if (!hasTruthyReturnTypes) {
+                    return context.report({
+                        node: callback,
+                        messageId: 'alwaysFalsyFunc',
+                    });
+                }
+            }
+        }
+        // Recursively searches an optional chain for an array index expression
+        //  Has to search the entire chain, because an array index will "infect" the rest of the types
+        //  Example:
+        //  ```
+        //  [{x: {y: "z"} }][n] // type is {x: {y: "z"}}
+        //    ?.x // type is {y: "z"}
+        //    ?.y // This access is considered "unnecessary" according to the types
+        //  ```
+        function optionChainContainsOptionArrayIndex(node) {
+            const lhsNode = node.type === utils_1.AST_NODE_TYPES.CallExpression ? node.callee : node.object;
+            if (node.optional && isArrayIndexExpression(lhsNode)) {
+                return true;
+            }
+            if (lhsNode.type === utils_1.AST_NODE_TYPES.MemberExpression ||
+                lhsNode.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                return optionChainContainsOptionArrayIndex(lhsNode);
+            }
+            return false;
+        }
+        function isNullablePropertyType(objType, propertyType) {
+            if (propertyType.isUnion()) {
+                return propertyType.types.some(type => isNullablePropertyType(objType, type));
+            }
+            if (propertyType.isNumberLiteral() || propertyType.isStringLiteral()) {
+                const propType = (0, util_1.getTypeOfPropertyOfName)(checker, objType, propertyType.value.toString());
+                if (propType) {
+                    return (0, util_1.isNullableType)(propType);
+                }
+            }
+            const typeName = (0, util_1.getTypeName)(checker, propertyType);
+            return checker
+                .getIndexInfosOfType(objType)
+                .some(info => (0, util_1.getTypeName)(checker, info.keyType) === typeName);
+        }
+        // Checks whether a member expression is nullable or not regardless of it's previous node.
+        //  Example:
+        //  ```
+        //  // 'bar' is nullable if 'foo' is null.
+        //  // but this function checks regardless of 'foo' type, so returns 'true'.
+        //  declare const foo: { bar : { baz: string } } | null
+        //  foo?.bar;
+        //  ```
+        function isMemberExpressionNullableOriginFromObject(node) {
+            const prevType = (0, util_1.getConstrainedTypeAtLocation)(services, node.object);
+            const property = node.property;
+            if (prevType.isUnion() && (0, util_1.isIdentifier)(property)) {
+                const isOwnNullable = prevType.types.some(type => {
+                    if (node.computed) {
+                        const propertyType = (0, util_1.getConstrainedTypeAtLocation)(services, node.property);
+                        return isNullablePropertyType(type, propertyType);
+                    }
+                    const propType = (0, util_1.getTypeOfPropertyOfName)(checker, type, property.name);
+                    if (propType) {
+                        return (0, util_1.isNullableType)(propType);
+                    }
+                    const indexInfo = checker.getIndexInfosOfType(type);
+                    return indexInfo.some(info => {
+                        const isStringTypeName = (0, util_1.getTypeName)(checker, info.keyType) === 'string';
+                        return (isStringTypeName &&
+                            (isNoUncheckedIndexedAccess || (0, util_1.isNullableType)(info.type)));
+                    });
+                });
+                return !isOwnNullable && (0, util_1.isNullableType)(prevType);
+            }
+            return false;
+        }
+        function isCallExpressionNullableOriginFromCallee(node) {
+            const prevType = (0, util_1.getConstrainedTypeAtLocation)(services, node.callee);
+            if (prevType.isUnion()) {
+                const isOwnNullable = prevType.types.some(type => {
+                    const signatures = type.getCallSignatures();
+                    return signatures.some(sig => (0, util_1.isNullableType)(sig.getReturnType()));
+                });
+                return !isOwnNullable && (0, util_1.isNullableType)(prevType);
+            }
+            return false;
+        }
+        function isOptionableExpression(node) {
+            const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
+            const isOwnNullable = node.type === utils_1.AST_NODE_TYPES.MemberExpression
+                ? !isMemberExpressionNullableOriginFromObject(node)
+                : node.type === utils_1.AST_NODE_TYPES.CallExpression
+                    ? !isCallExpressionNullableOriginFromCallee(node)
+                    : true;
+            return (isConditionalAlwaysNecessary(type) ||
+                (isOwnNullable && (0, util_1.isNullableType)(type)));
+        }
+        function checkOptionalChain(node, beforeOperator, fix) {
+            // We only care if this step in the chain is optional. If just descend
+            // from an optional chain, then that's fine.
+            if (!node.optional) {
+                return;
+            }
+            // Since typescript array index signature types don't represent the
+            //  possibility of out-of-bounds access, if we're indexing into an array
+            //  just skip the check, to avoid false positives
+            if (!isNoUncheckedIndexedAccess &&
+                optionChainContainsOptionArrayIndex(node)) {
+                return;
+            }
+            const nodeToCheck = node.type === utils_1.AST_NODE_TYPES.CallExpression ? node.callee : node.object;
+            if (isOptionableExpression(nodeToCheck)) {
+                return;
+            }
+            const questionDotOperator = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(beforeOperator, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === '?.'), util_1.NullThrowsReasons.MissingToken('operator', node.type));
+            context.report({
+                loc: questionDotOperator.loc,
+                node,
+                messageId: 'neverOptionalChain',
+                suggest: [
+                    {
+                        messageId: 'suggestRemoveOptionalChain',
+                        fix(fixer) {
+                            return fixer.replaceText(questionDotOperator, fix);
+                        },
+                    },
+                ],
+            });
+        }
+        function checkOptionalMemberExpression(node) {
+            checkOptionalChain(node, node.object, node.computed ? '' : '.');
+        }
+        function checkOptionalCallExpression(node) {
+            checkOptionalChain(node, node.callee, '');
+        }
+        function checkAssignmentExpression(node) {
+            // Similar to checkLogicalExpressionForUnnecessaryConditionals, since
+            // a ||= b is equivalent to a || (a = b)
+            if (['&&=', '||='].includes(node.operator)) {
+                checkNode(node.left);
+            }
+            else if (node.operator === '??=') {
+                checkNodeForNullish(node.left);
+            }
+        }
+        return {
+            AssignmentExpression: checkAssignmentExpression,
+            BinaryExpression(node) {
+                const { operator } = node;
+                if (isBoolOperator(operator)) {
+                    checkIfBoolExpressionIsNecessaryConditional(node, node.left, node.right, operator);
+                }
+            },
+            CallExpression: checkCallExpression,
+            'CallExpression[optional = true]': checkOptionalCallExpression,
+            ConditionalExpression: (node) => checkNode(node.test),
+            DoWhileStatement: checkIfLoopIsNecessaryConditional,
+            ForStatement: checkIfLoopIsNecessaryConditional,
+            IfStatement: (node) => checkNode(node.test),
+            LogicalExpression: checkLogicalExpressionForUnnecessaryConditionals,
+            'MemberExpression[optional = true]': checkOptionalMemberExpression,
+            SwitchCase({ parent, test }) {
+                // only check `case ...:`, not `default:`
+                if (test) {
+                    checkIfBoolExpressionIsNecessaryConditional(test, parent.discriminant, test, '===');
+                }
+            },
+            WhileStatement: checkIfLoopIsNecessaryConditional,
+        };
+    },
+});
+function normalizeAllowConstantLoopConditions(allowConstantLoopConditions) {
+    if (allowConstantLoopConditions === true) {
+        return 'always';
+    }
+    if (allowConstantLoopConditions === false) {
+        return 'never';
+    }
+    return allowConstantLoopConditions;
+}