@askviraj/linter 1.1.4 → 1.1.6

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/return-await.js

@@ -220,7 +220,18 @@ exports.default = (0, util_1.createRule)({
             if (nextToken) {
                 endAt = nextToken.range[0];
             }
-            return fixer.removeRange([startAt, endAt]);
+            const awaitRemovalFix = fixer.removeRange([startAt, endAt]);
+            const firstOperandToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(awaitToken), util_1.NullThrowsReasons.MissingToken('operand', 'await expression'));
+            const shouldWrapInParentheses = (0, util_1.isOpeningBraceToken)(firstOperandToken) &&
+                (0, util_1.isStartOfArrowFunctionBody)(node, context.sourceCode);
+            if (shouldWrapInParentheses) {
+                return [
+                    awaitRemovalFix,
+                    fixer.insertTextBefore(node.argument, '('),
+                    fixer.insertTextAfter(node.argument, ')'),
+                ];
+            }
+            return awaitRemovalFix;
         }
         function insertAwait(fixer, node, isHighPrecedence) {
             if (isHighPrecedence) {
@@ -361,3 +372,4 @@ function getConfiguration(option) {
             };
     }
 }
+//# sourceMappingURL=return-await.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/sort-type-constituents.js

@@ -270,3 +270,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=sort-type-constituents.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-boolean-expressions.js

@@ -880,3 +880,4 @@ function isBrandedBoolean(type) {
 function isBooleanType(expressionType) {
     return tsutils.isTypeFlagSet(expressionType, ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral);
 }
+//# sourceMappingURL=strict-boolean-expressions.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-void-return.d.ts

@@ -1,10 +1,11 @@
+import type { TSESLint } from '@typescript-eslint/utils';
 type Options = [
     {
         allowReturnAny?: boolean;
     }
 ];
-type MessageId = `asyncFunc` | `nonVoidFunc` | `nonVoidReturn`;
-declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageId, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+type MessageId = `asyncFunc` | `nonVoidFunc` | `nonVoidReturn` | `suggestAddVoidOp` | `suggestWrapInAsyncIIFE`;
+declare const _default: TSESLint.RuleModule<MessageId, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
     name: string;
 };
 export default _default;

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-void-return.js

@@ -45,10 +45,13 @@ exports.default = util.createRule({
             description: 'Disallow passing a value-returning function in a position accepting a void function',
             requiresTypeChecking: true,
         },
+        hasSuggestions: true,
         messages: {
             asyncFunc: 'Async function used in a context where a void function is expected.',
             nonVoidFunc: 'Value-returning function used in a context where a void function is expected.',
             nonVoidReturn: 'Value returned in a context where a void return is expected.',
+            suggestAddVoidOp: 'Add a void operator to discard the return value.',
+            suggestWrapInAsyncIIFE: 'Wrap the function body in an async IIFE.',
         },
         schema: [
             {
@@ -324,20 +327,55 @@ exports.default = util.createRule({
             }
             if (funcNode.async) {
                 // The provided function is an async function.
-                // Async functions aren't allowed.
+                if (funcNode.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                    // This async function is an arrow function shorthand without braces.
+                    return context.report({
+                        loc: util.getFunctionHeadLoc(funcNode, sourceCode),
+                        messageId: 'asyncFunc',
+                        suggest: utils_1.ASTUtils.hasSideEffect(funcNode.body, sourceCode)
+                            ? // This function has side effects, e.g. `async () => doSomething()`.
+                                // Suggest removing the async keyword and adding a void operator.
+                                [
+                                    {
+                                        messageId: 'suggestAddVoidOp',
+                                        fix: fixer => addVoidToArrowFix(fixer, funcNode),
+                                    },
+                                ]
+                            : [],
+                    });
+                }
+                // This async function has a block body.
+                // Suggest wrapping its body in an async IIFE.
                 return context.report({
                     loc: util.getFunctionHeadLoc(funcNode, sourceCode),
-                    messageId: `asyncFunc`,
+                    messageId: 'asyncFunc',
+                    suggest: [
+                        {
+                            messageId: 'suggestWrapInAsyncIIFE',
+                            fix: fixer => wrapInAsyncIIFEFix(fixer, funcNode),
+                        },
+                    ],
                 });
             }
+            // This function is a regular or arrow sync function.
             if (funcNode.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
-                // The provided function is an arrow function shorthand without braces.
+                // This function is an arrow function shorthand without braces.
                 return context.report({
                     node: funcNode.body,
-                    messageId: `nonVoidReturn`,
+                    messageId: 'nonVoidReturn',
+                    suggest: utils_1.ASTUtils.hasSideEffect(funcNode.body, sourceCode)
+                        ? // This function has side effects, e.g. `() => doSomething()`.
+                            // Suggest adding a void operator.
+                            [
+                                {
+                                    messageId: 'suggestAddVoidOp',
+                                    fix: fixer => addVoidToArrowFix(fixer, funcNode),
+                                },
+                            ]
+                        : [],
                 });
             }
-            // The function is a regular or arrow function with a block body.
+            // This function is a regular or arrow sync function with a block body.
             // Check return type annotation.
             if (funcNode.returnType != null) {
                 // The provided function has an explicit return type annotation.
@@ -373,5 +411,59 @@ exports.default = util.createRule({
             }
             // No invalid returns found. The function is allowed.
         }
+        /**
+         * Removes the async keyword and replaces the return type with void.
+         */
+        function* makeSyncFuncFix(fixer, funcNode) {
+            if (funcNode.async) {
+                // Remove async keyword
+                const funcHeadNode = funcNode.parent.type === utils_1.AST_NODE_TYPES.Property ||
+                    funcNode.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition
+                    ? funcNode.parent
+                    : funcNode;
+                const asyncToken = util.nullThrows(sourceCode.getFirstToken(funcHeadNode, {
+                    filter: token => token.value === 'async',
+                }), util.NullThrowsReasons.MissingToken('async keyword', funcNode.type));
+                yield fixer.remove(asyncToken);
+            }
+            // Replace return type with void
+            if (funcNode.returnType != null) {
+                yield fixer.replaceText(funcNode.returnType.typeAnnotation, 'void');
+            }
+        }
+        /**
+         * Makes the function sync and adds a void operator to the arrow shorthand body.
+         */
+        function* addVoidToArrowFix(fixer, funcNode) {
+            yield* makeSyncFuncFix(fixer, funcNode);
+            // Add void operator
+            yield util.getWrappingFixer({
+                node: funcNode.body,
+                sourceCode,
+                wrap: code => `void ${code}`,
+            })(fixer);
+        }
+        /**
+         * Makes the function sync and wraps the body in an inner async IIFE.
+         */
+        function* wrapInAsyncIIFEFix(fixer, funcNode) {
+            yield* makeSyncFuncFix(fixer, funcNode);
+            // Wrap body in async IIFE.
+            // This preserves the node kind (normal/arrow) for the _outer_ function
+            // and uses an arrow function for the _inner_ function,
+            // so that `this` will always refer to the same value as before.
+            if (funcNode.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                const arrowToken = util.nullThrows(sourceCode.getTokenBefore(funcNode.body, {
+                    filter: token => token.value === '=>',
+                }), util.NullThrowsReasons.MissingToken('arrow token', 'before arrow function body'));
+                yield fixer.insertTextAfter(arrowToken, ' void (async () =>');
+                yield fixer.insertTextAfter(funcNode, ')()');
+            }
+            else {
+                yield fixer.insertTextBefore(funcNode.body, '{ (async () => ');
+                yield fixer.insertTextAfter(funcNode.body, ')(); }');
+            }
+        }
     },
 });
+//# sourceMappingURL=strict-void-return.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/switch-exhaustiveness-check.js

@@ -289,3 +289,4 @@ function doesTypeContainNonLiteralType(type) {
         .intersectionConstituents(type)
         .every(subType => !isTypeLiteralLikeType(subType)));
 }
+//# sourceMappingURL=switch-exhaustiveness-check.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/triple-slash-reference.js

@@ -108,3 +108,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=triple-slash-reference.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/typedef.js

@@ -237,3 +237,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=typedef.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unbound-method.js

@@ -359,3 +359,4 @@ function isSafeUse(node) {
     }
     return false;
 }
+//# sourceMappingURL=unbound-method.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unified-signatures.d.ts

@@ -1,4 +1,4 @@
-export type MessageIds = 'omittingRestParameter' | 'omittingSingleParameter' | 'singleParameterDifference';
+export type MessageIds = 'allParametersAreSame' | 'omittingRestParameter' | 'omittingSingleParameter' | 'singleParameterDifference';
 export type Options = [
     {
         ignoreDifferentlyNamedParameters?: boolean;

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/unified-signatures.js

@@ -12,9 +12,10 @@ exports.default = (0, util_1.createRule)({
             recommended: 'strict',
         },
         messages: {
+            allParametersAreSame: '{{failureStringStart}} with identical parameters.',
             omittingRestParameter: '{{failureStringStart}} with a rest parameter.',
             omittingSingleParameter: '{{failureStringStart}} with an optional parameter.',
-            singleParameterDifference: '{{failureStringStart}} taking `{{type1}} | {{type2}}`.',
+            singleParameterDifference: '{{failureStringStart}} taking `{{types}}`.',
         },
         schema: [
             {
@@ -57,20 +58,15 @@ exports.default = (0, util_1.createRule)({
                     case 'single-parameter-difference': {
                         const { p0, p1 } = unify;
                         const lineOfOtherOverload = only2 ? undefined : p0.loc.start.line;
-                        const typeAnnotation0 = isTSParameterProperty(p0)
-                            ? p0.parameter.typeAnnotation
-                            : p0.typeAnnotation;
-                        const typeAnnotation1 = isTSParameterProperty(p1)
-                            ? p1.parameter.typeAnnotation
-                            : p1.typeAnnotation;
+                        const typeAnnotation0 = getParameterTypeAnnotation(p0);
+                        const typeAnnotation1 = getParameterTypeAnnotation(p1);
                         context.report({
                             loc: p1.loc,
                             node: p1,
                             messageId: 'singleParameterDifference',
                             data: {
                                 failureStringStart: failureStringStart(lineOfOtherOverload),
-                                type1: context.sourceCode.getText(typeAnnotation0?.typeAnnotation),
-                                type2: context.sourceCode.getText(typeAnnotation1?.typeAnnotation),
+                                types: getUnifiedTypeText(typeAnnotation0, typeAnnotation1),
                             },
                         });
                         break;
@@ -90,7 +86,24 @@ exports.default = (0, util_1.createRule)({
                                 failureStringStart: failureStringStart(lineOfOtherOverload),
                             },
                         });
+                        break;
+                    }
+                    case 'all-parameters-are-same': {
+                        const { signature0, signature1 } = unify;
+                        const lineOfOtherOverload = only2
+                            ? undefined
+                            : signature0.loc.start.line;
+                        context.report({
+                            node: signature1,
+                            messageId: 'allParametersAreSame',
+                            data: {
+                                failureStringStart: failureStringStart(lineOfOtherOverload),
+                            },
+                        });
+                        break;
                     }
+                    default:
+                        unify;
                 }
             }
         }
@@ -114,7 +127,7 @@ exports.default = (0, util_1.createRule)({
                 return undefined;
             }
             return a.params.length === b.params.length
-                ? signaturesDifferBySingleParameter(a.params, b.params)
+                ? signaturesHaveSameAmountOfParameters(a, b)
                 : signaturesDifferByOptionalOrRestParameter(a, b);
         }
         function signaturesCanBeUnified(a, b, isTypeParameter) {
@@ -138,15 +151,20 @@ exports.default = (0, util_1.createRule)({
                     return false;
                 }
             }
-            return (typesAreEqual(a.returnType, b.returnType) &&
+            return (typesAreEqual(a.returnType?.typeAnnotation, b.returnType?.typeAnnotation) &&
                 // Must take the same type parameters.
                 // If one uses a type parameter (from outside) and the other doesn't, they shouldn't be joined.
                 (0, util_1.arraysAreEqual)(aTypeParams, bTypeParams, typeParametersAreEqual) &&
                 signatureUsesTypeParameter(a, isTypeParameter) ===
                     signatureUsesTypeParameter(b, isTypeParameter));
         }
-        /** Detect `a(x: number, y: number, z: number)` and `a(x: number, y: string, z: number)`. */
-        function signaturesDifferBySingleParameter(types1, types2) {
+        /**
+         * Detect no difference, i.e. `a(x: number, y: string)` and `a(x: number, y: string)`,
+         * or one param difference, i.e. `a(x: number, y: number, z: number)` and `a(x: number, y: string, z: number)`.
+         */
+        function signaturesHaveSameAmountOfParameters(signature0, signature1) {
+            const types1 = signature0.params;
+            const types2 = signature1.params;
             const firstParam1 = types1[0];
             const firstParam2 = types2[0];
             // exempt signatures with `this: void` from the rule
@@ -155,7 +173,11 @@ exports.default = (0, util_1.createRule)({
             }
             const index = getIndexOfFirstDifference(types1, types2, parametersAreEqual);
             if (index == null) {
-                return undefined;
+                return {
+                    kind: 'all-parameters-are-same',
+                    signature0,
+                    signature1,
+                };
             }
             // If remaining arrays are equal, the signatures differ by just one parameter type
             if (!(0, util_1.arraysAreEqual)(types1.slice(index + 1), types2.slice(index + 1), parametersAreEqual)) {
@@ -170,6 +192,39 @@ exports.default = (0, util_1.createRule)({
                 ? { kind: 'single-parameter-difference', p0: a, p1: b }
                 : undefined;
         }
+        function getParameterTypeAnnotation(parameter) {
+            return isTSParameterProperty(parameter)
+                ? parameter.parameter.typeAnnotation?.typeAnnotation
+                : parameter.typeAnnotation?.typeAnnotation;
+        }
+        function getUnifiedTypeText(type0, type1) {
+            // When a signature's parameter has no type annotation
+            if (type0 == null || type1 == null) {
+                return getUnionMemberText((0, util_1.nullThrows)(type0 ?? type1, 'Expected a type annotation for one of the parameters, but both were undefined'));
+            }
+            const members = [...getUnionMembers(type0), ...getUnionMembers(type1)];
+            const uniqueMembers = [];
+            for (const member of members) {
+                if (!uniqueMembers.some(other => typesAreEqual(other, member))) {
+                    uniqueMembers.push(member);
+                }
+            }
+            return uniqueMembers
+                .map(member => getUnionMemberText(member))
+                .join(' | ');
+        }
+        function getUnionMembers(type) {
+            return type.type === utils_1.AST_NODE_TYPES.TSUnionType
+                ? type.types.flatMap(getUnionMembers)
+                : [type];
+        }
+        function getUnionMemberText(type) {
+            const text = context.sourceCode.getText(type);
+            const needsParentheses = type.type === utils_1.AST_NODE_TYPES.TSConditionalType ||
+                type.type === utils_1.AST_NODE_TYPES.TSConstructorType ||
+                type.type === utils_1.AST_NODE_TYPES.TSFunctionType;
+            return needsParentheses ? `(${text})` : text;
+        }
         function isThisParam(param) {
             return param?.type === utils_1.AST_NODE_TYPES.Identifier && param.name === 'this';
         }
@@ -209,15 +264,7 @@ exports.default = (0, util_1.createRule)({
                 }
             }
             for (let i = 0; i < minLength; i++) {
-                const sig1i = sig1[i];
-                const sig2i = sig2[i];
-                const typeAnnotation1 = isTSParameterProperty(sig1i)
-                    ? sig1i.parameter.typeAnnotation
-                    : sig1i.typeAnnotation;
-                const typeAnnotation2 = isTSParameterProperty(sig2i)
-                    ? sig2i.parameter.typeAnnotation
-                    : sig2i.typeAnnotation;
-                if (!typesAreEqual(typeAnnotation1, typeAnnotation2)) {
+                if (!typesAreEqual(getParameterTypeAnnotation(sig1[i]), getParameterTypeAnnotation(sig2[i]))) {
                     return undefined;
                 }
             }
@@ -265,14 +312,8 @@ exports.default = (0, util_1.createRule)({
             return node.type === utils_1.AST_NODE_TYPES.TSParameterProperty;
         }
         function parametersAreEqual(a, b) {
-            const typeAnnotationA = isTSParameterProperty(a)
-                ? a.parameter.typeAnnotation
-                : a.typeAnnotation;
-            const typeAnnotationB = isTSParameterProperty(b)
-                ? b.parameter.typeAnnotation
-                : b.typeAnnotation;
             return (parametersHaveEqualSigils(a, b) &&
-                typesAreEqual(typeAnnotationA, typeAnnotationB));
+                typesAreEqual(getParameterTypeAnnotation(a), getParameterTypeAnnotation(b)));
         }
         /** True for optional/rest parameters. */
         function parameterMayBeMissing(p) {
@@ -300,8 +341,7 @@ exports.default = (0, util_1.createRule)({
             return (a === b ||
                 (a != null &&
                     b != null &&
-                    context.sourceCode.getText(a.typeAnnotation) ===
-                        context.sourceCode.getText(b.typeAnnotation)));
+                    context.sourceCode.getText(a) === context.sourceCode.getText(b)));
         }
         function constraintsAreEqual(a, b) {
             return a === b || (a != null && a.type === b?.type);
@@ -463,3 +503,4 @@ function isPrivateIdentifier(node) {
 function isGetterOrSetter(node) {
     return node.kind === 'get' || node.kind === 'set';
 }
+//# sourceMappingURL=unified-signatures.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/use-unknown-in-catch-callback-variable.js

@@ -259,3 +259,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=use-unknown-in-catch-callback-variable.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/util/FunctionSignature.d.ts

@@ -0,0 +1,15 @@
+import * as ts from 'typescript';
+/**
+ * Tracks checking the parameters of a single function signature.
+ * This allows rules to "consume" parameters and check for unsafe comparisons.
+ */
+export declare class FunctionSignature {
+    private readonly paramTypes;
+    private readonly restType;
+    private hasConsumedArguments;
+    private parameterTypeIndex;
+    private constructor();
+    static create(checker: ts.TypeChecker, tsNode: ts.CallLikeExpression): FunctionSignature;
+    consumeRemainingArguments(): void;
+    getNextParameterType(): ts.Type | null;
+}

package/node_modules/@typescript-eslint/eslint-plugin/dist/util/FunctionSignature.js

@@ -0,0 +1,123 @@
+"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 });
+exports.FunctionSignature = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const ts = __importStar(require("typescript"));
+const misc_1 = require("./misc");
+const { nullThrows } = utils_1.ESLintUtils;
+var RestTypeKind;
+(function (RestTypeKind) {
+    RestTypeKind[RestTypeKind["Array"] = 0] = "Array";
+    RestTypeKind[RestTypeKind["Other"] = 1] = "Other";
+    RestTypeKind[RestTypeKind["Tuple"] = 2] = "Tuple";
+})(RestTypeKind || (RestTypeKind = {}));
+/**
+ * Tracks checking the parameters of a single function signature.
+ * This allows rules to "consume" parameters and check for unsafe comparisons.
+ */
+class FunctionSignature {
+    paramTypes;
+    restType;
+    hasConsumedArguments = false;
+    parameterTypeIndex = 0;
+    constructor(paramTypes, restType) {
+        this.paramTypes = paramTypes;
+        this.restType = restType;
+    }
+    static create(checker, tsNode) {
+        // getResolvedSignature only returns undefined for nodes outside the parse
+        // tree, and tsNode always comes from the AST node map.
+        const signature = nullThrows(checker.getResolvedSignature(tsNode), 'Expected the call-like node to resolve to a signature.');
+        const paramTypes = [];
+        let restType = null;
+        const parameters = signature.getParameters();
+        for (let index = 0; index < parameters.length; index += 1) {
+            const param = parameters[index];
+            const declaration = param.getDeclarations()?.[0];
+            const type = checker.getTypeOfSymbolAtLocation(param, tsNode);
+            const constrainedType = checker.getBaseConstraintOfType(type) ?? type;
+            if (declaration && (0, misc_1.isRestParameterDeclaration)(declaration)) {
+                if (checker.isTupleType(constrainedType)) {
+                    restType = {
+                        index,
+                        kind: RestTypeKind.Tuple,
+                        typeArguments: checker.getTypeArguments(constrainedType),
+                    };
+                }
+                else {
+                    const elementType = checker.getIndexTypeOfType(constrainedType, ts.IndexKind.Number);
+                    restType = elementType
+                        ? { index, kind: RestTypeKind.Array, type: elementType }
+                        : { index, kind: RestTypeKind.Other, type: constrainedType };
+                }
+                break;
+            }
+            paramTypes.push(type);
+        }
+        return new FunctionSignature(paramTypes, restType);
+    }
+    consumeRemainingArguments() {
+        this.hasConsumedArguments = true;
+    }
+    getNextParameterType() {
+        const index = this.parameterTypeIndex;
+        this.parameterTypeIndex += 1;
+        if (index >= this.paramTypes.length || this.hasConsumedArguments) {
+            if (this.restType == null) {
+                return null;
+            }
+            switch (this.restType.kind) {
+                case RestTypeKind.Tuple: {
+                    const { typeArguments } = this.restType;
+                    if (this.hasConsumedArguments) {
+                        return typeArguments[typeArguments.length - 1];
+                    }
+                    const typeIndex = index - this.restType.index;
+                    if (typeIndex >= typeArguments.length) {
+                        return typeArguments[typeArguments.length - 1];
+                    }
+                    return typeArguments[typeIndex];
+                }
+                case RestTypeKind.Array:
+                case RestTypeKind.Other:
+                    return this.restType.type;
+            }
+        }
+        return this.paramTypes[index];
+    }
+}
+exports.FunctionSignature = FunctionSignature;
+//# sourceMappingURL=FunctionSignature.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/util/assertionFunctionUtils.js

@@ -114,3 +114,4 @@ function findTypeGuardAssertedArgument(services, node) {
         type,
     };
 }
+//# sourceMappingURL=assertionFunctionUtils.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/util/astUtils.js

@@ -141,3 +141,4 @@ function forEachChildESTree(node, callback) {
     }
     return visit(node);
 }
+//# sourceMappingURL=astUtils.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/util/baseTypeUtils.d.ts

@@ -1,6 +1,8 @@
 import type { ParserServicesWithTypeInformation } from '@typescript-eslint/utils';
 import type { InterfaceType, Type } from 'typescript';
 export declare function hasBaseTypes(type: Type): type is InterfaceType;
+export declare function isNumberLike(type: Type): boolean;
+export declare function isStringLike(type: Type): boolean;
 /**
  * Recursively checks if a type or any of its base types matches the provided
  * matcher function.

package/node_modules/@typescript-eslint/eslint-plugin/dist/util/baseTypeUtils.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasBaseTypes = hasBaseTypes;
+exports.isNumberLike = isNumberLike;
+exports.isStringLike = isStringLike;
 exports.matchesTypeOrBaseType = matchesTypeOrBaseType;
 const ts_api_utils_1 = require("ts-api-utils");
 const tsutils = __importStar(require("ts-api-utils"));
@@ -53,6 +55,20 @@ function hasBaseTypes(type) {
     return ((0, ts_api_utils_1.isObjectType)(type) &&
         (0, ts_api_utils_1.isObjectFlagSet)(type, ts.ObjectFlags.Interface | ts.ObjectFlags.Class));
 }
+function isNumberLike(type) {
+    return tsutils
+        .unionConstituents(type)
+        .every(unionPart => tsutils
+        .intersectionConstituents(unionPart)
+        .some(intersectionPart => tsutils.isTypeFlagSet(intersectionPart, ts.TypeFlags.NumberLike)));
+}
+function isStringLike(type) {
+    return tsutils
+        .unionConstituents(type)
+        .every(unionPart => tsutils
+        .intersectionConstituents(unionPart)
+        .some(intersectionPart => tsutils.isTypeFlagSet(intersectionPart, ts.TypeFlags.StringLike)));
+}
 /**
  * Recursively checks if a type or any of its base types matches the provided
  * matcher function.
@@ -73,3 +89,4 @@ function matchesTypeOrBaseType(services, matcher, type, seen = new Set()) {
     const checker = services.program.getTypeChecker();
     return getBaseTypesForType(checker, type).some(base => matchesTypeOrBaseType(services, matcher, base, seen));
 }
+//# sourceMappingURL=baseTypeUtils.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/classScopeAnalyzer.js

@@ -564,3 +564,4 @@ function traverseScopes(currentScope, analysisResults = new Map()) {
     }
     return analysisResults;
 }
+//# sourceMappingURL=classScopeAnalyzer.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/extractComputedName.js

@@ -68,3 +68,4 @@ function extractNameForMemberExpression(node) {
     }
     return extractNonComputedName(node.property);
 }
+//# sourceMappingURL=extractComputedName.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/util/class-scope-analyzer/types.js

@@ -8,3 +8,4 @@ function publicKey(name) {
 function privateKey(node) {
     return `#private@@${node.name}`;
 }
+//# sourceMappingURL=types.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/util/collectUnusedVariables.js

@@ -599,3 +599,4 @@ function isUsedVariable(variable) {
 function collectVariables(context) {
     return UnusedVarsVisitor.collectUnusedVariables(context.sourceCode.ast, utils_1.ESLintUtils.nullThrows(context.sourceCode.scopeManager, 'Missing required scope manager'));
 }
+//# sourceMappingURL=collectUnusedVariables.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/util/createRule.js

@@ -3,3 +3,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRule = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 exports.createRule = utils_1.ESLintUtils.RuleCreator(name => `https://typescript-eslint.io/rules/${name}`);
+//# sourceMappingURL=createRule.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/util/escapeRegExp.js

@@ -12,3 +12,4 @@ function escapeRegExp(string = '') {
         ? string.replaceAll(reRegExpChar, '\\$&')
         : string;
 }
+//# sourceMappingURL=escapeRegExp.js.map