@askviraj/linter 1.1.2 → 1.1.4

package/node_modules/@types/hast/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/hast",
-    "version": "3.0.4",
+    "version": "3.0.5",
     "description": "TypeScript definitions for hast",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/hast",
     "license": "MIT",
@@ -24,6 +24,11 @@
             "name": "Remco Haszing",
             "githubUsername": "remcohaszing",
             "url": "https://github.com/remcohaszing"
+        },
+        {
+            "name": "Titus Wormer",
+            "githubUsername": "wooorm",
+            "url": "https://github.com/wooorm"
         }
     ],
     "main": "",
@@ -37,6 +42,7 @@
     "dependencies": {
         "@types/unist": "*"
     },
-    "typesPublisherContentHash": "3f3f73826d79157c12087f5bb36195319c6f435b9e218fa7a8de88d1cc64d097",
-    "typeScriptVersion": "4.6"
+    "peerDependencies": {},
+    "typesPublisherContentHash": "7c853a7c57790776fc3d5f6a721e61b09901a7222feadc4c561ddf607e7b29fc",
+    "typeScriptVersion": "5.6"
 }

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.d.ts

@@ -58,8 +58,6 @@ declare const _default: {
         'no-invalid-this': "off";
         '@typescript-eslint/no-invalid-this': "error";
         '@typescript-eslint/no-invalid-void-type': "error";
-        'no-loop-func': "off";
-        '@typescript-eslint/no-loop-func': "error";
         'no-magic-numbers': "off";
         '@typescript-eslint/no-magic-numbers': "error";
         '@typescript-eslint/no-meaningless-void-operator': "error";
@@ -75,8 +73,6 @@ declare const _default: {
         '@typescript-eslint/no-redeclare': "error";
         '@typescript-eslint/no-redundant-type-constituents': "error";
         '@typescript-eslint/no-require-imports': "error";
-        'no-restricted-imports': "off";
-        '@typescript-eslint/no-restricted-imports': "error";
         '@typescript-eslint/no-restricted-types': "error";
         'no-shadow': "off";
         '@typescript-eslint/no-shadow': "error";

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.js

@@ -65,8 +65,6 @@ module.exports = {
         'no-invalid-this': 'off',
         '@typescript-eslint/no-invalid-this': 'error',
         '@typescript-eslint/no-invalid-void-type': 'error',
-        'no-loop-func': 'off',
-        '@typescript-eslint/no-loop-func': 'error',
         'no-magic-numbers': 'off',
         '@typescript-eslint/no-magic-numbers': 'error',
         '@typescript-eslint/no-meaningless-void-operator': 'error',
@@ -82,8 +80,6 @@ module.exports = {
         '@typescript-eslint/no-redeclare': 'error',
         '@typescript-eslint/no-redundant-type-constituents': 'error',
         '@typescript-eslint/no-require-imports': 'error',
-        'no-restricted-imports': 'off',
-        '@typescript-eslint/no-restricted-imports': 'error',
         '@typescript-eslint/no-restricted-types': 'error',
         'no-shadow': 'off',
         '@typescript-eslint/no-shadow': 'error',

package/node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/all.js

@@ -78,8 +78,6 @@ exports.default = (plugin, parser) => [
             'no-invalid-this': 'off',
             '@typescript-eslint/no-invalid-this': 'error',
             '@typescript-eslint/no-invalid-void-type': 'error',
-            'no-loop-func': 'off',
-            '@typescript-eslint/no-loop-func': 'error',
             'no-magic-numbers': 'off',
             '@typescript-eslint/no-magic-numbers': 'error',
             '@typescript-eslint/no-meaningless-void-operator': 'error',
@@ -95,8 +93,6 @@ exports.default = (plugin, parser) => [
             '@typescript-eslint/no-redeclare': 'error',
             '@typescript-eslint/no-redundant-type-constituents': 'error',
             '@typescript-eslint/no-require-imports': 'error',
-            'no-restricted-imports': 'off',
-            '@typescript-eslint/no-restricted-imports': 'error',
             '@typescript-eslint/no-restricted-types': 'error',
             'no-shadow': 'off',
             '@typescript-eslint/no-shadow': 'error',

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

@@ -60,8 +60,6 @@ declare const _default: {
                 'no-invalid-this': "off";
                 '@typescript-eslint/no-invalid-this': "error";
                 '@typescript-eslint/no-invalid-void-type': "error";
-                'no-loop-func': "off";
-                '@typescript-eslint/no-loop-func': "error";
                 'no-magic-numbers': "off";
                 '@typescript-eslint/no-magic-numbers': "error";
                 '@typescript-eslint/no-meaningless-void-operator': "error";
@@ -77,8 +75,6 @@ declare const _default: {
                 '@typescript-eslint/no-redeclare': "error";
                 '@typescript-eslint/no-redundant-type-constituents': "error";
                 '@typescript-eslint/no-require-imports': "error";
-                'no-restricted-imports': "off";
-                '@typescript-eslint/no-restricted-imports': "error";
                 '@typescript-eslint/no-restricted-types': "error";
                 'no-shadow': "off";
                 '@typescript-eslint/no-shadow': "error";

package/node_modules/@typescript-eslint/eslint-plugin/dist/index.js

@@ -1,6 +1,53 @@
 "use strict";
+/* eslint-disable import/first -- intentionally executing code before rest of the require()s. This will not work with ESM. */
+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;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+const ts = __importStar(require("typescript"));
+const [versionMajor, _versionMinor] = ts.versionMajorMinor
+    .split('.')
+    .map(Number);
+if (versionMajor >= 7) {
+    // eslint-disable-next-line no-console
+    console.error([
+        'typescript-eslint does not support TS 7.0.',
+        'Please see https://devblogs.microsoft.com/typescript/announcing-typescript-7-0/#running-side-by-side-with-typescript-6.0 to run typescript-eslint using the TS 6 API.',
+        "See also https://github.com/typescript-eslint/typescript-eslint/issues/10940 for tracking typescript-eslint's support for TS >=7.1",
+    ].join('\n'));
+    throw new Error('typescript-eslint does not support TS 7.0.');
+}
 const raw_plugin_1 = __importDefault(require("./raw-plugin"));
 module.exports = raw_plugin_1.default.plugin;

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

@@ -82,8 +82,6 @@ declare const _default: {
                     'no-invalid-this': "off";
                     '@typescript-eslint/no-invalid-this': "error";
                     '@typescript-eslint/no-invalid-void-type': "error";
-                    'no-loop-func': "off";
-                    '@typescript-eslint/no-loop-func': "error";
                     'no-magic-numbers': "off";
                     '@typescript-eslint/no-magic-numbers': "error";
                     '@typescript-eslint/no-meaningless-void-operator': "error";
@@ -99,8 +97,6 @@ declare const _default: {
                     '@typescript-eslint/no-redeclare': "error";
                     '@typescript-eslint/no-redundant-type-constituents': "error";
                     '@typescript-eslint/no-require-imports': "error";
-                    'no-restricted-imports': "off";
-                    '@typescript-eslint/no-restricted-imports': "error";
                     '@typescript-eslint/no-restricted-types': "error";
                     'no-shadow': "off";
                     '@typescript-eslint/no-shadow': "error";

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-ts-comment.js

@@ -54,19 +54,19 @@ exports.default = (0, util_1.createRule)({
                     },
                     'ts-check': {
                         $ref: '#/items/0/$defs/directiveConfigSchema',
-                        description: 'Whether allow ts-check directives, and with which restrictions.',
+                        description: 'Whether to allow ts-check directives, and with which restrictions.',
                     },
                     'ts-expect-error': {
                         $ref: '#/items/0/$defs/directiveConfigSchema',
-                        description: 'Whether and when expect-error directives, and with which restrictions.',
+                        description: 'Whether to allow ts-expect-error directives, and with which restrictions.',
                     },
                     'ts-ignore': {
                         $ref: '#/items/0/$defs/directiveConfigSchema',
-                        description: 'Whether allow ts-ignore directives, and with which restrictions.',
+                        description: 'Whether to allow ts-ignore directives, and with which restrictions.',
                     },
                     'ts-nocheck': {
                         $ref: '#/items/0/$defs/directiveConfigSchema',
-                        description: 'Whether allow ts-nocheck directives, and with which restrictions.',
+                        description: 'Whether to allow ts-nocheck directives, and with which restrictions.',
                     },
                 },
             },

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/method-signature-style.d.ts

@@ -1,5 +1,5 @@
 export type Options = [('method' | 'property')?];
-export type MessageIds = 'errorMethod' | 'errorProperty';
+export type MessageIds = 'convertToMethodSignature' | 'errorMethod' | 'errorProperty';
 declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

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

@@ -10,7 +10,9 @@ exports.default = (0, util_1.createRule)({
             description: 'Enforce using a particular method signature syntax',
         },
         fixable: 'code',
+        hasSuggestions: true,
         messages: {
+            convertToMethodSignature: 'Convert to a method signature. This removes the `readonly` modifier, allowing the member to be reassigned.',
             errorMethod: 'Shorthand method signature is forbidden. Use a function property instead.',
             errorProperty: 'Function property signature is forbidden. Use a method shorthand instead.',
         },
@@ -32,9 +34,6 @@ exports.default = (0, util_1.createRule)({
             if (node.optional) {
                 key = `${key}?`;
             }
-            if (node.readonly) {
-                key = `readonly ${key}`;
-            }
             return key;
         }
         function getMethodParams(node) {
@@ -164,16 +163,30 @@ exports.default = (0, util_1.createRule)({
                     if (typeNode?.type !== utils_1.AST_NODE_TYPES.TSFunctionType) {
                         return;
                     }
+                    const fix = fixer => {
+                        const key = getMethodKey(propertyNode);
+                        const params = getMethodParams(typeNode);
+                        const returnType = getMethodReturnType(typeNode);
+                        const delimiter = getDelimiter(propertyNode);
+                        return fixer.replaceText(propertyNode, `${key}${params}: ${returnType}${delimiter}`);
+                    };
+                    // There is no syntax for a `readonly` method signature, so converting
+                    // a `readonly` function-typed property drops the `readonly` modifier.
+                    // That is a behavioral change (a method may be reassigned, a
+                    // `readonly` property may not), so it is offered as a suggestion
+                    // rather than applied as an autofix.
+                    if (propertyNode.readonly) {
+                        context.report({
+                            node: propertyNode,
+                            messageId: 'errorProperty',
+                            suggest: [{ messageId: 'convertToMethodSignature', fix }],
+                        });
+                        return;
+                    }
                     context.report({
                         node: propertyNode,
                         messageId: 'errorProperty',
-                        fix: fixer => {
-                            const key = getMethodKey(propertyNode);
-                            const params = getMethodParams(typeNode);
-                            const returnType = getMethodReturnType(typeNode);
-                            const delimiter = getDelimiter(propertyNode);
-                            return fixer.replaceText(propertyNode, `${key}${params}: ${returnType}${delimiter}`);
-                        },
+                        fix,
                     });
                 },
             }),

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-base-to-string.js

@@ -234,7 +234,7 @@ exports.default = (0, util_1.createRule)({
                 node.arguments[0]) {
                 const scope = context.sourceCode.getScope(node);
                 // eslint-disable-next-line @typescript-eslint/internal/prefer-ast-types-enum
-                const variable = scope.set.get('String');
+                const variable = utils_1.ASTUtils.findVariable(scope, 'String');
                 return !variable?.defs.length;
             }
             return false;

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

@@ -4,11 +4,24 @@ 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');
+const CONSTANT_BINDINGS = new Set(['await using', 'const', 'using']);
 exports.default = (0, util_1.createRule)({
     name: 'no-loop-func',
     meta: {
         type: 'suggestion',
         // defaultOptions, -- base rule does not use defaultOptions
+        deprecated: {
+            deprecatedSince: '8.64.0',
+            replacedBy: [
+                {
+                    rule: {
+                        name: 'no-loop-func',
+                        url: 'https://eslint.org/docs/latest/rules/no-loop-func',
+                    },
+                },
+            ],
+            url: 'https://github.com/typescript-eslint/typescript-eslint/issues/12496',
+        },
         docs: {
             description: 'Disallow function declarations that contain unsafe references inside loop statements',
             extendsBaseRule: true,
@@ -100,8 +113,9 @@ exports.default = (0, util_1.createRule)({
             if (reference.isTypeReference) {
                 return true;
             }
-            // Variables which are declared by `const` is safe.
-            if (kind === 'const') {
+            // Variables which are declared by `const`, `using`, or `await using` are
+            // safe. They can't be reassigned, so each iteration captures a fresh one.
+            if (CONSTANT_BINDINGS.has(kind)) {
                 return true;
             }
             /*

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

@@ -340,11 +340,27 @@ exports.default = (0, util_1.createRule)({
         }
         function checkVariableDeclaration(node) {
             const tsNode = services.esTreeNodeToTSNodeMap.get(node);
-            if (tsNode.initializer == null ||
-                node.init == null ||
-                node.id.typeAnnotation == null) {
+            if (tsNode.initializer == null || node.init == null) {
                 return;
             }
+            if (node.parent.kind === 'using' &&
+                hasWellKnownSymbolWithThenableReturn(checker, tsNode.initializer, checker.getTypeAtLocation(tsNode.initializer), 'dispose')) {
+                context.report({
+                    node: node.init,
+                    messageId: 'voidReturnVariable',
+                });
+            }
+            if (node.id.typeAnnotation == null) {
+                return;
+            }
+            const variableType = services.getTypeAtLocation(node.id);
+            if (hasWellKnownSymbolWithVoidReturn(checker, tsNode.name, variableType, 'dispose') &&
+                hasWellKnownSymbolWithThenableReturn(checker, tsNode.initializer, checker.getTypeAtLocation(tsNode.initializer), 'dispose')) {
+                context.report({
+                    node: node.init,
+                    messageId: 'voidReturnVariable',
+                });
+            }
             // syntactically ignore some known-good cases to avoid touching type info
             if (!isPossiblyFunctionType(node.id.typeAnnotation)) {
                 return;
@@ -763,3 +779,25 @@ function isStaticMember(node) {
         node.type === utils_1.AST_NODE_TYPES.AccessorProperty) &&
         node.static);
 }
+function hasWellKnownSymbolWithThenableReturn(checker, node, type, symbolName) {
+    return tsutils
+        .unionConstituents(checker.getApparentType(type))
+        .some(typePart => {
+        const symbol = tsutils.getWellKnownSymbolPropertyOfType(typePart, symbolName, checker);
+        if (symbol == null) {
+            return false;
+        }
+        return isThenableReturningFunctionType(checker, node, checker.getTypeOfSymbolAtLocation(symbol, node));
+    });
+}
+function hasWellKnownSymbolWithVoidReturn(checker, node, type, symbolName) {
+    return tsutils
+        .unionConstituents(checker.getApparentType(type))
+        .some(typePart => {
+        const symbol = tsutils.getWellKnownSymbolPropertyOfType(typePart, symbolName, checker);
+        if (symbol == null) {
+            return false;
+        }
+        return isVoidReturningFunctionType(checker, node, checker.getTypeOfSymbolAtLocation(symbol, node));
+    });
+}

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

@@ -135,6 +135,18 @@ exports.default = (0, util_1.createRule)({
     meta: {
         type: 'suggestion',
         // defaultOptions, -- base rule does not use defaultOptions
+        deprecated: {
+            deprecatedSince: '8.64.0',
+            replacedBy: [
+                {
+                    rule: {
+                        name: 'no-restricted-imports',
+                        url: 'https://eslint.org/docs/latest/rules/no-restricted-imports',
+                    },
+                },
+            ],
+            url: 'https://github.com/typescript-eslint/typescript-eslint/pull/12527',
+        },
         docs: {
             description: 'Disallow specified modules when loaded by `import`',
             extendsBaseRule: true,

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

@@ -1,5 +1,5 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-export type MessageIds = 'noShadow' | 'noShadowGlobal';
+export type MessageIds = 'noEnumShadow' | 'noShadow' | 'noShadowGlobal';
 export type Options = [
     {
         allow?: string[];

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

@@ -27,6 +27,7 @@ exports.default = (0, util_1.createRule)({
             extendsBaseRule: true,
         },
         messages: {
+            noEnumShadow: "Enum members are added to the enum scope, so references to '{{name}}' in enum member initializers resolve to this member instead of the declaration in the upper scope on line {{shadowedLine}} column {{shadowedColumn}}.",
             noShadow: "'{{name}}' is already declared in the upper scope on line {{shadowedLine}} column {{shadowedColumn}}.",
             noShadowGlobal: "'{{name}}' is already a global variable.",
         },
@@ -57,7 +58,7 @@ exports.default = (0, util_1.createRule)({
                     },
                     ignoreOnInitialization: {
                         type: 'boolean',
-                        description: 'Whether to ignore the variable initializers when the shadowed variable is presumably still unitialized.',
+                        description: 'Whether to ignore the variable initializers when the shadowed variable is presumably still uninitialized.',
                     },
                     ignoreTypeValueShadow: {
                         type: 'boolean',
@@ -274,8 +275,7 @@ exports.default = (0, util_1.createRule)({
                 return false;
             }
             const { variableScope } = variable.scope;
-            if (!((variableScope.block.type ===
-                utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            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;
@@ -514,6 +514,7 @@ exports.default = (0, util_1.createRule)({
                         isInitPatternNode(variable, shadowed)) &&
                     !(options.hoist !== 'all' && isInTdz(variable, shadowed))) {
                     const location = getDeclaredLocation(shadowed);
+                    const isEnumDeclaration = shadowed.defs.some(def => def.type === scope_manager_1.DefinitionType.TSEnumName);
                     context.report({
                         node: variable.identifiers[0],
                         ...(location.global
@@ -524,7 +525,7 @@ exports.default = (0, util_1.createRule)({
                                 },
                             }
                             : {
-                                messageId: 'noShadow',
+                                messageId: isEnumDeclaration ? 'noEnumShadow' : 'noShadow',
                                 data: {
                                     name: variable.name,
                                     shadowedColumn: location.column,

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

@@ -21,7 +21,7 @@ exports.default = (0, util_1.createRule)({
                 properties: {
                     allowDestructuring: {
                         type: 'boolean',
-                        description: 'Whether to ignore destructurings, such as `const { props, state } = this`.',
+                        description: 'Whether to ignore destructuring, such as `const { props, state } = this`.',
                     },
                     allowedNames: {
                         type: 'array',

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-parameter-property-assignment.js

@@ -27,7 +27,7 @@ exports.default = (0, util_1.createRule)({
             if (!isThisMemberExpression(node)) {
                 return null;
             }
-            if (node.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+            if (!node.computed && node.property.type === utils_1.AST_NODE_TYPES.Identifier) {
                 return node.property.name;
             }
             if (node.computed) {

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-template-expression.js

@@ -173,7 +173,7 @@ exports.default = (0, util_1.createRule)({
             }
             return false;
         }
-        function isUnncessaryTypeInterpolation({ interpolation, nextQuasi, prevQuasi, }) {
+        function isUnnecessaryTypeInterpolation({ interpolation, nextQuasi, prevQuasi, }) {
             if (hasCommentsBetweenQuasi(prevQuasi, nextQuasi)) {
                 return false;
             }
@@ -337,7 +337,7 @@ exports.default = (0, util_1.createRule)({
                         return;
                     }
                 }
-                const infos = getInterpolationInfos(node).filter(isUnncessaryTypeInterpolation);
+                const infos = getInterpolationInfos(node).filter(isUnnecessaryTypeInterpolation);
                 for (const reportDescriptor of getReportDescriptors(infos)) {
                     context.report(reportDescriptor);
                 }

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-assertion.js

@@ -414,7 +414,11 @@ exports.default = (0, util_1.createRule)({
                 !parent.arguments.includes(node)) {
                 return false;
             }
-            const calleeType = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(parent.callee));
+            // An optional-chained callee (`foo?.bar(...)`) types as `<method> | undefined`,
+            // and a union exposes no call signatures — strip the nullability first.
+            const calleeType = services
+                .getTypeAtLocation(parent.callee)
+                .getNonNullableType();
             const signatures = calleeType.getCallSignatures();
             if (signatures.length <= 1) {
                 return false;

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unused-vars.js

@@ -113,7 +113,7 @@ exports.default = (0, util_1.createRule)({
                             },
                             ignoreRestSiblings: {
                                 type: 'boolean',
-                                description: 'Whether to ignore sibling properties in `...` destructurings.',
+                                description: 'Whether to ignore sibling properties in `...` destructuring.',
                             },
                             ignoreUsingDeclarations: {
                                 type: 'boolean',

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-string-starts-ends-with.js

@@ -206,7 +206,8 @@ exports.default = (0, util_1.createRule)({
             }
             const { flags, source } = evaluated.value;
             const isStartsWith = source.startsWith('^');
-            const isEndsWith = source.endsWith('$');
+            // ends with a $ preceded by an even number of backslashes (or zero)
+            const isEndsWith = /[^\\](\\\\)*\$$/.test(source);
             if (isStartsWith === isEndsWith ||
                 flags.includes('i') ||
                 flags.includes('m')) {

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/require-array-sort-compare.js

@@ -37,7 +37,7 @@ exports.default = (0, util_1.createRule)({
          * Check if a given node is an array which all elements are string.
          */
         function isStringArrayNode(node) {
-            const type = services.getTypeAtLocation(node);
+            const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
             if (checker.isArrayType(type) || checker.isTupleType(type)) {
                 const typeArgs = checker.getTypeArguments(type);
                 return typeArgs.every(arg => (0, util_1.getTypeName)(checker, arg) === 'string');

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

@@ -153,6 +153,31 @@ exports.default = (0, util_1.createRule)({
             }
             return false;
         }
+        function checkUnionConstituentsAndReport(reportNode, propertyName, type) {
+            for (const intersectionPart of tsutils
+                .unionConstituents(type)
+                .flatMap(unionPart => tsutils.intersectionConstituents(unionPart))) {
+                const reported = checkIfMethodAndReport(reportNode, intersectionPart.getProperty(propertyName));
+                if (reported) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function getAccessedPropertyNames(node) {
+            if (!node.computed) {
+                return node.property.type === utils_1.AST_NODE_TYPES.Identifier
+                    ? [node.property.name]
+                    : [];
+            }
+            return tsutils
+                .unionConstituents(services.getTypeAtLocation(node.property))
+                .flatMap(part => {
+                return part.isStringLiteral() || part.isNumberLiteral()
+                    ? [part.value.toString()]
+                    : [];
+            });
+        }
         function isNativelyBound(object, property) {
             // We can't rely entirely on the type-level checks made at the end of this
             // function, because sometimes type declarations don't come from the
@@ -181,7 +206,16 @@ exports.default = (0, util_1.createRule)({
                 if (isSafeUse(node) || isNativelyBound(node.object, node.property)) {
                     return;
                 }
-                checkIfMethodAndReport(node, services.getSymbolAtLocation(node));
+                const propertyNames = getAccessedPropertyNames(node);
+                if (propertyNames.length === 0) {
+                    return;
+                }
+                const objectType = services.getTypeAtLocation(node.object);
+                for (const propertyName of propertyNames) {
+                    if (checkUnionConstituentsAndReport(node, propertyName, objectType)) {
+                        break;
+                    }
+                }
             },
             ObjectPattern(node) {
                 if (isNodeInsideTypeDeclaration(node)) {
@@ -217,14 +251,7 @@ exports.default = (0, util_1.createRule)({
                             continue;
                         }
                     }
-                    for (const intersectionPart of tsutils
-                        .unionConstituents(services.getTypeAtLocation(node))
-                        .flatMap(unionPart => tsutils.intersectionConstituents(unionPart))) {
-                        const reported = checkIfMethodAndReport(property.key, intersectionPart.getProperty(property.key.name));
-                        if (reported) {
-                            break;
-                        }
-                    }
+                    checkUnionConstituentsAndReport(property.key, property.key.name, services.getTypeAtLocation(node));
                 }
             },
         };

package/node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore/index.js

@@ -57,6 +57,15 @@ const sanitizeRange = range => range.replace(
     : EMPTY
 )
 
+// > An optional `!` or `^` at the start of a class negates it, so that it
+// >   matches any character not in the set. (gitignore(5), fnmatch(3))
+// The leading `^` has already been escaped to `\^` by the metacharacter
+//   escaper, so we strip the literal `!` or escaped `^` and emit a single
+//   regex `^` which is the JavaScript negation token.
+const negateRange = range => range.startsWith('!') || range.startsWith('\\^')
+  ? `^${range.slice(range[0] === '!' ? 1 : 2)}`
+  : range
+
 // See fixtures #59
 const cleanRangeBackSlash = slashes => {
   const {length} = slashes
@@ -161,7 +170,7 @@ const REPLACERS = [
     // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
     // >   under directory "foo".
     // Notice that the '*'s have been replaced as '\\*'
-    /^\^*\\\*\\\*\\\//,
+    /^\^*(?:\\\*\\\*\\\/)+/,
 
     // '**/foo' <-> 'foo'
     () => '^(?:.*\\/)?'
@@ -272,7 +281,7 @@ const REPLACERS = [
           // A normal case, and it is a range notation
           // '[bar]'
           // '[bar\\\\]'
-          ? `[${sanitizeRange(range)}${endEscape}]`
+          ? `[${negateRange(sanitizeRange(range))}${endEscape}]`
           // Invalid range notaton
           // '[bar\\]' -> '[bar\\\\]'
           : '[]'