coc-pyright 1.1.395 → 1.1.398

package/lib/index.js

@@ -518,6 +518,7 @@ var require_core = __commonJS({
     exports2.isDefined = isDefined;
     exports2.getEnumNames = getEnumNames;
     exports2.containsOnlyWhitespace = containsOnlyWhitespace;
+    exports2.cloneStr = cloneStr;
     var textRange_1 = require_textRange();
     var Comparison;
     (function(Comparison2) {
@@ -606,6 +607,9 @@ var require_core = __commonJS({
       }
       return /^\s*$/.test(text);
     }
+    function cloneStr(str) {
+      return Buffer.from(str, "utf8").toString("utf8");
+    }
     var Disposable;
     (function(Disposable2) {
       function is(value) {
@@ -2155,6 +2159,7 @@ var require_serviceKeys = __commonJS({
       ServiceKeys2.docStringService = new serviceProvider_1.ServiceKey();
       ServiceKeys2.windowService = new serviceProvider_1.ServiceKey();
       ServiceKeys2.commandService = new serviceProvider_1.ServiceKey();
+      ServiceKeys2.cancellationProvider = new serviceProvider_1.ServiceKey();
     })(ServiceKeys || (exports2.ServiceKeys = ServiceKeys = {}));
   }
 });
@@ -3201,6 +3206,7 @@ var require_diagnostic = __commonJS({
         this.range = range;
         this.priority = priority;
         this._relatedInfo = [];
+        this._data = null;
       }
       toJsonObj() {
         return {
@@ -3210,6 +3216,7 @@ var require_diagnostic = __commonJS({
           priority: this.priority,
           actions: this._actions,
           rule: this._rule,
+          data: this._data,
           relatedInfo: this._relatedInfo.map((info) => DiagnosticRelatedInfo.toJsonObj(info))
         };
       }
@@ -3218,6 +3225,7 @@ var require_diagnostic = __commonJS({
         diag._actions = obj.actions;
         diag._rule = obj.rule;
         diag._relatedInfo = obj.relatedInfo.map((info) => DiagnosticRelatedInfo.fromJsonObj(info));
+        diag._data = obj.data;
         return diag;
       }
       addAction(action) {
@@ -3227,6 +3235,12 @@ var require_diagnostic = __commonJS({
           this._actions.push(action);
         }
       }
+      setData(data) {
+        this._data = data;
+      }
+      getData() {
+        return this._data;
+      }
       getActions() {
         return this._actions;
       }
@@ -12564,7 +12578,7 @@ var require_cancellationUtils = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/common/cancellationUtils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.CancellationThrottle = exports2.FileBasedToken = exports2.DefaultCancellationProvider = exports2.OperationCanceledException = void 0;
+    exports2.CancellationThrottle = exports2.FileBasedToken = exports2.CancelledTokenId = exports2.DefaultCancellationProvider = exports2.OperationCanceledException = exports2.CancellationProvider = void 0;
     exports2.getCancellationFolderName = getCancellationFolderName;
     exports2.setCancellationFolderName = setCancellationFolderName;
     exports2.invalidateTypeCacheIfCanceled = invalidateTypeCacheIfCanceled;
@@ -12579,6 +12593,13 @@ var require_cancellationUtils = __commonJS({
     var vscode_languageserver_1 = require_api3();
     var core_1 = require_core();
     var uriUtils_1 = require_uriUtils();
+    var CancellationProvider;
+    (function(CancellationProvider2) {
+      function is(value) {
+        return value && !!value.createCancellationTokenSource;
+      }
+      CancellationProvider2.is = is;
+    })(CancellationProvider || (exports2.CancellationProvider = CancellationProvider = {}));
     var cancellationFolderName;
     function getCancellationFolderName() {
       return cancellationFolderName;
@@ -12654,7 +12675,11 @@ var require_cancellationUtils = __commonJS({
       }
     };
     exports2.DefaultCancellationProvider = DefaultCancellationProvider;
+    exports2.CancelledTokenId = "cancelled";
     function getCancellationTokenId(token) {
+      if (token === vscode_languageserver_1.CancellationToken.Cancelled) {
+        return exports2.CancelledTokenId;
+      }
       return token instanceof FileBasedToken ? token.id : void 0;
     }
     var FileBasedToken = class {
@@ -15052,63 +15077,127 @@ var require_programTypes = __commonJS({
   }
 });
 
-// node_modules/@zzzen/pyright-internal/dist/common/fileSystem.js
-var require_fileSystem = __commonJS({
-  "node_modules/@zzzen/pyright-internal/dist/common/fileSystem.js"(exports2) {
+// node_modules/@zzzen/pyright-internal/dist/analyzer/pyTypedUtils.js
+var require_pyTypedUtils = __commonJS({
+  "node_modules/@zzzen/pyright-internal/dist/analyzer/pyTypedUtils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.VirtualDirent = exports2.TempFile = exports2.FileSystem = void 0;
-    var FileSystem;
-    (function(FileSystem2) {
-      function is(value) {
-        return value.createFileSystemWatcher && value.createReadStream && value.createWriteStream && value.copyFileSync;
-      }
-      FileSystem2.is = is;
-    })(FileSystem || (exports2.FileSystem = FileSystem = {}));
-    var TempFile;
-    (function(TempFile2) {
-      function is(value) {
-        return value.tmpdir && value.tmpfile;
+    exports2.getPyTypedInfo = getPyTypedInfo;
+    exports2.getPyTypedInfoForPyTypedFile = getPyTypedInfoForPyTypedFile;
+    var uriUtils_1 = require_uriUtils();
+    function getPyTypedInfo(fileSystem, dirPath) {
+      if (!fileSystem.existsSync(dirPath) || !(0, uriUtils_1.isDirectory)(fileSystem, dirPath)) {
+        return void 0;
       }
-      TempFile2.is = is;
-    })(TempFile || (exports2.TempFile = TempFile = {}));
-    var VirtualDirent = class {
-      constructor(name, _file, parentPath) {
-        this.name = name;
-        this._file = _file;
-        this.parentPath = parentPath;
+      const pyTypedPath = dirPath.pytypedUri;
+      if (!fileSystem.existsSync(pyTypedPath) || !(0, uriUtils_1.isFile)(fileSystem, pyTypedPath)) {
+        return void 0;
       }
-      /**
-       * Alias for `dirent.parentPath`.
-       * @since v20.1.0
-       * @deprecated Since v20.12.0
-       */
-      get path() {
-        return this.parentPath;
+      return getPyTypedInfoForPyTypedFile(fileSystem, pyTypedPath);
+    }
+    function getPyTypedInfoForPyTypedFile(fileSystem, pyTypedPath) {
+      let isPartiallyTyped = false;
+      const fileStats = fileSystem.statSync(pyTypedPath);
+      if (fileStats.size > 0 && fileStats.size < 64 * 1024) {
+        const pyTypedContents = fileSystem.readFileSync(pyTypedPath, "utf8");
+        if (pyTypedContents.match(/partial\n/) || pyTypedContents.match(/partial\r\n/)) {
+          isPartiallyTyped = true;
+        }
       }
-      isFile() {
-        return this._file;
+      return {
+        pyTypedPath,
+        isPartiallyTyped
+      };
+    }
+  }
+});
+
+// node_modules/@zzzen/pyright-internal/dist/partialStubService.js
+var require_partialStubService = __commonJS({
+  "node_modules/@zzzen/pyright-internal/dist/partialStubService.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PartialStubService = exports2.SupportPartialStubs = void 0;
+    var pyTypedUtils_1 = require_pyTypedUtils();
+    var pathConsts_1 = require_pathConsts();
+    var uriUtils_1 = require_uriUtils();
+    var SupportPartialStubs;
+    (function(SupportPartialStubs2) {
+      function is(value) {
+        return value.isPartialStubPackagesScanned && value.isPathScanned && value.processPartialStubPackages && value.clearPartialStubs;
       }
-      isDirectory() {
-        return !this._file;
+      SupportPartialStubs2.is = is;
+    })(SupportPartialStubs || (exports2.SupportPartialStubs = SupportPartialStubs = {}));
+    var PartialStubService = class {
+      constructor(_realFs) {
+        this._realFs = _realFs;
+        this._rootSearched = /* @__PURE__ */ new Set();
+        this._partialStubPackagePaths = /* @__PURE__ */ new Set();
+        this._movedDirectories = [];
       }
-      isBlockDevice() {
-        return false;
+      isPartialStubPackagesScanned(execEnv) {
+        return execEnv.root ? this.isPathScanned(execEnv.root) : false;
       }
-      isCharacterDevice() {
-        return false;
+      isPathScanned(uri) {
+        return this._rootSearched.has(uri.key);
       }
-      isSymbolicLink() {
-        return false;
+      processPartialStubPackages(paths, roots, bundledStubPath, allowMoving) {
+        var _a;
+        const allowMovingFn = allowMoving ?? this._allowMoving.bind(this);
+        for (const path13 of paths) {
+          this._rootSearched.add(path13.key);
+          if (!this._realFs.existsSync(path13) || !(0, uriUtils_1.isDirectory)(this._realFs, path13)) {
+            continue;
+          }
+          let dirEntries = [];
+          try {
+            dirEntries = this._realFs.readdirEntriesSync(path13);
+          } catch {
+          }
+          const isBundledStub = path13.equals(bundledStubPath);
+          for (const entry of dirEntries) {
+            const partialStubPackagePath = path13.combinePaths(entry.name);
+            const isDirectory = !entry.isSymbolicLink() ? entry.isDirectory() : !!((_a = (0, uriUtils_1.tryStat)(this._realFs, partialStubPackagePath)) == null ? void 0 : _a.isDirectory());
+            if (!isDirectory || !entry.name.endsWith(pathConsts_1.stubsSuffix)) {
+              continue;
+            }
+            const pyTypedInfo = (0, pyTypedUtils_1.getPyTypedInfo)(this._realFs, partialStubPackagePath);
+            if (!pyTypedInfo || !pyTypedInfo.isPartiallyTyped) {
+              continue;
+            }
+            this._partialStubPackagePaths.add(partialStubPackagePath.key);
+            const packageName = entry.name.substr(0, entry.name.length - pathConsts_1.stubsSuffix.length);
+            for (const root of roots) {
+              const packagePath = root.combinePaths(packageName);
+              try {
+                const stat = (0, uriUtils_1.tryStat)(this._realFs, packagePath);
+                if (!(stat == null ? void 0 : stat.isDirectory())) {
+                  continue;
+                }
+                if (!allowMovingFn(isBundledStub, (0, pyTypedUtils_1.getPyTypedInfo)(this._realFs, packagePath), pyTypedInfo)) {
+                  continue;
+                }
+                this._movedDirectories.push(this._realFs.mapDirectory(packagePath, partialStubPackagePath, (u, fs8) => u.hasExtension(".pyi") || fs8.existsSync(u) && fs8.statSync(u).isDirectory()));
+              } catch {
+              }
+            }
+          }
+        }
       }
-      isFIFO() {
-        return false;
+      clearPartialStubs() {
+        this._rootSearched.clear();
+        this._partialStubPackagePaths.clear();
+        this._movedDirectories.forEach((d) => d.dispose());
+        this._movedDirectories = [];
       }
-      isSocket() {
-        return false;
+      _allowMoving(isBundled, packagePyTyped, _stubPyTyped) {
+        if (!isBundled) {
+          return true;
+        }
+        return !packagePyTyped || packagePyTyped.isPartiallyTyped;
       }
     };
-    exports2.VirtualDirent = VirtualDirent;
+    exports2.PartialStubService = PartialStubService;
   }
 });
 
@@ -15831,6 +15920,66 @@ var require_docStringService = __commonJS({
   }
 });
 
+// node_modules/@zzzen/pyright-internal/dist/common/fileSystem.js
+var require_fileSystem = __commonJS({
+  "node_modules/@zzzen/pyright-internal/dist/common/fileSystem.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.VirtualDirent = exports2.TempFile = exports2.FileSystem = void 0;
+    var FileSystem;
+    (function(FileSystem2) {
+      function is(value) {
+        return value.createFileSystemWatcher && value.createReadStream && value.createWriteStream && value.copyFileSync;
+      }
+      FileSystem2.is = is;
+    })(FileSystem || (exports2.FileSystem = FileSystem = {}));
+    var TempFile;
+    (function(TempFile2) {
+      function is(value) {
+        return value.tmpdir && value.tmpfile;
+      }
+      TempFile2.is = is;
+    })(TempFile || (exports2.TempFile = TempFile = {}));
+    var VirtualDirent = class {
+      constructor(name, _file, parentPath) {
+        this.name = name;
+        this._file = _file;
+        this.parentPath = parentPath;
+      }
+      /**
+       * Alias for `dirent.parentPath`.
+       * @since v20.1.0
+       * @deprecated Since v20.12.0
+       */
+      get path() {
+        return this.parentPath;
+      }
+      isFile() {
+        return this._file;
+      }
+      isDirectory() {
+        return !this._file;
+      }
+      isBlockDevice() {
+        return false;
+      }
+      isCharacterDevice() {
+        return false;
+      }
+      isSymbolicLink() {
+        return false;
+      }
+      isFIFO() {
+        return false;
+      }
+      isSocket() {
+        return false;
+      }
+    };
+    exports2.VirtualDirent = VirtualDirent;
+  }
+});
+
 // node_modules/@zzzen/pyright-internal/dist/common/languageServerInterface.js
 var require_languageServerInterface = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/common/languageServerInterface.js"(exports2) {
@@ -15861,158 +16010,6 @@ var require_languageServerInterface = __commonJS({
   }
 });
 
-// node_modules/@zzzen/pyright-internal/dist/analyzer/pyTypedUtils.js
-var require_pyTypedUtils = __commonJS({
-  "node_modules/@zzzen/pyright-internal/dist/analyzer/pyTypedUtils.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.getPyTypedInfo = getPyTypedInfo;
-    exports2.getPyTypedInfoForPyTypedFile = getPyTypedInfoForPyTypedFile;
-    var uriUtils_1 = require_uriUtils();
-    function getPyTypedInfo(fileSystem, dirPath) {
-      if (!fileSystem.existsSync(dirPath) || !(0, uriUtils_1.isDirectory)(fileSystem, dirPath)) {
-        return void 0;
-      }
-      const pyTypedPath = dirPath.pytypedUri;
-      if (!fileSystem.existsSync(pyTypedPath) || !(0, uriUtils_1.isFile)(fileSystem, pyTypedPath)) {
-        return void 0;
-      }
-      return getPyTypedInfoForPyTypedFile(fileSystem, pyTypedPath);
-    }
-    function getPyTypedInfoForPyTypedFile(fileSystem, pyTypedPath) {
-      let isPartiallyTyped = false;
-      const fileStats = fileSystem.statSync(pyTypedPath);
-      if (fileStats.size > 0 && fileStats.size < 64 * 1024) {
-        const pyTypedContents = fileSystem.readFileSync(pyTypedPath, "utf8");
-        if (pyTypedContents.match(/partial\n/) || pyTypedContents.match(/partial\r\n/)) {
-          isPartiallyTyped = true;
-        }
-      }
-      return {
-        pyTypedPath,
-        isPartiallyTyped
-      };
-    }
-  }
-});
-
-// node_modules/@zzzen/pyright-internal/dist/partialStubService.js
-var require_partialStubService = __commonJS({
-  "node_modules/@zzzen/pyright-internal/dist/partialStubService.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.PartialStubService = exports2.SupportPartialStubs = void 0;
-    var pyTypedUtils_1 = require_pyTypedUtils();
-    var pathConsts_1 = require_pathConsts();
-    var uriUtils_1 = require_uriUtils();
-    var SupportPartialStubs;
-    (function(SupportPartialStubs2) {
-      function is(value) {
-        return value.isPartialStubPackagesScanned && value.isPathScanned && value.processPartialStubPackages && value.clearPartialStubs;
-      }
-      SupportPartialStubs2.is = is;
-    })(SupportPartialStubs || (exports2.SupportPartialStubs = SupportPartialStubs = {}));
-    var PartialStubService = class {
-      constructor(_realFs) {
-        this._realFs = _realFs;
-        this._rootSearched = /* @__PURE__ */ new Set();
-        this._partialStubPackagePaths = /* @__PURE__ */ new Set();
-        this._movedDirectories = [];
-      }
-      isPartialStubPackagesScanned(execEnv) {
-        return execEnv.root ? this.isPathScanned(execEnv.root) : false;
-      }
-      isPathScanned(uri) {
-        return this._rootSearched.has(uri.key);
-      }
-      processPartialStubPackages(paths, roots, bundledStubPath, allowMoving) {
-        var _a;
-        const allowMovingFn = allowMoving ?? this._allowMoving.bind(this);
-        for (const path13 of paths) {
-          this._rootSearched.add(path13.key);
-          if (!this._realFs.existsSync(path13) || !(0, uriUtils_1.isDirectory)(this._realFs, path13)) {
-            continue;
-          }
-          let dirEntries = [];
-          try {
-            dirEntries = this._realFs.readdirEntriesSync(path13);
-          } catch {
-          }
-          const isBundledStub = path13.equals(bundledStubPath);
-          for (const entry of dirEntries) {
-            const partialStubPackagePath = path13.combinePaths(entry.name);
-            const isDirectory = !entry.isSymbolicLink() ? entry.isDirectory() : !!((_a = (0, uriUtils_1.tryStat)(this._realFs, partialStubPackagePath)) == null ? void 0 : _a.isDirectory());
-            if (!isDirectory || !entry.name.endsWith(pathConsts_1.stubsSuffix)) {
-              continue;
-            }
-            const pyTypedInfo = (0, pyTypedUtils_1.getPyTypedInfo)(this._realFs, partialStubPackagePath);
-            if (!pyTypedInfo || !pyTypedInfo.isPartiallyTyped) {
-              continue;
-            }
-            this._partialStubPackagePaths.add(partialStubPackagePath.key);
-            const packageName = entry.name.substr(0, entry.name.length - pathConsts_1.stubsSuffix.length);
-            for (const root of roots) {
-              const packagePath = root.combinePaths(packageName);
-              try {
-                const stat = (0, uriUtils_1.tryStat)(this._realFs, packagePath);
-                if (!(stat == null ? void 0 : stat.isDirectory())) {
-                  continue;
-                }
-                if (!allowMovingFn(isBundledStub, (0, pyTypedUtils_1.getPyTypedInfo)(this._realFs, packagePath), pyTypedInfo)) {
-                  continue;
-                }
-                this._movedDirectories.push(this._realFs.mapDirectory(packagePath, partialStubPackagePath, (u, fs8) => u.hasExtension(".pyi") || fs8.existsSync(u) && fs8.statSync(u).isDirectory()));
-              } catch {
-              }
-            }
-          }
-        }
-      }
-      clearPartialStubs() {
-        this._rootSearched.clear();
-        this._partialStubPackagePaths.clear();
-        this._movedDirectories.forEach((d) => d.dispose());
-        this._movedDirectories = [];
-      }
-      _allowMoving(isBundled, packagePyTyped, _stubPyTyped) {
-        if (!isBundled) {
-          return true;
-        }
-        return !packagePyTyped || packagePyTyped.isPartiallyTyped;
-      }
-      _getRelativePathPartialStubs(partialStubPath) {
-        const relativePaths = [];
-        const searchAllStubs = (uri) => {
-          for (const entry of this._realFs.readdirEntriesSync(uri)) {
-            const filePath = uri.combinePaths(entry.name);
-            let isDirectory = entry.isDirectory();
-            let isFile = entry.isFile();
-            if (entry.isSymbolicLink()) {
-              const stat = (0, uriUtils_1.tryStat)(this._realFs, filePath);
-              if (stat) {
-                isDirectory = stat.isDirectory();
-                isFile = stat.isFile();
-              }
-            }
-            if (isDirectory) {
-              searchAllStubs(filePath);
-            }
-            if (isFile && entry.name.endsWith(".pyi")) {
-              const relative = partialStubPath.getRelativePathComponents(filePath).join("/");
-              if (relative) {
-                relativePaths.push(relative);
-              }
-            }
-          }
-        };
-        searchAllStubs(partialStubPath);
-        return relativePaths;
-      }
-    };
-    exports2.PartialStubService = PartialStubService;
-  }
-});
-
 // node_modules/@zzzen/pyright-internal/dist/common/serviceProviderExtensions.js
 var require_serviceProviderExtensions = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/common/serviceProviderExtensions.js"(exports2) {
@@ -16022,14 +16019,15 @@ var require_serviceProviderExtensions = __commonJS({
     var cacheManager_1 = require_cacheManager();
     var programTypes_1 = require_programTypes();
     var sourceFile_1 = require_sourceFile();
-    var serviceKeys_1 = require_serviceKeys();
+    var partialStubService_1 = require_partialStubService();
+    var cancellationUtils_1 = require_cancellationUtils();
     var caseSensitivityDetector_1 = require_caseSensitivityDetector();
     var console_1 = require_console();
-    var fileSystem_1 = require_fileSystem();
-    var serviceProvider_1 = require_serviceProvider();
     var docStringService_1 = require_docStringService();
+    var fileSystem_1 = require_fileSystem();
     var languageServerInterface_1 = require_languageServerInterface();
-    var partialStubService_1 = require_partialStubService();
+    var serviceKeys_1 = require_serviceKeys();
+    var serviceProvider_1 = require_serviceProvider();
     function createServiceProvider(...services2) {
       const sp = new serviceProvider_1.ServiceProvider();
       services2.forEach((service) => {
@@ -16063,6 +16061,9 @@ var require_serviceProviderExtensions = __commonJS({
         if (languageServerInterface_1.CommandService.is(service)) {
           sp.add(serviceKeys_1.ServiceKeys.commandService, service);
         }
+        if (cancellationUtils_1.CancellationProvider.is(service)) {
+          sp.add(serviceKeys_1.ServiceKeys.cancellationProvider, service);
+        }
       });
       return sp;
     }
@@ -16073,11 +16074,18 @@ var require_serviceProviderExtensions = __commonJS({
       return this.get(serviceKeys_1.ServiceKeys.console);
     };
     serviceProvider_1.ServiceProvider.prototype.partialStubs = function() {
+      const result = this.tryGet(serviceKeys_1.ServiceKeys.partialStubs);
+      if (!result) {
+        this.add(serviceKeys_1.ServiceKeys.partialStubs, new partialStubService_1.PartialStubService(this.fs()));
+      }
       return this.get(serviceKeys_1.ServiceKeys.partialStubs);
     };
     serviceProvider_1.ServiceProvider.prototype.tmp = function() {
       return this.tryGet(serviceKeys_1.ServiceKeys.tempFile);
     };
+    serviceProvider_1.ServiceProvider.prototype.cancellationProvider = function() {
+      return this.tryGet(serviceKeys_1.ServiceKeys.cancellationProvider) ?? new cancellationUtils_1.DefaultCancellationProvider();
+    };
     serviceProvider_1.ServiceProvider.prototype.sourceFileFactory = function() {
       const result = this.tryGet(serviceKeys_1.ServiceKeys.sourceFileFactory);
       return result || DefaultSourceFileFactory;
@@ -16091,8 +16099,8 @@ var require_serviceProviderExtensions = __commonJS({
       return result;
     };
     var DefaultSourceFileFactory = {
-      createSourceFile(serviceProvider, fileUri, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, editMode, console2, logTracker, ipythonMode) {
-        return new sourceFile_1.SourceFile(serviceProvider, fileUri, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, editMode, console2, logTracker, ipythonMode);
+      createSourceFile(serviceProvider, fileUri, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, isModulePrivate, editMode, console2, logTracker, ipythonMode) {
+        return new sourceFile_1.SourceFile(serviceProvider, fileUri, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, isModulePrivate, editMode, console2, logTracker, ipythonMode);
       }
     };
   }
@@ -16291,6 +16299,7 @@ var require_package_nls_cs = __commonJS({
         baseClassUnknown: "Typ z\xE1kladn\xED t\u0159\xEDdy je nezn\xE1m\xFD, co zakr\xFDv\xE1 typ odvozen\xE9 t\u0159\xEDdy",
         baseClassVariableTypeIncompatible: "Z\xE1kladn\xED t\u0159\xEDdy pro t\u0159\xEDdu {classType} definuj\xED prom\u011Bnnou {name} nekompatibiln\xEDm zp\u016Fsobem",
         binaryOperationNotAllowed: "Ve v\xFDrazu typu nen\xED povolen\xFD bin\xE1rn\xED oper\xE1tor.",
+        bindParamMissing: "Nepovedlo se vytvo\u0159it vazbu metody {methodName}, proto\u017Ee chyb\xED parametr self nebo cls",
         bindTypeMismatch: "Nepovedlo se vytvo\u0159it vazbu metody \u201E{methodName}\u201C, proto\u017Ee \u201E{type}\u201C nejde p\u0159i\u0159adit k parametru \u201E{paramName}\u201C",
         breakInExceptionGroup: "V bloku except* nen\xED povolen\xE1 mo\u017Enost break.",
         breakOutsideLoop: "\u201Ebreak\u201C se d\xE1 pou\u017E\xEDt jenom ve smy\u010Dce",
@@ -16722,6 +16731,7 @@ var require_package_nls_cs = __commonJS({
         typeAliasRedeclared: "\u201E{name}\u201C se deklaruje jako TypeAlias a d\xE1 se p\u0159i\u0159adit jenom jednou.",
         typeAliasStatementBadScope: "P\u0159\xEDkaz type se d\xE1 pou\u017E\xEDt jenom v r\xE1mci oboru modulu nebo t\u0159\xEDdy.",
         typeAliasStatementIllegal: "P\u0159\xEDkaz alias typu vy\u017Eaduje Python 3.12 nebo nov\u011Bj\u0161\xED",
+        typeAliasTypeBadScope: "Alias typu se d\xE1 definovat jenom v r\xE1mci oboru modulu nebo t\u0159\xEDdy",
         typeAliasTypeBaseClass: 'Alias typu definovan\xFD v p\u0159\xEDkazu "type" nejde pou\u017E\xEDt jako z\xE1kladn\xED t\u0159\xEDdu.',
         typeAliasTypeMustBeAssigned: "Typ TypeAliasType mus\xED b\xFDt p\u0159i\u0159azen prom\u011Bnn\xE9 se stejn\xFDm n\xE1zvem jako alias typu",
         typeAliasTypeNameArg: "Prvn\xED argument TypeAliasType mus\xED b\xFDt \u0159et\u011Bzcov\xFD liter\xE1l p\u0159edstavuj\xEDc\xED n\xE1zev aliasu typu.",
@@ -17130,6 +17140,7 @@ var require_package_nls_de = __commonJS({
         baseClassUnknown: "Der Basisklassentyp ist unbekannt, sodass der Typ der abgeleiteten Klasse verdeckt wird.",
         baseClassVariableTypeIncompatible: 'Basisklassen f\xFCr die Klasse "{classType}" definieren die Variable "{name}" auf inkompatible Weise.',
         binaryOperationNotAllowed: "Der bin\xE4rer Operator ist im Typausdruck nicht zul\xE4ssig",
+        bindParamMissing: "Die Methode \u201E{methodName}\u201C konnte nicht gebunden werden, weil der Parameter \u201Eself\u201C oder \u201Ecls\u201C fehlt.",
         bindTypeMismatch: 'Die Methode "{methodName}" konnte nicht gebunden werden, da "{type}" dem Parameter "{paramName}" nicht zugewiesen werden kann.',
         breakInExceptionGroup: "\u201Ebreak\u201C ist in einem \u201Eexcept*\u201C Block nicht zul\xE4ssig.",
         breakOutsideLoop: '"break" kann nur innerhalb einer Schleife verwendet werden.',
@@ -17561,6 +17572,7 @@ var require_package_nls_de = __commonJS({
         typeAliasRedeclared: '"{name}" ist als TypeAlias deklariert und kann nur einmal zugewiesen werden.',
         typeAliasStatementBadScope: "Eine type Anweisung kann nur innerhalb eines Moduls oder Klassenbereichs verwendet werden.",
         typeAliasStatementIllegal: "Die Typaliasanweisung erfordert Python 3.12 oder h\xF6her.",
+        typeAliasTypeBadScope: "Ein Typalias kann nur innerhalb eines Modul- oder Klassenbereichs definiert werden.",
         typeAliasTypeBaseClass: 'Ein in einer "type"-Anweisung definierter type Alias kann nicht als Basisklasse verwendet werden.',
         typeAliasTypeMustBeAssigned: "TypeAliasType muss einer Variablen mit dem gleichen Namen wie der Typalias zugewiesen werden.",
         typeAliasTypeNameArg: "Das erste Argument f\xFCr TypeAliasType muss ein Zeichenfolgenliteral sein, das den Namen des Typalias darstellt.",
@@ -17656,11 +17668,11 @@ var require_package_nls_de = __commonJS({
         typedDictSecondArgDict: "Es wird ein dict- oder Schl\xFCsselwortparameter als zweiter Parameter erwartet.",
         typedDictSecondArgDictEntry: "Einfacher W\xF6rterbucheintrag erwartet",
         typedDictSet: "Element konnte in TypedDict nicht zugewiesen werden.",
-        unaccessedClass: 'Auf die Klasse "{name}" kann nicht zugegriffen werden.',
-        unaccessedFunction: 'Auf die Funktion "{name}" kann nicht zugegriffen werden.',
-        unaccessedImport: 'Auf den Import "{name}" kann nicht zugegriffen werden.',
-        unaccessedSymbol: 'Auf "{name}" kann nicht zugegriffen werden.',
-        unaccessedVariable: 'Auf die Variable "{name}" kann nicht zugegriffen werden.',
+        unaccessedClass: 'Auf Klasse "{name}" wird nicht zugegriffen',
+        unaccessedFunction: 'Auf Funktion "{name}" wird nicht zugegriffen',
+        unaccessedImport: 'Auf Import "{name}" wird nicht zugegriffen',
+        unaccessedSymbol: 'Auf "{name}" wird nicht zugegriffen',
+        unaccessedVariable: 'Auf Variable "{name}" wird nicht zugegriffen',
         unannotatedFunctionSkipped: 'Die Analyse der Funktion "{name}" wird \xFCbersprungen, da sie nicht kommentiert wurde.',
         unaryOperationNotAllowed: "Der un\xE4re Operator ist im Typausdruck nicht zul\xE4ssig",
         unexpectedAsyncToken: 'Es wurde erwartet, dass "def", "with" oder "for" auf "async" folgt.',
@@ -20085,6 +20097,7 @@ var require_package_nls_es = __commonJS({
         baseClassUnknown: "Se desconoce el tipo de la clase base, lo que oculta el tipo de la clase derivada.",
         baseClassVariableTypeIncompatible: 'Las clases base para la clase "{classType}" definen la variable "{name}" de forma incompatible',
         binaryOperationNotAllowed: "Operador binario no permitido en la expresi\xF3n de tipo",
+        bindParamMissing: 'No se pudo enlazar el m\xE9todo "{methodName}" porque falta un par\xE1metro "self" o "cls"',
         bindTypeMismatch: 'No se pudo enlazar el m\xE9todo "{methodName}" porque "{type}" no se puede asignar al par\xE1metro "{paramName}"',
         breakInExceptionGroup: 'No se permite "break" en un bloque "except*"',
         breakOutsideLoop: '"break" solo se puede usar dentro de un bucle',
@@ -20516,6 +20529,7 @@ var require_package_nls_es = __commonJS({
         typeAliasRedeclared: '"{name}" se declara como TypeAlias y solo puede asignarse una vez',
         typeAliasStatementBadScope: "Una instrucci\xF3n de type solo se puede usar en el \xE1mbito de un m\xF3dulo o de una clase",
         typeAliasStatementIllegal: "La sentencia Type alias requiere Python 3.12 o posterior",
+        typeAliasTypeBadScope: "Un alias de tipo solo se puede definir dentro de un \xE1mbito de m\xF3dulo o clase",
         typeAliasTypeBaseClass: 'Un alias de tipo definido en una instrucci\xF3n "type" no se puede usar como clase base',
         typeAliasTypeMustBeAssigned: "TypeAliasType debe asignarse a una variable con el mismo nombre que el alias de tipo",
         typeAliasTypeNameArg: "El primer argumento de TypeAliasType debe ser un literal de cadena que represente el nombre del alias de tipo",
@@ -20924,6 +20938,7 @@ var require_package_nls_fr = __commonJS({
         baseClassUnknown: "Le type de classe de base est inconnu, ce qui masque le type de classe d\xE9riv\xE9e",
         baseClassVariableTypeIncompatible: "Les classes de base de la classe \xAB\xA0{classType}\xA0\xBB d\xE9finissent la variable \xAB\xA0{name}\xA0\xBB de mani\xE8re incompatible",
         binaryOperationNotAllowed: "Op\xE9rateur binaire non autoris\xE9 dans l'expression de type",
+        bindParamMissing: "Impossible de lier la m\xE9thode \xAB\xA0{methodName}\xA0\xBB, car il manque un param\xE8tre \xAB\xA0self\xA0\xBB ou \xAB\xA0cls\xA0\xBB",
         bindTypeMismatch: `Impossible de lier la m\xE9thode "{methodName}" car "{type}" n'est pas attribuable au param\xE8tre "{paramName}"`,
         breakInExceptionGroup: "\xAB\xA0break\xA0\xBB n\u2019est pas autoris\xE9 dans un bloc \xAB\xA0except*\xA0\xBB",
         breakOutsideLoop: `"break" ne peut \xEAtre utilis\xE9 qu'\xE0 l'int\xE9rieur d'une boucle`,
@@ -21355,6 +21370,7 @@ var require_package_nls_fr = __commonJS({
         typeAliasRedeclared: "\xAB {name} \xBB est d\xE9clar\xE9 en tant que TypeAlias et ne peut \xEAtre attribu\xE9 qu\u2019une seule fois",
         typeAliasStatementBadScope: "Une instruction de type ne peut \xEAtre utilis\xE9e que dans une \xE9tendue de module ou de classe",
         typeAliasStatementIllegal: "L\u2019instruction d\u2019alias de type n\xE9cessite Python 3.12 ou version ult\xE9rieure",
+        typeAliasTypeBadScope: "Vous ne pouvez d\xE9finir un alias de type qu\u2019au sein d\u2019un module ou d\u2019une \xE9tendue de classe",
         typeAliasTypeBaseClass: 'A type alias defined in a "type" statement cannot be used as a base class',
         typeAliasTypeMustBeAssigned: "TypeAliasType doit \xEAtre affect\xE9 \xE0 une variable portant le m\xEAme nom que l'alias de type",
         typeAliasTypeNameArg: "Le premier argument de TypeAliasType doit \xEAtre un litt\xE9ral de cha\xEEne repr\xE9sentant le nom de l'alias de type",
@@ -21763,6 +21779,7 @@ var require_package_nls_it = __commonJS({
         baseClassUnknown: "Il tipo della classe di base \xE8 sconosciuto. \xC8 in corso il tentativo di determinare il tipo della classe derivata",
         baseClassVariableTypeIncompatible: 'Le classi di base per la classe "{classType}" definiscono la variabile "{name}" in modo incompatibile',
         binaryOperationNotAllowed: "Operatore binario non consentito nell'espressione di tipo",
+        bindParamMissing: 'Impossibile associare il metodo "{methodName}" dal momento che il parametro "self" o "cls" risulta mancante',
         bindTypeMismatch: 'Non \xE8 stato possibile associare il metodo "{methodName}" perch\xE9 non \xE8 possibile assegnare"{type}" al parametro "{paramName}"',
         breakInExceptionGroup: '"break" non consentito in un blocco "except*"',
         breakOutsideLoop: `"break" pu\xF2 essere usato solo all'interno di un ciclo`,
@@ -22194,6 +22211,7 @@ var require_package_nls_it = __commonJS({
         typeAliasRedeclared: '"{name}" \xE8 dichiarato come TypeAlias e pu\xF2 essere assegnato una sola volta',
         typeAliasStatementBadScope: "Un'istruzione type pu\xF2 essere usata solo all'interno di un modulo o di un ambito della classe",
         typeAliasStatementIllegal: "L'istruzione alias di tipo richiede Python 3.12 o versione successiva",
+        typeAliasTypeBadScope: "\xC8 possibile definire un alias di tipo solo all'interno di un ambito classe o modulo",
         typeAliasTypeBaseClass: `Impossibile utilizzare come classe di base un alias di tipo definito in un'istruzione "type"`,
         typeAliasTypeMustBeAssigned: "TypeAliasType deve essere assegnato a una variabile con lo stesso nome dell'alias di tipo",
         typeAliasTypeNameArg: "Il primo argomento di TypeAliasType deve essere un valore letterale stringa che rappresenta il nome dell'alias di tipo",
@@ -22602,6 +22620,7 @@ var require_package_nls_ja = __commonJS({
         baseClassUnknown: "\u57FA\u5E95\u30AF\u30E9\u30B9\u306E\u578B\u304C\u4E0D\u660E\u3067\u3001\u6D3E\u751F\u30AF\u30E9\u30B9\u306E\u578B\u304C\u4E0D\u660E\u3067\u3059",
         baseClassVariableTypeIncompatible: '\u30AF\u30E9\u30B9 "{classType}" \u306E\u57FA\u5E95\u30AF\u30E9\u30B9\u306F\u3001\u4E92\u63DB\u6027\u306E\u306A\u3044\u65B9\u6CD5\u3067\u5909\u6570 "{name}" \u3092\u5B9A\u7FA9\u3057\u307E\u3059',
         binaryOperationNotAllowed: "2 \u9805\u6F14\u7B97\u5B50\u306F\u578B\u5F0F\u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093",
+        bindParamMissing: '"self" \u307E\u305F\u306F "cls" \u30D1\u30E9\u30E1\u30FC\u30BF\u30FC\u304C\u306A\u3044\u305F\u3081\u3001\u30E1\u30BD\u30C3\u30C9 "{methodName}" \u3092\u30D0\u30A4\u30F3\u30C9\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F',
         bindTypeMismatch: '"{type}" \u304C\u30D1\u30E9\u30E1\u30FC\u30BF\u30FC "{paramName}" \u306B\u5272\u308A\u5F53\u3066\u3067\u304D\u306A\u3044\u305F\u3081\u3001\u30E1\u30BD\u30C3\u30C9 "{methodName}" \u3092\u30D0\u30A4\u30F3\u30C9\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F',
         breakInExceptionGroup: '"except*" \u30D6\u30ED\u30C3\u30AF\u3067\u306F "break" \u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093',
         breakOutsideLoop: '"break" \u306F\u30EB\u30FC\u30D7\u5185\u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059',
@@ -23033,6 +23052,7 @@ var require_package_nls_ja = __commonJS({
         typeAliasRedeclared: '"{name}" \u306F TypeAlias \u3068\u3057\u3066\u5BA3\u8A00\u3055\u308C\u3066\u304A\u308A\u30011 \u56DE\u3060\u3051\u5272\u308A\u5F53\u3066\u308B\u3053\u3068\u304C\u3067\u304D\u307E\u3059',
         typeAliasStatementBadScope: "type \u30B9\u30C6\u30FC\u30C8\u30E1\u30F3\u30C8\u306F\u3001\u30E2\u30B8\u30E5\u30FC\u30EB\u307E\u305F\u306F\u30AF\u30E9\u30B9\u30B9\u30B3\u30FC\u30D7\u5185\u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059",
         typeAliasStatementIllegal: "\u578B\u30A8\u30A4\u30EA\u30A2\u30B9 \u30B9\u30C6\u30FC\u30C8\u30E1\u30F3\u30C8\u306B\u306F Python 3.12 \u4EE5\u964D\u304C\u5FC5\u8981\u3067\u3059",
+        typeAliasTypeBadScope: "\u578B\u30A8\u30A4\u30EA\u30A2\u30B9\u306F\u3001\u30E2\u30B8\u30E5\u30FC\u30EB\u307E\u305F\u306F\u30AF\u30E9\u30B9 \u30B9\u30B3\u30FC\u30D7\u5185\u3067\u306E\u307F\u5B9A\u7FA9\u3067\u304D\u307E\u3059",
         typeAliasTypeBaseClass: '"type" \u30B9\u30C6\u30FC\u30C8\u30E1\u30F3\u30C8\u3067\u5B9A\u7FA9\u3055\u308C\u305F\u578B\u30A8\u30A4\u30EA\u30A2\u30B9\u3092\u57FA\u5E95\u30AF\u30E9\u30B9\u3068\u3057\u3066\u4F7F\u7528\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',
         typeAliasTypeMustBeAssigned: "TypeAliasType \u306F\u3001\u578B\u30A8\u30A4\u30EA\u30A2\u30B9\u3068\u540C\u3058\u540D\u524D\u306E\u5909\u6570\u306B\u5272\u308A\u5F53\u3066\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
         typeAliasTypeNameArg: "TypeAliasType \u306E\u6700\u521D\u306E\u5F15\u6570\u306F\u3001\u578B\u30A8\u30A4\u30EA\u30A2\u30B9\u306E\u540D\u524D\u3092\u8868\u3059\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
@@ -23441,6 +23461,7 @@ var require_package_nls_ko = __commonJS({
         baseClassUnknown: "\uAE30\uBCF8 \uD074\uB798\uC2A4 \uD615\uC2DD\uC744 \uC54C \uC218 \uC5C6\uC73C\uBBC0\uB85C \uD30C\uC0DD \uD074\uB798\uC2A4\uC758 \uD615\uC2DD\uC774 \uBAA8\uD638\uD569\uB2C8\uB2E4.",
         baseClassVariableTypeIncompatible: '"{classType}" \uD074\uB798\uC2A4\uC758 \uAE30\uBCF8 \uD074\uB798\uC2A4\uAC00 "{name}" \uBCC0\uC218\uB97C \uD638\uD658\uB418\uC9C0 \uC54A\uB294 \uBC29\uC2DD\uC73C\uB85C \uC815\uC758\uD569\uB2C8\uB2E4.',
         binaryOperationNotAllowed: "\uD615\uC2DD \uC2DD\uC5D0\uB294 \uC774\uD56D \uC5F0\uC0B0\uC790\uB97C \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
+        bindParamMissing: '"self" \uB610\uB294 "cls" \uB9E4\uAC1C \uBCC0\uC218\uAC00 \uB204\uB77D\uB418\uC5C8\uAE30 \uB54C\uBB38\uC5D0 \uBA54\uC11C\uB4DC "{methodName}"\uC744(\uB97C) \uBC14\uC778\uB529\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
         bindTypeMismatch: "\u2018{type}\u2019\uC744(\uB97C) \uB9E4\uAC1C \uBCC0\uC218 \u2018{paramName}\u2019\uC5D0 \uD560\uB2F9\uD560 \uC218 \uC5C6\uC73C\uBBC0\uB85C \u2018{methodName}\u2019 \uBA54\uC11C\uB4DC\uB97C \uBC14\uC778\uB529\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
         breakInExceptionGroup: '"except*" \uBE14\uB85D\uC5D0\uB294 "break"\uB97C \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4',
         breakOutsideLoop: "\u2018break\u2019\uB294 \uB8E8\uD504 \uB0B4\uC5D0\uC11C\uB9CC \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.",
@@ -23872,6 +23893,7 @@ var require_package_nls_ko = __commonJS({
         typeAliasRedeclared: '"{name}"\uC740(\uB294) TypeAlias\uB85C \uC120\uC5B8\uB418\uBA70 \uD55C \uBC88\uB9CC \uD560\uB2F9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.',
         typeAliasStatementBadScope: "type \uBB38\uC740 \uBAA8\uB4C8 \uB610\uB294 \uD074\uB798\uC2A4 \uBC94\uC704 \uB0B4\uC5D0\uC11C\uB9CC \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.",
         typeAliasStatementIllegal: "\uD615\uC2DD \uBCC4\uCE6D \uBB38\uC5D0\uB294 Python 3.12 \uC774\uC0C1\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.",
+        typeAliasTypeBadScope: "\uD615\uC2DD \uBCC4\uCE6D\uC740 \uBAA8\uB4C8 \uB610\uB294 \uD074\uB798\uC2A4 \uBC94\uC704 \uB0B4\uC5D0\uC11C\uB9CC \uC815\uC758\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.",
         typeAliasTypeBaseClass: '"type" \uBB38\uC5D0 \uC815\uC758\uB41C \uD615\uC2DD \uBCC4\uCE6D\uC740 \uAE30\uBCF8 \uD074\uB798\uC2A4\uB85C \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
         typeAliasTypeMustBeAssigned: "TypeAliasType\uC740 \uD615\uC2DD \uBCC4\uCE6D\uACFC \uC774\uB984\uC774 \uAC19\uC740 \uBCC0\uC218\uC5D0 \uD560\uB2F9\uD574\uC57C \uD569\uB2C8\uB2E4.",
         typeAliasTypeNameArg: "TypeAliasType\uC758 \uCCAB \uBC88\uC9F8 \uC778\uC218\uB294 \uD615\uC2DD \uBCC4\uCE6D\uC758 \uC774\uB984\uC744 \uB098\uD0C0\uB0B4\uB294 \uBB38\uC790\uC5F4 \uB9AC\uD130\uB7F4\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.",
@@ -24280,6 +24302,7 @@ var require_package_nls_pl = __commonJS({
         baseClassUnknown: "Typ klasy bazowej jest nieznany, zas\u0142aniaj\u0105c typ klasy pochodnej",
         baseClassVariableTypeIncompatible: "Klasy bazowe dla klasy \u201E{classType}\u201D definiuj\u0105 zmienn\u0105 \u201E{name}\u201D w niezgodny spos\xF3b",
         binaryOperationNotAllowed: "Operator binarny nie jest dozwolony w wyra\u017Ceniu typu",
+        bindParamMissing: "Nie mo\u017Cna powi\u0105za\u0107 metody \u201E{methodName}\u201D, poniewa\u017C brakuje w niej parametru \u201Eself\u201D lub \u201Ecls\u201D",
         bindTypeMismatch: "Nie mo\u017Cna powi\u0105za\u0107 metody \u201E{methodName}\u201D, poniewa\u017C nie mo\u017Cna przypisa\u0107 typu \u201E{type}\u201D do parametru \u201E{paramName}\u201D",
         breakInExceptionGroup: "\u201Ebreak\u201D nie jest dozwolone w bloku \u201Eexcept*\u201D",
         breakOutsideLoop: "Warto\u015B\u0107 \u201Ebreak\u201D mo\u017Ce by\u0107 u\u017Cywana tylko w p\u0119tli",
@@ -24711,6 +24734,7 @@ var require_package_nls_pl = __commonJS({
         typeAliasRedeclared: "Nazwa \u201E{name}\u201D jest zadeklarowana jako TypeAlias i mo\u017Ce by\u0107 przypisana tylko raz",
         typeAliasStatementBadScope: "Instrukcja type mo\u017Ce by\u0107 u\u017Cyta tylko w zakresie modu\u0142u lub klasy",
         typeAliasStatementIllegal: "Instrukcja typu alias wymaga j\u0119zyka Python w wersji 3.12 lub nowszej",
+        typeAliasTypeBadScope: "Alias typu mo\u017Cna zdefiniowa\u0107 tylko w zakresie modu\u0142u lub klasy",
         typeAliasTypeBaseClass: 'A type alias defined in a "type" statement cannot be used as a base class',
         typeAliasTypeMustBeAssigned: "Typ TypeAliasType musi by\u0107 przypisany do zmiennej o takiej samej nazwie jak alias typu",
         typeAliasTypeNameArg: "Pierwszy argument dla typu TypeAliasType musi by\u0107 litera\u0142em ci\u0105gu reprezentuj\u0105cym nazw\u0119 aliasu typu",
@@ -25119,6 +25143,7 @@ var require_package_nls_pt_br = __commonJS({
         baseClassUnknown: "O tipo de classe base \xE9 desconhecido, ocultando o tipo de classe derivada",
         baseClassVariableTypeIncompatible: 'Classes base para a classe "{classType}" definem a vari\xE1vel "{name}" de maneira incompat\xEDvel',
         binaryOperationNotAllowed: "Operador bin\xE1rio n\xE3o permitido na express\xE3o de tipo",
+        bindParamMissing: 'N\xE3o foi poss\xEDvel vincular o m\xE9todo "{methodName}" porque est\xE1 faltando um par\xE2metro "self" ou "cls"',
         bindTypeMismatch: 'N\xE3o foi poss\xEDvel associar o m\xE9todo "{methodName}" porque "{type}" n\xE3o \xE9 atribu\xEDvel ao par\xE2metro "{paramName}"',
         breakInExceptionGroup: '"break" n\xE3o \xE9 permitido em um bloco "except*"',
         breakOutsideLoop: '"break" s\xF3 pode ser usado dentro de um loop',
@@ -25550,6 +25575,7 @@ var require_package_nls_pt_br = __commonJS({
         typeAliasRedeclared: '"{name}" \xE9 declarado como um TypeAlias e s\xF3 pode ser atribu\xEDdo uma vez',
         typeAliasStatementBadScope: "Uma instru\xE7\xE3o type s\xF3 pode ser usada dentro de um m\xF3dulo ou escopo de classe",
         typeAliasStatementIllegal: "A instru\xE7\xE3o de alias de tipo requer o Python 3.12 ou mais recente",
+        typeAliasTypeBadScope: "Um alias de tipo s\xF3 pode ser definido dentro de um m\xF3dulo ou escopo de classe",
         typeAliasTypeBaseClass: 'Um alias de tipo definido em uma instru\xE7\xE3o "type" n\xE3o pode ser usado como uma classe base',
         typeAliasTypeMustBeAssigned: "TypeAliasType deve ser atribu\xEDdo a uma vari\xE1vel com o mesmo nome que o alias de tipo",
         typeAliasTypeNameArg: "O primeiro argumento para TypeAliasType deve ser um literal de cadeia de caracteres que representa o nome do alias de tipo",
@@ -25958,6 +25984,7 @@ var require_package_nls_qps_ploc = __commonJS({
         baseClassUnknown: "[QQxIX][\u0E19\u0E31\u0E49\xDF\xE6s\xEB \xE7l\xE6ss t\xFFp\xEB \xEFs \xB5\xF1k\xF1\xF8w\xF1, \xF8\xFEs\xE7\xB5r\xEF\xF1g t\xFFp\xEB \xF8f \xF0\xEBr\xEFv\xEB\xF0 \xE7l\xE6ss\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
         baseClassVariableTypeIncompatible: '[YmxlD][\u0E19\u0E31\u0E49\xDF\xE6s\xEB \xE7l\xE6ss\xEBs f\xF8r \xE7l\xE6ss "{\xE7l\xE6ssT\xFFp\xEB}" \xF0\xEBf\xEF\xF1\xEB v\xE6r\xEF\xE6\xFEl\xEB "{\xF1\xE6m\xEB}" \xEF\xF1 \xEF\xF1\xE7\xF8mp\xE6t\xEF\xFEl\xEB w\xE6\xFF\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         binaryOperationNotAllowed: "[1lzlz][\u0E19\u0E31\u0E49\xDF\xEF\xF1\xE6r\xFF \xF8p\xEBr\xE6t\xF8r \xF1\xF8t \xE6ll\xF8w\xEB\xF0 \xEF\xF1 t\xFFp\xEB \xEBxpr\xEBss\xEF\xF8\xF1\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
+        bindParamMissing: '[6ggqn][\u0E19\u0E31\u0E49\xC7\xF8\xB5l\xF0 \xF1\xF8t \xFE\xEF\xF1\xF0 m\xEBth\xF8\xF0 "{m\xEBth\xF8\xF0\xD1\xE6m\xEB}" \xFE\xEB\xE7\xE6\xB5s\xEB \xEFt \xEFs m\xEFss\xEF\xF1g \xE6 "s\xEBlf" \xF8r "\xE7ls" p\xE6r\xE6m\xEBt\xEBr\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         bindTypeMismatch: '[x4sbf][\u0E19\u0E31\u0E49\xC7\xF8\xB5l\xF0 \xF1\xF8t \xFE\xEF\xF1\xF0 m\xEBth\xF8\xF0 "{m\xEBth\xF8\xF0\xD1\xE6m\xEB}" \xFE\xEB\xE7\xE6\xB5s\xEB "{t\xFFp\xEB}" \xEFs \xF1\xF8t \xE6ss\xEFg\xF1\xE6\xFEl\xEB t\xF8 p\xE6r\xE6m\xEBt\xEBr "{p\xE6r\xE6m\xD1\xE6m\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         breakInExceptionGroup: '[Kwoku][\u0E19\u0E31\u0E49"break" \xEFs \xF1\xF8t \xE6ll\xF8w\xEB\xF0 \xEF\xF1 \xE6\xF1 "except*" \xFEl\xF8\xE7k\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         breakOutsideLoop: '[Ca4Ip][\u0E19\u0E31\u0E49"break" \xE7\xE6\xF1 \xFE\xEB \xB5s\xEB\xF0 \xF8\xF1l\xFF w\xEFth\xEF\xF1 \xE6 l\xF8\xF8p\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
@@ -26389,6 +26416,7 @@ var require_package_nls_qps_ploc = __commonJS({
         typeAliasRedeclared: '[P036x][\u0E19\u0E31\u0E49"{\xF1\xE6m\xEB}" \xEFs \xF0\xEB\xE7l\xE6r\xEB\xF0 \xE6s \xE6 TypeAlias \xE6\xF1\xF0 \xE7\xE6\xF1 \xFE\xEB \xE6ss\xEFg\xF1\xEB\xF0 \xF8\xF1l\xFF \xF8\xF1\xE7\xEB\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typeAliasStatementBadScope: "[C24Up][\u0E19\u0E31\u0E49\xC6 type st\xE6t\xEBm\xEB\xF1t \xE7\xE6\xF1 \xFE\xEB \xB5s\xEB\xF0 \xF8\xF1l\xFF w\xEFth\xEF\xF1 \xE6 m\xF8\xF0\xB5l\xEB \xF8r \xE7l\xE6ss s\xE7\xF8p\xEB\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
         typeAliasStatementIllegal: "[2EW0Q][\u0E19\u0E31\u0E49T\xFFp\xEB \xE6l\xEF\xE6s st\xE6t\xEBm\xEB\xF1t r\xEBq\xB5\xEFr\xEBs P\xFFth\xF8\xF1 3.12 \xF8r \xF1\xEBw\xEBr\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
+        typeAliasTypeBadScope: "[kdK34][\u0E19\u0E31\u0E49\xC6 t\xFFp\xEB \xE6l\xEF\xE6s \xE7\xE6\xF1 \xFE\xEB \xF0\xEBf\xEF\xF1\xEB\xF0 \xF8\xF1l\xFF w\xEFth\xEF\xF1 \xE6 m\xF8\xF0\xB5l\xEB \xF8r \xE7l\xE6ss s\xE7\xF8p\xEB\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
         typeAliasTypeBaseClass: '[RIpMs][\u0E19\u0E31\u0E49\xC6 t\xFFp\xEB \xE6l\xEF\xE6s \xF0\xEBf\xEF\xF1\xEB\xF0 \xEF\xF1 \xE6 "type" st\xE6t\xEBm\xEB\xF1t \xE7\xE6\xF1\xF1\xF8t \xFE\xEB \xB5s\xEB\xF0 \xE6s \xE6 \xFE\xE6s\xEB \xE7l\xE6ss\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typeAliasTypeMustBeAssigned: "[aV4Nn][\u0E19\u0E31\u0E49TypeAliasType m\xB5st \xFE\xEB \xE6ss\xEFg\xF1\xEB\xF0 t\xF8 \xE6 v\xE6r\xEF\xE6\xFEl\xEB w\xEFth th\xEB s\xE6m\xEB \xF1\xE6m\xEB \xE6s th\xEB t\xFFp\xEB \xE6l\xEF\xE6s\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
         typeAliasTypeNameArg: "[dUUf1][\u0E19\u0E31\u0E49F\xEFrst \xE6rg\xB5m\xEB\xF1t t\xF8 TypeAliasType m\xB5st \xFE\xEB \xE6 str\xEF\xF1g l\xEFt\xEBr\xE6l r\xEBpr\xEBs\xEB\xF1t\xEF\xF1g th\xEB \xF1\xE6m\xEB \xF8f th\xEB t\xFFp\xEB \xE6l\xEF\xE6s\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
@@ -26797,6 +26825,7 @@ var require_package_nls_ru = __commonJS({
         baseClassUnknown: "\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\u0439 \u0442\u0438\u043F \u0431\u0430\u0437\u043E\u0432\u043E\u0433\u043E \u043A\u043B\u0430\u0441\u0441\u0430 \u0441\u043A\u0440\u044B\u0432\u0430\u0435\u0442 \u0442\u0438\u043F \u043F\u0440\u043E\u0438\u0437\u0432\u043E\u0434\u043D\u043E\u0433\u043E \u043A\u043B\u0430\u0441\u0441\u0430",
         baseClassVariableTypeIncompatible: '\u0411\u0430\u0437\u043E\u0432\u044B\u0435 \u043A\u043B\u0430\u0441\u0441\u044B \u043A\u043B\u0430\u0441\u0441\u0430 "{classType}" \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u044F\u044E\u0442 \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u0443\u044E "{name}" \u043D\u0435\u0441\u043E\u0432\u043C\u0435\u0441\u0442\u0438\u043C\u044B\u043C \u0441\u043F\u043E\u0441\u043E\u0431\u043E\u043C',
         binaryOperationNotAllowed: "\u0411\u0438\u043D\u0430\u0440\u043D\u044B\u0439 \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440 \u043D\u0435\u043B\u044C\u0437\u044F \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C \u0432 \u0432\u044B\u0440\u0430\u0436\u0435\u043D\u0438\u0438 \u0442\u0438\u043F\u0430",
+        bindParamMissing: '\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0440\u0438\u0432\u044F\u0437\u0430\u0442\u044C \u043C\u0435\u0442\u043E\u0434 "{methodName}", \u0442\u0430\u043A \u043A\u0430\u043A \u0432 \u043D\u0435\u043C \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u0435\u0442 \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 "self" \u0438\u043B\u0438 "cls"',
         bindTypeMismatch: '\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0440\u0438\u0432\u044F\u0437\u0430\u0442\u044C \u043C\u0435\u0442\u043E\u0434 "{methodName}", "{type}" \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u043D\u0430\u0437\u043D\u0430\u0447\u0435\u043D \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u0443 "{paramName}"',
         breakInExceptionGroup: '\u0417\u0430\u043F\u0440\u0435\u0449\u0435\u043D\u043E \u043D\u0430\u043B\u0438\u0447\u0438\u0435 "break" \u0432 \u0431\u043B\u043E\u043A\u0435 "except*"',
         breakOutsideLoop: '"break" \u043C\u043E\u0436\u043D\u043E \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C \u0442\u043E\u043B\u044C\u043A\u043E \u0432\u043D\u0443\u0442\u0440\u0438 \u0446\u0438\u043A\u043B\u0430',
@@ -27228,6 +27257,7 @@ var require_package_nls_ru = __commonJS({
         typeAliasRedeclared: '"{name}" \u043E\u0431\u044A\u044F\u0432\u043B\u0435\u043D \u043A\u0430\u043A TypeAlias \u0438 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u043F\u0440\u0438\u0441\u0432\u043E\u0435\u043D \u0442\u043E\u043B\u044C\u043A\u043E \u043E\u0434\u0438\u043D \u0440\u0430\u0437',
         typeAliasStatementBadScope: "\u0423\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u0435 type \u043C\u043E\u0436\u043D\u043E \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C \u0442\u043E\u043B\u044C\u043A\u043E \u0432\u043D\u0443\u0442\u0440\u0438 \u043E\u0431\u043B\u0430\u0441\u0442\u0438 \u043C\u043E\u0434\u0443\u043B\u044F \u0438\u043B\u0438 \u043A\u043B\u0430\u0441\u0441\u0430",
         typeAliasStatementIllegal: "\u041E\u043F\u0435\u0440\u0430\u0442\u043E\u0440 \u043F\u0441\u0435\u0432\u0434\u043E\u043D\u0438\u043C\u0430 \u0442\u0438\u043F\u0430 \u043C\u043E\u0436\u043D\u043E \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C \u0432 Python \u0432\u0435\u0440\u0441\u0438\u0438 \u043D\u0435 \u043D\u0438\u0436\u0435 3.12",
+        typeAliasTypeBadScope: "\u041F\u0441\u0435\u0432\u0434\u043E\u043D\u0438\u043C \u0442\u0438\u043F\u0430 \u043C\u043E\u0436\u043D\u043E \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0438\u0442\u044C \u0442\u043E\u043B\u044C\u043A\u043E \u0432\u043D\u0443\u0442\u0440\u0438 \u043E\u0431\u043B\u0430\u0441\u0442\u0438 \u043C\u043E\u0434\u0443\u043B\u044F \u0438\u043B\u0438 \u043A\u043B\u0430\u0441\u0441\u0430",
         typeAliasTypeBaseClass: '\u041F\u0441\u0435\u0432\u0434\u043E\u043D\u0438\u043C \u0442\u0438\u043F\u0430, \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u044F\u0435\u043C\u044B\u0439 \u0432 \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440\u0435 "type", \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C\u0441\u044F \u0432 \u043A\u0430\u0447\u0435\u0441\u0442\u0432\u0435 \u0431\u0430\u0437\u043E\u0432\u043E\u0433\u043E \u043A\u043B\u0430\u0441\u0441\u0430.',
         typeAliasTypeMustBeAssigned: "TypeAliasType \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043D\u0430\u0437\u043D\u0430\u0447\u0435\u043D \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u043E\u0439 \u0441 \u0442\u0435\u043C \u0436\u0435 \u0438\u043C\u0435\u043D\u0435\u043C, \u0447\u0442\u043E \u0438 \u043F\u0441\u0435\u0432\u0434\u043E\u043D\u0438\u043C \u0442\u0438\u043F\u0430",
         typeAliasTypeNameArg: "\u041F\u0435\u0440\u0432\u044B\u0439 \u0430\u0440\u0433\u0443\u043C\u0435\u043D\u0442 TypeAliasType \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0441\u0442\u0440\u043E\u043A\u043E\u0432\u044B\u043C \u043B\u0438\u0442\u0435\u0440\u0430\u043B\u043E\u043C, \u043F\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u043B\u044F\u044E\u0449\u0438\u043C \u0438\u043C\u044F \u043F\u0441\u0435\u0432\u0434\u043E\u043D\u0438\u043C\u0430 \u0442\u0438\u043F\u0430",
@@ -27636,6 +27666,7 @@ var require_package_nls_tr = __commonJS({
         baseClassUnknown: "Temel s\u0131n\u0131f t\xFCr\xFC bilinmiyor, t\xFCretilmi\u015F s\u0131n\u0131f\u0131 gizliyor",
         baseClassVariableTypeIncompatible: '"{classType}" s\u0131n\u0131f\u0131 i\xE7in temel s\u0131n\u0131flar, "{name}" de\u011Fi\u015Fkenini uyumsuz bir \u015Fekilde tan\u0131ml\u0131yor',
         binaryOperationNotAllowed: "T\xFCr ifadesinde ikili i\u015Fle\xE7 kullan\u0131lamaz",
+        bindParamMissing: '"self" veya "cls" parametresi eksik oldu\u011Fundan "{methodName}" y\xF6ntemi ba\u011Flanamad\u0131',
         bindTypeMismatch: '"{type}", "{paramName}" parametresine atanamad\u0131\u011F\u0131ndan "{methodName}" metodu ba\u011Flanamad\u0131',
         breakInExceptionGroup: '"except*" blo\u011Funda "break" kullan\u0131lamaz',
         breakOutsideLoop: '"break" yaln\u0131zca bir d\xF6ng\xFC i\xE7inde kullan\u0131labilir',
@@ -28067,6 +28098,7 @@ var require_package_nls_tr = __commonJS({
         typeAliasRedeclared: '"{name}" bir TypeAlias olarak bildirilmi\u015F ve yaln\u0131zca bir kez atanabilir',
         typeAliasStatementBadScope: "A type statement can be used only within a module or class scope",
         typeAliasStatementIllegal: "T\xFCr di\u011Fer ad\u0131 deyimi i\xE7in Python 3.12 veya daha yeni bir s\xFCr\xFCm\xFC gerekiyor",
+        typeAliasTypeBadScope: "T\xFCr di\u011Fer ad\u0131 yaln\u0131zca bir mod\xFCl veya s\u0131n\u0131f kapsam\u0131nda tan\u0131mlanabilir",
         typeAliasTypeBaseClass: 'Bir "type" deyiminde tan\u0131mlanan type di\u011Fer ad\u0131 temel s\u0131n\u0131f olarak kullan\u0131lamaz',
         typeAliasTypeMustBeAssigned: "TypeAliasType, t\xFCr di\u011Fer ad\u0131yla ayn\u0131 ada sahip bir de\u011Fi\u015Fkene atanmal\u0131d\u0131r",
         typeAliasTypeNameArg: "TypeAliasType i\xE7in ilk ba\u011F\u0131ms\u0131z de\u011Fi\u015Fken, t\xFCr di\u011Fer ad\u0131n\u0131n ad\u0131n\u0131 temsil eden bir sabit de\u011Ferli dize olmal\u0131d\u0131r",
@@ -28475,6 +28507,7 @@ var require_package_nls_zh_cn = __commonJS({
         baseClassUnknown: "\u57FA\u7C7B\u7C7B\u578B\u672A\u77E5\uFF0C\u9690\u853D\u6D3E\u751F\u7C7B\u7684\u7C7B\u578B",
         baseClassVariableTypeIncompatible: "\u7C7B\u201C{classType}\u201D\u7684\u57FA\u7C7B\u4EE5\u4E0D\u517C\u5BB9\u7684\u65B9\u5F0F\u5B9A\u4E49\u53D8\u91CF\u201C{name}\u201D",
         binaryOperationNotAllowed: "\u7C7B\u578B\u8868\u8FBE\u5F0F\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528\u4E8C\u5143\u8FD0\u7B97\u7B26",
+        bindParamMissing: "\u65E0\u6CD5\u7ED1\u5B9A\u65B9\u6CD5\u201C{methodName}\u201D\uFF0C\u56E0\u4E3A\u5B83\u7F3A\u5C11 \u201Cself\u201D \u6216 \u201Ccls\u201D \u53C2\u6570",
         bindTypeMismatch: "\u65E0\u6CD5\u7ED1\u5B9A\u65B9\u6CD5\u201C{methodName}\u201D\uFF0C\u56E0\u4E3A\u201C{type}\u201D\u4E0D\u80FD\u5206\u914D\u7ED9\u53C2\u6570\u201C{paramName}\u201D",
         breakInExceptionGroup: '"except*" \u5757\u4E2D\u4E0D\u5141\u8BB8 "break"',
         breakOutsideLoop: "\u201Cbreak\u201D\u53EA\u80FD\u5728\u5FAA\u73AF\u4E2D\u4F7F\u7528",
@@ -28906,6 +28939,7 @@ var require_package_nls_zh_cn = __commonJS({
         typeAliasRedeclared: "\u201C{name}\u201D\u58F0\u660E\u4E3A TypeAlias\uFF0C\u53EA\u80FD\u5206\u914D\u4E00\u6B21",
         typeAliasStatementBadScope: "type \u8BED\u53E5\u53EA\u80FD\u5728\u6A21\u5757\u6216\u7C7B\u8303\u56F4\u5185\u4F7F\u7528",
         typeAliasStatementIllegal: "\u7C7B\u578B\u522B\u540D\u8BED\u53E5\u9700\u8981 Python 3.12 \u6216\u66F4\u9AD8\u7248\u672C",
+        typeAliasTypeBadScope: "\u53EA\u80FD\u5728\u6A21\u5757\u6216\u7C7B\u8303\u56F4\u5185\u5B9A\u4E49\u7C7B\u578B\u522B\u540D",
         typeAliasTypeBaseClass: '"type" \u8BED\u53E5\u4E2D\u5B9A\u4E49\u7684\u7C7B\u578B\u522B\u540D\u4E0D\u80FD\u7528\u4F5C\u57FA\u7C7B',
         typeAliasTypeMustBeAssigned: "\u5FC5\u987B\u5C06 TypeAliasType \u5206\u914D\u7ED9\u4E0E\u7C7B\u578B\u522B\u540D\u540C\u540D\u7684\u53D8\u91CF",
         typeAliasTypeNameArg: "TypeAliasType \u7684\u7B2C\u4E00\u4E2A\u53C2\u6570\u5FC5\u987B\u662F\u8868\u793A\u7C7B\u578B\u522B\u540D\u540D\u79F0\u7684\u5B57\u7B26\u4E32\u6587\u672C",
@@ -29314,6 +29348,7 @@ var require_package_nls_zh_tw = __commonJS({
         baseClassUnknown: "\u57FA\u5E95\u985E\u5225\u985E\u578B\u672A\u77E5\uFF0C\u906E\u853D\u884D\u751F\u985E\u5225\u7684\u985E\u578B",
         baseClassVariableTypeIncompatible: '\u985E\u5225 "{classType}" \u7684\u57FA\u5E95\u985E\u5225\u4EE5\u4E0D\u76F8\u5BB9\u7684\u65B9\u5F0F\u5B9A\u7FA9\u8B8A\u6578 "{name}"',
         binaryOperationNotAllowed: "\u985E\u578B\u904B\u7B97\u5F0F\u4E2D\u4E0D\u5141\u8A31\u4E8C\u5143\u904B\u7B97\u5B50",
+        bindParamMissing: '\u7121\u6CD5\u7E6B\u7D50\u65B9\u6CD5 "{methodName}"\uFF0C\u56E0\u70BA\u7F3A\u5C11 "self" \u6216 "cls" \u53C3\u6578',
         bindTypeMismatch: '\u7121\u6CD5\u7E6B\u7D50\u65B9\u6CD5 "{methodName}"\uFF0C\u56E0\u70BA "{type}" \u7121\u6CD5\u6307\u6D3E\u7D66\u53C3\u6578 "{paramName}"',
         breakInExceptionGroup: '"except*" \u5340\u584A\u4E2D\u4E0D\u5141\u8A31 "break"',
         breakOutsideLoop: '"break" \u53EA\u80FD\u5728\u8FF4\u5708\u5167\u4F7F\u7528',
@@ -29745,6 +29780,7 @@ var require_package_nls_zh_tw = __commonJS({
         typeAliasRedeclared: '"{name}" \u5BA3\u544A\u70BA TypeAlias\uFF0C\u4E14\u53EA\u80FD\u6307\u6D3E\u4E00\u6B21',
         typeAliasStatementBadScope: "A type statement can be used only within a module or class scope",
         typeAliasStatementIllegal: "\u985E\u578B\u5225\u540D\u9673\u8FF0\u5F0F\u9700\u8981 Python 3.12 \u6216\u66F4\u65B0\u7248\u672C",
+        typeAliasTypeBadScope: "\u985E\u578B\u5225\u540D\u53EA\u80FD\u5728\u6A21\u7D44\u6216\u985E\u5225\u7BC4\u570D\u5167\u5B9A\u7FA9",
         typeAliasTypeBaseClass: '"type" \u9673\u8FF0\u5F0F\u4E2D\u5B9A\u7FA9\u7684\u985E\u578B\u5225\u540D\u4E0D\u80FD\u505A\u70BA\u57FA\u5E95\u985E\u5225\u4F7F\u7528',
         typeAliasTypeMustBeAssigned: "TypeAliasType \u5FC5\u9808\u6307\u6D3E\u7D66\u8207\u578B\u5225\u5225\u540D\u76F8\u540C\u7684\u8B8A\u6578",
         typeAliasTypeNameArg: "TypeAliasType \u7684\u7B2C\u4E00\u500B\u5F15\u6578\u5FC5\u9808\u662F\u4EE3\u8868\u578B\u5225\u5225\u540D\u540D\u7A31\u7684\u5B57\u4E32\u5E38\u503C",
@@ -33007,6 +33043,9 @@ var require_codeFlowTypes = __commonJS({
       if (reference.nodeType === 35) {
         return isCodeFlowSupportedForReference(reference.d.leftExpr);
       }
+      if (reference.nodeType === 4) {
+        return true;
+      }
       if (reference.nodeType === 27) {
         if (reference.d.items.length !== 1 || reference.d.trailingComma || reference.d.items[0].d.name !== void 0 || reference.d.items[0].d.argCategory !== 0) {
           return false;
@@ -33026,6 +33065,8 @@ var require_codeFlowTypes = __commonJS({
       let key;
       if (reference.nodeType === 38) {
         key = reference.d.value;
+      } else if (reference.nodeType === 4) {
+        key = reference.d.name.d.value;
       } else if (reference.nodeType === 35) {
         const leftKey = createKeyForReference(reference.d.leftExpr);
         key = `${leftKey}.${reference.d.member.d.value}`;
@@ -33056,6 +33097,9 @@ var require_codeFlowTypes = __commonJS({
       if (reference.nodeType === 38) {
         return [createKeyForReference(reference)];
       }
+      if (reference.nodeType === 4) {
+        return [createKeyForReference(reference.d.name)];
+      }
       if (reference.nodeType === 35) {
         return [
           ...createKeysForReferenceSubexpressions(reference.d.leftExpr),
@@ -33126,9 +33170,6 @@ var require_analyzerNodeInfo = __commonJS({
       if (info == null ? void 0 : info.dunderAllInfo) {
         info.dunderAllInfo = void 0;
       }
-      if (info == null ? void 0 : info.typeParamSymbol) {
-        info.typeParamSymbol = void 0;
-      }
     }
     function getImportInfo(node) {
       const info = getAnalyzerInfo(node);
@@ -33993,6 +34034,8 @@ var require_parseTreeUtils = __commonJS({
     exports2.checkDecorator = checkDecorator;
     exports2.isSimpleDefault = isSimpleDefault;
     exports2.getPreviousNonWhitespaceToken = getPreviousNonWhitespaceToken;
+    exports2.getNextNonWhitespaceToken = getNextNonWhitespaceToken;
+    exports2.getNextMatchingToken = getNextMatchingToken;
     var AnalyzerNodeInfo = __importStar(require_analyzerNodeInfo());
     var core_1 = require_core();
     var debug_1 = require_debug();
@@ -36126,6 +36169,23 @@ var require_parseTreeUtils = __commonJS({
       }
       return void 0;
     }
+    function getNextNonWhitespaceToken(tokens, offset) {
+      return getNextMatchingToken(tokens, offset, (token) => !isWhitespace(token));
+    }
+    function getNextMatchingToken(tokens, offset, match2, exit = () => false) {
+      let tokenIndex = tokens.getItemAtPosition(offset) + 1;
+      while (tokenIndex < tokens.count) {
+        const token = tokens.getItemAt(tokenIndex);
+        if (match2(token)) {
+          return token;
+        }
+        if (exit(token)) {
+          return void 0;
+        }
+        tokenIndex += 1;
+      }
+      return void 0;
+    }
   }
 });
 
@@ -41154,6 +41214,7 @@ var require_tokenizer = __commonJS({
     exports2.Tokenizer = void 0;
     var parseTreeUtils_1 = require_parseTreeUtils();
     var sourceFile_1 = require_sourceFile();
+    var core_1 = require_core();
     var textRangeCollection_1 = require_textRangeCollection();
     var characters_1 = require_characters();
     var characterStream_1 = require_characterStream();
@@ -42024,7 +42085,7 @@ var require_tokenizer = __commonJS({
           if (_keywords.has(value)) {
             this._tokens.push(tokenizerTypes_1.KeywordToken.create(start, this._cs.position - start, _keywords.get(value), this._getComments()));
           } else {
-            this._tokens.push(tokenizerTypes_1.IdentifierToken.create(start, this._cs.position - start, value, this._getComments()));
+            this._tokens.push(tokenizerTypes_1.IdentifierToken.create(start, this._cs.position - start, (0, core_1.cloneStr)(value), this._getComments()));
           }
           return true;
         }
@@ -42361,7 +42422,7 @@ var require_tokenizer = __commonJS({
           if (endTrimmed.length > 0) {
             commentRules.push({
               range: { start: currentOffset, length: endTrimmed.length },
-              text: endTrimmed
+              text: (0, core_1.cloneStr)(endTrimmed)
             });
           }
           currentOffset += frontTrimmed.length + 1;
@@ -43613,7 +43674,7 @@ var require_binder = __commonJS({
         var _a;
         const isBuiltInModule = this._fileInfo.builtinsScope === void 0;
         this._addTypingImportAliasesFromBuiltinsScope();
-        this._createNewScope(
+        const moduleScope = this._createNewScope(
           isBuiltInModule ? 5 : 4,
           this._fileInfo.builtinsScope,
           /* proxyScope */
@@ -43625,7 +43686,7 @@ var require_binder = __commonJS({
             this._addImplicitSymbolToCurrentScope("__loader__", node, "Any");
             this._addImplicitSymbolToCurrentScope("__package__", node, "str | None");
             this._addImplicitSymbolToCurrentScope("__spec__", node, "Any");
-            this._addImplicitSymbolToCurrentScope("__path__", node, "Iterable[str]");
+            this._addImplicitSymbolToCurrentScope("__path__", node, "MutableSequence[str]");
             this._addImplicitSymbolToCurrentScope("__file__", node, "str");
             this._addImplicitSymbolToCurrentScope("__cached__", node, "str");
             this._addImplicitSymbolToCurrentScope("__dict__", node, "Dict[str, Any]");
@@ -43640,16 +43701,22 @@ var require_binder = __commonJS({
           }
         );
         this._bindDeferred();
-        this._potentialHiddenSymbols.forEach((symbol, name) => {
-          var _a2;
-          if (!((_a2 = this._dunderAllNames) == null ? void 0 : _a2.some((sym) => sym === name))) {
-            if (this._fileInfo.isStubFile) {
-              symbol.setIsExternallyHidden();
-            } else {
-              symbol.setPrivatePyTypedImport();
+        if (this._fileInfo.isModulePrivate) {
+          moduleScope.symbolTable.forEach((symbol) => {
+            symbol.setPrivatePyTypedImport();
+          });
+        } else {
+          this._potentialHiddenSymbols.forEach((symbol, name) => {
+            var _a2;
+            if (!((_a2 = this._dunderAllNames) == null ? void 0 : _a2.some((sym) => sym === name))) {
+              if (this._fileInfo.isStubFile) {
+                symbol.setIsExternallyHidden();
+              } else {
+                symbol.setPrivatePyTypedImport();
+              }
             }
-          }
-        });
+          });
+        }
         this._potentialPrivateSymbols.forEach((symbol, name) => {
           var _a2;
           if (!((_a2 = this._dunderAllNames) == null ? void 0 : _a2.some((sym) => sym === name))) {
@@ -43685,6 +43752,7 @@ var require_binder = __commonJS({
         return false;
       }
       visitModuleName(node) {
+        var _a;
         const importResult = AnalyzerNodeInfo.getImportInfo(node);
         (0, debug_1.assert)(importResult !== void 0);
         if (importResult.isNativeLib) {
@@ -43697,7 +43765,19 @@ var require_binder = __commonJS({
           }), node);
           return true;
         }
+        let reportStubMissing = false;
         if (!importResult.isStubFile && importResult.importType === 1 && !importResult.pyTypedInfo) {
+          reportStubMissing = true;
+          if (importResult.isNamespacePackage && ((_a = node.parent) == null ? void 0 : _a.nodeType) === 25) {
+            if (node.parent.d.imports.every((importAs) => {
+              const implicitImport = importResult.filteredImplicitImports.get(importAs.d.name.d.value);
+              return !!(implicitImport == null ? void 0 : implicitImport.pyTypedInfo);
+            })) {
+              reportStubMissing = false;
+            }
+          }
+        }
+        if (reportStubMissing) {
           const diagnostic = this._addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeStubs, localize_1.LocMessage.stubFileMissing().format({ importName: importResult.importName }), node);
           if (diagnostic) {
             const createTypeStubAction = {
@@ -47567,6 +47647,15 @@ var require_types = __commonJS({
           }
           return true;
         }
+        const subclassDepth = TypeBase.getInstantiableDepth(subclassType);
+        if (subclassDepth > 0) {
+          if (isBuiltIn(parentClassType, "type") && TypeBase.getInstantiableDepth(parentClassType) < subclassDepth) {
+            if (inheritanceChain) {
+              inheritanceChain.push(parentClassType);
+            }
+            return true;
+          }
+        }
         if (ClassType2.isBuiltIn(subclassType, "property") && ClassType2.isBuiltIn(parentClassType, "property")) {
           if (inheritanceChain) {
             inheritanceChain.push(subclassType);
@@ -47712,16 +47801,14 @@ var require_types = __commonJS({
         if (stripFirstParam) {
           if (type.shared.parameters.length > 0) {
             if (type.shared.parameters[0].category === 0) {
-              if (type.shared.parameters.length > 0 && !FunctionParam.isTypeInferred(type.shared.parameters[0])) {
-                newFunction.priv.strippedFirstParamType = getParamType(type, 0);
+              if (type.shared.parameters.length > 0) {
+                newFunction.priv.strippedFirstParamType = FunctionParam.isTypeInferred(type.shared.parameters[0]) ? AnyType.create() : getParamType(type, 0);
               }
               newFunction.shared.parameters = type.shared.parameters.slice(1);
             }
           } else {
             stripFirstParam = false;
           }
-          newFunction.shared.flags &= ~(1 | 2);
-          newFunction.shared.flags |= 4;
         }
         if ((_a = type.props) == null ? void 0 : _a.typeAliasInfo) {
           TypeBase.setTypeAliasInfo(newFunction, type.props.typeAliasInfo);
@@ -47733,7 +47820,7 @@ var require_types = __commonJS({
             returnType: type.priv.specializedTypes.returnType
           };
         }
-        newFunction.priv.inferredReturnType = type.priv.inferredReturnType;
+        newFunction.shared.inferredReturnType = type.shared.inferredReturnType;
         return newFunction;
       }
       FunctionType2.clone = clone;
@@ -47766,20 +47853,13 @@ var require_types = __commonJS({
         return newInstance;
       }
       FunctionType2.cloneAsInstantiable = cloneAsInstantiable;
-      function specialize(type, specializedTypes, specializedInferredReturnType) {
-        var _a;
+      function specialize(type, specializedTypes) {
         const newFunction = TypeBase.cloneType(type);
         (0, debug_1.assert)(specializedTypes.parameterTypes.length === type.shared.parameters.length);
         if (specializedTypes.parameterDefaultTypes) {
           (0, debug_1.assert)(specializedTypes.parameterDefaultTypes.length === type.shared.parameters.length);
         }
         newFunction.priv.specializedTypes = specializedTypes;
-        if (specializedInferredReturnType) {
-          newFunction.priv.inferredReturnType = {
-            type: specializedInferredReturnType,
-            isIncomplete: (_a = type.priv.inferredReturnType) == null ? void 0 : _a.isIncomplete
-          };
-        }
         return newFunction;
       }
       FunctionType2.specialize = specialize;
@@ -47895,8 +47975,8 @@ var require_types = __commonJS({
             newFunction.priv.specializedTypes.parameterDefaultTypes = newFunction.priv.specializedTypes.parameterDefaultTypes.slice(0, newFunction.priv.specializedTypes.parameterDefaultTypes.length - paramsToDrop);
           }
         }
-        if (type.priv.inferredReturnType) {
-          newFunction.priv.inferredReturnType = type.priv.inferredReturnType;
+        if (type.shared.inferredReturnType) {
+          newFunction.shared.inferredReturnType = type.shared.inferredReturnType;
         }
         return newFunction;
       }
@@ -48095,7 +48175,7 @@ var require_types = __commonJS({
           return type.shared.declaredReturnType;
         }
         if (includeInferred) {
-          return (_b = type.priv.inferredReturnType) == null ? void 0 : _b.type;
+          return (_b = type.shared.inferredReturnType) == null ? void 0 : _b.type;
         }
         return void 0;
       }
@@ -48881,15 +48961,15 @@ var require_types = __commonJS({
           if (type1.priv.specializedTypes && type1.priv.specializedTypes.returnType) {
             return1Type = type1.priv.specializedTypes.returnType;
           }
-          if (!return1Type && type1.priv.inferredReturnType) {
-            return1Type = (_e = type1.priv.inferredReturnType) == null ? void 0 : _e.type;
+          if (!return1Type && type1.shared.inferredReturnType) {
+            return1Type = (_e = type1.shared.inferredReturnType) == null ? void 0 : _e.type;
           }
           let return2Type = functionType2.shared.declaredReturnType;
           if (functionType2.priv.specializedTypes && functionType2.priv.specializedTypes.returnType) {
             return2Type = functionType2.priv.specializedTypes.returnType;
           }
-          if (!return2Type && functionType2.priv.inferredReturnType) {
-            return2Type = (_f = functionType2.priv.inferredReturnType) == null ? void 0 : _f.type;
+          if (!return2Type && functionType2.shared.inferredReturnType) {
+            return2Type = (_f = functionType2.shared.inferredReturnType) == null ? void 0 : _f.type;
           }
           if (return1Type || return2Type) {
             if (!return1Type || !return2Type || !isTypeSame(return1Type, return2Type, { ...options, ignoreTypeFlags: false }, recursionCount)) {
@@ -49422,7 +49502,7 @@ var require_typeWalker = __commonJS({
           }
         }
         if (!this._isWalkCanceled && !types_1.FunctionType.isParamSpecValue(type) && !types_1.FunctionType.isParamSpecValue(type)) {
-          const returnType = type.shared.declaredReturnType ?? ((_a = type.priv.inferredReturnType) == null ? void 0 : _a.type);
+          const returnType = type.shared.declaredReturnType ?? ((_a = type.shared.inferredReturnType) == null ? void 0 : _a.type);
           if (returnType) {
             this.walk(returnType);
           }
@@ -51531,8 +51611,8 @@ var require_typeUtils = __commonJS({
             if (requiresSpecialization(declaredReturnType, options, recursionCount)) {
               return true;
             }
-          } else if (type.priv.inferredReturnType) {
-            if (requiresSpecialization((_b = type.priv.inferredReturnType) == null ? void 0 : _b.type, options, recursionCount)) {
+          } else if (type.shared.inferredReturnType) {
+            if (requiresSpecialization((_b = type.shared.inferredReturnType) == null ? void 0 : _b.type, options, recursionCount)) {
               return true;
             }
           }
@@ -52114,9 +52194,10 @@ var require_typeUtils = __commonJS({
             }
           }
           let specializedInferredReturnType;
-          if (functionType.priv.inferredReturnType) {
-            specializedInferredReturnType = this.apply((_a = functionType.priv.inferredReturnType) == null ? void 0 : _a.type, recursionCount);
-            if (specializedInferredReturnType !== ((_b = functionType.priv.inferredReturnType) == null ? void 0 : _b.type)) {
+          if (functionType.shared.inferredReturnType) {
+            specializedInferredReturnType = this.apply((_a = functionType.shared.inferredReturnType) == null ? void 0 : _a.type, recursionCount);
+            if (specializedInferredReturnType !== ((_b = functionType.shared.inferredReturnType) == null ? void 0 : _b.type)) {
+              specializedParams.returnType = specializedInferredReturnType;
               typesRequiredSpecialization = true;
             }
           }
@@ -52131,7 +52212,7 @@ var require_typeUtils = __commonJS({
               );
             }
           }
-          if (functionType.priv.strippedFirstParamType) {
+          if (functionType.priv.strippedFirstParamType && !(0, types_1.isAnyOrUnknown)(functionType.priv.strippedFirstParamType)) {
             const newStrippedType = this.apply(functionType.priv.strippedFirstParamType, recursionCount);
             if (newStrippedType !== functionType.priv.strippedFirstParamType) {
               functionType = types_1.TypeBase.cloneType(functionType);
@@ -52145,7 +52226,7 @@ var require_typeUtils = __commonJS({
             specializedParams.parameterDefaultTypes = specializedDefaultArgs;
           }
           if (!variadicTypesToUnpack) {
-            return types_1.FunctionType.specialize(functionType, specializedParams, specializedInferredReturnType);
+            return types_1.FunctionType.specialize(functionType, specializedParams);
           }
           const newFunctionType = types_1.TypeBase.isInstantiable(functionType) ? types_1.FunctionType.createInstantiable(
             functionType.shared.flags | 64
@@ -54543,7 +54624,7 @@ var require_constraintSolver = __commonJS({
       }
       if (destType.shared.boundType) {
         const updatedType = newLowerBound || newUpperBound;
-        if (types_1.TypeBase.isInstantiable(destType) && !(0, typeUtils_1.isEffectivelyInstantiable)(srcType)) {
+        if (types_1.TypeBase.isInstantiable(destType) && !(0, typeUtils_1.isEffectivelyInstantiable)(srcType, { honorTypeVarBounds: true })) {
           return false;
         }
         const effectiveConstraints = types_1.TypeVarType.isSelf(destType) ? constraints : void 0;
@@ -54868,11 +54949,12 @@ var require_parameterUtils = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/analyzer/parameterUtils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.ParamKind = void 0;
+    exports2.ParamAssignmentTracker = exports2.ParamKind = void 0;
     exports2.isTypedKwargs = isTypedKwargs;
     exports2.getParamListDetails = getParamListDetails;
     exports2.isParamSpecArgs = isParamSpecArgs;
     exports2.isParamSpecKwargs = isParamSpecKwargs;
+    var debug_1 = require_debug();
     var symbolNameUtils_1 = require_symbolNameUtils();
     var types_1 = require_types();
     var typeUtils_1 = require_typeUtils();
@@ -55044,7 +55126,7 @@ var require_parameterUtils = __commonJS({
         }
       });
       result.paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(type);
-      result.firstPositionOrKeywordIndex = result.params.findIndex((p) => p.kind !== ParamKind.Positional);
+      result.firstPositionOrKeywordIndex = result.params.findIndex((p) => p.kind !== ParamKind.Positional && p.kind !== ParamKind.ExpandedArgs);
       if (result.firstPositionOrKeywordIndex < 0) {
         result.firstPositionOrKeywordIndex = result.params.length;
       }
@@ -55082,6 +55164,60 @@ var require_parameterUtils = __commonJS({
       });
       return isCompatible;
     }
+    var ParamAssignmentTracker = class {
+      constructor(paramInfos) {
+        this.params = paramInfos.map((p) => {
+          const argsNeeded = !!p.defaultType || p.param.category !== 0 ? 0 : 1;
+          return { paramDetails: p, argsNeeded, argsReceived: 0 };
+        });
+      }
+      // Add a virtual keyword parameter for a keyword argument that
+      // targets a **kwargs parameter. This allows us to detect duplicate
+      // keyword arguments.
+      addKeywordParam(name, info) {
+        this.params.push({
+          paramDetails: info,
+          keywordName: name,
+          argsNeeded: 1,
+          argsReceived: 1
+        });
+      }
+      lookupName(name) {
+        return this.params.find((p) => {
+          const kind = p.paramDetails.kind;
+          if (kind === ParamKind.Positional || kind === ParamKind.ExpandedArgs) {
+            return false;
+          }
+          const effectiveName = p.keywordName ?? p.paramDetails.param.name;
+          return effectiveName === name;
+        });
+      }
+      lookupDetails(paramInfo) {
+        const info = this.params.find((p) => p.paramDetails === paramInfo);
+        (0, debug_1.assert)(info !== void 0);
+        return info;
+      }
+      markArgReceived(paramInfo) {
+        const entry = this.lookupDetails(paramInfo);
+        entry.argsReceived++;
+      }
+      // Returns a list of params that have not received their
+      // required number of arguments.
+      getUnassignedParams() {
+        const unassignedParams = [];
+        this.params.forEach((p) => {
+          if (!p.paramDetails.param.name) {
+            return;
+          }
+          if (p.argsReceived >= p.argsNeeded) {
+            return;
+          }
+          unassignedParams.push(p.paramDetails.param.name);
+        });
+        return unassignedParams;
+      }
+    };
+    exports2.ParamAssignmentTracker = ParamAssignmentTracker;
   }
 });
 
@@ -56521,7 +56657,7 @@ var require_constructorTransform = __commonJS({
       newParamList.forEach((param) => {
         types_1.FunctionType.addParam(newCallMemberType, param);
       });
-      newCallMemberType.shared.declaredReturnType = specializedFunctionType.shared.declaredReturnType ? types_1.FunctionType.getEffectiveReturnType(specializedFunctionType) : (_a = specializedFunctionType.priv.inferredReturnType) == null ? void 0 : _a.type;
+      newCallMemberType.shared.declaredReturnType = specializedFunctionType.shared.declaredReturnType ? types_1.FunctionType.getEffectiveReturnType(specializedFunctionType) : (_a = specializedFunctionType.shared.inferredReturnType) == null ? void 0 : _a.type;
       newCallMemberType.shared.declaration = partialCallMemberType.shared.declaration;
       newCallMemberType.shared.typeVarScopeId = specializedFunctionType.shared.typeVarScopeId;
       return { returnType: newCallMemberType, isTypeIncomplete: false, argumentErrors };
@@ -57185,7 +57321,7 @@ var require_constructors = __commonJS({
       return skipInitCheck;
     }
     function isDefaultNewMethod(newMethod) {
-      var _a;
+      var _a, _b;
       if (!newMethod || !(0, types_1.isFunction)(newMethod)) {
         return false;
       }
@@ -57196,7 +57332,12 @@ var require_constructors = __commonJS({
       if (params[0].category !== 1 || params[1].category !== 2) {
         return false;
       }
-      const returnType = newMethod.shared.declaredReturnType ?? ((_a = newMethod.priv.inferredReturnType) == null ? void 0 : _a.type);
+      let returnType;
+      if (newMethod.shared.declaredReturnType) {
+        returnType = newMethod.shared.declaredReturnType;
+      } else {
+        returnType = ((_a = newMethod.priv.specializedTypes) == null ? void 0 : _a.returnType) ?? ((_b = newMethod.shared.inferredReturnType) == null ? void 0 : _b.type);
+      }
       if (!returnType || !(0, types_1.isTypeVar)(returnType) || !types_1.TypeVarType.isSelf(returnType)) {
         return false;
       }
@@ -59895,8 +60036,23 @@ var require_typeGuards = __commonJS({
               } else {
                 filteredTypes.push((0, typeUtils_1.convertToInstance)(filterType));
               }
-            } else if (evaluator.assignType((0, typeUtils_1.convertToInstance)(convertVarTypeToFree(concreteFilterType)), varType)) {
-              filteredTypes.push((0, typeUtils_1.convertToInstance)(varType));
+            } else {
+              const filterTypeInstance = (0, typeUtils_1.convertToInstance)(convertVarTypeToFree(concreteFilterType));
+              if (evaluator.assignType(filterTypeInstance, varType)) {
+                filteredTypes.push((0, typeUtils_1.convertToInstance)(varType));
+              } else {
+                if ((0, types_1.isClassInstance)(filterTypeInstance) && !types_1.ClassType.isFinal(filterTypeInstance)) {
+                  const gradualFunc = types_1.FunctionType.createSynthesizedInstance(
+                    "",
+                    32768
+                    /* FunctionTypeFlags.GradualCallableForm */
+                  );
+                  types_1.FunctionType.addDefaultParams(gradualFunc);
+                  if (!evaluator.assignType(gradualFunc, filterTypeInstance)) {
+                    filteredTypes.push((0, typeUtils_1.convertToInstance)(filterType));
+                  }
+                }
+              }
             }
           }
         } else {
@@ -60136,10 +60292,10 @@ var require_typeGuards = __commonJS({
             if (!evaluator.isTypeComparable(elementSubtype, referenceSubtype)) {
               return void 0;
             }
-            if ((0, types_1.isClassInstance)(elementSubtype) && ((0, typeUtils_1.isLiteralType)(elementSubtype) || (0, typeUtils_1.isNoneInstance)(elementSubtype)) && evaluator.assignType(referenceSubtype, elementSubtype)) {
+            if ((0, types_1.isClassInstance)(elementSubtype) && ((0, typeUtils_1.isLiteralLikeType)(elementSubtype) || (0, typeUtils_1.isNoneInstance)(elementSubtype)) && evaluator.assignType(referenceSubtype, elementSubtype)) {
               return (0, typeUtils_1.stripTypeForm)((0, typeUtils_1.addConditionToType)(elementSubtype, (_a = referenceSubtype.props) == null ? void 0 : _a.condition));
             }
-            if ((0, types_1.isClassInstance)(referenceSubtype) && ((0, typeUtils_1.isLiteralType)(referenceSubtype) || (0, typeUtils_1.isNoneInstance)(referenceSubtype)) && evaluator.assignType(elementSubtype, referenceSubtype)) {
+            if ((0, types_1.isClassInstance)(referenceSubtype) && ((0, typeUtils_1.isLiteralLikeType)(referenceSubtype) || (0, typeUtils_1.isNoneInstance)(referenceSubtype)) && evaluator.assignType(elementSubtype, referenceSubtype)) {
               return (0, typeUtils_1.stripTypeForm)((0, typeUtils_1.addConditionToType)(referenceSubtype, (_b = elementSubtype.props) == null ? void 0 : _b.condition));
             }
             if ((0, types_1.isInstantiableClass)(elementSubtype) && !elementSubtype.priv.includeSubclasses && evaluator.assignType(referenceSubtype, elementSubtype)) {
@@ -60410,24 +60566,29 @@ var require_typeGuards = __commonJS({
               return literalType;
             }
             return subtype;
-          } else if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isSameGenericClass(literalType, subtype)) {
+          }
+          if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isSameGenericClass(literalType, subtype)) {
             if (subtype.priv.literalValue !== void 0) {
               const literalValueMatches = types_1.ClassType.isLiteralValueSame(subtype, literalType);
               if (isPositiveTest) {
                 return literalValueMatches ? subtype : void 0;
-              } else {
-                const isEnumOrBool = types_1.ClassType.isEnumClass(literalType) || types_1.ClassType.isBuiltIn(literalType, "bool");
-                return literalValueMatches && (isEnumOrBool || !isIsOperator) ? void 0 : subtype;
               }
-            } else if (isPositiveTest) {
+              const isEnumOrBool = types_1.ClassType.isEnumClass(literalType) || types_1.ClassType.isBuiltIn(literalType, "bool");
+              return literalValueMatches && (isEnumOrBool || !isIsOperator) ? void 0 : subtype;
+            }
+            if (isPositiveTest) {
+              return literalType;
+            }
+            const allLiteralTypes = enumerateLiteralsForType(evaluator, subtype);
+            if (allLiteralTypes && allLiteralTypes.length > 0) {
+              return (0, types_1.combineTypes)(allLiteralTypes.filter((type) => !types_1.ClassType.isLiteralValueSame(type, literalType)));
+            }
+            return subtype;
+          }
+          if (isPositiveTest) {
+            if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, "LiteralString")) {
               return literalType;
-            } else {
-              const allLiteralTypes = enumerateLiteralsForType(evaluator, subtype);
-              if (allLiteralTypes && allLiteralTypes.length > 0) {
-                return (0, types_1.combineTypes)(allLiteralTypes.filter((type) => !types_1.ClassType.isLiteralValueSame(type, literalType)));
-              }
             }
-          } else if (isPositiveTest) {
             if (isIsOperator || (0, typeUtils_1.isNoneInstance)(subtype)) {
               const isSubtype = evaluator.assignType(subtype, literalType);
               return isSubtype ? literalType : void 0;
@@ -61595,7 +61756,7 @@ var require_importResolver = __commonJS({
       return result;
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.ImportResolver = exports2.supportedFileExtensions = void 0;
+    exports2.ImportResolver = exports2.supportedFileExtensions = exports2.supportedSourceFileExtensions = void 0;
     exports2.createImportedModuleDescriptor = createImportedModuleDescriptor;
     exports2.formatImportName = formatImportName;
     exports2.getParentImportResolutionRoot = getParentImportResolutionRoot;
@@ -61606,7 +61767,6 @@ var require_importResolver = __commonJS({
     var pathConsts_1 = require_pathConsts();
     var pathUtils_1 = require_pathUtils();
     var pythonVersion_1 = require_pythonVersion();
-    var serviceKeys_1 = require_serviceKeys();
     var StringUtils = __importStar(require_stringUtils());
     var stringUtils_1 = require_stringUtils();
     var uri_1 = require_uri();
@@ -61637,8 +61797,8 @@ var require_importResolver = __commonJS({
       };
     }
     var supportedNativeLibExtensions = [".pyd", ".so", ".dylib"];
-    var supportedSourceFileExtensions = [".py", ".pyi"];
-    exports2.supportedFileExtensions = [...supportedSourceFileExtensions, ...supportedNativeLibExtensions];
+    exports2.supportedSourceFileExtensions = [".py", ".pyi"];
+    exports2.supportedFileExtensions = [...exports2.supportedSourceFileExtensions, ...supportedNativeLibExtensions];
     var allowPartialResolutionForThirdPartyPackages = false;
     var ImportResolver = class _ImportResolver {
       constructor(serviceProvider, _configOptions, host) {
@@ -61659,11 +61819,11 @@ var require_importResolver = __commonJS({
         return this.serviceProvider.tmp();
       }
       get partialStubs() {
-        return this.serviceProvider.tryGet(serviceKeys_1.ServiceKeys.partialStubs);
+        return this.serviceProvider.partialStubs();
       }
       static isSupportedImportSourceFile(uri) {
         const fileExtension = uri.lastExtension.toLowerCase();
-        return supportedSourceFileExtensions.some((ext2) => fileExtension === ext2);
+        return exports2.supportedSourceFileExtensions.some((ext2) => fileExtension === ext2);
       }
       static isSupportedImportFile(uri) {
         const fileExtension = uri.lastExtension.toLowerCase();
@@ -62197,6 +62357,7 @@ var require_importResolver = __commonJS({
           importType: 2,
           isStubFile: false,
           isNativeLib: false,
+          isModulePrivate: false,
           implicitImports: /* @__PURE__ */ new Map(),
           filteredImplicitImports: /* @__PURE__ */ new Map(),
           nonStubImportResult: void 0
@@ -62281,6 +62442,7 @@ var require_importResolver = __commonJS({
         let importType = 0;
         let isLocalTypingsFile = false;
         let isThirdPartyPyTypedPresent = false;
+        const isModulePrivate = false;
         let isTypeshedFile = false;
         const importFailureInfo = [];
         let moduleNameWithInvalidCharacters;
@@ -62299,7 +62461,8 @@ var require_importResolver = __commonJS({
                 importType,
                 isTypeshedFile: true,
                 isLocalTypingsFile,
-                isThirdPartyPyTypedPresent
+                isThirdPartyPyTypedPresent,
+                isModulePrivate
               };
             }
           }
@@ -62398,7 +62561,14 @@ var require_importResolver = __commonJS({
           }
         }
         if (moduleName) {
-          return { moduleName, importType, isTypeshedFile, isLocalTypingsFile, isThirdPartyPyTypedPresent };
+          return {
+            moduleName,
+            importType,
+            isTypeshedFile,
+            isLocalTypingsFile,
+            isThirdPartyPyTypedPresent,
+            isModulePrivate
+          };
         }
         if (allowInvalidModuleName && moduleNameWithInvalidCharacters) {
           return {
@@ -62406,7 +62576,8 @@ var require_importResolver = __commonJS({
             isTypeshedFile,
             importType,
             isLocalTypingsFile,
-            isThirdPartyPyTypedPresent
+            isThirdPartyPyTypedPresent,
+            isModulePrivate
           };
         }
         return {
@@ -62414,7 +62585,8 @@ var require_importResolver = __commonJS({
           isTypeshedFile,
           importType: 2,
           isLocalTypingsFile,
-          isThirdPartyPyTypedPresent
+          isThirdPartyPyTypedPresent,
+          isModulePrivate
         };
       }
       _invalidateFileSystemCache() {
@@ -62438,6 +62610,7 @@ var require_importResolver = __commonJS({
         let implicitImports = /* @__PURE__ */ new Map();
         let packageDirectory;
         let pyTypedInfo;
+        let isModulePrivate = false;
         if (moduleDescriptor.nameParts.length === 0) {
           const pyFilePath = dirPath.initPyUri;
           const pyiFilePath = dirPath.initPyiUri;
@@ -62458,7 +62631,11 @@ var require_importResolver = __commonJS({
           for (let i = 0; i < moduleDescriptor.nameParts.length; i++) {
             const isFirstPart = i === 0;
             const isLastPart = i === moduleDescriptor.nameParts.length - 1;
-            dirPath = dirPath.combinePaths(moduleDescriptor.nameParts[i]);
+            const namePart = moduleDescriptor.nameParts[i];
+            dirPath = dirPath.combinePaths(namePart);
+            if (SymbolNameUtils.isProtectedName(namePart)) {
+              isModulePrivate = true;
+            }
             if (useStubPackage && isFirstPart) {
               dirPath = dirPath.addPath(pathConsts_1.stubsSuffix);
               isStubPackage = true;
@@ -62539,6 +62716,9 @@ var require_importResolver = __commonJS({
         } else {
           importFound = resolvedPaths.length >= moduleDescriptor.nameParts.length;
         }
+        if (!isStubFile && !pyTypedInfo) {
+          isModulePrivate = false;
+        }
         return {
           importName,
           isRelative: false,
@@ -62555,6 +62735,7 @@ var require_importResolver = __commonJS({
           isNativeLib,
           implicitImports,
           pyTypedInfo,
+          isModulePrivate,
           filteredImplicitImports: implicitImports,
           packageDirectory
         };
@@ -64878,11 +65059,7 @@ var require_properties = __commonJS({
       propertyClass.priv.isAsymmetricDescriptor = false;
       updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
       propertyObject.priv.fgetInfo = {
-        methodType: types_1.FunctionType.cloneWithNewFlags(
-          fget,
-          fget.shared.flags | 4
-          /* FunctionTypeFlags.StaticMethod */
-        ),
+        methodType: fget,
         classType: fget.shared.methodClass
       };
       if (types_1.FunctionType.isClassMethod(fget)) {
@@ -64938,11 +65115,7 @@ var require_properties = __commonJS({
       });
       updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
       propertyObject.priv.fsetInfo = {
-        methodType: types_1.FunctionType.cloneWithNewFlags(
-          fset,
-          fset.shared.flags | 4
-          /* FunctionTypeFlags.StaticMethod */
-        ),
+        methodType: fset,
         classType: fset.shared.methodClass
       };
       addSetMethodToPropertySymbolTable(evaluator, propertyObject, fset);
@@ -64972,11 +65145,7 @@ var require_properties = __commonJS({
       });
       updateGetSetDelMethodForClonedProperty(evaluator, propertyObject);
       propertyObject.priv.fdelInfo = {
-        methodType: types_1.FunctionType.cloneWithNewFlags(
-          fdel,
-          fdel.shared.flags | 4
-          /* FunctionTypeFlags.StaticMethod */
-        ),
+        methodType: fdel,
         classType: fdel.shared.methodClass
       };
       addDelMethodToPropertySymbolTable(evaluator, propertyObject, fdel);
@@ -65117,7 +65286,7 @@ var require_properties = __commonJS({
       accessors.forEach((accessorInfo) => {
         let destAccessType = accessorInfo.getFunction(destPropertyType);
         if (destAccessType && (0, types_1.isFunction)(destAccessType)) {
-          let srcAccessType = accessorInfo.getFunction(srcPropertyType);
+          const srcAccessType = accessorInfo.getFunction(srcPropertyType);
           if (!srcAccessType || !(0, types_1.isFunction)(srcAccessType)) {
             diag == null ? void 0 : diag.addMessage(accessorInfo.missingDiagMsg());
             isAssignable = false;
@@ -65128,16 +65297,6 @@ var require_properties = __commonJS({
           if (selfSolution) {
             destAccessType = (0, typeUtils_1.applySolvedTypeVars)(destAccessType, selfSolution);
           }
-          destAccessType = types_1.FunctionType.cloneWithNewFlags(
-            destAccessType,
-            destAccessType.shared.flags & ~4
-            /* FunctionTypeFlags.StaticMethod */
-          );
-          srcAccessType = types_1.FunctionType.cloneWithNewFlags(
-            srcAccessType,
-            srcAccessType.shared.flags & ~4
-            /* FunctionTypeFlags.StaticMethod */
-          );
           const boundDestAccessType = evaluator.bindFunctionToClassOrObject(
             destObjectToBind,
             destAccessType,
@@ -68424,7 +68583,7 @@ var require_operations = __commonJS({
         }
         if (!type) {
           if (!isIncomplete) {
-            if (inferenceContext) {
+            if (inferenceContext && !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType)) {
               evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOperatorIssue, localize_1.LocMessage.typeNotSupportUnaryOperatorBidirectional().format({
                 operator: (0, parseTreeUtils_1.printOperator)(node.d.operator),
                 type: evaluator.printType(exprType),
@@ -68627,10 +68786,13 @@ var require_operations = __commonJS({
               } else if (operator === 13) {
                 if (rightLiteralValue !== BigInt(0)) {
                   newValue = leftLiteralValue / rightLiteralValue;
+                  if (newValue * rightLiteralValue !== leftLiteralValue && leftLiteralValue < BigInt(0) !== rightLiteralValue < BigInt(0)) {
+                    newValue -= BigInt(1);
+                  }
                 }
               } else if (operator === 24) {
                 if (rightLiteralValue !== BigInt(0)) {
-                  newValue = leftLiteralValue % rightLiteralValue;
+                  newValue = (leftLiteralValue % rightLiteralValue + rightLiteralValue) % rightLiteralValue;
                 }
               } else if (operator === 29) {
                 if (rightLiteralValue >= BigInt(0)) {
@@ -68640,9 +68802,13 @@ var require_operations = __commonJS({
                   }
                 }
               } else if (operator === 17) {
-                newValue = leftLiteralValue << rightLiteralValue;
+                if (rightLiteralValue >= BigInt(0)) {
+                  newValue = leftLiteralValue << rightLiteralValue;
+                }
               } else if (operator === 31) {
-                newValue = leftLiteralValue >> rightLiteralValue;
+                if (rightLiteralValue >= BigInt(0)) {
+                  newValue = leftLiteralValue >> rightLiteralValue;
+                }
               } else if (operator === 3) {
                 newValue = leftLiteralValue & rightLiteralValue;
               } else if (operator === 6) {
@@ -68813,7 +68979,7 @@ var require_operations = __commonJS({
               }
             }
             if (!resultTypeResult) {
-              if (inferenceContext) {
+              if (inferenceContext && !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType)) {
                 diag.addMessage(localize_1.LocMessage.typeNotSupportBinaryOperatorBidirectional().format({
                   operator: (0, parseTreeUtils_1.printOperator)(operator),
                   leftType: evaluator.printType(leftSubtypeExpanded),
@@ -68980,6 +69146,8 @@ var require_tuples = __commonJS({
         type = makeTupleObject(evaluator, evaluator.buildTupleTypesList(
           entryTypeResults,
           /* stripLiterals */
+          false,
+          /* convertModule */
           false
         ));
       }
@@ -68995,7 +69163,12 @@ var require_tuples = __commonJS({
       if (node.d.items.length > maxInferredTupleEntryCount) {
         return { type: makeTupleObject(evaluator, [{ type: types_1.UnknownType.create(), isUnbounded: true }]) };
       }
-      const type = makeTupleObject(evaluator, evaluator.buildTupleTypesList(entryTypeResults, (flags & 268435456) !== 0));
+      const type = makeTupleObject(evaluator, evaluator.buildTupleTypesList(
+        entryTypeResults,
+        (flags & 268435456) !== 0,
+        /* convertModule */
+        true
+      ));
       if (isIncomplete) {
         if ((0, typeUtils_1.getContainerDepth)(type) > typeEvaluatorTypes_1.maxInferredContainerDepth) {
           return { type: types_1.UnknownType.create() };
@@ -70390,6 +70563,7 @@ var require_typeEvaluator = __commonJS({
     exports2.createTypeEvaluator = createTypeEvaluator;
     var cancellationUtils_1 = require_cancellationUtils();
     var collectionUtils_1 = require_collectionUtils();
+    var core_1 = require_core();
     var debug_1 = require_debug();
     var diagnostic_1 = require_diagnostic();
     var diagnosticRules_1 = require_diagnosticRules();
@@ -70434,7 +70608,6 @@ var require_typeEvaluator = __commonJS({
     var TypePrinter = __importStar(require_typePrinter());
     var types_1 = require_types();
     var typeUtils_1 = require_typeUtils();
-    var core_1 = require_core();
     var nonSubscriptableBuiltinTypes = /* @__PURE__ */ new Map([
       ["asyncio.futures.Future", pythonVersion_1.pythonVersion3_9],
       ["asyncio.tasks.Task", pythonVersion_1.pythonVersion3_9],
@@ -70463,6 +70636,7 @@ var require_typeEvaluator = __commonJS({
     var maxReturnCallSiteTypeInferenceCodeFlowComplexity = 8;
     var maxCallSiteReturnTypeCacheSize = 8;
     var maxEntriesToUseForInference = 64;
+    var maxReturnTypeInferenceAttempts = 8;
     var maxDeclarationsToUseForInference = 64;
     var maxEffectiveTypeEvaluationAttempts = 16;
     var maxTotalOverloadArgTypeExpansionCount = 256;
@@ -70487,7 +70661,7 @@ var require_typeEvaluator = __commonJS({
       let deferredClassCompletions = [];
       let cancellationToken;
       let printExpressionSpaceCount = 0;
-      let incompleteGenerationCount = 0;
+      let incompleteGenCount = 0;
       const returnTypeInferenceContextStack = [];
       let returnTypeInferenceTypeCache;
       const signatureTrackerStack = [];
@@ -70537,7 +70711,7 @@ var require_typeEvaluator = __commonJS({
         if (!cacheEntry) {
           return false;
         }
-        return !cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenerationCount === incompleteGenerationCount;
+        return !cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenCount === incompleteGenCount;
       }
       function readTypeCache(node, flags) {
         var _a;
@@ -70565,18 +70739,18 @@ var require_typeEvaluator = __commonJS({
       function writeTypeCache(node, typeResult, flags, inferenceContext, allowSpeculativeCaching = false) {
         const typeCacheToUse = returnTypeInferenceTypeCache && isNodeInReturnTypeInferenceContext(node) ? returnTypeInferenceTypeCache : typeCache;
         if (!typeResult.isIncomplete) {
-          incompleteGenerationCount++;
+          incompleteGenCount++;
         } else {
           const oldValue = typeCacheToUse.get(node.id);
           if (oldValue !== void 0 && !(0, types_1.isTypeSame)(typeResult.type, oldValue.typeResult.type)) {
-            incompleteGenerationCount++;
+            incompleteGenCount++;
           }
         }
-        typeCacheToUse.set(node.id, { typeResult, flags, incompleteGenerationCount });
+        typeCacheToUse.set(node.id, { typeResult, flags, incompleteGenCount });
         if (isSpeculativeModeInUse(node)) {
           speculativeTypeTracker.trackEntry(typeCacheToUse, node.id);
           if (allowSpeculativeCaching) {
-            speculativeTypeTracker.addSpeculativeType(node, typeResult, incompleteGenerationCount, inferenceContext == null ? void 0 : inferenceContext.expectedType);
+            speculativeTypeTracker.addSpeculativeType(node, typeResult, incompleteGenCount, inferenceContext == null ? void 0 : inferenceContext.expectedType);
           }
         }
       }
@@ -70790,18 +70964,21 @@ var require_typeEvaluator = __commonJS({
       }
       function getTypeOfExpression(node, flags = 0, inferenceContext) {
         const cacheEntry = readTypeCacheEntry(node);
-        if (cacheEntry && (!cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenerationCount === incompleteGenerationCount)) {
-          if (printExpressionTypes) {
-            console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cacheEntry.typeResult.type)} ${cacheEntry.typeResult.typeErrors ? " Errors" : ""}`);
+        if (cacheEntry) {
+          if (!cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenCount === incompleteGenCount) {
+            if (printExpressionTypes) {
+              console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cacheEntry.typeResult.type)} ${cacheEntry.typeResult.typeErrors ? " Errors" : ""}`);
+            }
+            return cacheEntry.typeResult;
           }
-          return cacheEntry.typeResult;
-        } else {
-          const cacheEntry2 = speculativeTypeTracker.getSpeculativeType(node, inferenceContext == null ? void 0 : inferenceContext.expectedType);
-          if (cacheEntry2 && (!cacheEntry2.typeResult.isIncomplete || cacheEntry2.incompleteGenerationCount === incompleteGenerationCount)) {
+        }
+        const specCacheEntry = speculativeTypeTracker.getSpeculativeType(node, inferenceContext == null ? void 0 : inferenceContext.expectedType);
+        if (specCacheEntry) {
+          if (!specCacheEntry.typeResult.isIncomplete || specCacheEntry.incompleteGenerationCount === incompleteGenCount) {
             if (printExpressionTypes) {
-              console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(cacheEntry2.typeResult.type)}`);
+              console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(specCacheEntry.typeResult.type)}`);
             }
-            return cacheEntry2.typeResult;
+            return specCacheEntry.typeResult;
           }
         }
         if (printExpressionTypes) {
@@ -72519,7 +72696,7 @@ var require_typeEvaluator = __commonJS({
             }
             destType = declaredType;
           } else {
-            destType = narrowTypeBasedOnAssignment(nameNode, declaredType, typeResult).type;
+            destType = narrowTypeBasedOnAssignment(declaredType, typeResult).type;
           }
         } else {
           const scope = ScopeUtils.getScopeForNode(nameNode);
@@ -73110,7 +73287,7 @@ var require_typeEvaluator = __commonJS({
               if (!isTypeAliasAnnotation) {
                 if (assignType(annotationType, typeResult.type)) {
                   if (!(0, types_1.isClassInstance)(typeResult.type) || !types_1.ClassType.isEnumClass(typeResult.type)) {
-                    typeResult = narrowTypeBasedOnAssignment(target, annotationType, typeResult);
+                    typeResult = narrowTypeBasedOnAssignment(annotationType, typeResult);
                   }
                 }
               }
@@ -74118,8 +74295,9 @@ var require_typeEvaluator = __commonJS({
                   if (isModuleGetAttrSupported) {
                     const getAttrTypeResult = getEffectiveTypeOfSymbolForUsage(getAttrSymbol);
                     if ((0, types_1.isFunction)(getAttrTypeResult.type)) {
-                      type = getEffectiveReturnType(getAttrTypeResult.type);
-                      if (getAttrTypeResult.isIncomplete) {
+                      const returnTypeResult = getEffectiveReturnTypeResult(getAttrTypeResult.type);
+                      type = returnTypeResult.type;
+                      if (getAttrTypeResult.isIncomplete || returnTypeResult.isIncomplete) {
                         isIncomplete = true;
                       }
                     }
@@ -74414,7 +74592,7 @@ var require_typeEvaluator = __commonJS({
         });
         if (!isDescriptorError && usage.method === "set" && usage.setType) {
           if (errorNode && memberInfo.symbol.hasTypedDeclarations()) {
-            narrowedTypeForSet = isDescriptorApplied ? usage.setType.type : narrowTypeBasedOnAssignment(errorNode, type, usage.setType).type;
+            narrowedTypeForSet = isDescriptorApplied ? usage.setType.type : narrowTypeBasedOnAssignment(type, usage.setType).type;
           }
           if (!assignType(type, usage.setType.type, diag == null ? void 0 : diag.createAddendum())) {
             if (!usage.setType.isIncomplete) {
@@ -75811,7 +75989,7 @@ var require_typeEvaluator = __commonJS({
         }
         return typeResult;
       }
-      function buildTupleTypesList(entryTypeResults, stripLiterals) {
+      function buildTupleTypesList(entryTypeResults, stripLiterals, convertModule) {
         const entryTypes = [];
         for (const typeResult of entryTypeResults) {
           let possibleUnpackedTuple;
@@ -75833,12 +76011,7 @@ var require_typeEvaluator = __commonJS({
               true
             ), isUnbounded: false });
           } else {
-            let entryType = convertSpecialFormToRuntimeValue(
-              typeResult.type,
-              0,
-              /* convertModule */
-              true
-            );
+            let entryType = convertSpecialFormToRuntimeValue(typeResult.type, 0, convertModule);
             entryType = stripLiterals ? (0, typeUtils_1.stripTypeForm)(stripLiteralValue(entryType)) : entryType;
             entryTypes.push({ type: entryType, isUnbounded: !!typeResult.unpackedType });
           }
@@ -76336,7 +76509,7 @@ var require_typeEvaluator = __commonJS({
       }
       function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, constraints, skipUnknownArgCheck, inferenceContext) {
         const returnTypes = [];
-        const matchedOverloads = [];
+        let matchedOverloads = [];
         let isTypeIncomplete = false;
         let overloadsUsedForCall = [];
         let isDefinitiveMatchFound = false;
@@ -76387,10 +76560,12 @@ var require_typeEvaluator = __commonJS({
                 argResults: callResult.argResults ?? []
               };
               matchedOverloads.push(matchedOverloadInfo);
-              if (callResult.anyOrUnknownArg) {
+              if (callResult.anyOrUnknownArg || matchResults.unpackedArgOfUnknownLength) {
                 possibleMatchResults.push(matchedOverloadInfo);
-                if ((0, typeUtils_1.isIncompleteUnknown)(callResult.anyOrUnknownArg)) {
-                  possibleMatchInvolvesIncompleteUnknown = true;
+                if (callResult.anyOrUnknownArg) {
+                  if ((0, typeUtils_1.isIncompleteUnknown)(callResult.anyOrUnknownArg)) {
+                    possibleMatchInvolvesIncompleteUnknown = true;
+                  }
                 }
               } else {
                 returnTypes.push(callResult.returnType);
@@ -76400,10 +76575,12 @@ var require_typeEvaluator = __commonJS({
             }
           }
           if (!isDefinitiveMatchFound && possibleMatchResults.length > 0) {
+            possibleMatchResults = filterOverloadMatchesForUnpackedArgs(possibleMatchResults);
             possibleMatchResults = filterOverloadMatchesForAnyArgs(possibleMatchResults);
             if (possibleMatchResults.length === 1) {
               overloadsUsedForCall = [possibleMatchResults[0].overload];
               returnTypes.push(possibleMatchResults[0].returnType);
+              matchedOverloads = [possibleMatchResults[0]];
             } else {
               let dedupedMatchResults = [];
               let dedupedResultsIncludeAny = false;
@@ -76474,15 +76651,19 @@ var require_typeEvaluator = __commonJS({
           overloadsUsedForCall
         };
       }
-      function filterOverloadMatchesForAnyArgs(matches) {
+      function filterOverloadMatchesForUnpackedArgs(matches) {
         if (matches.length < 2) {
           return matches;
         }
-        if (matches[0].matchResults.relevance !== matches[matches.length - 1].matchResults.relevance) {
-          matches = matches.filter((m) => m.matchResults.relevance === matches[0].matchResults.relevance);
-          if (matches.length < 2) {
-            return matches;
-          }
+        const unpackedArgsOverloads = matches.filter((match2) => match2.matchResults.unpackedArgMapsToVariadic);
+        if (unpackedArgsOverloads.length === matches.length || unpackedArgsOverloads.length === 0) {
+          return matches;
+        }
+        return unpackedArgsOverloads;
+      }
+      function filterOverloadMatchesForAnyArgs(matches) {
+        if (matches.length < 2) {
+          return matches;
         }
         if ((0, typeUtils_1.areTypesSame)(matches.map((match2) => match2.returnType), { treatAnySameAsUnknown: true })) {
           return [matches[0]];
@@ -76507,7 +76688,7 @@ var require_typeEvaluator = __commonJS({
       }
       function getBestOverloadForArgs(errorNode, typeResult, argList) {
         let overloadIndex = 0;
-        let matches = [];
+        const matches = [];
         const speculativeNode = getSpeculativeNodeForCall(errorNode);
         useSignatureTracker(errorNode, () => {
           types_1.OverloadedType.getOverloads(typeResult.type).forEach((overload) => {
@@ -76520,7 +76701,6 @@ var require_typeEvaluator = __commonJS({
             });
           });
         });
-        matches = sortOverloadsByBestMatch(matches);
         let winningOverloadIndex;
         matches.forEach((match2, matchIndex) => {
           if (winningOverloadIndex === void 0) {
@@ -76540,16 +76720,8 @@ var require_typeEvaluator = __commonJS({
         });
         return winningOverloadIndex === void 0 ? void 0 : matches[winningOverloadIndex].overload;
       }
-      function sortOverloadsByBestMatch(matches) {
-        return matches.sort((a, b) => {
-          if (a.relevance !== b.relevance) {
-            return b.relevance - a.relevance;
-          }
-          return a.overloadIndex - b.overloadIndex;
-        });
-      }
       function validateOverloadedArgTypes(errorNode, argList, typeResult, constraints, skipUnknownArgCheck, inferenceContext) {
-        let filteredMatchResults = [];
+        const filteredMatchResults = [];
         let contextFreeArgTypes;
         let isTypeIncomplete = !!typeResult.isIncomplete;
         const type = typeResult.type;
@@ -76564,7 +76736,6 @@ var require_typeEvaluator = __commonJS({
             overloadIndex++;
           });
         });
-        filteredMatchResults = sortOverloadsByBestMatch(filteredMatchResults);
         if (filteredMatchResults.length === 0) {
           if (!canSkipDiagnosticForNode(errorNode)) {
             const overloads = types_1.OverloadedType.getOverloads(type);
@@ -76755,22 +76926,33 @@ var require_typeEvaluator = __commonJS({
         };
       }
       function validateCallArgsForSubtype(errorNode, argList, expandedCallType, unexpandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext, recursionCount) {
+        function touchArgTypes() {
+          if (!isCallTypeIncomplete) {
+            argList.forEach((arg) => {
+              if (arg.valueExpression && !isSpeculativeModeInUse(arg.valueExpression)) {
+                getTypeOfArg(
+                  arg,
+                  /* inferenceContext */
+                  void 0
+                );
+              }
+            });
+          }
+        }
         switch (expandedCallType.category) {
           case 3:
           case 1:
           case 2: {
-            if (!isCallTypeIncomplete) {
-              argList.forEach((arg) => {
-                if (arg.valueExpression && !isSpeculativeModeInUse(arg.valueExpression)) {
-                  getTypeOfArg(
-                    arg,
-                    /* inferenceContext */
-                    void 0
-                  );
-                }
-              });
-            }
-            return { returnType: expandedCallType };
+            const dummyFunctionType = types_1.FunctionType.createInstance(
+              "",
+              "",
+              "",
+              0
+              /* FunctionTypeFlags.None */
+            );
+            types_1.FunctionType.addDefaultParams(dummyFunctionType);
+            const dummyCallResult = validateCallForFunction(errorNode, argList, dummyFunctionType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext);
+            return { ...dummyCallResult, returnType: expandedCallType };
           }
           case 4: {
             return validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext);
@@ -76781,6 +76963,7 @@ var require_typeEvaluator = __commonJS({
           case 6: {
             if ((0, typeUtils_1.isNoneInstance)(expandedCallType)) {
               addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalCall, localize_1.LocMessage.noneNotCallable(), errorNode);
+              touchArgTypes();
               return { argumentErrors: true };
             }
             if (types_1.TypeBase.isInstantiable(expandedCallType)) {
@@ -76797,9 +76980,11 @@ var require_typeEvaluator = __commonJS({
           }
           case 7: {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.moduleNotCallable(), errorNode);
+            touchArgTypes();
             return { argumentErrors: true };
           }
         }
+        touchArgTypes();
         return { argumentErrors: true };
       }
       function validateCallForFunction(errorNode, argList, type, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext) {
@@ -77238,24 +77423,13 @@ var require_typeEvaluator = __commonJS({
         const paramDetails = (0, parameterUtils_1.getParamListDetails)(overload, { disallowExtraKwargsForTd: true });
         const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(overload);
         let argIndex = 0;
-        let matchedUnpackedListOfUnknownLength = false;
+        let unpackedArgOfUnknownLength = false;
+        let unpackedArgMapsToVariadic = false;
         let reportedArgError = false;
         let isTypeIncomplete = !!typeResult.isIncomplete;
         let isTypeVarTupleFullyMatched = false;
         argList = expandArgList(argList);
-        const paramMap = /* @__PURE__ */ new Map();
-        paramDetails.params.forEach((paramInfo) => {
-          var _a2;
-          (0, debug_1.assert)(paramInfo !== void 0, "paramInfo is undefined for param name map");
-          const param = paramInfo.param;
-          if (param.name && param.category === 0 && paramInfo.kind !== parameterUtils_1.ParamKind.Positional) {
-            let argsNeeded = ((_a2 = paramMap.get(param.name)) == null ? void 0 : _a2.argsNeeded) ?? 0;
-            if (param.category === 0 && !paramInfo.defaultType) {
-              argsNeeded += 1;
-            }
-            paramMap.set(param.name, { argsNeeded, argsReceived: 0 });
-          }
-        });
+        const paramTracker = new parameterUtils_1.ParamAssignmentTracker(paramDetails.params);
         let positionalOnlyLimitIndex = paramDetails.positionOnlyParamCount;
         let positionParamLimitIndex = paramDetails.firstKeywordOnlyIndex ?? paramDetails.params.length;
         const varArgListParamIndex = paramDetails.argsIndex;
@@ -77354,6 +77528,8 @@ var require_typeEvaluator = __commonJS({
                 ).type;
                 if ((0, types_1.isClassInstance)(argType) && (0, typeUtils_1.isTupleClass)(argType) && !(0, typeUtils_1.isUnboundedTupleClass)(argType) && argType.priv.tupleTypeArgs !== void 0 && argType.priv.tupleTypeArgs.length > 0) {
                   tooManyPositionals = true;
+                } else {
+                  unpackedArgOfUnknownLength = true;
                 }
               } else {
                 tooManyPositionals = true;
@@ -77385,6 +77561,7 @@ var require_typeEvaluator = __commonJS({
               void 0
             );
             let listElementType;
+            let enforceIterable = false;
             let advanceToNextArg = false;
             if (paramIndex < positionParamLimitIndex) {
               if ((0, types_1.isParamSpec)(argTypeResult.type) && argTypeResult.type.priv.paramSpecAccess === "args" && paramInfo.param.category !== 1) {
@@ -77425,14 +77602,27 @@ var require_typeEvaluator = __commonJS({
                 /* emitNotIterableError */
                 false
               )) == null ? void 0 : _a.type;
+              if (!listElementType) {
+                enforceIterable = true;
+              }
+              unpackedArgOfUnknownLength = true;
               if (paramInfo.param.category === 1) {
-                matchedUnpackedListOfUnknownLength = true;
+                unpackedArgMapsToVariadic = true;
+              }
+              if (isParamVariadic && listElementType) {
+                isArgCompatibleWithVariadic = true;
+                listElementType = (0, tuples_1.makeTupleObject)(
+                  evaluatorInterface,
+                  [{ type: listElementType, isUnbounded: true }],
+                  /* isUnpacked */
+                  true
+                );
               }
             }
             const funcArg = listElementType ? {
               argCategory: 0,
               typeResult: { type: listElementType, isIncomplete: argTypeResult.isIncomplete }
-            } : { ...argList[argIndex] };
+            } : { ...argList[argIndex], enforceIterable };
             if (argTypeResult.isIncomplete) {
               isTypeIncomplete = true;
             }
@@ -77459,8 +77649,8 @@ var require_typeEvaluator = __commonJS({
               }
             }
             trySetActive(argList[argIndex], paramDetails.params[paramIndex].param);
-            if (paramName && paramDetails.params[paramIndex].param.category === 0 && paramMap.has(paramName)) {
-              paramMap.get(paramName).argsReceived++;
+            if (paramName && paramDetails.params[paramIndex].param.category === 0) {
+              paramTracker.markArgReceived(paramInfo);
             }
             if (advanceToNextArg || paramDetails.params[paramIndex].param.category === 1) {
               argIndex++;
@@ -77518,9 +77708,7 @@ var require_typeEvaluator = __commonJS({
               isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(paramInfo2.param)
             });
             trySetActive(argList[argIndex], paramInfo2.param);
-            if (paramName2 && paramMap.has(paramName2) && paramInfo2.kind !== parameterUtils_1.ParamKind.Positional) {
-              paramMap.get(paramName2).argsReceived++;
-            }
+            paramTracker.markArgReceived(paramInfo2);
             argIndex++;
             paramIndex++;
           }
@@ -77566,7 +77754,7 @@ var require_typeEvaluator = __commonJS({
                 const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, argType);
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 tdEntries.knownItems.forEach((entry, name) => {
-                  const paramEntry = paramMap.get(name);
+                  const paramEntry = paramTracker.lookupName(name);
                   if (paramEntry) {
                     if (paramEntry.argsReceived > 0) {
                       diag.addMessage(localize_1.LocMessage.paramAlreadyAssigned().format({ name }));
@@ -77600,10 +77788,7 @@ var require_typeEvaluator = __commonJS({
                       errorNode: argList[argIndex].valueExpression ?? errorNode,
                       paramName: name
                     });
-                    paramMap.set(name, {
-                      argsNeeded: 1,
-                      argsReceived: 1
-                    });
+                    paramTracker.addKeywordParam(name, paramDetails.params[paramDetails.kwargsIndex]);
                   } else {
                     if (!paramDetails.hasUnpackedTypedDict) {
                       diag.addMessage(localize_1.LocMessage.paramNameMissing().format({ name }));
@@ -77679,6 +77864,7 @@ var require_typeEvaluator = __commonJS({
                       unpackedDictArgType = types_1.UnknownType.create();
                     }
                   }
+                  unpackedArgOfUnknownLength = true;
                   if (paramDetails.kwargsIndex !== void 0 && unpackedDictArgType) {
                     const paramType = paramDetails.params[paramDetails.kwargsIndex].type;
                     validateArgTypeParams.push({
@@ -77690,6 +77876,7 @@ var require_typeEvaluator = __commonJS({
                       errorNode: argList[argIndex].valueExpression || errorNode,
                       paramName: paramDetails.params[paramDetails.kwargsIndex].param.name
                     });
+                    unpackedArgMapsToVariadic = true;
                   }
                   if (!isValidMappingType) {
                     if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
@@ -77706,7 +77893,7 @@ var require_typeEvaluator = __commonJS({
               const paramName = argList[argIndex].name;
               if (paramName) {
                 const paramNameValue = paramName.d.value;
-                const paramEntry = paramMap.get(paramNameValue);
+                const paramEntry = paramTracker.lookupName(paramNameValue);
                 if (paramEntry) {
                   if (paramEntry.argsReceived > 0) {
                     if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
@@ -77746,11 +77933,8 @@ var require_typeEvaluator = __commonJS({
                       errorNode: argList[argIndex].valueExpression ?? errorNode,
                       paramName: paramNameValue
                     });
-                    paramMap.set(paramNameValue, {
-                      argsNeeded: 1,
-                      argsReceived: 1
-                    });
                     (0, debug_1.assert)(paramDetails.params[paramDetails.kwargsIndex], "paramDetails.kwargsIndex params entry is undefined");
+                    paramTracker.addKeywordParam(paramNameValue, paramDetails.params[paramDetails.kwargsIndex]);
                   }
                   trySetActive(argList[argIndex], paramDetails.params[paramDetails.kwargsIndex].param);
                 } else {
@@ -77800,7 +77984,7 @@ var require_typeEvaluator = __commonJS({
             paramDetails.params.forEach((paramInfo, paramIndex2) => {
               var _a2;
               const param = paramInfo.param;
-              if (paramIndex2 >= paramDetails.firstPositionOrKeywordIndex && param.category === 0 && param.name && paramMap.has(param.name) && paramMap.get(param.name).argsReceived === 0) {
+              if (paramIndex2 >= paramDetails.firstPositionOrKeywordIndex && param.category === 0 && param.name && paramTracker.lookupDetails(paramInfo).argsReceived === 0) {
                 const paramType = paramDetails.params[paramIndex2].type;
                 if (!unpackedDictKeyNames || unpackedDictKeyNames.includes(param.name)) {
                   validateArgTypeParams.push({
@@ -77818,16 +78002,13 @@ var require_typeEvaluator = __commonJS({
                     paramName: param.name,
                     isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(param)
                   });
-                  paramMap.get(param.name).argsReceived = 1;
+                  paramTracker.markArgReceived(paramDetails.params[paramIndex2]);
                 }
               }
             });
           }
           if (!unpackedDictArgType && !types_1.FunctionType.isDefaultParamCheckDisabled(overload)) {
-            const unassignedParams = Array.from(paramMap.keys()).filter((name) => {
-              const entry = paramMap.get(name);
-              return !entry || entry.argsReceived < entry.argsNeeded;
-            });
+            const unassignedParams = paramTracker.getUnassignedParams();
             if (unassignedParams.length > 0) {
               if (!canSkipDiagnosticForNode(errorNode)) {
                 const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(", ");
@@ -77840,21 +78021,24 @@ var require_typeEvaluator = __commonJS({
             paramDetails.params.forEach((paramInfo) => {
               const param = paramInfo.param;
               if (param.category === 0 && param.name) {
-                const entry = paramMap.get(param.name);
-                if (entry && entry.argsNeeded === 0 && entry.argsReceived === 0 && paramInfo.defaultType) {
-                  validateArgTypeParams.push({
-                    paramCategory: param.category,
-                    paramType: paramInfo.type,
-                    requiresTypeVarMatching: true,
-                    argument: {
-                      argCategory: 0,
-                      typeResult: { type: paramInfo.defaultType }
-                    },
-                    isDefaultArg: true,
-                    errorNode,
-                    paramName: param.name,
-                    isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(param)
-                  });
+                const entry = paramTracker.lookupDetails(paramInfo);
+                if (entry.argsNeeded === 0 && entry.argsReceived === 0) {
+                  const defaultArgType = paramInfo.defaultType;
+                  if (defaultArgType && !(0, typeUtils_1.isEllipsisType)(defaultArgType) && (0, typeUtils_1.requiresSpecialization)(paramInfo.declaredType, { ignorePseudoGeneric: true })) {
+                    validateArgTypeParams.push({
+                      paramCategory: param.category,
+                      paramType: paramInfo.type,
+                      requiresTypeVarMatching: true,
+                      argument: {
+                        argCategory: 0,
+                        typeResult: { type: defaultArgType }
+                      },
+                      isDefaultArg: true,
+                      errorNode,
+                      paramName: param.name,
+                      isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(param)
+                    });
+                  }
                 }
               }
             });
@@ -77919,10 +78103,6 @@ var require_typeEvaluator = __commonJS({
             }
           }
         }
-        let relevance = 0;
-        if (matchedUnpackedListOfUnknownLength) {
-          relevance++;
-        }
         if (types_1.FunctionType.isBuiltIn(overload, ["isinstance", "issubclass"]) && validateArgTypeParams.length === 2) {
           validateArgTypeParams[1].isinstanceParam = true;
         }
@@ -77935,7 +78115,8 @@ var require_typeEvaluator = __commonJS({
           paramSpecTarget,
           paramSpecArgList,
           activeParam,
-          relevance,
+          unpackedArgOfUnknownLength,
+          unpackedArgMapsToVariadic,
           argumentMatchScore: 0
         };
       }
@@ -78175,9 +78356,13 @@ var require_typeEvaluator = __commonJS({
             argumentMatchScore += 1;
           }
         }
-        let returnType = getEffectiveReturnType(type, {
+        const returnTypeResult = getEffectiveReturnTypeResult(type, {
           callSiteInfo: { args: matchResults.argParams, errorNode }
         });
+        let returnType = returnTypeResult.type;
+        if (returnTypeResult.isIncomplete) {
+          isTypeIncomplete = true;
+        }
         if (condition.length > 0) {
           returnType = types_1.TypeBase.cloneForCondition(returnType, condition);
         }
@@ -78276,7 +78461,13 @@ var require_typeEvaluator = __commonJS({
               getTypeOfExpression(arg.valueExpression);
             }
           });
+          const possibleType = types_1.FunctionType.getEffectiveReturnType(typeResult.type);
           return {
+            returnType: possibleType && !(0, types_1.isAnyOrUnknown)(possibleType) ? types_1.UnknownType.createPossibleType(
+              possibleType,
+              /* isIncomplete */
+              false
+            ) : void 0,
             argumentErrors: true,
             activeParam: matchResults.activeParam,
             overloadsUsedForCall: []
@@ -78410,12 +78601,19 @@ var require_typeEvaluator = __commonJS({
             const flags = argParam.isinstanceParam ? 536871546 : 16 | 2;
             const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult == null ? void 0 : typeResult.isIncomplete)));
             argType = exprTypeResult.type;
+            if (argParam.argument.argCategory === 1 && argParam.argument.enforceIterable) {
+              const iteratorType = getTypeOfIterator(
+                exprTypeResult,
+                /* isAsync */
+                false,
+                argParam.argument.valueExpression
+              );
+              argType = (iteratorType == null ? void 0 : iteratorType.type) ?? types_1.UnknownType.create();
+            }
             if (exprTypeResult.isIncomplete) {
               isTypeIncomplete = true;
             }
-            if (exprTypeResult.typeErrors) {
-              isCompatible = false;
-            } else if (expectedType && (0, typeUtils_1.requiresSpecialization)(expectedType)) {
+            if (expectedType && (0, typeUtils_1.requiresSpecialization)(expectedType)) {
               const clonedConstraints = constraints.clone();
               if (assignType(
                 expectedType,
@@ -79382,18 +79580,8 @@ var require_typeEvaluator = __commonJS({
         if (keyValueResult.typeErrors) {
           typeErrors = true;
         }
-        const keyTypes = keyTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(
-          stripLiteralValue(t.type),
-          flags,
-          /* convertModule */
-          true
-        )));
-        const valueTypes = valueTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(
-          stripLiteralValue(t.type),
-          flags,
-          /* convertModule */
-          true
-        )));
+        const keyTypes = keyTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags, !hasExpectedType)));
+        const valueTypes = valueTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags, !hasExpectedType)));
         if (keyTypes.length > 0) {
           if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.strictDictionaryInference || hasExpectedType) {
             keyType = (0, types_1.combineTypes)(keyTypes);
@@ -79767,12 +79955,7 @@ var require_typeEvaluator = __commonJS({
               /* EvalFlags.StripTupleLiterals */
             );
           }
-          entryTypeResult.type = (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(
-            entryTypeResult.type,
-            flags,
-            /* convertModule */
-            true
-          ));
+          entryTypeResult.type = (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(entryTypeResult.type, flags, !hasExpectedType));
           if (entryTypeResult.isIncomplete) {
             isIncomplete = true;
           }
@@ -80064,7 +80247,7 @@ var require_typeEvaluator = __commonJS({
               void 0,
               (0, typeUtils_1.makeInferenceContext)(expectedReturnType)
             );
-            functionType.priv.inferredReturnType = {
+            functionType.shared.inferredReturnType = {
               type: returnTypeResult.type
             };
             if (returnTypeResult.isIncomplete) {
@@ -82115,6 +82298,9 @@ var require_typeEvaluator = __commonJS({
               }
             }
           };
+          if (node.d.name.d.value === "Any" && fileInfo.isTypingStubFile) {
+            decoratedType = types_1.AnyType.createSpecialForm();
+          }
           writeTypeCache(
             node.d.name,
             { type: classType },
@@ -82788,15 +82974,6 @@ var require_typeEvaluator = __commonJS({
           if (functionType.shared.declaredReturnType && returnTypeAnnotationNode) {
             (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParamsSeen, (0, typeUtils_1.getTypeVarArgsRecursive)(functionType.shared.declaredReturnType), functionType.shared.typeVarScopeId);
           }
-          if (fileInfo.isStubFile || ParseTreeUtils.isSuiteEmpty(node.d.suite)) {
-            if (functionType.shared.declaredReturnType && (0, types_1.isClassInstance)(functionType.shared.declaredReturnType) && types_1.ClassType.isBuiltIn(functionType.shared.declaredReturnType, [
-              "Generator",
-              "AsyncGenerator",
-              "AwaitableGenerator"
-            ])) {
-              functionType.shared.flags |= 16;
-            }
-          }
           functionType.shared.typeParams.forEach((typeParam, index) => {
             let bestErrorNode = node.d.name;
             if (node.d.typeParams && index < node.d.typeParams.d.params.length) {
@@ -82961,7 +83138,7 @@ var require_typeEvaluator = __commonJS({
         if (functionType.shared.declaredReturnType) {
           awaitableFunctionType.shared.declaredReturnType = createAwaitableReturnType(node, functionType.shared.declaredReturnType, types_1.FunctionType.isGenerator(functionType));
         } else {
-          awaitableFunctionType.priv.inferredReturnType = {
+          awaitableFunctionType.shared.inferredReturnType = {
             type: createAwaitableReturnType(node, getInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType))
           };
         }
@@ -82984,8 +83161,12 @@ var require_typeEvaluator = __commonJS({
                 }
                 awaitableReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(asyncGeneratorType, typeArgs));
               }
-            } else if (["AsyncGenerator", "AsyncIterator", "AsyncIterable"].some((name) => name === returnType.shared.name)) {
+            } else if (["AsyncIterator", "AsyncIterable"].some((name) => name === returnType.shared.name)) {
               awaitableReturnType = returnType;
+            } else if (returnType.shared.name === "AsyncGenerator") {
+              if (isGenerator) {
+                awaitableReturnType = returnType;
+              }
             }
           }
         }
@@ -85058,11 +85239,11 @@ var require_typeEvaluator = __commonJS({
               if (declaration.intrinsicType === "int") {
                 return { type: intType };
               }
-              if (declaration.intrinsicType === "Iterable[str]") {
-                const iterableType = getBuiltInType(declaration.node, "Iterable");
-                if ((0, types_1.isInstantiableClass)(iterableType)) {
+              if (declaration.intrinsicType === "MutableSequence[str]") {
+                const sequenceType = getBuiltInType(declaration.node, "MutableSequence");
+                if ((0, types_1.isInstantiableClass)(sequenceType)) {
                   return {
-                    type: types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(iterableType, [strType]))
+                    type: types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(sequenceType, [strType]))
                   };
                 }
               }
@@ -85331,27 +85512,53 @@ var require_typeEvaluator = __commonJS({
           }
           if (loaderActions.implicitImports) {
             loaderActions.implicitImports.forEach((implicitImport, name) => {
+              const existingLoaderField = moduleType.priv.loaderFields.get(name);
               let symbolType;
               if (implicitImport.isUnresolved) {
                 symbolType = types_1.UnknownType.create();
               } else {
-                const moduleName = moduleType.priv.moduleName ? moduleType.priv.moduleName + "." + name : "";
-                const importedModuleType = types_1.ModuleType.create(moduleName, implicitImport.uri);
+                let importedModuleType;
+                const existingType = existingLoaderField == null ? void 0 : existingLoaderField.getSynthesizedType();
+                if ((existingType == null ? void 0 : existingType.type) && (0, types_1.isModule)(existingType.type)) {
+                  importedModuleType = existingType.type;
+                } else {
+                  const moduleName = moduleType.priv.moduleName ? moduleType.priv.moduleName + "." + name : "";
+                  importedModuleType = types_1.ModuleType.create(moduleName, implicitImport.uri);
+                }
                 symbolType = applyLoaderActionsToModuleType(importedModuleType, implicitImport, importLookup2);
               }
-              const importedModuleSymbol = symbol_1.Symbol.createWithType(0, symbolType);
-              moduleType.priv.loaderFields.set(name, importedModuleSymbol);
+              if (!existingLoaderField) {
+                const importedModuleSymbol = symbol_1.Symbol.createWithType(0, symbolType);
+                moduleType.priv.loaderFields.set(name, importedModuleSymbol);
+              }
             });
           }
           return moduleType;
         }
         if (resolvedDecl.type === 8) {
-          const moduleType = types_1.ModuleType.create(resolvedDecl.moduleName, resolvedDecl.uri);
-          if (resolvedDecl.symbolName && resolvedDecl.submoduleFallback) {
-            return applyLoaderActionsToModuleType(moduleType, resolvedDecl.submoduleFallback, importLookup);
-          } else {
-            return applyLoaderActionsToModuleType(moduleType, resolvedDecl, importLookup);
+          let moduleType;
+          if (resolvedDecl.node.nodeType === 24) {
+            const cachedType = readTypeCache(
+              resolvedDecl.node.d.module,
+              0
+              /* EvalFlags.None */
+            );
+            if (cachedType && (0, types_1.isModule)(cachedType)) {
+              moduleType = cachedType;
+            }
+          }
+          if (!moduleType) {
+            moduleType = types_1.ModuleType.create(resolvedDecl.moduleName, resolvedDecl.uri);
+            if (resolvedDecl.node.nodeType === 24) {
+              writeTypeCache(
+                resolvedDecl.node.d.module,
+                { type: moduleType },
+                0
+                /* EvalFlags.None */
+              );
+            }
           }
+          return applyLoaderActionsToModuleType(moduleType, resolvedDecl.symbolName && resolvedDecl.submoduleFallback ? resolvedDecl.submoduleFallback : resolvedDecl, importLookup);
         }
         const declaredType = getTypeForDeclaration(resolvedDecl);
         if (declaredType.type) {
@@ -85802,33 +86009,42 @@ var require_typeEvaluator = __commonJS({
           }
         }
       }
-      function getEffectiveReturnType(type, options) {
+      function getEffectiveReturnType(type) {
+        return getEffectiveReturnTypeResult(type).type;
+      }
+      function getInferredReturnType(type) {
+        return getInferredReturnTypeResult(type).type;
+      }
+      function getEffectiveReturnTypeResult(type, options) {
         const specializedReturnType = types_1.FunctionType.getEffectiveReturnType(
           type,
           /* includeInferred */
           false
         );
         if (specializedReturnType && !(0, types_1.isUnknown)(specializedReturnType)) {
-          return specializedReturnType;
+          return { type: specializedReturnType };
         }
-        return getInferredReturnType(type, options == null ? void 0 : options.callSiteInfo);
+        return getInferredReturnTypeResult(type, options == null ? void 0 : options.callSiteInfo);
       }
-      function _getInferredReturnType(type, callSiteInfo) {
-        var _a, _b, _c;
+      function _getInferredReturnTypeResult(type, callSiteInfo) {
+        var _a, _b, _c, _d;
         let returnType;
         let isIncomplete = false;
         const analyzeUnannotatedFunctions = true;
         if (types_1.FunctionType.isStubDefinition(type)) {
-          return types_1.UnknownType.create();
+          return { type: types_1.UnknownType.create() };
         }
         if (types_1.FunctionType.isParamSpecValue(type)) {
-          return types_1.UnknownType.create();
+          return { type: types_1.UnknownType.create() };
         }
         if (types_1.FunctionType.isOverloaded(type) && !types_1.FunctionType.isSynthesizedMethod(type)) {
-          return types_1.UnknownType.create();
+          return { type: types_1.UnknownType.create() };
         }
-        if (type.priv.inferredReturnType && !type.priv.inferredReturnType.isIncomplete) {
-          returnType = type.priv.inferredReturnType.type;
+        const evalCount = ((_a = type.shared.inferredReturnType) == null ? void 0 : _a.evaluationCount) ?? 0;
+        if (type.shared.inferredReturnType && !type.shared.inferredReturnType.isIncomplete) {
+          returnType = type.shared.inferredReturnType.type;
+        } else if (evalCount > maxReturnTypeInferenceAttempts) {
+          returnType = types_1.UnknownType.create();
         } else {
           if (types_1.FunctionType.isInstanceMethod(type) && type.shared.name === "__init__") {
             returnType = getNoneType();
@@ -85857,16 +86073,16 @@ var require_typeEvaluator = __commonJS({
           if (type.shared.typeVarScopeId) {
             typeVarScopes.push(type.shared.typeVarScopeId);
           }
-          if ((_a = type.shared.methodClass) == null ? void 0 : _a.shared.typeVarScopeId) {
+          if ((_b = type.shared.methodClass) == null ? void 0 : _b.shared.typeVarScopeId) {
             typeVarScopes.push(type.shared.methodClass.shared.typeVarScopeId);
           }
           returnType = (0, typeUtils_1.makeTypeVarsFree)(returnType, typeVarScopes);
-          type.priv.inferredReturnType = { type: returnType, isIncomplete };
+          type.shared.inferredReturnType = { type: returnType, isIncomplete, evaluationCount: evalCount + 1 };
         }
         if (!isIncomplete && analyzeUnannotatedFunctions && (0, typeUtils_1.isPartlyUnknown)(returnType) && types_1.FunctionType.hasUnannotatedParams(type) && !types_1.FunctionType.isStubDefinition(type) && !types_1.FunctionType.isPyTypedDefinition(type) && callSiteInfo) {
           let hasDecorators = false;
           let isAsync = false;
-          const declNode = (_b = type.shared.declaration) == null ? void 0 : _b.node;
+          const declNode = (_c = type.shared.declaration) == null ? void 0 : _c.node;
           if (declNode) {
             if (declNode.d.decorators.length > 0) {
               hasDecorators = true;
@@ -85879,14 +86095,14 @@ var require_typeEvaluator = __commonJS({
             const contextualReturnType = inferReturnTypeForCallSite(type, callSiteInfo);
             if (contextualReturnType) {
               returnType = contextualReturnType;
-              if ((_c = type.shared.declaration) == null ? void 0 : _c.node) {
+              if ((_d = type.shared.declaration) == null ? void 0 : _d.node) {
                 const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(type.shared.declaration.node);
                 returnType = (0, typeUtils_1.makeTypeVarsFree)(returnType, liveScopeIds);
               }
             }
           }
         }
-        return returnType;
+        return { type: returnType, isIncomplete };
       }
       function inferReturnTypeForCallSite(type, callSiteInfo) {
         const args = callSiteInfo.args;
@@ -87225,7 +87441,7 @@ var require_typeEvaluator = __commonJS({
           recursionCount
         );
       }
-      function isTypeComparable(leftType, rightType) {
+      function isTypeComparable(leftType, rightType, assumeIsOperator = false) {
         var _a, _b;
         if ((0, types_1.isAnyOrUnknown)(leftType) || (0, types_1.isAnyOrUnknown)(rightType)) {
           return true;
@@ -87285,6 +87501,12 @@ var require_typeEvaluator = __commonJS({
             if (assignType(genericLeftType, genericRightType) || assignType(genericRightType, genericLeftType)) {
               return true;
             }
+            if (assumeIsOperator && (0, typeUtils_1.isNoneInstance)(rightType)) {
+              if ((0, typeUtils_1.isNoneInstance)(leftType)) {
+                return true;
+              }
+              return assignType(leftType, rightType);
+            }
             if (types_1.ClassType.isBuiltIn(leftType) && types_1.ClassType.isBuiltIn(rightType) && types_1.TypeBase.isInstance(rightType)) {
               let boolType;
               let intType;
@@ -88095,58 +88317,7 @@ var require_typeEvaluator = __commonJS({
         }
         return canAssign;
       }
-      function replaceTypeArgsWithAny(node, declaredType, assignedType, recursionCount = 0) {
-        if (recursionCount > types_1.maxTypeRecursionCount) {
-          return void 0;
-        }
-        recursionCount++;
-        if (assignedType.shared.typeParams.length > 0 && assignedType.priv.typeArgs && assignedType.priv.typeArgs.length <= assignedType.shared.typeParams.length && !assignedType.priv.tupleTypeArgs) {
-          const constraints = new constraintTracker_1.ConstraintTracker();
-          (0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.specialize(
-            assignedType,
-            /* typeArgs */
-            void 0
-          ), declaredType, constraints, ParseTreeUtils.getTypeVarScopesForNode(node), node.start);
-          let replacedTypeArg = false;
-          const solution = (0, constraintSolver_1.solveConstraints)(evaluatorInterface, constraints).getMainSolutionSet();
-          const newTypeArgs = assignedType.priv.typeArgs.map((typeArg, index) => {
-            const typeParam = assignedType.shared.typeParams[index];
-            const expectedTypeArgType = solution.getType(typeParam);
-            if (expectedTypeArgType) {
-              if ((0, types_1.isAnyOrUnknown)(expectedTypeArgType) || (0, types_1.isAnyOrUnknown)(typeArg)) {
-                replacedTypeArg = true;
-                return expectedTypeArgType;
-              }
-              if ((0, types_1.isClassInstance)(expectedTypeArgType) && (0, types_1.isClassInstance)(typeArg)) {
-                const recursiveReplacement = replaceTypeArgsWithAny(node, expectedTypeArgType, typeArg, recursionCount);
-                if (recursiveReplacement) {
-                  replacedTypeArg = true;
-                  return recursiveReplacement;
-                }
-              } else if ((0, typeUtils_1.containsAnyRecursive)(expectedTypeArgType)) {
-                const variance = types_1.TypeVarType.getVariance(typeParam);
-                const isSubtype = assignType(expectedTypeArgType, typeArg);
-                const isSupertype = assignType(typeArg, expectedTypeArgType);
-                if ((variance === 4 || isSubtype) && (variance === 3 || isSupertype)) {
-                  replacedTypeArg = true;
-                  return expectedTypeArgType;
-                }
-              }
-            }
-            return typeArg;
-          });
-          if (replacedTypeArg) {
-            return types_1.ClassType.specialize(assignedType, newTypeArgs);
-          }
-        }
-        if (types_1.ClassType.isSameGenericClass(declaredType, assignedType)) {
-          if ((0, typeUtils_1.containsAnyRecursive)(assignedType) && !(0, typeUtils_1.containsAnyRecursive)(declaredType)) {
-            return declaredType;
-          }
-        }
-        return void 0;
-      }
-      function narrowTypeBasedOnAssignment(node, declaredType, assignedTypeResult) {
+      function narrowTypeBasedOnAssignment(declaredType, assignedTypeResult) {
         const narrowedType = (0, typeUtils_1.mapSubtypes)(assignedTypeResult.type, (assignedSubtype) => {
           if ((0, types_1.isClass)(assignedSubtype) && (0, typeUtils_1.isLiteralType)(assignedSubtype)) {
             if ((0, types_1.isUnion)(declaredType) && types_1.UnionType.containsType(declaredType, assignedSubtype)) {
@@ -88154,33 +88325,24 @@ var require_typeEvaluator = __commonJS({
             }
           }
           const narrowedSubtype = (0, typeUtils_1.mapSubtypes)(declaredType, (declaredSubtype) => {
-            if ((0, types_1.isAnyOrUnknown)(declaredSubtype)) {
-              return declaredSubtype;
+            if (!assignType(declaredSubtype, assignedSubtype)) {
+              return void 0;
             }
-            if (assignType(declaredSubtype, assignedSubtype)) {
-              if ((0, types_1.isAny)(assignedSubtype)) {
-                return declaredSubtype;
-              }
-              if ((0, types_1.isClass)(declaredSubtype) && (0, types_1.isClass)(assignedSubtype) && types_1.TypeBase.isInstance(declaredSubtype) === types_1.TypeBase.isInstance(assignedSubtype)) {
-                const result = replaceTypeArgsWithAny(node, declaredSubtype, assignedSubtype);
-                if (result) {
-                  assignedSubtype = result;
-                }
+            if ((0, types_1.isUnknown)(assignedSubtype)) {
+              return assignedSubtype;
+            }
+            if (assignType(assignedSubtype, declaredSubtype)) {
+              if ((0, types_1.isClass)(assignedSubtype) && assignedSubtype.priv.typedDictNarrowedEntries && (0, types_1.isTypeSame)(assignedSubtype, declaredSubtype, { ignoreTypedDictNarrowEntries: true })) {
                 return assignedSubtype;
               }
-              if (!(0, types_1.isTypeVar)(declaredSubtype) && (0, types_1.isTypeVar)(assignedSubtype) && !types_1.TypeVarType.isBound(assignedSubtype)) {
-                return declaredSubtype;
-              }
-              if ((0, typeUtils_1.containsAnyRecursive)(
-                assignedSubtype,
-                /* includeUnknown */
-                false
-              ) && !(0, typeUtils_1.containsAnyRecursive)(declaredSubtype)) {
-                return declaredSubtype;
+              if ((0, types_1.isClassInstance)(declaredSubtype) && types_1.ClassType.isProtocolClass(declaredSubtype)) {
+                if ((0, types_1.isFunction)(assignedSubtype) || (0, types_1.isOverloaded)(assignedSubtype)) {
+                  return assignedSubtype;
+                }
               }
-              return assignedSubtype;
+              return declaredSubtype;
             }
-            return void 0;
+            return assignedSubtype;
           });
           if ((0, types_1.isNever)(narrowedSubtype)) {
             return assignedSubtype;
@@ -88188,11 +88350,11 @@ var require_typeEvaluator = __commonJS({
           return narrowedSubtype;
         });
         if ((0, typeUtils_1.isIncompleteUnknown)(narrowedType)) {
-          return { type: narrowedType };
+          return { type: narrowedType, isIncomplete: assignedTypeResult.isIncomplete };
         } else if ((0, types_1.isUnknown)(narrowedType)) {
-          return { type: (0, types_1.combineTypes)([narrowedType, declaredType]) };
+          return { type: (0, types_1.combineTypes)([narrowedType, declaredType]), isIncomplete: assignedTypeResult.isIncomplete };
         }
-        return { type: narrowedType };
+        return { type: narrowedType, isIncomplete: assignedTypeResult.isIncomplete };
       }
       function validateOverrideMethod(baseMethod, overrideMethod, baseClass, diag, enforceParamNames = true) {
         if (!(0, types_1.isFunction)(baseMethod) && !(0, types_1.isOverloaded)(baseMethod)) {
@@ -88243,9 +88405,7 @@ var require_typeEvaluator = __commonJS({
               overrideOverload,
               /* diag */
               void 0,
-              enforceParamNames,
-              /* exemptSelfClsParam */
-              false
+              enforceParamNames
             );
             if (isCompatible && index <= previousMatchIndex && possibleMatchIndex === void 0) {
               possibleMatchIndex = index;
@@ -88300,7 +88460,7 @@ var require_typeEvaluator = __commonJS({
           /* AssignTypeFlags.Default */
         );
       }
-      function validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames, exemptSelfClsParam = true) {
+      function validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames) {
         const baseParamDetails = (0, parameterUtils_1.getParamListDetails)(baseMethod);
         const overrideParamDetails = (0, parameterUtils_1.getParamListDetails)(overrideMethod);
         const constraints = new constraintTracker_1.ConstraintTracker();
@@ -88334,8 +88494,8 @@ var require_typeEvaluator = __commonJS({
                   baseParamDetails.params[i].type,
                   diag == null ? void 0 : diag.createAddendum(),
                   constraints,
-                  2
-                  /* AssignTypeFlags.Contravariant */
+                  0
+                  /* AssignTypeFlags.Default */
                 )) {
                   localize_1.LocAddendum.overrideParamType().format({
                     index: i + 1,
@@ -88363,7 +88523,7 @@ var require_typeEvaluator = __commonJS({
           }
           const positionalParamCount = Math.min(baseParamDetails.positionParamCount, overrideParamDetails.positionParamCount);
           for (let i = 0; i < positionalParamCount; i++) {
-            if (i === 0 && exemptSelfClsParam) {
+            if (i === 0) {
               if (types_1.FunctionType.isInstanceMethod(overrideMethod) || types_1.FunctionType.isClassMethod(overrideMethod) || types_1.FunctionType.isConstructorMethod(overrideMethod)) {
                 continue;
               }
@@ -88401,14 +88561,14 @@ var require_typeEvaluator = __commonJS({
               const overrideParamType = overrideParamDetails.params[i].type;
               const baseIsSynthesizedTypeVar = (0, types_1.isTypeVar)(baseParamType) && baseParamType.shared.isSynthesized;
               const overrideIsSynthesizedTypeVar = (0, types_1.isTypeVar)(overrideParamType) && overrideParamType.shared.isSynthesized;
-              if (!exemptSelfClsParam || !baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar) {
+              if (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar) {
                 if (baseParam.category !== overrideParam.category || !assignType(
                   overrideParamType,
                   baseParamType,
                   diag == null ? void 0 : diag.createAddendum(),
                   constraints,
-                  2
-                  /* AssignTypeFlags.Contravariant */
+                  0
+                  /* AssignTypeFlags.Default */
                 )) {
                   diag == null ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamType().format({
                     index: i + 1,
@@ -88452,8 +88612,8 @@ var require_typeEvaluator = __commonJS({
                 baseParamType,
                 diag == null ? void 0 : diag.createAddendum(),
                 constraints,
-                2
-                /* AssignTypeFlags.Contravariant */
+                0
+                /* AssignTypeFlags.Default */
               )) {
                 diag == null ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamKeywordType().format({
                   name: overrideParamDetails.params[overrideParamDetails.argsIndex].param.name ?? "?",
@@ -88489,8 +88649,8 @@ var require_typeEvaluator = __commonJS({
                 paramInfo.type,
                 diag == null ? void 0 : diag.createAddendum(),
                 constraints,
-                2
-                /* AssignTypeFlags.Contravariant */
+                0
+                /* AssignTypeFlags.Default */
               )) {
                 diag == null ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamKeywordType().format({
                   name: paramInfo.param.name ?? "?",
@@ -88669,6 +88829,9 @@ var require_typeEvaluator = __commonJS({
               true
             );
           }
+          if (functionType.priv.strippedFirstParamType) {
+            return functionType;
+          }
           if (types_1.FunctionType.isInstanceMethod(functionType)) {
             if ((0, typeUtils_1.isInstantiableMetaclass)(baseType)) {
               return functionType;
@@ -88721,6 +88884,18 @@ var require_typeEvaluator = __commonJS({
               constraints.setBounds(memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType) ? (0, typeUtils_1.convertToInstance)(firstParamType) : firstParamType);
             } else {
               const subDiag = diag == null ? void 0 : diag.createAddendum();
+              if ((0, types_1.isFunction)(memberTypeFirstParamType) || (0, types_1.isOverloaded)(memberTypeFirstParamType)) {
+                if ((0, types_1.isClassInstance)(firstParamType) && types_1.ClassType.isProtocolClass(firstParamType)) {
+                  if (subDiag) {
+                    subDiag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({
+                      type: printType(firstParamType),
+                      methodName: memberType.shared.name || "<anonymous>",
+                      paramName: memberTypeFirstParam.name || "__p0"
+                    }));
+                  }
+                  return void 0;
+                }
+              }
               if (!assignType(memberTypeFirstParamType, firstParamType, subDiag == null ? void 0 : subDiag.createAddendum(), constraints, 8192, recursionCount)) {
                 if (memberTypeFirstParam.name && !types_1.FunctionParam.isNameSynthesized(memberTypeFirstParam) && types_1.FunctionParam.isTypeDeclared(memberTypeFirstParam)) {
                   if (subDiag) {
@@ -88973,7 +89148,7 @@ var require_typeEvaluator = __commonJS({
       function printControlFlowGraph(flowNode, reference, callName, logger) {
         return codeFlowEngine.printControlFlowGraph(flowNode, reference, callName, logger);
       }
-      const getInferredReturnType = wrapWithLogger(_getInferredReturnType);
+      const getInferredReturnTypeResult = wrapWithLogger(_getInferredReturnTypeResult);
       const evaluatorInterface = {
         runWithCancellationToken,
         getType,
@@ -89175,6 +89350,7 @@ var require_checker = __commonJS({
         this._isUnboundCheckSuppressed = false;
         this._scopedNodes = [];
         this._typeParamLists = [];
+        this._multipartImports = [];
         this._moduleNode = parseResults.parseTree;
         this._fileInfo = AnalyzerNodeInfo.getFileInfo(this._moduleNode);
       }
@@ -89195,6 +89371,7 @@ var require_checker = __commonJS({
           this._reportUnusedDunderAllSymbols(dunderAllInfo.stringNodes);
         }
         this._validateSymbolTables();
+        this._reportUnusedMultipartImports();
         this._reportDuplicateImports();
       }
       walk(node) {
@@ -89948,7 +90125,9 @@ var require_checker = __commonJS({
         const typeResult = this._evaluator.getTypeResult(node.d.member);
         const type = (typeResult == null ? void 0 : typeResult.type) ?? types_1.UnknownType.create();
         const leftExprType = this._evaluator.getType(node.d.leftExpr);
-        this._reportDeprecatedUseForType(node.d.member, type, leftExprType && (0, types_1.isModule)(leftExprType) && leftExprType.priv.moduleName === "typing");
+        const moduleName = leftExprType && (0, types_1.isModule)(leftExprType) ? leftExprType.priv.moduleName : void 0;
+        const isImportedFromTyping = moduleName === "typing" || moduleName === "typing_extensions";
+        this._reportDeprecatedUseForType(node.d.member, type, isImportedFromTyping);
         if (typeResult == null ? void 0 : typeResult.memberAccessDeprecationInfo) {
           this._reportDeprecatedUseForMemberAccess(node.d.member, typeResult.memberAccessDeprecationInfo);
         }
@@ -89959,6 +90138,10 @@ var require_checker = __commonJS({
       visitImportAs(node) {
         this._conditionallyReportShadowedImport(node);
         this._evaluator.evaluateTypesForStatement(node);
+        const nameParts = node.d.module.d.nameParts;
+        if (nameParts.length > 1 && !node.d.alias) {
+          this._multipartImports.push(node);
+        }
         return true;
       }
       visitImportFrom(node) {
@@ -90013,7 +90196,8 @@ var require_checker = __commonJS({
         let isImportFromTyping = false;
         if (((_b = node.parent) == null ? void 0 : _b.nodeType) === 25) {
           if (node.parent.d.module.d.leadingDots === 0 && node.parent.d.module.d.nameParts.length === 1) {
-            if (node.parent.d.module.d.nameParts[0].d.value === "typing") {
+            const namePart = node.parent.d.module.d.nameParts[0].d.value;
+            if (namePart === "typing" || namePart === "typing_extensions") {
               isImportFromTyping = true;
             }
           }
@@ -90103,6 +90287,49 @@ var require_checker = __commonJS({
         }
         return false;
       }
+      _reportUnusedMultipartImports() {
+        this._multipartImports.forEach((node) => {
+          const nameParts = node.d.module.d.nameParts;
+          if (this._isMultipartImportUnused(node)) {
+            const multipartName = nameParts.map((np) => np.d.value).join(".");
+            let textRange = { start: nameParts[0].start, length: nameParts[0].length };
+            textRange = textRange_1.TextRange.extend(textRange, nameParts[nameParts.length - 1]);
+            this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.LocMessage.unaccessedSymbol().format({ name: multipartName }), textRange, {
+              action: "pyright.unusedImport"
+              /* Commands.unusedImport */
+            });
+            this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportUnusedImport, localize_1.LocMessage.unaccessedImport().format({ name: multipartName }), textRange);
+          }
+        });
+      }
+      _isMultipartImportUnused(node) {
+        var _a;
+        const nameParts = node.d.module.d.nameParts;
+        (0, debug_1.assert)(nameParts.length > 1);
+        let moduleType = (_a = this._evaluator.evaluateTypeForSubnode(node, () => {
+          this._evaluator.evaluateTypesForStatement(node);
+        })) == null ? void 0 : _a.type;
+        if (!moduleType || !(0, types_1.isModule)(moduleType)) {
+          return false;
+        }
+        for (let i = 1; i < nameParts.length - 1; i++) {
+          const symbol2 = types_1.ModuleType.getField(moduleType, nameParts[i].d.value);
+          if (!symbol2) {
+            return false;
+          }
+          const submoduleType = symbol2.getSynthesizedType();
+          if (!submoduleType || !(0, types_1.isModule)(submoduleType.type)) {
+            return false;
+          }
+          moduleType = submoduleType.type;
+        }
+        const lastPartName = nameParts[nameParts.length - 1].d.value;
+        const symbol = types_1.ModuleType.getField(moduleType, lastPartName);
+        if (!symbol) {
+          return false;
+        }
+        return !this._fileInfo.accessedSymbolSet.has(symbol.id);
+      }
       _getImportResult(node, uri) {
         const execEnv = this._importResolver.getConfigOptions().findExecEnvironment(uri);
         const moduleNameNode = node.parent.d.module;
@@ -90317,6 +90544,7 @@ var require_checker = __commonJS({
       // have overlapping types.
       _validateComparisonTypes(node) {
         let rightExpression = node.d.rightExpr;
+        const assumeIsOperator = node.d.operator === 39 || node.d.operator === 40;
         if (rightExpression.nodeType === 7 && !rightExpression.d.hasParens && ParseTreeUtils.operatorSupportsChaining(rightExpression.d.operator)) {
           rightExpression = rightExpression.d.leftExpr;
         }
@@ -90361,7 +90589,7 @@ var require_checker = __commonJS({
               if (isComparable) {
                 return;
               }
-              if (this._evaluator.isTypeComparable(leftSubtype, rightSubtype)) {
+              if (this._evaluator.isTypeComparable(leftSubtype, rightSubtype, assumeIsOperator)) {
                 isComparable = true;
               }
               return rightSubtype;
@@ -91372,16 +91600,10 @@ var require_checker = __commonJS({
                 }
               } else {
                 const nameParts = decl.node.d.module.d.nameParts;
-                if (nameParts.length > 0) {
-                  const multipartName = nameParts.map((np) => np.d.value).join(".");
-                  let textRange = { start: nameParts[0].start, length: nameParts[0].length };
-                  textRange = textRange_1.TextRange.extend(textRange, nameParts[nameParts.length - 1]);
-                  this._fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.LocMessage.unaccessedSymbol().format({ name: multipartName }), textRange, {
-                    action: "pyright.unusedImport"
-                    /* Commands.unusedImport */
-                  });
-                  this._evaluator.addDiagnosticForTextRange(this._fileInfo, diagnosticRules_1.DiagnosticRule.reportUnusedImport, localize_1.LocMessage.unaccessedImport().format({ name: multipartName }), textRange);
-                  return;
+                if (nameParts.length === 1) {
+                  nameNode = nameParts[0];
+                  this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedImport, localize_1.LocMessage.unaccessedImport().format({ name: nameNode.d.value }), nameNode);
+                  message = localize_1.LocMessage.unaccessedImport().format({ name: nameNode.d.value });
                 }
               }
             } else if (decl.node.nodeType === 26) {
@@ -92102,7 +92324,7 @@ var require_checker = __commonJS({
           }
           if (declaredReturnType && !functionNeverReturns && implicitlyReturnsNone) {
             if ((0, types_1.isNever)(declaredReturnType)) {
-              if (!ParseTreeUtils.isSuiteEmpty(node.d.suite) && !types_1.FunctionType.isOverloaded(functionType) && !types_1.FunctionType.isAsync(functionType)) {
+              if (!ParseTreeUtils.isSuiteEmpty(node.d.suite) && !types_1.FunctionType.isOverloaded(functionType)) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportReturnType, localize_1.LocMessage.noReturnReturnsNone(), returnAnnotation);
               }
             } else if (!types_1.FunctionType.isAbstractMethod(functionType)) {
@@ -93253,8 +93475,9 @@ var require_checker = __commonJS({
           return;
         }
         const baseClass = baseClassAndSymbol.classType;
+        const baseClassSelf = types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(baseClass, { useBoundTypeVars: true }));
         const childClassSelf = types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(childClassType, { useBoundTypeVars: true }));
-        let baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, this._evaluator.getTypeClassType(), childClassSelf);
+        let baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, this._evaluator.getTypeClassType(), baseClassSelf);
         overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, childClassType, this._evaluator.getTypeClassType(), childClassSelf);
         if (childClassType.shared.typeVarScopeId) {
           overrideType = (0, typeUtils_1.makeTypeVarsBound)(overrideType, [childClassType.shared.typeVarScopeId]);
@@ -94379,7 +94602,7 @@ var require_sourceFile = __commonJS({
       }
     };
     var SourceFile = class {
-      constructor(serviceProvider, uri, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, editMode, console2, logTracker, ipythonMode) {
+      constructor(serviceProvider, uri, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, isModulePrivate, editMode, console2, logTracker, ipythonMode) {
         this.serviceProvider = serviceProvider;
         this._diagnosticRuleSet = (0, configOptions_1.getBasicDiagnosticRuleSet)();
         this._ipythonMode = IPythonMode.None;
@@ -94393,6 +94616,7 @@ var require_sourceFile = __commonJS({
         this._isStubFile = uri.hasExtension(".pyi");
         this._isThirdPartyImport = isThirdPartyImport;
         this._isThirdPartyPyTypedPresent = isThirdPartyPyTypedPresent;
+        this._isModulePrivate = isModulePrivate;
         const fileName = uri.fileName;
         this._isTypingStubFile = this._isStubFile && (this._uri.pathEndsWith("stdlib/typing.pyi") || fileName === "typing_extensions.pyi");
         this._isTypingExtensionsStubFile = this._isStubFile && fileName === "typing_extensions.pyi";
@@ -95056,6 +95280,7 @@ var require_sourceFile = __commonJS({
           isTypeshedStubFile: this._isTypeshedStubFile,
           isBuiltInStubFile: this._isBuiltInStubFile,
           isInPyTypedPackage: this._isThirdPartyPyTypedPresent,
+          isModulePrivate: this._isModulePrivate,
           ipythonMode: this._ipythonMode,
           accessedSymbolSet: /* @__PURE__ */ new Set()
         };
@@ -106016,7 +106241,7 @@ var require_AnimationFrameAction = __commonJS({
           return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay);
         }
         var actions = scheduler.actions;
-        if (id != null && ((_a = actions[actions.length - 1]) === null || _a === void 0 ? void 0 : _a.id) !== id) {
+        if (id != null && id === scheduler._scheduled && ((_a = actions[actions.length - 1]) === null || _a === void 0 ? void 0 : _a.id) !== id) {
           animationFrameProvider_1.animationFrameProvider.cancelAnimationFrame(id);
           scheduler._scheduled = void 0;
         }
@@ -106061,8 +106286,13 @@ var require_AnimationFrameScheduler = __commonJS({
       }
       AnimationFrameScheduler2.prototype.flush = function(action) {
         this._active = true;
-        var flushId = this._scheduled;
-        this._scheduled = void 0;
+        var flushId;
+        if (action) {
+          flushId = action.id;
+        } else {
+          flushId = this._scheduled;
+          this._scheduled = void 0;
+        }
         var actions = this.actions;
         var error;
         action = action || actions.shift();
@@ -110546,7 +110776,6 @@ var require_merge2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.merge = void 0;
     var lift_1 = require_lift();
-    var argsOrArgArray_1 = require_argsOrArgArray();
     var mergeAll_1 = require_mergeAll();
     var args_1 = require_args();
     var from_1 = require_from();
@@ -110557,7 +110786,6 @@ var require_merge2 = __commonJS({
       }
       var scheduler = args_1.popScheduler(args);
       var concurrent = args_1.popNumber(args, Infinity);
-      args = argsOrArgArray_1.argsOrArgArray(args);
       return lift_1.operate(function(source, subscriber) {
         mergeAll_1.mergeAll(concurrent)(from_1.from(__spreadArray([source], __read(args)), scheduler)).subscribe(subscriber);
       });
@@ -115805,6 +116033,9 @@ var PythonCodeActionProvider = class {
   ignoreAction(document, range) {
     const ignoreTxt = "# type: ignore";
     const doc = import_coc4.workspace.getDocument(document.uri);
+    if (!doc) {
+      return null;
+    }
     if (this.wholeRange(document, range)) {
       let pos = import_coc4.Position.create(0, 0);
       if (doc.getline(0).startsWith("#!")) pos = import_coc4.Position.create(1, 0);
@@ -116897,7 +117128,7 @@ var TypeInlayHintsProvider = class {
     });
     import_coc11.workspace.onDidChangeTextDocument((e) => {
       const doc = import_coc11.workspace.getDocument(e.bufnr);
-      if (doc.languageId === "python") {
+      if ((doc == null ? void 0 : doc.languageId) === "python") {
         this._onDidChangeInlayHints.fire();
       }
     });
@@ -118911,6 +119142,9 @@ var PyDocStyle = class extends BaseLinter {
       outputLines.push(oldOutputLines[2 * counter] + oldOutputLines[2 * counter + 1]);
     }
     const doc = import_coc21.workspace.getDocument(document.uri);
+    if (!doc) {
+      return [];
+    }
     return outputLines.filter((value, index) => index < maxLines && value.indexOf(":") >= 0).map((line) => {
       if (this.isWindows) {
         return line.substring(line.indexOf(`${baseFileName}:`) + baseFileName.length + 1).trim();
@@ -119304,14 +119538,15 @@ var LintingEngine = class {
     this.diagnosticCollection.set(document.uri, diagnostics);
   }
   createDiagnostics(message, document) {
+    var _a;
     let start = import_coc27.Position.create(message.line > 0 ? message.line - 1 : 0, message.column);
     const endLine = message.endLine ?? message.line;
     const endColumn = message.endColumn ?? message.column + 1;
     let end = import_coc27.Position.create(endLine > 0 ? endLine - 1 : 0, endColumn);
     const ms = /['"](.*?)['"]/g.exec(message.message);
     if (ms && ms.length > 0) {
-      const line = import_coc27.workspace.getDocument(document.uri).getline(message.line - 1);
-      if (line.includes(ms[1])) {
+      const line = (_a = import_coc27.workspace.getDocument(document.uri)) == null ? void 0 : _a.getline(message.line - 1);
+      if (line == null ? void 0 : line.includes(ms[1])) {
         const s = message.column > line.indexOf(ms[1]) ? message.column : line.indexOf(ms[1]);
         start = import_coc27.Position.create(message.line - 1, s);
         end = import_coc27.Position.create(message.line - 1, s + ms[1].length);
@@ -119447,6 +119682,9 @@ var LinterProvider = class {
   }
   onDocumentChanged(e) {
     const document = import_coc28.workspace.getDocument(e.textDocument.uri);
+    if (!document) {
+      return;
+    }
     this.engine.lintDocument(document.textDocument, true).catch(() => {
     });
   }
@@ -119623,6 +119861,9 @@ async function extractVariable(root, document, range, outputChannel) {
     return;
   }
   const doc = import_coc29.workspace.getDocument(document.uri);
+  if (!doc) {
+    return;
+  }
   const tempFile = await getTempFileWithDocumentContents(document);
   const workspaceFolder = import_coc29.workspace.getWorkspaceFolder(doc.uri);
   const workspaceRoot = workspaceFolder ? import_coc29.Uri.parse(workspaceFolder.uri).fsPath : import_coc29.workspace.cwd;
@@ -119644,6 +119885,9 @@ async function extractMethod(root, document, range, outputChannel) {
     return;
   }
   const doc = import_coc29.workspace.getDocument(document.uri);
+  if (!doc) {
+    return;
+  }
   const tempFile = await getTempFileWithDocumentContents(document);
   const workspaceFolder = import_coc29.workspace.getWorkspaceFolder(doc.uri);
   const workspaceRoot = workspaceFolder ? import_coc29.Uri.parse(workspaceFolder.uri).fsPath : import_coc29.workspace.cwd;
@@ -119942,6 +120186,7 @@ async function activate(context) {
   }
   if (pyrightCfg.get("disableDiagnostics")) {
     disabledFeatures.push("diagnostics");
+    disabledFeatures.push("pullDiagnostic");
   }
   if (pyrightCfg.get("disableDocumentation")) {
     disabledFeatures.push("hover");