coc-pyright 1.1.393 → 1.1.395

package/lib/index.js

@@ -12571,6 +12571,8 @@ var require_cancellationUtils = __commonJS({
     exports2.throwIfCancellationRequested = throwIfCancellationRequested;
     exports2.onCancellationRequested = onCancellationRequested;
     exports2.CancelAfter = CancelAfter;
+    exports2.createCombinedToken = createCombinedToken;
+    exports2.setupCombinedTokensFor = setupCombinedTokensFor;
     exports2.getCancellationTokenId = getCancellationTokenId;
     exports2.raceCancellation = raceCancellation;
     var vscode_jsonrpc_1 = require_api();
@@ -12620,6 +12622,22 @@ var require_cancellationUtils = __commonJS({
     }
     function CancelAfter(provider, ...tokens) {
       const source = provider.createCancellationTokenSource();
+      setupCombinedTokensFor(source, ...tokens);
+      return source;
+    }
+    function createCombinedToken(...tokens) {
+      const source = new vscode_jsonrpc_1.CancellationTokenSource();
+      setupCombinedTokensFor(source, ...tokens);
+      return source.token;
+    }
+    function setupCombinedTokensFor(source, ...tokens) {
+      for (const token of tokens) {
+        if (!token.isCancellationRequested) {
+          continue;
+        }
+        source.cancel();
+        return;
+      }
       const disposables = [];
       for (const token of tokens) {
         disposables.push(onCancellationRequested(token, () => {
@@ -12629,7 +12647,6 @@ var require_cancellationUtils = __commonJS({
       disposables.push(onCancellationRequested(source.token, () => {
         disposables.forEach((d) => d.dispose());
       }));
-      return source;
     }
     var DefaultCancellationProvider = class {
       createCancellationTokenSource() {
@@ -15035,41 +15052,6 @@ var require_programTypes = __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/common/fileSystem.js
 var require_fileSystem = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/common/fileSystem.js"(exports2) {
@@ -15130,294 +15112,6 @@ var require_fileSystem = __commonJS({
   }
 });
 
-// node_modules/@zzzen/pyright-internal/dist/readonlyAugmentedFileSystem.js
-var require_readonlyAugmentedFileSystem = __commonJS({
-  "node_modules/@zzzen/pyright-internal/dist/readonlyAugmentedFileSystem.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.ReadOnlyAugmentedFileSystem = void 0;
-    var collectionUtils_1 = require_collectionUtils();
-    var fileSystem_1 = require_fileSystem();
-    var ReadOnlyAugmentedFileSystem = class {
-      constructor(realFS) {
-        this.realFS = realFS;
-        this._entryMap = /* @__PURE__ */ new Map();
-        this._reverseEntryMap = /* @__PURE__ */ new Map();
-        this._folderMap = /* @__PURE__ */ new Map();
-      }
-      existsSync(uri) {
-        if (this.isMovedEntry(uri)) {
-          return false;
-        }
-        return this.realFS.existsSync(this.getOriginalPath(uri));
-      }
-      mkdirSync(uri, options) {
-        throw new Error("Operation is not allowed.");
-      }
-      chdir(uri) {
-        throw new Error("Operation is not allowed.");
-      }
-      readdirEntriesSync(uri) {
-        const entries = [];
-        const movedEntries = this._folderMap.get(uri.key);
-        if (!movedEntries || this.realFS.existsSync(uri)) {
-          (0, collectionUtils_1.appendArray)(entries, this.realFS.readdirEntriesSync(uri).filter((item) => {
-            return !this.isMovedEntry(uri.combinePaths(item.name)) && !(movedEntries == null ? void 0 : movedEntries.some((movedEntry) => movedEntry.name === item.name));
-          }));
-        }
-        if (!movedEntries) {
-          return entries;
-        }
-        const dirPath = uri.getFilePath();
-        return entries.concat(movedEntries.map((e) => new fileSystem_1.VirtualDirent(e.name, e.isFile, dirPath)));
-      }
-      readdirSync(uri) {
-        return this.readdirEntriesSync(uri).map((p) => p.name);
-      }
-      readFileSync(uri, encoding) {
-        return this.realFS.readFileSync(this.getOriginalPath(uri), encoding);
-      }
-      writeFileSync(uri, data, encoding) {
-        throw new Error("Operation is not allowed.");
-      }
-      statSync(uri) {
-        return this.realFS.statSync(this.getOriginalPath(uri));
-      }
-      rmdirSync(uri) {
-        throw new Error("Operation is not allowed.");
-      }
-      unlinkSync(uri) {
-        throw new Error("Operation is not allowed.");
-      }
-      realpathSync(uri) {
-        if (this._entryMap.has(uri.key)) {
-          return uri;
-        }
-        return this.realFS.realpathSync(uri);
-      }
-      getModulePath() {
-        return this.realFS.getModulePath();
-      }
-      createFileSystemWatcher(paths, listener) {
-        return this.realFS.createFileSystemWatcher(paths, listener);
-      }
-      createReadStream(uri) {
-        return this.realFS.createReadStream(this.getOriginalPath(uri));
-      }
-      createWriteStream(uri) {
-        throw new Error("Operation is not allowed.");
-      }
-      copyFileSync(src, dst) {
-        throw new Error("Operation is not allowed.");
-      }
-      // Async I/O
-      readFile(uri) {
-        return this.realFS.readFile(this.getOriginalPath(uri));
-      }
-      readFileText(uri, encoding) {
-        return this.realFS.readFileText(this.getOriginalPath(uri), encoding);
-      }
-      realCasePath(uri) {
-        return this.realFS.realCasePath(uri);
-      }
-      // See whether the file is mapped to another location.
-      isMappedUri(fileUri) {
-        return this._entryMap.has(fileUri.key) || this.realFS.isMappedUri(fileUri);
-      }
-      // Get original filepath if the given filepath is mapped.
-      getOriginalUri(mappedFileUri) {
-        return this.realFS.getOriginalUri(this.getOriginalPath(mappedFileUri));
-      }
-      // Get mapped filepath if the given filepath is mapped.
-      getMappedUri(originalFileUri) {
-        const mappedFileUri = this.realFS.getMappedUri(originalFileUri);
-        return this._reverseEntryMap.get(mappedFileUri.key) ?? mappedFileUri;
-      }
-      isInZip(uri) {
-        return this.realFS.isInZip(uri);
-      }
-      recordMovedEntry(mappedUri, originalUri, rootPath) {
-        this._entryMap.set(mappedUri.key, originalUri);
-        this._reverseEntryMap.set(originalUri.key, mappedUri);
-        const directory = mappedUri.getDirectory();
-        const folderInfo = (0, collectionUtils_1.getOrAdd)(this._folderMap, directory.key, () => []);
-        const name = mappedUri.fileName;
-        if (!folderInfo.some((entry) => entry.name === name)) {
-          folderInfo.push({ name, isFile: true });
-        }
-        const subPathEntries = rootPath.getRelativePathComponents(directory);
-        for (let i = 0; i < subPathEntries.length; i++) {
-          const subdir = rootPath.combinePaths(...subPathEntries.slice(0, i + 1));
-          const parent = subdir.getDirectory().key;
-          const dirInfo = (0, collectionUtils_1.getOrAdd)(this._folderMap, parent, () => []);
-          const dirName = subdir.fileName;
-          if (!dirInfo.some((entry) => entry.name === dirName)) {
-            dirInfo.push({ name: dirName, isFile: false });
-          }
-        }
-      }
-      getOriginalPath(mappedFileUri) {
-        return this._entryMap.get(mappedFileUri.key) ?? mappedFileUri;
-      }
-      isMovedEntry(uri) {
-        return this._reverseEntryMap.has(uri.key);
-      }
-      clear() {
-        this._entryMap.clear();
-        this._reverseEntryMap.clear();
-        this._folderMap.clear();
-      }
-    };
-    exports2.ReadOnlyAugmentedFileSystem = ReadOnlyAugmentedFileSystem;
-  }
-});
-
-// node_modules/@zzzen/pyright-internal/dist/pyrightFileSystem.js
-var require_pyrightFileSystem = __commonJS({
-  "node_modules/@zzzen/pyright-internal/dist/pyrightFileSystem.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.PyrightFileSystem = exports2.SupportPartialStubs = void 0;
-    var pyTypedUtils_1 = require_pyTypedUtils();
-    var pathConsts_1 = require_pathConsts();
-    var uriUtils_1 = require_uriUtils();
-    var readonlyAugmentedFileSystem_1 = require_readonlyAugmentedFileSystem();
-    var SupportPartialStubs;
-    (function(SupportPartialStubs2) {
-      function is(value) {
-        return value.isPartialStubPackagesScanned && value.isPathScanned && value.processPartialStubPackages && value.clearPartialStubs;
-      }
-      SupportPartialStubs2.is = is;
-    })(SupportPartialStubs || (exports2.SupportPartialStubs = SupportPartialStubs = {}));
-    var PyrightFileSystem = class extends readonlyAugmentedFileSystem_1.ReadOnlyAugmentedFileSystem {
-      constructor(realFS) {
-        super(realFS);
-        this._rootSearched = /* @__PURE__ */ new Set();
-        this._partialStubPackagePaths = /* @__PURE__ */ new Set();
-      }
-      mkdirSync(uri, options) {
-        this.realFS.mkdirSync(uri, options);
-      }
-      chdir(uri) {
-        this.realFS.chdir(uri);
-      }
-      writeFileSync(uri, data, encoding) {
-        this.realFS.writeFileSync(this.getOriginalPath(uri), data, encoding);
-      }
-      rmdirSync(uri) {
-        this.realFS.rmdirSync(this.getOriginalPath(uri));
-      }
-      unlinkSync(uri) {
-        this.realFS.unlinkSync(this.getOriginalPath(uri));
-      }
-      createWriteStream(uri) {
-        return this.realFS.createWriteStream(this.getOriginalPath(uri));
-      }
-      copyFileSync(src, dst) {
-        this.realFS.copyFileSync(this.getOriginalPath(src), this.getOriginalPath(dst));
-      }
-      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);
-            let partialStubs;
-            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;
-                }
-                partialStubs = partialStubs ?? this._getRelativePathPartialStubs(partialStubPackagePath);
-                for (const partialStub of partialStubs) {
-                  const originalPyiFile = partialStubPackagePath.resolvePaths(partialStub);
-                  const mappedPyiFile = packagePath.resolvePaths(partialStub);
-                  this.recordMovedEntry(mappedPyiFile, originalPyiFile, packagePath);
-                }
-              } catch {
-              }
-            }
-          }
-        }
-      }
-      clearPartialStubs() {
-        super.clear();
-        this._rootSearched.clear();
-        this._partialStubPackagePaths.clear();
-      }
-      isMovedEntry(uri) {
-        return this._partialStubPackagePaths.has(uri.key) || super.isMovedEntry(uri);
-      }
-      _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.PyrightFileSystem = PyrightFileSystem;
-  }
-});
-
 // node_modules/@zzzen/pyright-internal/dist/analyzer/docStringUtils.js
 var require_docStringUtils = __commonJS({
   "node_modules/@zzzen/pyright-internal/dist/analyzer/docStringUtils.js"(exports2) {
@@ -16167,6 +15861,158 @@ 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) {
@@ -16176,7 +16022,6 @@ var require_serviceProviderExtensions = __commonJS({
     var cacheManager_1 = require_cacheManager();
     var programTypes_1 = require_programTypes();
     var sourceFile_1 = require_sourceFile();
-    var pyrightFileSystem_1 = require_pyrightFileSystem();
     var serviceKeys_1 = require_serviceKeys();
     var caseSensitivityDetector_1 = require_caseSensitivityDetector();
     var console_1 = require_console();
@@ -16184,6 +16029,7 @@ var require_serviceProviderExtensions = __commonJS({
     var serviceProvider_1 = require_serviceProvider();
     var docStringService_1 = require_docStringService();
     var languageServerInterface_1 = require_languageServerInterface();
+    var partialStubService_1 = require_partialStubService();
     function createServiceProvider(...services2) {
       const sp = new serviceProvider_1.ServiceProvider();
       services2.forEach((service) => {
@@ -16196,7 +16042,7 @@ var require_serviceProviderExtensions = __commonJS({
         if (programTypes_1.ISourceFileFactory.is(service)) {
           sp.add(serviceKeys_1.ServiceKeys.sourceFileFactory, service);
         }
-        if (pyrightFileSystem_1.SupportPartialStubs.is(service)) {
+        if (partialStubService_1.SupportPartialStubs.is(service)) {
           sp.add(serviceKeys_1.ServiceKeys.partialStubs, service);
         }
         if (fileSystem_1.TempFile.is(service)) {
@@ -16734,6 +16580,7 @@ var require_package_nls_cs = __commonJS({
         noneNotUsableWithAsync: "Objekt typu None nen\xED mo\u017En\xE9 pou\u017E\xEDt s typem async with.",
         noneOperator: "Oper\xE1tor {operator} se pro None nepodporuje",
         noneUnknownMember: "{name} nen\xED zn\xE1m\xFD atribut None.",
+        nonlocalTypeParam: "Pro parametr typu {name} nen\xED povolen\xE1 vazba nonlocal.",
         notRequiredArgCount: "Za NotRequired byl o\u010Dek\xE1v\xE1n jeden argument typu",
         notRequiredNotInTypedDict: "NotRequired nen\xED v tomto kontextu povolen\xE9",
         objectNotCallable: "Objekt typu {type} nen\xED mo\u017En\xE9 volat",
@@ -16752,11 +16599,11 @@ var require_package_nls_cs = __commonJS({
         overloadAbstractImplMismatch: "P\u0159et\xED\u017Een\xED mus\xED odpov\xEDdat abstraktn\xEDmu stavu implementace.",
         overloadAbstractMismatch: "Bu\u010F mus\xED b\xFDt v\u0161echna p\u0159et\xED\u017Een\xED abstraktn\xED, nebo naopak nesm\xED b\xFDt \u017E\xE1dn\xE9 z nich abstraktn\xED.",
         overloadClassMethodInconsistent: "P\u0159et\xED\u017Een\xED pro {name} pou\u017E\xEDvaj\xED @classmethod nekonzistentn\u011B.",
-        overloadFinalImpl: "@final decorator should be applied only to the implementation",
-        overloadFinalNoImpl: "Only the first overload should be marked @final",
+        overloadFinalImpl: "dekorat\xE9r @final by se m\u011Bl pou\u017E\xEDvat jenom pro implementaci.",
+        overloadFinalNoImpl: "Pouze prvn\xED p\u0159et\xED\u017Een\xED by m\u011Blo b\xFDt ozna\u010Deno @final",
         overloadImplementationMismatch: "P\u0159et\xED\u017Een\xE1 implementace nen\xED konzistentn\xED se signaturou p\u0159et\xED\u017Een\xED {index}",
-        overloadOverrideImpl: "@override decorator should be applied only to the implementation",
-        overloadOverrideNoImpl: "Only the first overload should be marked @override",
+        overloadOverrideImpl: "dekorat\xE9r @override by se m\u011Bl pou\u017E\xEDvat jenom pro implementaci.",
+        overloadOverrideNoImpl: "Pouze prvn\xED p\u0159et\xED\u017Een\xED by m\u011Blo b\xFDt ozna\u010Deno @override",
         overloadReturnTypeMismatch: "P\u0159et\xED\u017Een\xED {prevIndex} pro {name} se p\u0159ekr\xFDv\xE1 s p\u0159et\xED\u017Een\xEDm {newIndex} a vrac\xED nekompatibiln\xED typ",
         overloadStaticMethodInconsistent: "P\u0159et\xED\u017Een\xED pro {name} pou\u017E\xEDvaj\xED @staticmethod nekonzistentn\u011B.",
         overloadWithoutImplementation: "\u201E{name}\u201C je ozna\u010Den\xE9 jako p\u0159et\xED\u017Een\xED (overload), ale nen\xED zadan\xE1 \u017E\xE1dn\xE1 implementace.",
@@ -16952,14 +16799,14 @@ var require_package_nls_cs = __commonJS({
         typedDictBadVar: "T\u0159\xEDdy TypedDict m\u016F\u017Eou obsahovat jenom pozn\xE1mky typu",
         typedDictBaseClass: "V\u0161echny z\xE1kladn\xED t\u0159\xEDdy pro t\u0159\xEDdy TypedDict mus\xED b\xFDt tak\xE9 t\u0159\xEDdami TypedDict",
         typedDictBoolParam: "O\u010Dek\xE1valo se, \u017Ee parametr {name} bude m\xEDt hodnotu True nebo False",
-        typedDictClosedExtras: "Z\xE1kladn\xED t\u0159\xEDda {name} je closed TypedDict; dal\u0161\xED polo\u017Eky mus\xED b\xFDt typu {type}.",
+        typedDictClosedExtras: 'Z\xE1kladn\xED "{name}" t\u0159\xEDdy je TypedDict, kter\xFD omezuje typ dal\u0161\xEDch polo\u017Eek na typ "{type}"',
         typedDictClosedNoExtras: "Z\xE1kladn\xED t\u0159\xEDda {name} je closed TypedDict; polo\u017Eky nav\xEDc nejsou povolen\xE9.",
         typedDictDelete: "Nepovedlo se odstranit polo\u017Eku v TypedDict",
         typedDictEmptyName: "N\xE1zvy v r\xE1mci TypedDict nem\u016F\u017Eou b\xFDt pr\xE1zdn\xE9",
         typedDictEntryName: "O\u010Dek\xE1val se \u0159et\u011Bzcov\xFD liter\xE1l pro n\xE1zev polo\u017Eky slovn\xEDku",
         typedDictEntryUnique: "N\xE1zvy ve slovn\xEDku mus\xED b\xFDt jedine\u010Dn\xE9",
         typedDictExtraArgs: "Nadbyte\u010Dn\xE9 argumenty TypedDict nejsou podporov\xE1ny",
-        typedDictExtraItemsClosed: "Objekt TypedDict nelze closed, pokud podporuje dal\u0161\xED polo\u017Eky.",
+        typedDictExtraItemsClosed: 'TypedDict m\u016F\u017Ee pou\u017E\xEDvat bu\u010F "closed", nebo "extra_items", ale ne oboj\xED.',
         typedDictFieldNotRequiredRedefinition: "Polo\u017Eka TypedDict {name} nejde p\u0159edefinovat jako NotRequired.",
         typedDictFieldReadOnlyRedefinition: "Polo\u017Eka TypedDict {name} nejde p\u0159edefinovat jako ReadOnly.",
         typedDictFieldRequiredRedefinition: "Polo\u017Eka TypedDict {name} nejde p\u0159edefinovat jako Required.",
@@ -17201,7 +17048,6 @@ var require_package_nls_cs = __commonJS({
         typedDictFieldRequired: "{name} se vy\u017Eaduje v {type}",
         typedDictFieldTypeMismatch: "Typ {type} se ned\xE1 p\u0159i\u0159adit k polo\u017Ece {name}",
         typedDictFieldUndefined: "{name} je nedefinovan\xE1 polo\u017Eka v typu {type}",
-        typedDictFinalMismatch: "{sourceType} nen\xED kompatibiln\xED s {destType} z d\u016Fvodu neshody @final",
         typedDictKeyAccess: 'Pou\u017E\xEDt ["{name}"] k odkazov\xE1n\xED na polo\u017Eku v TypedDict',
         typedDictNotAllowed: "TypedDict se ned\xE1 pou\u017E\xEDt pro kontroly instanc\xED nebo t\u0159\xEDd.",
         unhashableType: "Typ \u201E{type}\u201C nejde zat\u0159i\u010Fovat",
@@ -17573,6 +17419,7 @@ var require_package_nls_de = __commonJS({
         noneNotUsableWithAsync: "Das Objekt vom Typ \u201ENone\u201C kann nicht mit \u201Easync with\u201C verwendet werden.",
         noneOperator: 'Der Operator "{operator}" wird f\xFCr den "{None}" nicht unterst\xFCtzt.',
         noneUnknownMember: "\u201E{name}\u201C ist kein bekanntes Attribut von \u201ENone\u201C",
+        nonlocalTypeParam: "Die Bindung \u201ENonlocal\u201C ist f\xFCr den Typparameter \u201E{name}\u201C nicht zul\xE4ssig.",
         notRequiredArgCount: 'Nach "NotRequired" wurde ein einzelnes Typargument erwartet.',
         notRequiredNotInTypedDict: '"NotRequired" ist in diesem Kontext nicht zul\xE4ssig.',
         objectNotCallable: 'Das Objekt vom Typ "{type}" kann nicht aufgerufen werden.',
@@ -17591,11 +17438,11 @@ var require_package_nls_de = __commonJS({
         overloadAbstractImplMismatch: "\xDCberladungen m\xFCssen dem abstrakten Status der Implementierung entsprechen.",
         overloadAbstractMismatch: "\xDCberladungen m\xFCssen alle abstrakt sein oder nicht.",
         overloadClassMethodInconsistent: '\xDCberladungen f\xFCr "{name}" verwenden @classmethod inkonsistent',
-        overloadFinalImpl: "@final decorator should be applied only to the implementation",
-        overloadFinalNoImpl: "Only the first overload should be marked @final",
+        overloadFinalImpl: "@final Decorator sollte nur auf die Implementierung angewendet werden.",
+        overloadFinalNoImpl: "Nur die erste \xDCberladung sollte @final markiert werden.",
         overloadImplementationMismatch: "Die \xFCberladene Implementierung ist nicht konsistent mit der Signatur der \xDCberladung {index}",
-        overloadOverrideImpl: "@override decorator should be applied only to the implementation",
-        overloadOverrideNoImpl: "Only the first overload should be marked @override",
+        overloadOverrideImpl: "@override Decorator sollte nur auf die Implementierung angewendet werden.",
+        overloadOverrideNoImpl: "Nur die erste \xDCberladung sollte @override markiert werden.",
         overloadReturnTypeMismatch: '\xDCberladung {prevIndex} f\xFCr "{name}" \xFCberlappt {newIndex} und gibt einen inkompatiblen Typ zur\xFCck.',
         overloadStaticMethodInconsistent: '\xDCberladungen f\xFCr "{name}" verwenden @staticmethod inkonsistent',
         overloadWithoutImplementation: '"{name}" ist als overload markiert, es wurde jedoch keine Implementierung bereitgestellt.',
@@ -17791,14 +17638,14 @@ var require_package_nls_de = __commonJS({
         typedDictBadVar: "TypedDict-Klassen d\xFCrfen nur Typanmerkungen enthalten.",
         typedDictBaseClass: "Alle Basisklassen f\xFCr TypedDict-Klassen m\xFCssen auch TypedDict-Klassen sein.",
         typedDictBoolParam: 'Es wird erwartet, dass "{name}" Parameter den Wert "True" oder "False" aufweist.',
-        typedDictClosedExtras: "Die Basisklasse \u201E{name}\u201C ist ein closed TypedDict; zus\xE4tzliche Elemente m\xFCssen vom Typ \u201E{type}\u201C sein.",
+        typedDictClosedExtras: 'Die Basisklasse "{name}" ist eine TypedDict, die den Typ zus\xE4tzlicher Elemente auf den Typ "{type}" beschr\xE4nkt.',
         typedDictClosedNoExtras: "Die Basisklasse \u201E{name}\u201C ist ein closed TypedDict; zus\xE4tzliche Elemente sind nicht zul\xE4ssig.",
         typedDictDelete: "Das Element in TypedDict konnte nicht gel\xF6scht werden.",
         typedDictEmptyName: "Namen innerhalb eines TypedDict d\xFCrfen nicht leer sein.",
         typedDictEntryName: "F\xFCr den W\xF6rterbucheintragsnamen wurde ein Zeichenfolgenliteral erwartet.",
         typedDictEntryUnique: "Namen innerhalb eines W\xF6rterbuchs m\xFCssen eindeutig sein.",
         typedDictExtraArgs: "Zus\xE4tzliche TypedDict-Argumente werden nicht unterst\xFCtzt.",
-        typedDictExtraItemsClosed: "Ein TypedDict kann nicht auf closed (geschlossen) gesetzt werden, wenn es zus\xE4tzliche Elemente unterst\xFCtzt.",
+        typedDictExtraItemsClosed: 'TypedDict k\xF6nnen entweder "closed" oder "extra_items" verwenden, aber nicht beides.',
         typedDictFieldNotRequiredRedefinition: "Das TypedDict-Element \u201E{name}\u201C kann nicht als \u201ENotRequired\u201C neu definiert werden.",
         typedDictFieldReadOnlyRedefinition: "Das TypedDict-Element \u201E{name}\u201C kann nicht als \u201EReadOnly\u201C neu definiert werden.",
         typedDictFieldRequiredRedefinition: "Das TypedDict-Element \u201E{name}\u201C kann nicht als \u201ERequired\u201C neu definiert werden.",
@@ -18040,7 +17887,6 @@ var require_package_nls_de = __commonJS({
         typedDictFieldRequired: '"{name}" ist in "{type}" erforderlich.',
         typedDictFieldTypeMismatch: "Der Typ \u201E{type}\u201C kann dem Element \u201E{name}\u201C nicht zugewiesen werden.",
         typedDictFieldUndefined: "\u201E{name}\u201C ist ein nicht definiertes Element im Typ \u201E{type}\u201C.",
-        typedDictFinalMismatch: '"{sourceType}" ist aufgrund eines @final-Konflikts nicht mit "{destType}" kompatibel.',
         typedDictKeyAccess: '["{name}"] verwenden, um in TypedDict auf ein Element zu verweisen',
         typedDictNotAllowed: "TypedDict kann nicht f\xFCr Instanzen- oder Klassen\xFCberpr\xFCfungen verwendet werden.",
         unhashableType: 'Der Typ "{type}" kann nicht mit einem Hash erstellt werden.',
@@ -18168,6 +18014,10 @@ var require_package_nls_en_us = __commonJS({
         baseClassUnknown: "Base class type is unknown, obscuring type of derived class",
         baseClassVariableTypeIncompatible: 'Base classes for class "{classType}" define variable "{name}" in incompatible way',
         binaryOperationNotAllowed: "Binary operator not allowed in type expression",
+        bindParamMissing: {
+          message: 'Could not bind method "{methodName}" because it is missing a "self" or "cls" parameter',
+          comment: "Binding is the process through which Pyright determines what object a name refers to"
+        },
         bindTypeMismatch: {
           message: 'Could not bind method "{methodName}" because "{type}" is not assignable to parameter "{paramName}"',
           comment: "Binding is the process through which Pyright determines what object a name refers to"
@@ -18909,6 +18759,10 @@ var require_package_nls_en_us = __commonJS({
           message: '"{name}" was already declared nonlocal',
           comment: "{Locked='nonlocal'}"
         },
+        nonlocalTypeParam: {
+          message: 'Nonlocal binding is not allowed for type parameter "{name}"',
+          comment: ["{StrContains=i'nonlocal'}", "'nonlocal' is a keyword and should not be localized. It is only capitalized here because it is the first word in the sentence"]
+        },
         noneNotCallable: {
           message: 'Object of type "None" cannot be called',
           comment: "{Locked='None'}"
@@ -19327,6 +19181,7 @@ var require_package_nls_en_us = __commonJS({
           comment: "{Locked='type'}"
         },
         typeAliasStatementIllegal: "Type alias statement requires Python 3.12 or newer",
+        typeAliasTypeBadScope: "A type alias can be defined only within a module or class scope",
         typeAliasTypeBaseClass: {
           message: 'A type alias defined in a "type" statement cannot be used as a base class',
           comment: `{Locked='"type"'}`
@@ -19537,7 +19392,7 @@ var require_package_nls_en_us = __commonJS({
           comment: "{Locked='True','False'}"
         },
         typedDictClosedExtras: {
-          message: 'Base class "{name}" is a closed TypedDict; extra items must be type "{type}"',
+          message: 'Base class "{name}" is a TypedDict that limits the type of extra items to type "{type}"',
           comment: "{Locked='closed','TypedDict'}"
         },
         typedDictClosedNoExtras: {
@@ -19559,8 +19414,8 @@ var require_package_nls_en_us = __commonJS({
           comment: "{Locked='TypedDict'}"
         },
         typedDictExtraItemsClosed: {
-          message: "A TypedDict cannot be closed if it supports extra items",
-          comment: "{Locked='TypedDict','closed'}"
+          message: 'TypedDict can use either "closed" or "extra_items" but not both',
+          comment: "{Locked='TypedDict','closed','extra_items'}"
         },
         typedDictFieldNotRequiredRedefinition: {
           message: 'TypedDict item "{name}" cannot be redefined as NotRequired',
@@ -20130,10 +19985,6 @@ var require_package_nls_en_us = __commonJS({
         typedDictFieldRequired: '"{name}" is required in "{type}"',
         typedDictFieldTypeMismatch: 'Type "{type}" is not assignable to item "{name}"',
         typedDictFieldUndefined: '"{name}" is an undefined item in type "{type}"',
-        typedDictFinalMismatch: {
-          message: '"{sourceType}" is incompatible with "{destType}" because of a @final mismatch',
-          comment: "{Locked='@final'}"
-        },
         typedDictKeyAccess: {
           message: 'Use ["{name}"] to reference item in TypedDict',
           comment: "{Locked='TypedDict'}"
@@ -20523,6 +20374,7 @@ var require_package_nls_es = __commonJS({
         noneNotUsableWithAsync: 'El objeto de tipo "None" no se puede usar con "async with"',
         noneOperator: 'El operador "{operator}" no es compatible con "None".',
         noneUnknownMember: '"{name}" no es un atributo conocido de "None"',
+        nonlocalTypeParam: 'No se permite el enlace nonlocal para el par\xE1metro de tipo "{name}"',
         notRequiredArgCount: 'Se esperaba un \xFAnico argumento de tipo despu\xE9s de "NotRequired".',
         notRequiredNotInTypedDict: '"NotRequired" no est\xE1 permitido en este contexto',
         objectNotCallable: 'El objeto de tipo "{type}" no es invocable',
@@ -20541,11 +20393,11 @@ var require_package_nls_es = __commonJS({
         overloadAbstractImplMismatch: "Las sobrecargas deben coincidir con el estado abstracto de la implementaci\xF3n",
         overloadAbstractMismatch: "Todos los m\xE9todos sobrecargados deben ser abstractos o no",
         overloadClassMethodInconsistent: 'Las sobrecargas de "{name}" usan @classmethod de forma incoherente',
-        overloadFinalImpl: "@final decorator should be applied only to the implementation",
-        overloadFinalNoImpl: "Only the first overload should be marked @final",
+        overloadFinalImpl: "@final elemento Decorator solo se debe aplicar a la implementaci\xF3n.",
+        overloadFinalNoImpl: "Solo la primera sobrecarga debe marcarse @final",
         overloadImplementationMismatch: "La implementaci\xF3n de la sobrecarga no es consistente con la firma de la sobrecarga {index}",
-        overloadOverrideImpl: "@override decorator should be applied only to the implementation",
-        overloadOverrideNoImpl: "Only the first overload should be marked @override",
+        overloadOverrideImpl: "@override elemento Decorator solo se debe aplicar a la implementaci\xF3n.",
+        overloadOverrideNoImpl: "Solo la primera sobrecarga debe marcarse @override",
         overloadReturnTypeMismatch: 'La sobrecarga {prevIndex} para " {name}" se superpone con la sobrecarga {newIndex} y devuelve un tipo incompatible',
         overloadStaticMethodInconsistent: 'Las sobrecargas de "{name}" usan @staticmethod de forma incoherente',
         overloadWithoutImplementation: '"{name}" est\xE1 marcado como overload, pero no se proporciona ninguna implementaci\xF3n.',
@@ -20741,14 +20593,14 @@ var require_package_nls_es = __commonJS({
         typedDictBadVar: "Las clases TypedDict solo pueden contener anotaciones de tipo",
         typedDictBaseClass: "Todas las clases base de las clases TypedDict deben ser tambi\xE9n clases TypedDict",
         typedDictBoolParam: 'Se esperaba que el par\xE1metro "{name}" tuviera un valor de True o False.',
-        typedDictClosedExtras: 'La clase base "{name}" es un TypedDict closed; los elementos adicionales deben ser de tipo "{type}"',
+        typedDictClosedExtras: 'El "{name}" de clase base es un TypedDict que limita el tipo de elementos adicionales al tipo "{type}"',
         typedDictClosedNoExtras: 'La clase base "{name}" es un TypedDict closed; no se permiten elementos adicionales',
         typedDictDelete: "No se puede eliminar un elemento en TypedDict",
         typedDictEmptyName: "Los nombres de un TypedDict no pueden estar vac\xEDos",
         typedDictEntryName: "Cadena literal esperada para el nombre de la entrada del diccionario",
         typedDictEntryUnique: "Los nombres dentro de un diccionario deben ser \xFAnicos",
         typedDictExtraArgs: "No se admiten argumentos TypedDict adicionales",
-        typedDictExtraItemsClosed: "Un TypedDict no puede tener el estado closed si admite elementos adicionales",
+        typedDictExtraItemsClosed: 'TypedDict puede usar "closed" o "extra_items", pero no ambos',
         typedDictFieldNotRequiredRedefinition: 'El elemento TypedDict "{name}" no se puede redefinir como NotRequired',
         typedDictFieldReadOnlyRedefinition: 'El elemento TypedDict "{name}" no se puede redefinir como ReadOnly',
         typedDictFieldRequiredRedefinition: 'El elemento TypedDict "{name}" no se puede redefinir como Required',
@@ -20990,7 +20842,6 @@ var require_package_nls_es = __commonJS({
         typedDictFieldRequired: '"{name}" es obligatorio en "{type}"',
         typedDictFieldTypeMismatch: 'El tipo "{type}" no se puede asignar al elemento "{name}"',
         typedDictFieldUndefined: '"{name}" es un elemento no definido en el tipo "{type}"',
-        typedDictFinalMismatch: '"{sourceType}" no es compatible con "{destType}" debido a una discrepancia @final',
         typedDictKeyAccess: 'Utilizar ["{name}"] para hacer referencia al elemento en TypedDict',
         typedDictNotAllowed: "No se puede usar TypedDict para comprobaciones de instancia o clase",
         unhashableType: 'El tipo "{type}" no admite hash',
@@ -21362,6 +21213,7 @@ var require_package_nls_fr = __commonJS({
         noneNotUsableWithAsync: "L\u2019objet de type \xAB\xA0None\xA0\xBB ne peut pas \xEAtre utilis\xE9 avec \xAB\xA0async with\xA0\xBB",
         noneOperator: "L\u2019op\xE9rateur \xAB\xA0{operator}\xA0\xBB n\u2019est pas pris en charge pour \xAB\xA0None\xA0\xBB",
         noneUnknownMember: "\xAB\xA0{name}\xA0\xBB n\u2019est pas un attribut connu de \xAB\xA0None\xA0\xBB",
+        nonlocalTypeParam: 'La liaison nonlocale n\u2019est pas autoris\xE9e pour le param\xE8tre de type "{name}"',
         notRequiredArgCount: "Argument de type unique attendu apr\xE8s \xAB NotRequired \xBB",
         notRequiredNotInTypedDict: "\xAB NotRequired \xBB n\u2019est pas autoris\xE9 dans ce contexte",
         objectNotCallable: "L\u2019objet de type \xAB\xA0{type}\xA0\xBB n\u2019est pas appelant",
@@ -21380,11 +21232,11 @@ var require_package_nls_fr = __commonJS({
         overloadAbstractImplMismatch: "Les surcharges doivent correspondre \xE0 l\u2019\xE9tat abstrait de l\u2019impl\xE9mentation",
         overloadAbstractMismatch: "Les surcharges doivent toutes \xEAtre abstraites ou non",
         overloadClassMethodInconsistent: "Les surcharges pour \xAB {name} \xBB utilisent @classmethod de mani\xE8re incoh\xE9rente",
-        overloadFinalImpl: "@final decorator should be applied only to the implementation",
-        overloadFinalNoImpl: "Only the first overload should be marked @final",
+        overloadFinalImpl: "@final decorator ne doit \xEAtre appliqu\xE9 qu\u2019\xE0 l\u2019impl\xE9mentation",
+        overloadFinalNoImpl: "Seule la premi\xE8re surcharge doit \xEAtre marqu\xE9e @final",
         overloadImplementationMismatch: "L\u2019impl\xE9mentation surcharg\xE9e n\u2019est pas coh\xE9rente avec la signature de la surcharge {index}",
-        overloadOverrideImpl: "@override decorator should be applied only to the implementation",
-        overloadOverrideNoImpl: "Only the first overload should be marked @override",
+        overloadOverrideImpl: "@override decorator ne doit \xEAtre appliqu\xE9 qu\u2019\xE0 l\u2019impl\xE9mentation",
+        overloadOverrideNoImpl: "Seule la premi\xE8re surcharge doit \xEAtre marqu\xE9e @override",
         overloadReturnTypeMismatch: "La surcharge {prevIndex} pour \xAB\xA0{name}\xA0\xBB chevauche la surcharge {newIndex} et retourne un type incompatible",
         overloadStaticMethodInconsistent: "Les surcharges pour \xAB {name} \xBB utilisent @staticmethod de mani\xE8re incoh\xE9rente",
         overloadWithoutImplementation: "\xAB\xA0{name}\xA0\xBB est marqu\xE9 comme overload, mais aucune impl\xE9mentation n\u2019est fournie",
@@ -21580,14 +21432,14 @@ var require_package_nls_fr = __commonJS({
         typedDictBadVar: "Les classes TypedDict ne peuvent contenir que des annotations de type",
         typedDictBaseClass: "Toutes les classes de base pour les classes TypedDict doivent \xE9galement \xEAtre des classes TypedDict",
         typedDictBoolParam: "Param\xE8tre \xAB\xA0{name}\xA0\xBB attendu avec la valeur True ou False",
-        typedDictClosedExtras: "La classe de base \xAB\xA0{name}\xA0\xBB est un TypedDict closed, les \xE9l\xE9ments suppl\xE9mentaires doivent \xEAtre de type \xAB\xA0{type}\xA0\xBB",
+        typedDictClosedExtras: 'Le "{name}" de classe de base est un TypedDict qui limite le type d\u2019\xE9l\xE9ments suppl\xE9mentaires au type "{type}"',
         typedDictClosedNoExtras: "La classe de base \xAB\xA0{name}\xA0\xBB est un TypedDict closed, les \xE9l\xE9ments suppl\xE9mentaires ne sont pas autoris\xE9s",
         typedDictDelete: "Impossible de supprimer l\u2019\xE9l\xE9ment dans TypedDict",
         typedDictEmptyName: "Les noms dans un TypedDict ne peuvent pas \xEAtre vides",
         typedDictEntryName: "Litt\xE9ral de cha\xEEne attendu pour le nom d\u2019entr\xE9e du dictionnaire",
         typedDictEntryUnique: "Les noms dans un dictionnaire doivent \xEAtre uniques",
         typedDictExtraArgs: "Arguments TypedDict suppl\xE9mentaires non pris en charge",
-        typedDictExtraItemsClosed: "Un TypedDict ne peut pas \xEAtre closed s\u2019il prend en charge les \xE9l\xE9ments suppl\xE9mentaires",
+        typedDictExtraItemsClosed: 'TypedDict pouvez utiliser "closed" ou "extra_items", mais pas les deux',
         typedDictFieldNotRequiredRedefinition: "L\u2019\xE9l\xE9ment TypedDict \xAB\xA0{name}\xA0\xBB ne peut pas \xEAtre red\xE9fini comme \xE9tant NotRequired",
         typedDictFieldReadOnlyRedefinition: "L\u2019\xE9l\xE9ment TypedDict \xAB\xA0{name}\xA0\xBB ne peut pas \xEAtre red\xE9fini comme \xE9tat En ReadOnly",
         typedDictFieldRequiredRedefinition: "L\u2019\xE9l\xE9ment TypedDict \xAB\xA0{name}\xA0\xBB ne peut pas \xEAtre red\xE9fini comme \xE9tant Required",
@@ -21829,7 +21681,6 @@ var require_package_nls_fr = __commonJS({
         typedDictFieldRequired: "\xAB\xA0{name}\xA0\xBB est obligatoire dans \xAB\xA0{type}\xA0\xBB",
         typedDictFieldTypeMismatch: "Le type \xAB\xA0{type}\xA0\xBB n'est pas attribuable \xE0 l\u2019\xE9l\xE9ment \xAB\xA0{name}\xA0\xBB",
         typedDictFieldUndefined: "\xAB\xA0{name}\xA0\xBB est un \xE9l\xE9ment non d\xE9fini dans le type \xAB\xA0{type}\xA0\xBB",
-        typedDictFinalMismatch: "\xAB {sourceType} \xBB n\u2019est pas compatible avec \xAB {destType} \xBB en raison d\u2019une incompatibilit\xE9 de @final",
         typedDictKeyAccess: "Utilisez [\xAB {name} \xBB] pour r\xE9f\xE9rencer l\u2019\xE9l\xE9ment dans TypedDict",
         typedDictNotAllowed: "TypedDict ne peut pas \xEAtre utilis\xE9 pour les v\xE9rifications d\u2019instance ou de classe",
         unhashableType: `Le type "{type}" n'est pas hachable`,
@@ -22201,6 +22052,7 @@ var require_package_nls_it = __commonJS({
         noneNotUsableWithAsync: `Impossibile utilizzare l'oggetto di tipo "None" con "async with"`,
         noneOperator: 'Operatore "{operator}" non supportato per "None"',
         noneUnknownMember: '"{name}" non \xE8 un attributo noto di "None"',
+        nonlocalTypeParam: `Non \xE8 consentita l'associazione nonlocal per il parametro di tipo "{name}"`,
         notRequiredArgCount: 'Previsto un singolo argomento tipo dopo "NotRequired"',
         notRequiredNotInTypedDict: '"NotRequired" non \xE8 consentito in questo contesto',
         objectNotCallable: `L'oggetto di tipo "{type}" non \xE8 chiamabile`,
@@ -22219,11 +22071,11 @@ var require_package_nls_it = __commonJS({
         overloadAbstractImplMismatch: "Gli overload devono corrispondere allo stato astratto dell'implementazione",
         overloadAbstractMismatch: "Gli overload devono essere tutti astratti o no",
         overloadClassMethodInconsistent: 'Gli overload per "{name}" usano @classmethod in modo incoerente',
-        overloadFinalImpl: "@final decorator should be applied only to the implementation",
-        overloadFinalNoImpl: "Only the first overload should be marked @final",
+        overloadFinalImpl: "@final'elemento Decorator deve essere applicato solo all'implementazione",
+        overloadFinalNoImpl: "Solo il primo overload deve essere contrassegnato @final",
         overloadImplementationMismatch: "L'implementazione di overload non \xE8 coerente con la firma dell'overload {index}",
-        overloadOverrideImpl: "@override decorator should be applied only to the implementation",
-        overloadOverrideNoImpl: "Only the first overload should be marked @override",
+        overloadOverrideImpl: "@override'elemento Decorator deve essere applicato solo all'implementazione",
+        overloadOverrideNoImpl: "Solo il primo overload deve essere contrassegnato @override",
         overloadReturnTypeMismatch: `L'overload {prevIndex} per "{name}" si sovrappone all'overload {newIndex} e restituisce un tipo incompatibile`,
         overloadStaticMethodInconsistent: 'Gli overload per "{name}" usano @staticmethod in modo incoerente',
         overloadWithoutImplementation: '"{name}" \xE8 contrassegnato come overload, ma non viene fornita alcuna implementazione',
@@ -22419,14 +22271,14 @@ var require_package_nls_it = __commonJS({
         typedDictBadVar: "Le classi TypedDict possono contenere solo annotazioni di tipo",
         typedDictBaseClass: "Anche tutte le classi di base per le classi TypedDict devono essere classi TypedDict",
         typedDictBoolParam: '\xC8 previsto che il parametro "{name}" abbia il valore True o False',
-        typedDictClosedExtras: 'La classe di base "{name}" \xE8 un TypedDict closed; gli elementi aggiuntivi devono essere di tipo "{type}"',
+        typedDictClosedExtras: 'La classe di base "{name}" \xE8 una TypedDict che limita il tipo di elementi aggiuntivi al tipo "{type}"',
         typedDictClosedNoExtras: 'La classe di base "{name}" \xE8 un TypedDict closed; elementi aggiuntivi non consentiti',
         typedDictDelete: "Non \xE8 stato possibile eliminare l'elemento in TypedDict",
         typedDictEmptyName: "I nomi all'interno di un TypedDict non possono essere vuoti",
         typedDictEntryName: "Valore letterale stringa previsto per il nome della voce del dizionario",
         typedDictEntryUnique: "I nomi all'interno di un dizionario devono essere univoci",
         typedDictExtraArgs: "Argomenti TypedDict aggiuntivi non supportati",
-        typedDictExtraItemsClosed: "TypedDict non pu\xF2 avere il valore \u201Cclosed\u201D se supporta elementi aggiuntivi",
+        typedDictExtraItemsClosed: 'TypedDict possono utilizzare "closed" o "extra_items" ma non entrambi',
         typedDictFieldNotRequiredRedefinition: 'Non \xE8 possibile ridefinire il campo TypedDict "{name}" come NotRequired',
         typedDictFieldReadOnlyRedefinition: 'Non \xE8 possibile ridefinire l\u2019elemento TypedDict "{name}" come ReadOnly',
         typedDictFieldRequiredRedefinition: 'Non \xE8 possibile ridefinire il campo TypedDict "{name}" come Required',
@@ -22668,7 +22520,6 @@ var require_package_nls_it = __commonJS({
         typedDictFieldRequired: '"{name}" \xE8 obbligatorio in "{type}"',
         typedDictFieldTypeMismatch: 'Il tipo "{type}" non pu\xF2 essere assegnato all\u2019elemento "{name}"',
         typedDictFieldUndefined: '"{name}" \xE8 un elemento non definito nel tipo "{type}"',
-        typedDictFinalMismatch: '"{sourceType}" non \xE8 compatibile con "{destType}" a causa di una @final mancata corrispondenza',
         typedDictKeyAccess: `Usare ["{name}"] per fare riferimento all'elemento in TypedDict`,
         typedDictNotAllowed: "Non \xE8 possibile usare TypedDict per i controlli di istanze o classi",
         unhashableType: 'Il tipo "{type}" non \xE8 hashable',
@@ -23040,6 +22891,7 @@ var require_package_nls_ja = __commonJS({
         noneNotUsableWithAsync: '\u578B "None" \u3068 "async with" \u306F\u540C\u6642\u306B\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093',
         noneOperator: '\u6F14\u7B97\u5B50 "{operator}" \u306F "None" \u3067\u306F\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093',
         noneUnknownMember: '"{name}" \u306F "None" \u306E\u65E2\u77E5\u306E\u5C5E\u6027\u3067\u306F\u3042\u308A\u307E\u305B\u3093',
+        nonlocalTypeParam: '\u578B\u30D1\u30E9\u30E1\u30FC\u30BF\u30FC "{name}" \u306B nonlocal \u30D0\u30A4\u30F3\u30C9\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093',
         notRequiredArgCount: '"NotRequired" \u306E\u5F8C\u306B 1 \u3064\u306E\u578B\u5F15\u6570\u304C\u5FC5\u8981\u3067\u3059',
         notRequiredNotInTypedDict: '"NotRequired" \u306F\u3053\u306E\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u3067\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093',
         objectNotCallable: '\u578B "{type}" \u306E\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u306F\u547C\u3073\u51FA\u3057\u53EF\u80FD\u3067\u306F\u3042\u308A\u307E\u305B\u3093',
@@ -23058,11 +22910,11 @@ var require_package_nls_ja = __commonJS({
         overloadAbstractImplMismatch: "\u30AA\u30FC\u30D0\u30FC\u30ED\u30FC\u30C9\u306F\u5B9F\u88C5\u306E\u62BD\u8C61\u72B6\u614B\u3068\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
         overloadAbstractMismatch: "\u30AA\u30FC\u30D0\u30FC\u30ED\u30FC\u30C9\u306F\u3059\u3079\u3066\u62BD\u8C61\u3067\u3042\u308B\u304B\u62BD\u8C61\u3067\u306A\u3044\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
         overloadClassMethodInconsistent: '"{name}" \u306E\u30AA\u30FC\u30D0\u30FC\u30ED\u30FC\u30C9\u3067\u306F\u3001@classmethod \u3092\u4E0D\u6574\u5408\u306B\u4F7F\u7528\u3057\u307E\u3059',
-        overloadFinalImpl: "@final decorator should be applied only to the implementation",
-        overloadFinalNoImpl: "Only the first overload should be marked @final",
+        overloadFinalImpl: "@final \u30C7\u30B3\u30EC\u30FC\u30BF\u30FC\u306F\u5B9F\u88C5\u306B\u306E\u307F\u9069\u7528\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+        overloadFinalNoImpl: "\u6700\u521D\u306E\u30AA\u30FC\u30D0\u30FC\u30ED\u30FC\u30C9\u306E\u307F\u3092 @final \u306B\u8A2D\u5B9A\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
         overloadImplementationMismatch: "\u30AA\u30FC\u30D0\u30FC\u30ED\u30FC\u30C9\u3055\u308C\u305F\u5B9F\u88C5\u304C\u30AA\u30FC\u30D0\u30FC\u30ED\u30FC\u30C9 {index} \u306E\u30B7\u30B0\u30CD\u30C1\u30E3\u3068\u4E00\u81F4\u3057\u307E\u305B\u3093",
-        overloadOverrideImpl: "@override decorator should be applied only to the implementation",
-        overloadOverrideNoImpl: "Only the first overload should be marked @override",
+        overloadOverrideImpl: "@override \u30C7\u30B3\u30EC\u30FC\u30BF\u30FC\u306F\u5B9F\u88C5\u306B\u306E\u307F\u9069\u7528\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+        overloadOverrideNoImpl: "\u6700\u521D\u306E\u30AA\u30FC\u30D0\u30FC\u30ED\u30FC\u30C9\u306E\u307F\u3092 @override \u306B\u8A2D\u5B9A\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
         overloadReturnTypeMismatch: '"{name}" \u306E\u30AA\u30FC\u30D0\u30FC\u30ED\u30FC\u30C9 {prevIndex} \u306F\u30AA\u30FC\u30D0\u30FC\u30ED\u30FC\u30C9 {newIndex} \u3068\u91CD\u8907\u3057\u3001\u4E92\u63DB\u6027\u306E\u306A\u3044\u578B\u3092\u8FD4\u3057\u307E\u3059',
         overloadStaticMethodInconsistent: '"{name}" \u306E\u30AA\u30FC\u30D0\u30FC\u30ED\u30FC\u30C9\u3067\u306F\u3001@staticmethod \u3092\u4E0D\u6574\u5408\u306B\u4F7F\u7528\u3057\u307E\u3059',
         overloadWithoutImplementation: '"{name}" \u306F overload \u3068\u3057\u3066\u30DE\u30FC\u30AF\u3055\u308C\u3066\u3044\u307E\u3059\u304C\u3001\u5B9F\u88C5\u304C\u63D0\u4F9B\u3055\u308C\u3066\u3044\u307E\u305B\u3093',
@@ -23258,14 +23110,14 @@ var require_package_nls_ja = __commonJS({
         typedDictBadVar: "TypedDict \u30AF\u30E9\u30B9\u306B\u306F\u578B\u6CE8\u91C8\u306E\u307F\u3092\u542B\u3081\u308B\u3053\u3068\u304C\u3067\u304D\u307E\u3059",
         typedDictBaseClass: "TypedDict \u30AF\u30E9\u30B9\u306E\u3059\u3079\u3066\u306E\u57FA\u5E95\u30AF\u30E9\u30B9\u3082 TypedDict \u30AF\u30E9\u30B9\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
         typedDictBoolParam: '"{name}" \u30D1\u30E9\u30E1\u30FC\u30BF\u30FC\u306E\u5024\u306F True \u307E\u305F\u306F False \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',
-        typedDictClosedExtras: '\u57FA\u5E95\u30AF\u30E9\u30B9 "{name}" \u306F closed \u3057\u305F TypedDict \u3067\u3059\u3002\u8FFD\u52A0\u306E\u9805\u76EE\u306F\u578B "{type}" \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059',
+        typedDictClosedExtras: '\u57FA\u5E95\u30AF\u30E9\u30B9 "{name}" \u306F\u3001\u4F59\u5206\u306A\u9805\u76EE\u306E\u578B\u3092\u578B "{type}" \u306B\u5236\u9650\u3059\u308B TypedDict \u3067\u3059',
         typedDictClosedNoExtras: '\u57FA\u5E95\u30AF\u30E9\u30B9 "{name}" \u306F closed \u3057\u305F TypedDict \u3067\u3059\u3002\u8FFD\u52A0\u306E\u9805\u76EE\u306F\u8A31\u53EF\u3055\u308C\u3066\u3044\u307E\u305B\u3093',
         typedDictDelete: "TypedDict \u306E\u9805\u76EE\u3092\u524A\u9664\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F",
         typedDictEmptyName: "TypedDict \u5185\u306E\u540D\u524D\u3092\u7A7A\u306B\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093",
         typedDictEntryName: "\u8F9E\u66F8\u30A8\u30F3\u30C8\u30EA\u540D\u306B\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u304C\u5FC5\u8981\u3067\u3059",
         typedDictEntryUnique: "\u30C7\u30A3\u30AF\u30B7\u30E7\u30CA\u30EA\u5185\u306E\u540D\u524D\u306F\u4E00\u610F\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
         typedDictExtraArgs: "\u8FFD\u52A0\u306E TypedDict \u5F15\u6570\u306F\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093",
-        typedDictExtraItemsClosed: "\u8FFD\u52A0\u306E\u9805\u76EE\u304C\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u308B\u5834\u5408\u3001TypedDict \u3092 closed \u306B\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093",
+        typedDictExtraItemsClosed: 'TypedDict \u306F "closed" \u307E\u305F\u306F "extra_items" \u3092\u4F7F\u7528\u3067\u304D\u307E\u3059\u304C\u3001\u4E21\u65B9\u3092\u4F7F\u7528\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',
         typedDictFieldNotRequiredRedefinition: 'TypedDict \u30A2\u30A4\u30C6\u30E0 "{name}" \u3092 NotRequired \u3068\u3057\u3066\u518D\u5B9A\u7FA9\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',
         typedDictFieldReadOnlyRedefinition: 'TypedDict \u30A2\u30A4\u30C6\u30E0 "{name}" \u3092 ReadOnly \u3068\u3057\u3066\u518D\u5B9A\u7FA9\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',
         typedDictFieldRequiredRedefinition: 'TypedDict \u30A2\u30A4\u30C6\u30E0 "{name}" \u3092 Required \u3068\u3057\u3066\u518D\u5B9A\u7FA9\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093',
@@ -23507,7 +23359,6 @@ var require_package_nls_ja = __commonJS({
         typedDictFieldRequired: '"{name}" \u306F "{type}" \u306B\u5FC5\u8981\u3067\u3059',
         typedDictFieldTypeMismatch: '\u578B "{type}" \u306F\u3001\u30A2\u30A4\u30C6\u30E0 "{name}" \u306B\u5272\u308A\u5F53\u3066\u3067\u304D\u307E\u305B\u3093',
         typedDictFieldUndefined: '"{name}" \u306F\u578B "{type}" \u306E\u672A\u5B9A\u7FA9\u306E\u30A2\u30A4\u30C6\u30E0\u3067\u3059',
-        typedDictFinalMismatch: '@final \u304C\u4E00\u81F4\u3057\u306A\u3044\u305F\u3081\u3001"{sourceType}" \u306F "{destType}" \u3068\u4E92\u63DB\u6027\u304C\u3042\u308A\u307E\u305B\u3093',
         typedDictKeyAccess: '["{name}"] \u3092\u4F7F\u7528\u3057\u3066 TypedDict \u306E\u9805\u76EE\u3092\u53C2\u7167\u3059\u308B',
         typedDictNotAllowed: "TypedDict \u306F\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u307E\u305F\u306F\u30AF\u30E9\u30B9\u306E\u30C1\u30A7\u30C3\u30AF\u306B\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093",
         unhashableType: '\u578B "{type}" \u306F\u30CF\u30C3\u30B7\u30E5\u53EF\u80FD\u3067\u306F\u3042\u308A\u307E\u305B\u3093',
@@ -23879,6 +23730,7 @@ var require_package_nls_ko = __commonJS({
         noneNotUsableWithAsync: '"None" \uD615\uC2DD\uC758 \uAC1C\uCCB4\uB294 "async with"\uC640 \uD568\uAED8 \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
         noneOperator: '"None"\uC5D0 \uB300\uD574 \uC5F0\uC0B0\uC790 "{operator}"\uC774(\uAC00) \uC9C0\uC6D0\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.',
         noneUnknownMember: '"{name}"\uC740(\uB294) "None"\uC758 \uC54C\uB824\uC9C4 \uD2B9\uC131\uC774 \uC544\uB2D8',
+        nonlocalTypeParam: 'Nonlocal \uBC14\uC778\uB529\uC740 \uD615\uC2DD \uB9E4\uAC1C\uBCC0\uC218 "{name}"\uC5D0 \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
         notRequiredArgCount: '"NotRequired" \uB4A4\uC5D0 \uB2E8\uC77C \uD615\uC2DD \uC778\uC218\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.',
         notRequiredNotInTypedDict: '\uC774 \uCEE8\uD14D\uC2A4\uD2B8\uC5D0\uC11C\uB294 "NotRequired"\uB97C \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
         objectNotCallable: '"{type}" \uD615\uC2DD\uC758 \uAC1C\uCCB4\uB97C \uD638\uCD9C\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
@@ -23897,11 +23749,11 @@ var require_package_nls_ko = __commonJS({
         overloadAbstractImplMismatch: "\uC624\uBC84\uB85C\uB4DC\uB294 \uAD6C\uD604\uC758 \uCD94\uC0C1 \uC0C1\uD0DC\uC640 \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4.",
         overloadAbstractMismatch: "\uC624\uBC84\uB85C\uB4DC\uB294 \uBAA8\uB450 \uCD94\uC0C1\uC774\uAC70\uB098 \uC544\uB2C8\uC5B4\uC57C \uD569\uB2C8\uB2E4",
         overloadClassMethodInconsistent: '"{name}"\uC758 \uC624\uBC84\uB85C\uB4DC\uAC00 @classmethod\uB97C \uC77C\uAD00\uB418\uC9C0 \uC54A\uAC8C \uC0AC\uC6A9\uD569\uB2C8\uB2E4.',
-        overloadFinalImpl: "@final decorator should be applied only to the implementation",
-        overloadFinalNoImpl: "Only the first overload should be marked @final",
+        overloadFinalImpl: "@final \uB370\uCF54\uB808\uC774\uD130\uB294 \uAD6C\uD604\uC5D0\uB9CC \uC801\uC6A9\uD574\uC57C \uD569\uB2C8\uB2E4.",
+        overloadFinalNoImpl: "\uCCAB \uBC88\uC9F8 \uC624\uBC84\uB85C\uB4DC\uB9CC @final \uD45C\uC2DC\uD574\uC57C \uD569\uB2C8\uB2E4.",
         overloadImplementationMismatch: "\uC624\uBC84\uB85C\uB4DC\uB41C \uAD6C\uD604\uC774 \uC624\uBC84\uB85C\uB4DC {index}\uC758 \uC2DC\uADF8\uB2C8\uCC98\uC640 \uC77C\uCE58\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.",
-        overloadOverrideImpl: "@override decorator should be applied only to the implementation",
-        overloadOverrideNoImpl: "Only the first overload should be marked @override",
+        overloadOverrideImpl: "@override \uB370\uCF54\uB808\uC774\uD130\uB294 \uAD6C\uD604\uC5D0\uB9CC \uC801\uC6A9\uD574\uC57C \uD569\uB2C8\uB2E4.",
+        overloadOverrideNoImpl: "\uCCAB \uBC88\uC9F8 \uC624\uBC84\uB85C\uB4DC\uB9CC @override \uD45C\uC2DC\uD574\uC57C \uD569\uB2C8\uB2E4.",
         overloadReturnTypeMismatch: '"{name}"\uC5D0 \uB300\uD55C {prevIndex} \uC624\uBC84\uB85C\uB4DC\uAC00 \uC624\uBC84\uB85C\uB4DC {newIndex}\uACFC(\uC640) \uACB9\uCE58\uACE0 \uD638\uD658\uB418\uC9C0 \uC54A\uB294 \uD615\uC2DD\uC744 \uBC18\uD658\uD569\uB2C8\uB2E4.',
         overloadStaticMethodInconsistent: '"{name}"\uC758 \uC624\uBC84\uB85C\uB4DC\uAC00 @staticmethod\uB97C \uC77C\uAD00\uB418\uC9C0 \uC54A\uAC8C \uC0AC\uC6A9\uD569\uB2C8\uB2E4.',
         overloadWithoutImplementation: "\u201C{name}\u201C\uC774(\uAC00) overload\uB85C \uD45C\uC2DC\uB418\uC5B4 \uC788\uC9C0\uB9CC \uAD6C\uD604\uC774 \uC81C\uACF5\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.",
@@ -24097,14 +23949,14 @@ var require_package_nls_ko = __commonJS({
         typedDictBadVar: "TypedDict \uD074\uB798\uC2A4\uB294 \uD615\uC2DD \uC8FC\uC11D\uB9CC \uD3EC\uD568\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.",
         typedDictBaseClass: "TypedDict \uD074\uB798\uC2A4\uC758 \uBAA8\uB4E0 \uAE30\uBCF8 \uD074\uB798\uC2A4\uB3C4 TypedDict \uD074\uB798\uC2A4\uC5EC\uC57C \uD569\uB2C8\uB2E4.",
         typedDictBoolParam: '"{name}" \uB9E4\uAC1C \uBCC0\uC218\uC5D0 True \uB610\uB294 False \uAC12\uC774 \uC788\uC5B4\uC57C \uD569\uB2C8\uB2E4.',
-        typedDictClosedExtras: '\uAE30\uBCF8 \uD074\uB798\uC2A4 "{name}"\uC740(\uB294) closed TypedDict\uC785\uB2C8\uB2E4. \uCD94\uAC00 \uD56D\uBAA9\uC740 "{type}" \uD615\uC2DD\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.',
+        typedDictClosedExtras: '\uAE30\uBCF8 \uD074\uB798\uC2A4 "{name}" \uCD94\uAC00 \uD56D\uBAA9\uC758 \uC720\uD615\uC744 "{type}" \uD615\uC2DD\uC73C\uB85C \uC81C\uD55C\uD558\uB294 TypedDict.',
         typedDictClosedNoExtras: '\uAE30\uBCF8 \uD074\uB798\uC2A4 "{name}"\uC740(\uB294) closed TypedDict\uC785\uB2C8\uB2E4. \uCD94\uAC00 \uD56D\uBAA9\uC740 \uD5C8\uC6A9\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.',
         typedDictDelete: "TypedDict\uC5D0\uC11C \uD56D\uBAA9\uC744 \uC0AD\uC81C\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
         typedDictEmptyName: "TypedDict \uB0B4\uC758 \uC774\uB984\uC740 \uBE44\uC6CC \uB458 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
         typedDictEntryName: "\uC0AC\uC804 \uD56D\uBAA9 \uC774\uB984\uC5D0 \uD544\uC694\uD55C \uBB38\uC790\uC5F4 \uB9AC\uD130\uB7F4",
         typedDictEntryUnique: "\uC0AC\uC804 \uB0B4\uC758 \uC774\uB984\uC740 \uACE0\uC720\uD574\uC57C \uD569\uB2C8\uB2E4.",
         typedDictExtraArgs: "\uCD94\uAC00 TypedDict \uC778\uC218\uAC00 \uC9C0\uC6D0\uB418\uC9C0 \uC54A\uC74C",
-        typedDictExtraItemsClosed: "\uCD94\uAC00 \uD56D\uBAA9\uC744 \uC9C0\uC6D0\uD558\uB294 \uACBD\uC6B0 TypedDict\uB97C closed \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
+        typedDictExtraItemsClosed: 'TypedDict "closed" \uB610\uB294 "extra_items" \uC911 \uD558\uB098\uB9CC \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.',
         typedDictFieldNotRequiredRedefinition: 'TypedDict \uD56D\uBAA9 "{name}"\uC740(\uB294) NotRequired\uB85C \uC7AC\uC815\uC758\uB420 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
         typedDictFieldReadOnlyRedefinition: 'TypedDict \uD56D\uBAA9 "{name}"\uC740(\uB294) ReadOnly\uB85C \uC7AC\uC815\uC758\uB420 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
         typedDictFieldRequiredRedefinition: 'TypedDict \uD56D\uBAA9 "{name}"\uC740(\uB294) Required\uB85C \uC7AC\uC815\uC758\uB420 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
@@ -24346,7 +24198,6 @@ var require_package_nls_ko = __commonJS({
         typedDictFieldRequired: '"{type}"\uC5D0 "{name}"\uC774(\uAC00) \uD544\uC694\uD569\uB2C8\uB2E4.',
         typedDictFieldTypeMismatch: '"{type}" \uD615\uC2DD\uC740 "{name}" \uD56D\uBAA9\uC5D0 \uD560\uB2F9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.',
         typedDictFieldUndefined: '"{name}"\uC740(\uB294) "{type}" \uD615\uC2DD\uC758 \uC815\uC758\uB418\uC9C0 \uC54A\uC740 \uD56D\uBAA9\uC785\uB2C8\uB2E4.',
-        typedDictFinalMismatch: '@final \uBD88\uC77C\uCE58\uB85C \uC778\uD574 "{sourceType}"\uC774(\uAC00) "{destType}"\uACFC(\uC640) \uD638\uD658\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.',
         typedDictKeyAccess: 'TypedDict\uC5D0\uC11C \uD56D\uBAA9\uC744 \uCC38\uC870\uD558\uB824\uBA74 ["{name}"]\uC744(\uB97C) \uC0AC\uC6A9\uD558\uC138\uC694.',
         typedDictNotAllowed: "TypedDict\uB294 \uC778\uC2A4\uD134\uC2A4 \uB610\uB294 \uD074\uB798\uC2A4 \uAC80\uC0AC\uC5D0 \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
         unhashableType: "\u2018{type}\u2019 \uD615\uC2DD\uC744 \uD574\uC2DC\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
@@ -24718,6 +24569,7 @@ var require_package_nls_pl = __commonJS({
         noneNotUsableWithAsync: "Obiekt typu \u201ENone\u201D nie mo\u017Ce by\u0107 u\u017Cywany z parametrem \u201Easync with\u201D",
         noneOperator: "Operator \u201E{operator}\u201D nie jest obs\u0142ugiwany dla warto\u015Bci \u201ENone\u201D",
         noneUnknownMember: "Nazwa \u201E{name}\u201D nie jest znanym atrybutem \u201ENone\u201D",
+        nonlocalTypeParam: "Powi\u0105zanie nonlocal nie jest dozwolone dla parametru typu \u201E{name}\u201D",
         notRequiredArgCount: "Oczekiwano jednego argumentu typu po warto\u015Bci \u201ENotRequired\u201D",
         notRequiredNotInTypedDict: "Element \u201ENotRequired\u201D jest niedozwolony w tym kontek\u015Bcie",
         objectNotCallable: "Obiekt typu \u201E{type}\u201D nie jest wywo\u0142ywalny",
@@ -24736,11 +24588,11 @@ var require_package_nls_pl = __commonJS({
         overloadAbstractImplMismatch: "Przeci\u0105\u017Cenia musz\u0105 by\u0107 zgodne ze stanem abstrakcyjnym implementacji",
         overloadAbstractMismatch: "Przeci\u0105\u017Cenia musz\u0105 by\u0107 abstrakcyjne lub nieabstrakcyjne",
         overloadClassMethodInconsistent: "Przeci\u0105\u017Cenia dla nazwy \u201E{name}\u201D u\u017Cywaj\u0105 metody @classmethod niekonsekwentnie",
-        overloadFinalImpl: "@final decorator should be applied only to the implementation",
-        overloadFinalNoImpl: "Only the first overload should be marked @final",
+        overloadFinalImpl: "@final dekorator powinien by\u0107 stosowany tylko do implementacji",
+        overloadFinalNoImpl: "Tylko pierwsze przeci\u0105\u017Cenie powinno by\u0107 oznaczone @final",
         overloadImplementationMismatch: "Przeci\u0105\u017Cone wdro\u017Cenie jest niesp\xF3jne z sygnatur\u0105 przeci\u0105\u017Cenia {index}",
-        overloadOverrideImpl: "@override decorator should be applied only to the implementation",
-        overloadOverrideNoImpl: "Only the first overload should be marked @override",
+        overloadOverrideImpl: "@override dekorator powinien by\u0107 stosowany tylko do implementacji",
+        overloadOverrideNoImpl: "Tylko pierwsze przeci\u0105\u017Cenie powinno by\u0107 oznaczone @override",
         overloadReturnTypeMismatch: "Przeci\u0105\u017Cenie {prevIndex} dla nazwy \u201E{name}\u201D nak\u0142ada si\u0119 na przeci\u0105\u017Cenie {newIndex} i zwraca niezgodny typ",
         overloadStaticMethodInconsistent: "Przeci\u0105\u017Cenia dla nazwy \u201E{name}\u201D u\u017Cywaj\u0105 metody @staticmethod niekonsekwentnie",
         overloadWithoutImplementation: "Nazwa \u201E{name}\u201D jest oznaczona jako overload, ale nie zapewniono implementacji",
@@ -24936,14 +24788,14 @@ var require_package_nls_pl = __commonJS({
         typedDictBadVar: "Klasy TypedDict mog\u0105 zawiera\u0107 tylko adnotacje typu",
         typedDictBaseClass: "Wszystkie klasy bazowe dla klas TypedDict musz\u0105 by\u0107 r\xF3wnie\u017C klasami TypedDict",
         typedDictBoolParam: "Oczekiwano, \u017Ce parametr \u201E{name}\u201D b\u0119dzie mia\u0142 warto\u015B\u0107 True lub False",
-        typedDictClosedExtras: "Klasa bazowa \u201E{name}\u201D jest closed TypedDict; dodatkowe elementy musz\u0105 by\u0107 typu \u201E{type}\u201D",
+        typedDictClosedExtras: '"{name}" klasy bazowej to TypedDict ograniczaj\u0105ca typ dodatkowych element\xF3w do typu "{type}"',
         typedDictClosedNoExtras: "Klasa bazowa \u201E{name}\u201D jest closed TypedDict; dodatkowe elementy s\u0105 niedozwolone",
         typedDictDelete: "Nie mo\u017Cna usun\u0105\u0107 elementu w typie TypedDict",
         typedDictEmptyName: "Nazwy w elemencie TypedDict nie mog\u0105 by\u0107 puste",
         typedDictEntryName: "Oczekiwano litera\u0142u ci\u0105gu dla nazwy wpisu s\u0142ownika",
         typedDictEntryUnique: "Nazwy w s\u0142owniku musz\u0105 by\u0107 unikatowe",
         typedDictExtraArgs: "Dodatkowe argumenty TypedDict nie s\u0105 obs\u0142ugiwane",
-        typedDictExtraItemsClosed: "Element TypedDict nie mo\u017Ce by\u0107 \u201Eclosed\u201D, je\u015Bli obs\u0142uguje dodatkowe elementy",
+        typedDictExtraItemsClosed: 'TypedDict mog\u0105 u\u017Cywa\u0107 "closed" lub "extra_items", ale nie obu',
         typedDictFieldNotRequiredRedefinition: "Element TypedDict \u201E{name}\u201D nie mo\u017Ce zosta\u0107 przedefiniowany jako NotRequired",
         typedDictFieldReadOnlyRedefinition: "Element TypedDict \u201E{name}\u201D nie mo\u017Ce by\u0107 przedefiniowany jako ReadOnly.",
         typedDictFieldRequiredRedefinition: "Element TypedDict \u201E{name}\u201D nie mo\u017Ce zosta\u0107 przedefiniowany jako Required",
@@ -25185,7 +25037,6 @@ var require_package_nls_pl = __commonJS({
         typedDictFieldRequired: "Nazwa \u201E{name}\u201D jest wymagana w typie \u201E{type}\u201D",
         typedDictFieldTypeMismatch: "Nie mo\u017Cna przypisa\u0107 typu \u201E{type}\u201D do elementu \u201E{name}\u201D",
         typedDictFieldUndefined: "Nazwa \u201E{name}\u201D jest niezdefiniowanym elementem w typie \u201E{type}\u201D",
-        typedDictFinalMismatch: "Typ \u201E{sourceType}\u201D jest niezgodny z typem \u201E{destType}\u201D z powodu niezgodno\u015Bci @final",
         typedDictKeyAccess: 'U\u017Cyj elementu ["{name}"], aby odwo\u0142a\u0107 si\u0119 do elementu w TypedDict',
         typedDictNotAllowed: "Funkcja TypedDict nie mo\u017Ce by\u0107 u\u017Cywana do sprawdzania wyst\u0105pie\u0144 lub klas",
         unhashableType: "Typ \u201E{type}\u201D nie jest warto\u015Bci\u0105 skr\xF3tu",
@@ -25557,6 +25408,7 @@ var require_package_nls_pt_br = __commonJS({
         noneNotUsableWithAsync: 'Objeto do\xA0tipo "None" n\xE3o pode ser usado com "async with"',
         noneOperator: 'Operador "{operator}" incompat\xEDvel com "None"',
         noneUnknownMember: '"{name}" n\xE3o \xE9 um atributo conhecido de "None"',
+        nonlocalTypeParam: 'Associa\xE7\xE3o nonlocal n\xE3o\xA0\xE9 permitida para o par\xE2metro de tipo "{name}"',
         notRequiredArgCount: 'Argumento de tipo \xFAnico esperado ap\xF3s "NotRequired"',
         notRequiredNotInTypedDict: '"NotRequired" n\xE3o \xE9 permitido neste contexto',
         objectNotCallable: 'O objeto do tipo "{type}" n\xE3o pode ser chamado',
@@ -25575,11 +25427,11 @@ var require_package_nls_pt_br = __commonJS({
         overloadAbstractImplMismatch: "As sobrecargas devem corresponder ao status abstrato da implementa\xE7\xE3o",
         overloadAbstractMismatch: "As sobrecargas devem ser abstratas ou n\xE3o",
         overloadClassMethodInconsistent: 'Sobrecargas para "{name}" usam @classmethod inconsistentemente',
-        overloadFinalImpl: "@final decorator should be applied only to the implementation",
-        overloadFinalNoImpl: "Only the first overload should be marked @final",
+        overloadFinalImpl: "@final decorador deve ser aplicado somente \xE0 implementa\xE7\xE3o",
+        overloadFinalNoImpl: "Somente a primeira sobrecarga deve ser marcada como @final",
         overloadImplementationMismatch: "A implementa\xE7\xE3o sobrecarregada n\xE3o \xE9 consistente com a assinatura da sobrecarga {index}",
-        overloadOverrideImpl: "@override decorator should be applied only to the implementation",
-        overloadOverrideNoImpl: "Only the first overload should be marked @override",
+        overloadOverrideImpl: "@override decorador deve ser aplicado somente \xE0 implementa\xE7\xE3o",
+        overloadOverrideNoImpl: "Somente a primeira sobrecarga deve ser marcada como @override",
         overloadReturnTypeMismatch: 'A sobrecarga {prevIndex} para "{name}" sobrep\xF5e a sobrecarga {newIndex} e retorna um tipo incompat\xEDvel',
         overloadStaticMethodInconsistent: 'Sobrecargas para "{name}" usam @staticmethod inconsistentemente',
         overloadWithoutImplementation: '"{name}" est\xE1 marcado como overload, mas nenhuma implementa\xE7\xE3o foi fornecida',
@@ -25775,14 +25627,14 @@ var require_package_nls_pt_br = __commonJS({
         typedDictBadVar: "As classes TypedDict podem conter apenas anota\xE7\xF5es de tipo",
         typedDictBaseClass: "Todas as classes base para classes TypedDict tamb\xE9m devem ser classes TypedDict",
         typedDictBoolParam: 'Esperava-se que o par\xE2metro "{name}" tivesse um valor True ou False',
-        typedDictClosedExtras: 'A classe base "{name}" \xE9 um TypedDict closed; itens extras devem ser do tipo "{type}"',
+        typedDictClosedExtras: 'A classe "{name}" \xE9 um TypedDict que limita o tipo de itens extras a serem digitados "{type}"',
         typedDictClosedNoExtras: 'A classe base "{name}" \xE9 um TypedDict closed; itens extras n\xE3o s\xE3o permitidos',
         typedDictDelete: "N\xE3o foi poss\xEDvel excluir o item em TypedDict",
         typedDictEmptyName: "Os nomes dentro de um TypedDict n\xE3o podem estar vazios",
         typedDictEntryName: "Literal de cadeia de caracteres esperado para o nome da entrada do dicion\xE1rio",
         typedDictEntryUnique: "Os nomes dentro de um dicion\xE1rio devem ser exclusivos",
         typedDictExtraArgs: "Argumentos TypedDict extras s\xE3o incompat\xEDveis",
-        typedDictExtraItemsClosed: "Um TypedDict n\xE3o pode ser closed se\xA0der suporte a itens extras",
+        typedDictExtraItemsClosed: 'TypedDict pode usar "closed" ou "extra_items" mas n\xE3o ambos',
         typedDictFieldNotRequiredRedefinition: 'O item TypedDict "{name}" n\xE3o pode ser redefinido como NotRequired',
         typedDictFieldReadOnlyRedefinition: 'O item TypedDict "{name}" n\xE3o pode ser redefinido como ReadOnly',
         typedDictFieldRequiredRedefinition: 'O item TypedDict "{name}" n\xE3o pode ser redefinido como Required',
@@ -26024,7 +25876,6 @@ var require_package_nls_pt_br = __commonJS({
         typedDictFieldRequired: '"{name}" \xE9 necess\xE1rio em "{type}"',
         typedDictFieldTypeMismatch: 'O tipo "{type}" n\xE3o \xE9 atribu\xEDvel ao item "{name}"',
         typedDictFieldUndefined: '"{name}" \xE9 um item indefinido no tipo "{type}"',
-        typedDictFinalMismatch: '"{sourceType}" \xE9 incompat\xEDvel com "{destType}" devido a uma @final incompat\xEDvel',
         typedDictKeyAccess: 'Usar ["{name}"] para fazer refer\xEAncia ao item em TypedDict',
         typedDictNotAllowed: "TypedDict n\xE3o pode ser usado para verifica\xE7\xF5es de inst\xE2ncia ou de classe",
         unhashableType: 'O tipo "{type}" n\xE3o \xE9 pode fazer hash',
@@ -26396,6 +26247,7 @@ var require_package_nls_qps_ploc = __commonJS({
         noneNotUsableWithAsync: '[2p5GE][\u0E19\u0E31\u0E49\xD8\xFEj\xEB\xE7t \xF8f t\xFFp\xEB "\xD1\xF8\xF1\xEB" \xE7\xE6\xF1\xF1\xF8t \xFE\xEB \xB5s\xEB\xF0 w\xEFth "\xE6s\xFF\xF1\xE7 w\xEFth"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         noneOperator: '[3U0d3][\u0E19\u0E31\u0E49\xD8p\xEBr\xE6t\xF8r "{\xF8p\xEBr\xE6t\xF8r}" \xF1\xF8t s\xB5pp\xF8rt\xEB\xF0 f\xF8r "None"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         noneUnknownMember: '[4KvEX][\u0E19\u0E31\u0E49"{\xF1\xE6m\xEB}" \xEFs \xF1\xF8t \xE6 k\xF1\xF8w\xF1 \xE6ttr\xEF\xFE\xB5t\xEB \xF8f "None"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
+        nonlocalTypeParam: '[S78yW][\u0E19\u0E31\u0E49Nonlocal \xFE\xEF\xF1\xF0\xEF\xF1g \xEFs \xF1\xF8t \xE6ll\xF8w\xEB\xF0 f\xF8r t\xFFp\xEB p\xE6r\xE6m\xEBt\xEBr "{\xF1\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\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         notRequiredArgCount: '[uOeAb][\u0E19\u0E31\u0E49\xCBxp\xEB\xE7t\xEB\xF0 \xE6 s\xEF\xF1gl\xEB t\xFFp\xEB \xE6rg\xB5m\xEB\xF1t \xE6ft\xEBr "NotRequired"\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]',
         notRequiredNotInTypedDict: '[Vl6XL][\u0E19\u0E31\u0E49"NotRequired" \xEFs \xF1\xF8t \xE6ll\xF8w\xEB\xF0 \xEF\xF1 th\xEFs \xE7\xF8\xF1t\xEBxt\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         objectNotCallable: '[bzlKk][\u0E19\u0E31\u0E49\xD8\xFEj\xEB\xE7t \xF8f t\xFFp\xEB "{t\xFFp\xEB}" \xEFs \xF1\xF8t \xE7\xE6ll\xE6\xFEl\xEB\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
@@ -26614,14 +26466,14 @@ var require_package_nls_qps_ploc = __commonJS({
         typedDictBadVar: "[OL8Ox][\u0E19\u0E31\u0E49TypedDict \xE7l\xE6ss\xEBs \xE7\xE6\xF1 \xE7\xF8\xF1t\xE6\xEF\xF1 \xF8\xF1l\xFF t\xFFp\xEB \xE6\xF1\xF1\xF8t\xE6t\xEF\xF8\xF1s\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]",
         typedDictBaseClass: "[HxyA2][\u0E19\u0E31\u0E49\xC6ll \xFE\xE6s\xEB \xE7l\xE6ss\xEBs f\xF8r TypedDict \xE7l\xE6ss\xEBs m\xB5st \xE6ls\xF8 \xFE\xEB TypedDict \xE7l\xE6ss\xEBs\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\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
         typedDictBoolParam: '[GALOD][\u0E19\u0E31\u0E49\xCBxp\xEB\xE7t\xEB\xF0 "{\xF1\xE6m\xEB}" p\xE6r\xE6m\xEBt\xEBr t\xF8 h\xE6v\xEB \xE6 v\xE6l\xB5\xEB \xF8f True \xF8r False\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]',
-        typedDictClosedExtras: '[mlkJO][\u0E19\u0E31\u0E49\xDF\xE6s\xEB \xE7l\xE6ss "{\xF1\xE6m\xEB}" \xEFs \xE6 closed TypedDict; \xEBxtr\xE6 \xEFt\xEBms m\xB5st \xFE\xEB t\xFFp\xEB "{t\xFFp\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\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
+        typedDictClosedExtras: '[mlkJO][\u0E19\u0E31\u0E49\xDF\xE6s\xEB \xE7l\xE6ss "{\xF1\xE6m\xEB}" \xEFs \xE6 TypedDict th\xE6t l\xEFm\xEFts th\xEB t\xFFp\xEB \xF8f \xEBxtr\xE6 \xEFt\xEBms t\xF8 t\xFFp\xEB "{t\xFFp\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\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictClosedNoExtras: '[BCyXd][\u0E19\u0E31\u0E49\xDF\xE6s\xEB \xE7l\xE6ss "{\xF1\xE6m\xEB}" \xEFs \xE6 closed TypedDict; \xEBxtr\xE6 \xEFt\xEBms \xE6r\xEB \xF1\xF8t \xE6ll\xF8w\xEB\xF0\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\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictDelete: "[bdBu7][\u0E19\u0E31\u0E49\xC7\xF8\xB5l\xF0 \xF1\xF8t \xF0\xEBl\xEBt\xEB \xEFt\xEBm \xEF\xF1 TypedDict\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
         typedDictEmptyName: "[h45e7][\u0E19\u0E31\u0E49\xD1\xE6m\xEBs w\xEFth\xEF\xF1 \xE6 TypedDict \xE7\xE6\xF1\xF1\xF8t \xFE\xEB \xEBmpt\xFF\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
         typedDictEntryName: "[NT4np][\u0E19\u0E31\u0E49\xCBxp\xEB\xE7t\xEB\xF0 str\xEF\xF1g l\xEFt\xEBr\xE6l f\xF8r \xF0\xEF\xE7t\xEF\xF8\xF1\xE6r\xFF \xEB\xF1tr\xFF \xF1\xE6m\xEB\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]",
         typedDictEntryUnique: "[nWy0L][\u0E19\u0E31\u0E49\xD1\xE6m\xEBs w\xEFth\xEF\xF1 \xE6 \xF0\xEF\xE7t\xEF\xF8\xF1\xE6r\xFF m\xB5st \xFE\xEB \xB5\xF1\xEFq\xB5\xEB\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
         typedDictExtraArgs: "[0gX32][\u0E19\u0E31\u0E49\xCBxtr\xE6 TypedDict \xE6rg\xB5m\xEB\xF1ts \xF1\xF8t s\xB5pp\xF8rt\xEB\xF0\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
-        typedDictExtraItemsClosed: "[5BDXE][\u0E19\u0E31\u0E49\xC6 TypedDict \xE7\xE6\xF1\xF1\xF8t \xFE\xEB closed \xEFf \xEFt s\xB5pp\xF8rts \xEBxtr\xE6 \xEFt\xEBms\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
+        typedDictExtraItemsClosed: '[5BDXE][\u0E19\u0E31\u0E49TypedDict \xE7\xE6\xF1 \xB5s\xEB \xEB\xEFth\xEBr "closed" \xF8r "extra_items" \xFE\xB5t \xF1\xF8t \xFE\xF8th\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]',
         typedDictFieldNotRequiredRedefinition: '[rNYD1][\u0E19\u0E31\u0E49TypedDict \xEFt\xEBm "{\xF1\xE6m\xEB}" \xE7\xE6\xF1\xF1\xF8t \xFE\xEB r\xEB\xF0\xEBf\xEF\xF1\xEB\xF0 \xE6s NotRequired\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]',
         typedDictFieldReadOnlyRedefinition: '[8IFAz][\u0E19\u0E31\u0E49TypedDict \xEFt\xEBm "{\xF1\xE6m\xEB}" \xE7\xE6\xF1\xF1\xF8t \xFE\xEB r\xEB\xF0\xEBf\xEF\xF1\xEB\xF0 \xE6s ReadOnly\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictFieldRequiredRedefinition: '[lpw97][\u0E19\u0E31\u0E49TypedDict \xEFt\xEBm "{\xF1\xE6m\xEB}" \xE7\xE6\xF1\xF1\xF8t \xFE\xEB r\xEB\xF0\xEBf\xEF\xF1\xEB\xF0 \xE6s Required\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
@@ -26863,7 +26715,6 @@ var require_package_nls_qps_ploc = __commonJS({
         typedDictFieldRequired: '[ckyH4][\u0E19\u0E31\u0E49"{\xF1\xE6m\xEB}" \xEFs r\xEBq\xB5\xEFr\xEB\xF0 \xEF\xF1 "{t\xFFp\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictFieldTypeMismatch: '[XYIBH][\u0E19\u0E31\u0E49T\xFFp\xEB "{t\xFFp\xEB}" \xEFs \xF1\xF8t \xE6ss\xEFg\xF1\xE6\xFEl\xEB t\xF8 \xEFt\xEBm "{\xF1\xE6m\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictFieldUndefined: '[UsDC9][\u0E19\u0E31\u0E49"{\xF1\xE6m\xEB}" \xEFs \xE6\xF1 \xB5\xF1\xF0\xEBf\xEF\xF1\xEB\xF0 \xEFt\xEBm \xEF\xF1 t\xFFp\xEB "{t\xFFp\xEB}"\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
-        typedDictFinalMismatch: '[tFb04][\u0E19\u0E31\u0E49"{s\xF8\xB5r\xE7\xEBT\xFFp\xEB}" \xEFs \xEF\xF1\xE7\xF8mp\xE6t\xEF\xFEl\xEB w\xEFth "{\xF0\xEBstT\xFFp\xEB}" \xFE\xEB\xE7\xE6\xB5s\xEB \xF8f \xE6 @final m\xEFsm\xE6t\xE7h\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\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictKeyAccess: '[67DLq][\u0E19\u0E31\u0E49\xDCs\xEB ["{\xF1\xE6m\xEB}"] t\xF8 r\xEBf\xEBr\xEB\xF1\xE7\xEB \xEFt\xEBm \xEF\xF1 TypedDict\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
         typedDictNotAllowed: "[eTsPP][\u0E19\u0E31\u0E49TypedDict \xE7\xE6\xF1\xF1\xF8t \xFE\xEB \xB5s\xEB\xF0 f\xF8r \xEF\xF1st\xE6\xF1\xE7\xEB \xF8r \xE7l\xE6ss \xE7h\xEB\xE7ks\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u307E\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0E19\u0E31\u0E49\u0922\u0942\u0901]",
         unhashableType: '[IJEeq][\u0E19\u0E31\u0E49T\xFFp\xEB "{t\xFFp\xEB}" \xEFs \xF1\xF8t h\xE6sh\xE6\xFEl\xEB\u1EA4\u011F\u502A\u0130\u0402\u04B0\u0915\u094D\u0930\u094D\u0924\u093F\u0943\u0E19\u0E31\u0E49\u0922\u0942\u0901]',
@@ -27235,6 +27086,7 @@ var require_package_nls_ru = __commonJS({
         noneNotUsableWithAsync: '\u041E\u0431\u044A\u0435\u043A\u0442 \u0442\u0438\u043F\u0430 "None" \u043D\u0435\u043B\u044C\u0437\u044F \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C \u0441 "async with"',
         noneOperator: '\u041E\u043F\u0435\u0440\u0430\u0442\u043E\u0440 "{operator}" \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F \u0434\u043B\u044F "None"',
         noneUnknownMember: '"{name}" \u043D\u0435 \u044F\u0432\u043B\u044F\u0435\u0442\u0441\u044F \u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\u043C \u0430\u0442\u0440\u0438\u0431\u0443\u0442\u043E\u043C "None"',
+        nonlocalTypeParam: '\u041F\u0440\u0438\u0432\u044F\u0437\u043A\u0430 nonlocal \u043D\u0435 \u0434\u043E\u043F\u0443\u0441\u043A\u0430\u0435\u0442\u0441\u044F \u0434\u043B\u044F \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u0430 \u0442\u0438\u043F\u0430 "{name}"',
         notRequiredArgCount: '\u041F\u043E\u0441\u043B\u0435 "NotRequired" \u043E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F \u043E\u0434\u0438\u043D \u0430\u0440\u0433\u0443\u043C\u0435\u043D\u0442 \u0442\u0438\u043F\u0430',
         notRequiredNotInTypedDict: '\u0418\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u0435 "NotRequired" \u0432 \u044D\u0442\u043E\u043C \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u0435 \u043D\u0435 \u0434\u043E\u043F\u0443\u0441\u043A\u0430\u0435\u0442\u0441\u044F',
         objectNotCallable: '\u041E\u0431\u044A\u0435\u043A\u0442 \u0442\u0438\u043F\u0430 "{type}" \u043D\u0435 \u044F\u0432\u043B\u044F\u0435\u0442\u0441\u044F \u0432\u044B\u0437\u044B\u0432\u0430\u0435\u043C\u044B\u043C',
@@ -27253,11 +27105,11 @@ var require_package_nls_ru = __commonJS({
         overloadAbstractImplMismatch: "\u041F\u0435\u0440\u0435\u0433\u0440\u0443\u0437\u043A\u0438 \u0434\u043E\u043B\u0436\u043D\u044B \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u043E\u0432\u0430\u0442\u044C \u0430\u0431\u0441\u0442\u0440\u0430\u043A\u0442\u043D\u043E\u043C\u0443 \u0441\u0442\u0430\u0442\u0443\u0441\u0443 \u0440\u0435\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438",
         overloadAbstractMismatch: "\u0412\u0441\u0435 \u043F\u0435\u0440\u0435\u0433\u0440\u0443\u0437\u043A\u0438 \u0434\u043E\u043B\u0436\u043D\u044B \u0431\u044B\u0442\u044C \u0430\u0431\u0441\u0442\u0440\u0430\u043A\u0442\u043D\u044B\u043C\u0438 \u0438\u043B\u0438 \u043D\u0435 \u0430\u0431\u0441\u0442\u0440\u0430\u043A\u0442\u043D\u044B\u043C\u0438",
         overloadClassMethodInconsistent: '\u041F\u0435\u0440\u0435\u0433\u0440\u0443\u0437\u043A\u0438 \u0434\u043B\u044F "{name}" \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u044E\u0442 @classmethod \u043D\u0435\u0441\u043E\u0433\u043B\u0430\u0441\u043E\u0432\u0430\u043D\u043D\u043E',
-        overloadFinalImpl: "@final decorator should be applied only to the implementation",
-        overloadFinalNoImpl: "Only the first overload should be marked @final",
+        overloadFinalImpl: "@final \u0434\u0435\u043A\u043E\u0440\u0430\u0442\u043E\u0440 \u0434\u043E\u043B\u0436\u0435\u043D \u043F\u0440\u0438\u043C\u0435\u043D\u044F\u0442\u044C\u0441\u044F \u0442\u043E\u043B\u044C\u043A\u043E \u043A \u0440\u0435\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438",
+        overloadFinalNoImpl: "\u0422\u043E\u043B\u044C\u043A\u043E \u043F\u0435\u0440\u0432\u0430\u044F \u043F\u0435\u0440\u0435\u0433\u0440\u0443\u0437\u043A\u0430 \u0434\u043E\u043B\u0436\u043D\u0430 \u0431\u044B\u0442\u044C \u043F\u043E\u043C\u0435\u0447\u0435\u043D\u0430 @final",
         overloadImplementationMismatch: "\u041F\u0435\u0440\u0435\u0433\u0440\u0443\u0436\u0435\u043D\u043D\u0430\u044F \u0440\u0435\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u044F \u043D\u0435 \u0441\u043E\u0433\u043B\u0430\u0441\u043E\u0432\u0430\u043D\u0430 \u0441 \u0441\u0438\u0433\u043D\u0430\u0442\u0443\u0440\u043E\u0439 \u043F\u0435\u0440\u0435\u0433\u0440\u0443\u0437\u043A\u0438 {index}",
-        overloadOverrideImpl: "@override decorator should be applied only to the implementation",
-        overloadOverrideNoImpl: "Only the first overload should be marked @override",
+        overloadOverrideImpl: "@override \u0434\u0435\u043A\u043E\u0440\u0430\u0442\u043E\u0440 \u0434\u043E\u043B\u0436\u0435\u043D \u043F\u0440\u0438\u043C\u0435\u043D\u044F\u0442\u044C\u0441\u044F \u0442\u043E\u043B\u044C\u043A\u043E \u043A \u0440\u0435\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438",
+        overloadOverrideNoImpl: "\u0422\u043E\u043B\u044C\u043A\u043E \u043F\u0435\u0440\u0432\u0430\u044F \u043F\u0435\u0440\u0435\u0433\u0440\u0443\u0437\u043A\u0430 \u0434\u043E\u043B\u0436\u043D\u0430 \u0431\u044B\u0442\u044C \u043F\u043E\u043C\u0435\u0447\u0435\u043D\u0430 @override",
         overloadReturnTypeMismatch: '\u041F\u0435\u0440\u0435\u0433\u0440\u0443\u0437\u043A\u0430 {prevIndex} \u0434\u043B\u044F "{name}" \u043F\u0435\u0440\u0435\u043A\u0440\u044B\u0432\u0430\u0435\u0442 \u043F\u0435\u0440\u0435\u0433\u0440\u0443\u0437\u043A\u0443 {newIndex} \u0438 \u0432\u043E\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u043D\u0435\u0441\u043E\u0432\u043C\u0435\u0441\u0442\u0438\u043C\u044B\u0439 \u0442\u0438\u043F',
         overloadStaticMethodInconsistent: '\u041F\u0435\u0440\u0435\u0433\u0440\u0443\u0437\u043A\u0438 \u0434\u043B\u044F "{name}" \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u044E\u0442 @staticmethod \u043D\u0435\u0441\u043E\u0433\u043B\u0430\u0441\u043E\u0432\u0430\u043D\u043D\u043E',
         overloadWithoutImplementation: '"{name}" \u043F\u043E\u043C\u0435\u0447\u0435\u043D \u043A\u0430\u043A overload, \u043D\u043E \u0440\u0435\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u044F \u043D\u0435 \u043F\u0440\u0435\u0434\u043E\u0441\u0442\u0430\u0432\u043B\u0435\u043D\u0430',
@@ -27453,14 +27305,14 @@ var require_package_nls_ru = __commonJS({
         typedDictBadVar: "\u041A\u043B\u0430\u0441\u0441\u044B TypedDict \u043C\u043E\u0433\u0443\u0442 \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C \u0442\u043E\u043B\u044C\u043A\u043E \u0437\u0430\u043C\u0435\u0442\u043A\u0438 \u0441 \u0442\u0438\u043F\u043E\u043C",
         typedDictBaseClass: "\u0412\u0441\u0435 \u0431\u0430\u0437\u043E\u0432\u044B\u0435 \u043A\u043B\u0430\u0441\u0441\u044B \u0434\u043B\u044F \u043A\u043B\u0430\u0441\u0441\u043E\u0432 TypedDict \u0442\u0430\u043A\u0436\u0435 \u0434\u043E\u043B\u0436\u043D\u044B \u0431\u044B\u0442\u044C \u043A\u043B\u0430\u0441\u0441\u0430\u043C\u0438 TypedDict",
         typedDictBoolParam: '\u041E\u0442 \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u0430 "{name}" \u043E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 True \u0438\u043B\u0438 False',
-        typedDictClosedExtras: '\u0411\u0430\u0437\u043E\u0432\u044B\u0439 \u043A\u043B\u0430\u0441\u0441 "{name}" \u043F\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u043B\u044F\u0435\u0442 \u0441\u043E\u0431\u043E\u0439 closed TypedDict; \u0434\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C\u043D\u044B\u0435 \u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B \u0434\u043E\u043B\u0436\u043D\u044B \u0438\u043C\u0435\u0442\u044C \u0442\u0438\u043F "{type}"',
+        typedDictClosedExtras: '\u0411\u0430\u0437\u043E\u0432\u044B\u0439 \u043A\u043B\u0430\u0441\u0441 "{name}" \u044F\u0432\u043B\u044F\u0435\u0442\u0441\u044F TypedDict, \u043A\u043E\u0442\u043E\u0440\u044B\u0439 \u043E\u0433\u0440\u0430\u043D\u0438\u0447\u0438\u0432\u0430\u0435\u0442 \u0442\u0438\u043F \u0434\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C\u043D\u044B\u0445 \u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432 \u0442\u0438\u043F\u043E\u043C "{type}"',
         typedDictClosedNoExtras: '\u0411\u0430\u0437\u043E\u0432\u044B\u0439 \u043A\u043B\u0430\u0441\u0441 "{name}" \u043F\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u043B\u044F\u0435\u0442 \u0441\u043E\u0431\u043E\u0439 closed TypedDict; \u0434\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C\u043D\u044B\u0435 \u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B \u043D\u0435 \u0440\u0430\u0437\u0440\u0435\u0448\u0435\u043D\u044B',
         typedDictDelete: "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0443\u0434\u0430\u043B\u0438\u0442\u044C \u044D\u043B\u0435\u043C\u0435\u043D\u0442 \u0432 TypedDict",
         typedDictEmptyName: "\u0418\u043C\u0435\u043D\u0430 \u0432 TypedDict \u043D\u0435 \u043C\u043E\u0433\u0443\u0442 \u0431\u044B\u0442\u044C \u043F\u0443\u0441\u0442\u044B\u043C\u0438",
         typedDictEntryName: "\u0414\u043B\u044F \u0438\u043C\u0435\u043D\u0438 \u0437\u0430\u043F\u0438\u0441\u0438 \u0441\u043B\u043E\u0432\u0430\u0440\u044F \u043E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F \u0441\u0442\u0440\u043E\u043A\u043E\u0432\u044B\u0439 \u043B\u0438\u0442\u0435\u0440\u0430\u043B",
         typedDictEntryUnique: "\u0418\u043C\u0435\u043D\u0430 \u0432 \u0441\u043B\u043E\u0432\u0430\u0440\u0435 \u0434\u043E\u043B\u0436\u043D\u044B \u0431\u044B\u0442\u044C \u0443\u043D\u0438\u043A\u0430\u043B\u044C\u043D\u044B\u043C\u0438",
         typedDictExtraArgs: "\u0414\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C\u043D\u044B\u0435 \u0430\u0440\u0433\u0443\u043C\u0435\u043D\u0442\u044B TypedDict \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u044E\u0442\u0441\u044F",
-        typedDictExtraItemsClosed: 'TypedDict \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C "closed", \u0435\u0441\u043B\u0438 \u043E\u043D \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442 \u0434\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C\u043D\u044B\u0435 \u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B',
+        typedDictExtraItemsClosed: 'TypedDict \u043C\u043E\u0436\u0435\u0442 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C "closed" \u0438\u043B\u0438 "extra_items", \u043D\u043E \u043D\u0435 \u043E\u0431\u0430',
         typedDictFieldNotRequiredRedefinition: '\u042D\u043B\u0435\u043C\u0435\u043D\u0442 TypedDict "{name}" \u043D\u0435\u043B\u044C\u0437\u044F \u043F\u0435\u0440\u0435\u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0438\u0442\u044C \u043A\u0430\u043A NotRequired',
         typedDictFieldReadOnlyRedefinition: '\u042D\u043B\u0435\u043C\u0435\u043D\u0442 TypedDict "{name}" \u043D\u0435\u043B\u044C\u0437\u044F \u043F\u0435\u0440\u0435\u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0438\u0442\u044C \u043A\u0430\u043A \u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B\u0439 ReadOnly',
         typedDictFieldRequiredRedefinition: '\u042D\u043B\u0435\u043C\u0435\u043D\u0442 TypedDict "{name}" \u043D\u0435\u043B\u044C\u0437\u044F \u043F\u0435\u0440\u0435\u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0438\u0442\u044C \u043A\u0430\u043A Required',
@@ -27702,7 +27554,6 @@ var require_package_nls_ru = __commonJS({
         typedDictFieldRequired: '"{name}" \u044F\u0432\u043B\u044F\u0435\u0442\u0441\u044F \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u044B\u043C \u0432 "{type}"',
         typedDictFieldTypeMismatch: '\u0422\u0438\u043F "{type}" \u043D\u0435\u043B\u044C\u0437\u044F \u043F\u0440\u0438\u0441\u0432\u043E\u0438\u0442\u044C \u043F\u043E\u043B\u044E "{name}"',
         typedDictFieldUndefined: '\u042D\u043B\u0435\u043C\u0435\u043D\u0442 "{name}" \u043D\u0435 \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0435\u043D \u0432 \u0442\u0438\u043F\u0435 "{type}"',
-        typedDictFinalMismatch: '"{sourceType}" \u043D\u0435\u0441\u043E\u0432\u043C\u0435\u0441\u0442\u0438\u043C \u0441 "{destType}" \u0438\u0437-\u0437\u0430 \u043D\u0435\u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0438\u044F @final',
         typedDictKeyAccess: '\u0418\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C ["{name}"] \u0434\u043B\u044F \u0441\u0441\u044B\u043B\u043A\u0438 \u043D\u0430 \u044D\u043B\u0435\u043C\u0435\u043D\u0442 \u0432 TypedDict',
         typedDictNotAllowed: "TypedDict \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C\u0441\u044F \u0434\u043B\u044F \u043F\u0440\u043E\u0432\u0435\u0440\u043E\u043A \u044D\u043A\u0437\u0435\u043C\u043F\u043B\u044F\u0440\u043E\u0432 \u0438\u043B\u0438 \u043A\u043B\u0430\u0441\u0441\u043E\u0432",
         unhashableType: '\u0422\u0438\u043F "{type}" \u043D\u0435 \u044F\u0432\u043B\u044F\u0435\u0442\u0441\u044F \u0445\u044D\u0448\u0438\u0440\u0443\u0435\u043C\u044B\u043C',
@@ -28074,6 +27925,7 @@ var require_package_nls_tr = __commonJS({
         noneNotUsableWithAsync: '"None" t\xFCr\xFCndeki nesne "async" ile kullan\u0131lamaz',
         noneOperator: '"{operator}" i\u015Fleci "None" i\xE7in desteklenmiyor',
         noneUnknownMember: '"{name}" bilinen bir "None" \xF6zniteli\u011Fi de\u011Fil',
+        nonlocalTypeParam: '"{name}" t\xFCr parametresi i\xE7in nonlocal ba\u011Flamaya izin verilmez',
         notRequiredArgCount: '"NotRequired" sonras\u0131nda tek bir t\xFCr ba\u011F\u0131ms\u0131z de\u011Fi\u015Fken bekleniyordu',
         notRequiredNotInTypedDict: 'Bu ba\u011Flamda "NotRequired" kullan\u0131m\u0131na izin verilmiyor',
         objectNotCallable: '"{type}" t\xFCr\xFCndeki nesne \xE7a\u011Fr\u0131lamaz',
@@ -28092,11 +27944,11 @@ var require_package_nls_tr = __commonJS({
         overloadAbstractImplMismatch: "A\u015F\u0131r\u0131 y\xFCklemeler uygulaman\u0131n \xF6zet durumuyla e\u015Fle\u015Fmelidir",
         overloadAbstractMismatch: "A\u015F\u0131r\u0131 y\xFCklemelerin t\xFCm\xFC soyut olmal\u0131 veya t\xFCm\xFC olmamal\u0131d\u0131r",
         overloadClassMethodInconsistent: '"{name}" i\xE7in a\u015F\u0131r\u0131 y\xFCklemeler, @classmethod y\xF6ntemini tutarl\u0131 kullan\u0131yor',
-        overloadFinalImpl: "@final decorator should be applied only to the implementation",
-        overloadFinalNoImpl: "Only the first overload should be marked @final",
+        overloadFinalImpl: "@final dekorat\xF6r yaln\u0131zca uygulamaya uygulanamaz",
+        overloadFinalNoImpl: "Yaln\u0131zca ilk a\u015F\u0131r\u0131 y\xFCkleme @final",
         overloadImplementationMismatch: "A\u015F\u0131r\u0131 y\xFCklenmi\u015F uygulama, {index} a\u015F\u0131r\u0131 y\xFCkleme imzas\u0131 ile tutarl\u0131 de\u011Fil",
-        overloadOverrideImpl: "@override decorator should be applied only to the implementation",
-        overloadOverrideNoImpl: "Only the first overload should be marked @override",
+        overloadOverrideImpl: "@override dekorat\xF6r yaln\u0131zca uygulamaya uygulanamaz",
+        overloadOverrideNoImpl: "Yaln\u0131zca ilk a\u015F\u0131r\u0131 y\xFCkleme @override",
         overloadReturnTypeMismatch: '"{name}" i\xE7in {prevIndex} a\u015F\u0131r\u0131 y\xFCklemesi {newIndex} a\u015F\u0131r\u0131 y\xFCklemesi ile \xE7ak\u0131\u015F\u0131yor ve uyumsuz bir t\xFCr d\xF6nd\xFCr\xFCyor',
         overloadStaticMethodInconsistent: '"{name}" i\xE7in a\u015F\u0131r\u0131 y\xFCklemeler, @staticmethod y\xF6ntemini tutars\u0131z kullan\u0131yor',
         overloadWithoutImplementation: '"{name}" is marked as overload, but no implementation is provided',
@@ -28292,14 +28144,14 @@ var require_package_nls_tr = __commonJS({
         typedDictBadVar: "TypedDict s\u0131n\u0131flar\u0131 yaln\u0131zca t\xFCr ek a\xE7\u0131klamalar\u0131 i\xE7erebilir",
         typedDictBaseClass: "TypedDict s\u0131n\u0131flar\u0131 i\xE7in t\xFCm temel s\u0131n\u0131flar da TypedDict s\u0131n\u0131flar\u0131 olmal\u0131d\u0131r",
         typedDictBoolParam: 'True veya False de\u011Feri olmas\u0131 i\xE7in "{name}" parametresi bekleniyordu',
-        typedDictClosedExtras: '"{name}" temel s\u0131n\u0131f\u0131 closed bir TypedDict \xF6\u011Fesidir; ek \xF6\u011Feler "{type}" t\xFCr\xFCnde olmal\u0131d\u0131r',
+        typedDictClosedExtras: 'Temel s\u0131n\u0131f "{name}", TypedDict \xF6\u011Fe t\xFCr\xFCn\xFC t\xFCrle s\u0131n\u0131rlanm\u0131\u015F bir "{type}"',
         typedDictClosedNoExtras: '"{name}" temel s\u0131n\u0131f\u0131 closed bir TypedDict \xF6\u011Fesidir; ek \xF6\u011Felere izin verilmiyor',
         typedDictDelete: "TypedDict'da \xF6\u011Fe silinemedi",
         typedDictEmptyName: "TypedDict i\xE7indeki adlar bo\u015F olamaz",
         typedDictEntryName: "S\xF6zl\xFCk girdisi ad\u0131 i\xE7in sabit de\u011Ferli dize bekleniyordu",
         typedDictEntryUnique: "S\xF6zl\xFCk i\xE7indeki adlar benzersiz olmal\u0131d\u0131r",
         typedDictExtraArgs: "Ekstra TypedDict ba\u011F\u0131ms\u0131z de\u011Fi\u015Fkenleri desteklenmiyor",
-        typedDictExtraItemsClosed: "Bir TypedDict ek \xF6\u011Feleri destekliyorsa closed olamaz",
+        typedDictExtraItemsClosed: 'TypedDict her ikisini birden "closed" veya "extra_items" ya da her ikisini birden kullanamaz',
         typedDictFieldNotRequiredRedefinition: '"{name}" TypedDict \xF6\u011Fesi NotRequired olarak yeniden tan\u0131mlanamaz',
         typedDictFieldReadOnlyRedefinition: '"{name}" TypedDict \xF6\u011Fesi ReadOnly olarak yeniden tan\u0131mlanamaz',
         typedDictFieldRequiredRedefinition: '"{name}" TypedDict \xF6\u011Fesi Required olarak yeniden tan\u0131mlanamaz',
@@ -28541,7 +28393,6 @@ var require_package_nls_tr = __commonJS({
         typedDictFieldRequired: '"{type}" i\xE7inde "{name}" gerekiyor',
         typedDictFieldTypeMismatch: '"{type}" t\xFCr\xFC "{name}" \xF6\u011Fesine atanamaz',
         typedDictFieldUndefined: '"{name}", "{type}" t\xFCr\xFCndeki tan\u0131ms\u0131z bir \xF6\u011Fedir',
-        typedDictFinalMismatch: '"{sourceType}" @final uyumsuzlu\u011Fu nedeniyle "{destType}" ile uyumsuz',
         typedDictKeyAccess: 'TypedDict\u2019te \xF6\u011Feye ba\u015Fvurmak i\xE7in ["{name}"] de\u011Ferini kullan\u0131n',
         typedDictNotAllowed: "TypedDict \xF6rnek veya s\u0131n\u0131f kontrolleri i\xE7in kullan\u0131lamaz",
         unhashableType: '"{type}" t\xFCr\xFC karmalanabilir de\u011Fil',
@@ -28913,6 +28764,7 @@ var require_package_nls_zh_cn = __commonJS({
         noneNotUsableWithAsync: '\u7C7B\u578B\u4E3A "None" \u7684\u5BF9\u8C61\u4E0D\u80FD\u4E0E "async with" \u4E00\u8D77\u4F7F\u7528',
         noneOperator: '\u201CNone\u201D\u4E0D\u652F\u6301\u8FD0\u7B97\u7B26"{operator}"',
         noneUnknownMember: '\u201C{name}\u201D\u4E0D\u662F "None" \u7684\u5DF2\u77E5\u5C5E\u6027',
+        nonlocalTypeParam: '\u7C7B\u578B\u53C2\u6570 "{name}" \u4E0D\u5141\u8BB8\u8FDB\u884C nonlocal \u7ED1\u5B9A',
         notRequiredArgCount: "\u201CNotRequired\u201D \u4E4B\u540E\u5E94\u4E3A\u5355\u4E2A\u7C7B\u578B\u53C2\u6570",
         notRequiredNotInTypedDict: "\u6B64\u4E0A\u4E0B\u6587\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528\u201CNotRequired\u201D",
         objectNotCallable: "\u7C7B\u578B\u4E3A\u201C{type}\u201D\u7684\u5BF9\u8C61\u4E0D\u53EF\u8C03\u7528",
@@ -28931,11 +28783,11 @@ var require_package_nls_zh_cn = __commonJS({
         overloadAbstractImplMismatch: "\u91CD\u8F7D\u5FC5\u987B\u4E0E\u5B9E\u73B0\u7684\u62BD\u8C61\u72B6\u6001\u5339\u914D",
         overloadAbstractMismatch: "\u91CD\u8F7D\u5FC5\u987B\u5168\u662F\u62BD\u8C61\u91CD\u8F7D\uFF0C\u6216\u8005\u5168\u90FD\u4E0D\u662F\u62BD\u8C61\u91CD\u8F7D",
         overloadClassMethodInconsistent: "\u201C{name}\u201D\u7684\u91CD\u8F7D\u4F7F\u7528 @classmethod \u7684\u65B9\u5F0F\u4E0D\u4E00\u81F4",
-        overloadFinalImpl: "@final decorator should be applied only to the implementation",
-        overloadFinalNoImpl: "Only the first overload should be marked @final",
+        overloadFinalImpl: "@final \u4FEE\u9970\u5668\u5E94\u4EC5\u5E94\u7528\u4E8E\u5B9E\u73B0",
+        overloadFinalNoImpl: "\u53EA\u5E94\u5C06\u7B2C\u4E00\u4E2A\u91CD\u8F7D\u6807\u8BB0\u4E3A @final",
         overloadImplementationMismatch: "\u91CD\u8F7D\u5B9E\u73B0\u4E0E\u91CD\u8F7D {index} \u7684\u7B7E\u540D\u4E0D\u4E00\u81F4",
-        overloadOverrideImpl: "@override decorator should be applied only to the implementation",
-        overloadOverrideNoImpl: "Only the first overload should be marked @override",
+        overloadOverrideImpl: "@override \u4FEE\u9970\u5668\u5E94\u4EC5\u5E94\u7528\u4E8E\u5B9E\u73B0",
+        overloadOverrideNoImpl: "\u53EA\u5E94\u5C06\u7B2C\u4E00\u4E2A\u91CD\u8F7D\u6807\u8BB0\u4E3A @override",
         overloadReturnTypeMismatch: "\u201C{name}\u201D\u7684\u91CD\u8F7D {prevIndex} \u4E0E\u91CD\u8F7D {newIndex} \u91CD\u53E0\uFF0C\u5E76\u8FD4\u56DE\u4E0D\u517C\u5BB9\u7684\u7C7B\u578B",
         overloadStaticMethodInconsistent: "\u201C{name}\u201D\u7684\u91CD\u8F7D\u4F7F\u7528 @staticmethod \u7684\u65B9\u5F0F\u4E0D\u4E00\u81F4",
         overloadWithoutImplementation: '"{name}" \u88AB\u6807\u8BB0\u4E3A overload\uFF0C\u4F46\u672A\u63D0\u4F9B\u5B9E\u73B0',
@@ -29131,14 +28983,14 @@ var require_package_nls_zh_cn = __commonJS({
         typedDictBadVar: "TypedDict \u7C7B\u53EA\u80FD\u5305\u542B\u7C7B\u578B\u6279\u6CE8",
         typedDictBaseClass: "TypedDict \u7C7B\u7684\u6240\u6709\u57FA\u7C7B\u4E5F\u5FC5\u987B\u662F TypedDict \u7C7B",
         typedDictBoolParam: "\u9884\u671F\u201C{name}\u201D\u53C2\u6570\u7684\u503C\u4E3A True \u6216 False",
-        typedDictClosedExtras: '\u57FA\u7C7B "{name}" \u662F closed TypedDict; \u989D\u5916\u7684\u9879\u5FC5\u987B\u662F\u7C7B\u578B "{type}"',
+        typedDictClosedExtras: '\u57FA\u7C7B "{name}" \u662F\u9650\u5236\u989D\u5916\u9879\u7C7B\u578B "{type}" \u7684 TypedDict',
         typedDictClosedNoExtras: '\u57FA\u7C7B "{name}" \u662F closed TypedDict; \u4E0D\u5141\u8BB8\u4F7F\u7528\u989D\u5916\u7684\u9879',
         typedDictDelete: "\u65E0\u6CD5\u5220\u9664 TypedDict \u4E2D\u7684\u9879",
         typedDictEmptyName: "TypedDict \u4E2D\u7684\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A",
         typedDictEntryName: "\u5B57\u5178\u6761\u76EE\u540D\u79F0\u7684\u9884\u671F\u5B57\u7B26\u4E32\u6587\u672C",
         typedDictEntryUnique: "\u5B57\u5178\u4E2D\u7684\u540D\u79F0\u5FC5\u987B\u552F\u4E00",
         typedDictExtraArgs: "\u4E0D\u652F\u6301\u989D\u5916\u7684 TypedDict \u53C2\u6570",
-        typedDictExtraItemsClosed: "\u5982\u679C TypedDict \u652F\u6301\u989D\u5916\u9879\u76EE\uFF0C\u5219\u65E0\u6CD5\u5C06\u5176 closed",
+        typedDictExtraItemsClosed: 'TypedDict \u53EF\u4EE5\u4F7F\u7528 "closed" \u6216 "extra_items"\uFF0C\u4F46\u4E0D\u80FD\u540C\u65F6\u4F7F\u7528',
         typedDictFieldNotRequiredRedefinition: "\u65E0\u6CD5\u5C06 TypedDict \u9879\u201C{name}\u201D\u91CD\u65B0\u5B9A\u4E49\u4E3A NotRequired",
         typedDictFieldReadOnlyRedefinition: "\u65E0\u6CD5\u5C06 TypedDict \u9879\u201C{name}\u201D\u91CD\u65B0\u5B9A\u4E49\u4E3A ReadOnly",
         typedDictFieldRequiredRedefinition: "\u65E0\u6CD5\u5C06 TypedDict \u9879\u201C{name}\u201D\u91CD\u65B0\u5B9A\u4E49\u4E3A Required",
@@ -29380,7 +29232,6 @@ var require_package_nls_zh_cn = __commonJS({
         typedDictFieldRequired: '"{type}"\u4E2D\u9700\u8981"{name}"',
         typedDictFieldTypeMismatch: "\u7C7B\u578B\u201C{type}\u201D\u4E0D\u53EF\u5206\u914D\u7ED9\u9879\u201C{name}\u201D",
         typedDictFieldUndefined: "\u201C{name}\u201D\u662F\u7C7B\u578B\u201C{type}\u201D\u4E2D\u7684\u672A\u5B9A\u4E49\u9879",
-        typedDictFinalMismatch: '"{sourceType}"\u4E0E"{destType}"\u4E0D\u517C\u5BB9\uFF0C\u56E0\u4E3A@final\u4E0D\u5339\u914D',
         typedDictKeyAccess: '\u4F7F\u7528 ["{name}"] \u5F15\u7528 TypedDict \u4E2D\u7684\u9879',
         typedDictNotAllowed: "\u4E0D\u80FD\u5BF9\u5B9E\u4F8B\u6216\u7C7B\u68C0\u67E5\u4F7F\u7528 TypedDict",
         unhashableType: "\u7C7B\u578B\u201C{type}\u201D\u4E0D\u53EF\u54C8\u5E0C",
@@ -29752,6 +29603,7 @@ var require_package_nls_zh_tw = __commonJS({
         noneNotUsableWithAsync: '\u985E\u578B "None" \u7684\u7269\u4EF6\u4E0D\u80FD\u8207 "async with" \u642D\u914D\u4F7F\u7528',
         noneOperator: '"None" \u4E0D\u652F\u63F4\u904B\u7B97\u5B50 "{operator}"',
         noneUnknownMember: '"{name}" \u4E0D\u662F "None" \u7684\u5DF2\u77E5\u5C6C\u6027',
+        nonlocalTypeParam: '\u985E\u578B\u53C3\u6578 "{name}" \u4E0D\u5141\u8A31\u4F7F\u7528\u975E Nonlocal \u7E6B\u7D50',
         notRequiredArgCount: '\u9810\u671F "NotRequired" \u4E4B\u5F8C\u70BA\u55AE\u4E00\u985E\u578B\u5F15\u6578',
         notRequiredNotInTypedDict: '\u6B64\u5167\u5BB9\u4E2D\u4E0D\u5141\u8A31 "NotRequired"',
         objectNotCallable: '\u985E\u578B "{type}" \u7684\u7269\u4EF6\u7121\u6CD5\u547C\u53EB',
@@ -29770,11 +29622,11 @@ var require_package_nls_zh_tw = __commonJS({
         overloadAbstractImplMismatch: "\u591A\u8F09\u5FC5\u9808\u7B26\u5408\u5BE6\u4F5C\u7684\u62BD\u8C61\u72C0\u614B",
         overloadAbstractMismatch: "\u591A\u8F09\u5FC5\u9808\u5168\u70BA\u62BD\u8C61\u6216\u4E0D\u62BD\u8C61",
         overloadClassMethodInconsistent: '"{name}" \u7684\u591A\u8F09\u4E0D\u4E00\u81F4\u5730\u4F7F\u7528 @classmethod',
-        overloadFinalImpl: "@final decorator should be applied only to the implementation",
-        overloadFinalNoImpl: "Only the first overload should be marked @final",
+        overloadFinalImpl: "@final \u88DD\u98FE\u61C9\u8A72\u53EA\u5957\u7528\u5230\u5BE6\u4F5C",
+        overloadFinalNoImpl: "\u53EA\u61C9\u5C07\u7B2C\u4E00\u500B\u591A\u8F09\u6A19\u793A\u70BA @final",
         overloadImplementationMismatch: "\u591A\u8F09\u7684\u5BE6\u4F5C\u8207\u591A\u8F09 {index} \u7684\u7C3D\u7AE0\u4E0D\u4E00\u81F4",
-        overloadOverrideImpl: "@override decorator should be applied only to the implementation",
-        overloadOverrideNoImpl: "Only the first overload should be marked @override",
+        overloadOverrideImpl: "@override \u88DD\u98FE\u61C9\u8A72\u53EA\u5957\u7528\u5230\u5BE6\u4F5C",
+        overloadOverrideNoImpl: "\u53EA\u61C9\u5C07\u7B2C\u4E00\u500B\u591A\u8F09\u6A19\u793A\u70BA @override",
         overloadReturnTypeMismatch: '"{name}" \u7684\u591A\u8F09 {prevIndex} \u8207\u591A\u8F09 {newIndex} \u91CD\u758A\uFF0C\u4E26\u50B3\u56DE\u4E0D\u76F8\u5BB9\u7684\u985E\u578B',
         overloadStaticMethodInconsistent: '"{name}" \u7684\u591A\u8F09\u4E0D\u4E00\u81F4\u5730\u4F7F\u7528 @staticmethod',
         overloadWithoutImplementation: '"{name}" \u6A19\u793A\u70BA overload\uFF0C\u4F46\u672A\u63D0\u4F9B\u5BE6\u4F5C',
@@ -29970,14 +29822,14 @@ var require_package_nls_zh_tw = __commonJS({
         typedDictBadVar: "TypedDict \u985E\u5225\u53EA\u80FD\u5305\u542B\u578B\u5225\u8A3B\u91CB",
         typedDictBaseClass: "TypedDict \u985E\u5225\u7684\u6240\u6709\u57FA\u5E95\u985E\u5225\u4E5F\u5FC5\u9808\u662F TypedDict \u985E\u5225",
         typedDictBoolParam: '\u9810\u671F "{name}" \u53C3\u6578\u7684\u503C\u70BA True \u6216 False',
-        typedDictClosedExtras: '\u57FA\u5E95\u985E\u5225 "{name}" \u662F closed \u7684 TypedDict; \u984D\u5916\u9805\u76EE\u5FC5\u9808\u70BA\u578B\u5225 "{type}"',
+        typedDictClosedExtras: '\u57FA\u985E "{name}" \u662F\u9650\u5236\u984D\u5916\u5C08\u6848\u985E\u578B\u7684 TypedDict "{type}"',
         typedDictClosedNoExtras: '\u57FA\u5E95\u985E\u5225 "{name}" \u662F closed \u7684 TypedDict; \u4E0D\u5141\u8A31\u984D\u5916\u9805\u76EE',
         typedDictDelete: "\u7121\u6CD5\u522A\u9664 TypedDict \u4E2D\u7684\u9805\u76EE",
         typedDictEmptyName: "TypedDict \u5167\u7684\u540D\u7A31\u4E0D\u53EF\u70BA\u7A7A\u767D",
         typedDictEntryName: "\u5B57\u5178\u9805\u76EE\u540D\u7A31\u9810\u671F\u70BA\u5B57\u4E32\u5E38\u503C",
         typedDictEntryUnique: "\u5B57\u5178\u5167\u7684\u540D\u7A31\u5FC5\u9808\u662F\u552F\u4E00\u7684",
         typedDictExtraArgs: "\u4E0D\u652F\u63F4\u984D\u5916\u7684 TypedDict \u5F15\u6578",
-        typedDictExtraItemsClosed: "\u5982\u679C TypedDict \u652F\u63F4\u984D\u5916\u9805\u76EE\uFF0C\u5C31\u4E0D\u80FD\u662F closed",
+        typedDictExtraItemsClosed: 'TypedDict \u53EF\u4EE5\u4F7F\u7528 "closed" \u6216 "extra_items"\uFF0C\u4F46\u4E0D\u80FD\u540C\u6642\u4F7F\u7528\u5169\u8005',
         typedDictFieldNotRequiredRedefinition: 'TypedDict \u9805\u76EE "{name}" \u4E0D\u80FD\u91CD\u65B0\u5B9A\u7FA9\u70BA NotRequired',
         typedDictFieldReadOnlyRedefinition: 'TypedDict \u9805\u76EE "{name}" \u4E0D\u80FD\u91CD\u65B0\u5B9A\u7FA9\u70BA ReadOnly',
         typedDictFieldRequiredRedefinition: 'TypedDict \u9805\u76EE "{name}" \u4E0D\u80FD\u91CD\u65B0\u5B9A\u7FA9\u70BA Required',
@@ -30219,7 +30071,6 @@ var require_package_nls_zh_tw = __commonJS({
         typedDictFieldRequired: '"{type}" \u4E2D\u9700\u8981 "{name}"',
         typedDictFieldTypeMismatch: '\u578B\u5225 "{type}" \u7121\u6CD5\u6307\u6D3E\u7D66\u9805\u76EE "{name}"',
         typedDictFieldUndefined: '"{name}" \u662F\u578B\u5225 "{type}" \u4E2D\u672A\u5B9A\u7FA9\u7684\u9805\u76EE',
-        typedDictFinalMismatch: '"{sourceType}" \u8207 "{destType}" \u4E0D\u76F8\u5BB9\uFF0C\u56E0\u70BA@final \u4E0D\u7B26',
         typedDictKeyAccess: '\u4F7F\u7528 ["{name}"] \u53C3\u8003 TypedDict \u4E2D\u7684\u9805\u76EE',
         typedDictNotAllowed: "\u57F7\u884C\u500B\u9AD4\u6216\u985E\u5225\u6AA2\u67E5\u7121\u6CD5\u4F7F\u7528 TypedDict",
         unhashableType: '\u578B\u5225 "{type}" \u7121\u6CD5\u96DC\u6E4A',
@@ -30443,6 +30294,7 @@ var require_localize = __commonJS({
         Diagnostic4.baseClassVariableTypeIncompatible = () => new ParameterizedString(getRawString("Diagnostic.baseClassVariableTypeIncompatible"));
         Diagnostic4.baseClassUnknown = () => getRawString("Diagnostic.baseClassUnknown");
         Diagnostic4.binaryOperationNotAllowed = () => getRawString("Diagnostic.binaryOperationNotAllowed");
+        Diagnostic4.bindParamMissing = () => new ParameterizedString(getRawString("Diagnostic.bindParamMissing"));
         Diagnostic4.bindTypeMismatch = () => new ParameterizedString(getRawString("Diagnostic.bindTypeMismatch"));
         Diagnostic4.breakInExceptionGroup = () => getRawString("Diagnostic.breakInExceptionGroup");
         Diagnostic4.breakOutsideLoop = () => getRawString("Diagnostic.breakOutsideLoop");
@@ -30724,11 +30576,12 @@ var require_localize = __commonJS({
         Diagnostic4.noneNotUsableWithAsync = () => getRawString("Diagnostic.noneNotUsableWithAsync");
         Diagnostic4.noneOperator = () => new ParameterizedString(getRawString("Diagnostic.noneOperator"));
         Diagnostic4.noneUnknownMember = () => new ParameterizedString(getRawString("Diagnostic.noneUnknownMember"));
+        Diagnostic4.nonLocalInModule = () => getRawString("Diagnostic.nonLocalInModule");
         Diagnostic4.nonLocalNoBinding = () => new ParameterizedString(getRawString("Diagnostic.nonLocalNoBinding"));
         Diagnostic4.nonLocalReassignment = () => new ParameterizedString(getRawString("Diagnostic.nonLocalReassignment"));
         Diagnostic4.nonLocalRedefinition = () => new ParameterizedString(getRawString("Diagnostic.nonLocalRedefinition"));
-        Diagnostic4.nonLocalInModule = () => getRawString("Diagnostic.nonLocalInModule");
         Diagnostic4.noOverload = () => new ParameterizedString(getRawString("Diagnostic.noOverload"));
+        Diagnostic4.nonlocalTypeParam = () => new ParameterizedString(getRawString("Diagnostic.nonlocalTypeParam"));
         Diagnostic4.noReturnContainsReturn = () => getRawString("Diagnostic.noReturnContainsReturn");
         Diagnostic4.noReturnContainsYield = () => getRawString("Diagnostic.noReturnContainsYield");
         Diagnostic4.noReturnReturnsNone = () => getRawString("Diagnostic.noReturnReturnsNone");
@@ -30872,6 +30725,7 @@ var require_localize = __commonJS({
         Diagnostic4.typeAliasRedeclared = () => new ParameterizedString(getRawString("Diagnostic.typeAliasRedeclared"));
         Diagnostic4.typeAliasStatementIllegal = () => getRawString("Diagnostic.typeAliasStatementIllegal");
         Diagnostic4.typeAliasStatementBadScope = () => getRawString("Diagnostic.typeAliasStatementBadScope");
+        Diagnostic4.typeAliasTypeBadScope = () => getRawString("Diagnostic.typeAliasTypeBadScope");
         Diagnostic4.typeAliasTypeBaseClass = () => getRawString("Diagnostic.typeAliasTypeBaseClass");
         Diagnostic4.typeAliasTypeMustBeAssigned = () => getRawString("Diagnostic.typeAliasTypeMustBeAssigned");
         Diagnostic4.typeAliasTypeNameArg = () => getRawString("Diagnostic.typeAliasTypeNameArg");
@@ -31184,7 +31038,6 @@ var require_localize = __commonJS({
         DiagnosticAddendum2.typedDictFieldRequired = () => new ParameterizedString(getRawString("DiagnosticAddendum.typedDictFieldRequired"));
         DiagnosticAddendum2.typedDictFieldTypeMismatch = () => new ParameterizedString(getRawString("DiagnosticAddendum.typedDictFieldTypeMismatch"));
         DiagnosticAddendum2.typedDictFieldUndefined = () => new ParameterizedString(getRawString("DiagnosticAddendum.typedDictFieldUndefined"));
-        DiagnosticAddendum2.typedDictFinalMismatch = () => new ParameterizedString(getRawString("DiagnosticAddendum.typedDictFinalMismatch"));
         DiagnosticAddendum2.typedDictKeyAccess = () => new ParameterizedString(getRawString("DiagnosticAddendum.typedDictKeyAccess"));
         DiagnosticAddendum2.typedDictNotAllowed = () => getRawString("DiagnosticAddendum.typedDictNotAllowed");
         DiagnosticAddendum2.typeIncompatible = () => new ParameterizedString(getRawString("DiagnosticAddendum.typeIncompatible"));
@@ -34139,6 +33992,7 @@ var require_parseTreeUtils = __commonJS({
     exports2.getTypeVarScopesForNode = getTypeVarScopesForNode;
     exports2.checkDecorator = checkDecorator;
     exports2.isSimpleDefault = isSimpleDefault;
+    exports2.getPreviousNonWhitespaceToken = getPreviousNonWhitespaceToken;
     var AnalyzerNodeInfo = __importStar(require_analyzerNodeInfo());
     var core_1 = require_core();
     var debug_1 = require_debug();
@@ -36261,6 +36115,17 @@ var require_parseTreeUtils = __commonJS({
           return false;
       }
     }
+    function getPreviousNonWhitespaceToken(tokens, offset) {
+      let tokenIndex = tokens.getItemAtPosition(offset);
+      while (tokenIndex >= 0) {
+        const token = tokens.getItemAt(tokenIndex);
+        if (!isWhitespace(token)) {
+          return token;
+        }
+        tokenIndex -= 1;
+      }
+      return void 0;
+    }
   }
 });
 
@@ -42655,6 +42520,7 @@ var require_tokenizer = __commonJS({
         }
       }
       _skipToEndOfStringLiteral(flags, inFormatSpecifier = false) {
+        var _a;
         const quoteChar = flags & 1 ? 39 : 34;
         const isTriplicate = (flags & 4) !== 0;
         const isFString = (flags & 64) !== 0;
@@ -42696,12 +42562,14 @@ var require_tokenizer = __commonJS({
               }
             }
           } else if (this._cs.currentChar === 10 || this._cs.currentChar === 13) {
-            if (!isTriplicate && !isFString) {
-              flags |= 65536;
-              return {
-                escapedValue: getEscapedValue(),
-                flags
-              };
+            if (!isTriplicate) {
+              if (!isFString || !((_a = this._activeFString) == null ? void 0 : _a.activeReplacementField)) {
+                flags |= 65536;
+                return {
+                  escapedValue: getEscapedValue(),
+                  flags
+                };
+              }
             }
             if (this._cs.currentChar === 13 && this._cs.nextChar === 10) {
               escapedValueLength++;
@@ -44325,6 +44193,7 @@ var require_binder = __commonJS({
           /* unbound */
           false
         );
+        this._addInferredTypeAssignmentForVariable(node.d.destExpr, node.d.rightExpr);
         if (node.d.operator === 1 && this._currentScope.type === 4 && node.d.leftExpr.nodeType === 38 && node.d.leftExpr.d.value === "__all__") {
           const expr = node.d.rightExpr;
           let emitDunderAllWarning = true;
@@ -46743,6 +46612,7 @@ var require_sourceFileInfoUtils = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.isUserCode = isUserCode;
     exports2.collectImportedByCells = collectImportedByCells;
+    exports2.collectImportedByRecursively = collectImportedByRecursively;
     exports2.verifyNoCyclesInChainedFiles = verifyNoCyclesInChainedFiles;
     exports2.createChainedByList = createChainedByList;
     var debug_1 = require_debug();
@@ -46754,9 +46624,18 @@ var require_sourceFileInfoUtils = __commonJS({
     function collectImportedByCells(program, fileInfo) {
       _parseAllOpenCells(program);
       const importedByCells = /* @__PURE__ */ new Set();
-      _collectImportedByCells(fileInfo, importedByCells);
+      collectImportedByRecursively(fileInfo, importedByCells);
       return importedByCells;
     }
+    function collectImportedByRecursively(fileInfo, importedBy) {
+      fileInfo.importedBy.forEach((dep) => {
+        if (importedBy.has(dep)) {
+          return;
+        }
+        importedBy.add(dep);
+        collectImportedByRecursively(dep, importedBy);
+      });
+    }
     function verifyNoCyclesInChainedFiles(program, fileInfo) {
       var _a;
       let nextChainedFile = fileInfo.chainedSourceFile;
@@ -46806,15 +46685,6 @@ var require_sourceFileInfoUtils = __commonJS({
         program.handleMemoryHighUsage();
       }
     }
-    function _collectImportedByCells(fileInfo, importedByCells) {
-      fileInfo.importedBy.forEach((dep) => {
-        if (importedByCells.has(dep)) {
-          return;
-        }
-        importedByCells.add(dep);
-        _collectImportedByCells(dep, importedByCells);
-      });
-    }
   }
 });
 
@@ -47897,13 +47767,19 @@ var require_types = __commonJS({
       }
       FunctionType2.cloneAsInstantiable = cloneAsInstantiable;
       function specialize(type, specializedTypes, specializedInferredReturnType) {
+        var _a;
         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;
-        newFunction.priv.inferredReturnType = specializedInferredReturnType;
+        if (specializedInferredReturnType) {
+          newFunction.priv.inferredReturnType = {
+            type: specializedInferredReturnType,
+            isIncomplete: (_a = type.priv.inferredReturnType) == null ? void 0 : _a.isIncomplete
+          };
+        }
         return newFunction;
       }
       FunctionType2.specialize = specialize;
@@ -48211,7 +48087,7 @@ var require_types = __commonJS({
       }
       FunctionType2.addKeywordOnlyParamSeparator = addKeywordOnlyParamSeparator;
       function getEffectiveReturnType(type, includeInferred = true) {
-        var _a;
+        var _a, _b;
         if ((_a = type.priv.specializedTypes) == null ? void 0 : _a.returnType) {
           return type.priv.specializedTypes.returnType;
         }
@@ -48219,7 +48095,7 @@ var require_types = __commonJS({
           return type.shared.declaredReturnType;
         }
         if (includeInferred) {
-          return type.priv.inferredReturnType;
+          return (_b = type.priv.inferredReturnType) == null ? void 0 : _b.type;
         }
         return void 0;
       }
@@ -48869,7 +48745,7 @@ var require_types = __commonJS({
       return void 0;
     }
     function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
-      var _a, _b, _c, _d, _e, _f, _g, _h;
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
       if (type1 === type2) {
         return true;
       }
@@ -49006,14 +48882,14 @@ var require_types = __commonJS({
             return1Type = type1.priv.specializedTypes.returnType;
           }
           if (!return1Type && type1.priv.inferredReturnType) {
-            return1Type = type1.priv.inferredReturnType;
+            return1Type = (_e = type1.priv.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 = functionType2.priv.inferredReturnType;
+            return2Type = (_f = functionType2.priv.inferredReturnType) == null ? void 0 : _f.type;
           }
           if (return1Type || return2Type) {
             if (!return1Type || !return2Type || !isTypeSame(return1Type, return2Type, { ...options, ignoreTypeFlags: false }, recursionCount)) {
@@ -49053,8 +48929,8 @@ var require_types = __commonJS({
             return false;
           }
           if (type1.shared.recursiveAlias && type2TypeVar.shared.recursiveAlias) {
-            const type1TypeArgs = ((_f = (_e = type1 == null ? void 0 : type1.props) == null ? void 0 : _e.typeAliasInfo) == null ? void 0 : _f.typeArgs) || [];
-            const type2TypeArgs = ((_h = (_g = type2 == null ? void 0 : type2.props) == null ? void 0 : _g.typeAliasInfo) == null ? void 0 : _h.typeArgs) || [];
+            const type1TypeArgs = ((_h = (_g = type1 == null ? void 0 : type1.props) == null ? void 0 : _g.typeAliasInfo) == null ? void 0 : _h.typeArgs) || [];
+            const type2TypeArgs = ((_j = (_i = type2 == null ? void 0 : type2.props) == null ? void 0 : _i.typeAliasInfo) == null ? void 0 : _j.typeArgs) || [];
             const typeArgCount = Math.max(type1TypeArgs.length, type2TypeArgs.length);
             for (let i = 0; i < typeArgCount; i++) {
               const typeArg1 = i < type1TypeArgs.length ? type1TypeArgs[i] : AnyType.create();
@@ -49535,6 +49411,7 @@ var require_typeWalker = __commonJS({
       visitNever(type) {
       }
       visitFunction(type) {
+        var _a;
         for (let i = 0; i < type.shared.parameters.length; i++) {
           if (type.shared.parameters[i].name) {
             const paramType = types_1.FunctionType.getParamType(type, i);
@@ -49545,7 +49422,7 @@ var require_typeWalker = __commonJS({
           }
         }
         if (!this._isWalkCanceled && !types_1.FunctionType.isParamSpecValue(type) && !types_1.FunctionType.isParamSpecValue(type)) {
-          const returnType = type.shared.declaredReturnType ?? type.priv.inferredReturnType;
+          const returnType = type.shared.declaredReturnType ?? ((_a = type.priv.inferredReturnType) == null ? void 0 : _a.type);
           if (returnType) {
             this.walk(returnType);
           }
@@ -49728,6 +49605,7 @@ var require_typeUtils = __commonJS({
       MemberAccessFlags2[MemberAccessFlags2["SkipAttributeAccessOverride"] = 512] = "SkipAttributeAccessOverride";
       MemberAccessFlags2[MemberAccessFlags2["DisallowGenericInstanceVariableAccess"] = 1024] = "DisallowGenericInstanceVariableAccess";
       MemberAccessFlags2[MemberAccessFlags2["TypeExpression"] = 2048] = "TypeExpression";
+      MemberAccessFlags2[MemberAccessFlags2["SkipTypedDictEntries"] = 4096] = "SkipTypedDictEntries";
     })(MemberAccessFlags || (exports2.MemberAccessFlags = MemberAccessFlags = {}));
     var ClassIteratorFlags;
     (function(ClassIteratorFlags2) {
@@ -50762,6 +50640,7 @@ var require_typeUtils = __commonJS({
       return (_b = memberItr.next()) == null ? void 0 : _b.value;
     }
     function* getClassMemberIterator(classType, memberName, flags = 0, skipMroClass) {
+      var _a;
       const declaredTypesOnly = (flags & 64) !== 0;
       let skippedUndeclaredType = false;
       if ((0, types_1.isClass)(classType)) {
@@ -50804,9 +50683,10 @@ var require_typeUtils = __commonJS({
             continue;
           }
           const memberFields = types_1.ClassType.getSymbolTable(specializedMroClass);
+          const skipTdEntry = (flags & 4096) !== 0 && ((_a = specializedMroClass.shared.typedDictEntries) == null ? void 0 : _a.knownItems.has(memberName));
           if ((flags & 16) === 0) {
             const symbol = memberFields.get(memberName);
-            if (symbol && symbol.isInstanceMember()) {
+            if (symbol && symbol.isInstanceMember() && !skipTdEntry) {
               const hasDeclaredType = symbol.hasTypedDeclarations();
               if (!declaredTypesOnly || hasDeclaredType) {
                 const cm = {
@@ -50828,7 +50708,7 @@ var require_typeUtils = __commonJS({
           }
           if ((flags & 32) === 0) {
             let symbol = memberFields.get(memberName);
-            if (symbol && symbol.isClassMember()) {
+            if (symbol && symbol.isClassMember() && !skipTdEntry) {
               const hasDeclaredType = symbol.hasTypedDeclarations();
               if (!declaredTypesOnly || hasDeclaredType) {
                 let isInstanceMember = symbol.isInstanceMember();
@@ -51618,7 +51498,7 @@ var require_typeUtils = __commonJS({
       return result;
     }
     function _requiresSpecialization(type, options, recursionCount = 0) {
-      var _a, _b;
+      var _a, _b, _c;
       if ((_a = type.props) == null ? void 0 : _a.condition) {
         return true;
       }
@@ -51652,7 +51532,7 @@ var require_typeUtils = __commonJS({
               return true;
             }
           } else if (type.priv.inferredReturnType) {
-            if (requiresSpecialization(type.priv.inferredReturnType, options, recursionCount)) {
+            if (requiresSpecialization((_b = type.priv.inferredReturnType) == null ? void 0 : _b.type, options, recursionCount)) {
               return true;
             }
           }
@@ -51679,7 +51559,7 @@ var require_typeUtils = __commonJS({
             }
             return true;
           }
-          const aliasInfo = (_b = type.props) == null ? void 0 : _b.typeAliasInfo;
+          const aliasInfo = (_c = type.props) == null ? void 0 : _c.typeAliasInfo;
           if (aliasInfo == null ? void 0 : aliasInfo.typeArgs) {
             return aliasInfo.typeArgs.some((typeArg) => requiresSpecialization(typeArg, options, recursionCount));
           }
@@ -52186,6 +52066,7 @@ var require_typeUtils = __commonJS({
       }
       transformTypeVarsInFunctionType(sourceType, recursionCount) {
         return this.doForEachConstraintSet(() => {
+          var _a, _b;
           let functionType = sourceType;
           const declaredReturnType = types_1.FunctionType.getEffectiveReturnType(functionType);
           const specializedReturnType = declaredReturnType ? this.apply(declaredReturnType, recursionCount) : void 0;
@@ -52234,8 +52115,8 @@ var require_typeUtils = __commonJS({
           }
           let specializedInferredReturnType;
           if (functionType.priv.inferredReturnType) {
-            specializedInferredReturnType = this.apply(functionType.priv.inferredReturnType, recursionCount);
-            if (specializedInferredReturnType !== 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)) {
               typesRequiredSpecialization = true;
             }
           }
@@ -53950,7 +53831,7 @@ var require_constraintTracker = __commonJS({
         return this._scopeIds.has(scopeId);
       }
       getScopeIds() {
-        return new Set(this._scopeIds);
+        return this._scopeIds ? [...this._scopeIds] : [];
       }
       hasUnificationVars() {
         for (const entry of this._typeVarMap.values()) {
@@ -53971,15 +53852,18 @@ var require_constraintTracker = __commonJS({
         newTypeVarMap._constraintSets = this._constraintSets.map((set) => set.clone());
         return newTypeVarMap;
       }
-      cloneWithSignature(scopeId) {
+      cloneWithSignature(scopeIds) {
         const cloned = this.clone();
-        if (scopeId) {
-          const filteredSets = this._constraintSets.filter((context) => context.hasScopeId(scopeId));
+        const nonEmptyScopeIds = scopeIds.filter((scopeId) => !!scopeId);
+        if (nonEmptyScopeIds.length > 0) {
+          const filteredSets = this._constraintSets.filter((context) => nonEmptyScopeIds.every((scopeId) => context.hasScopeId(scopeId)));
           if (filteredSets.length > 0) {
             cloned._constraintSets = filteredSets;
           } else {
             cloned._constraintSets.forEach((context) => {
-              context.addScopeId(scopeId);
+              nonEmptyScopeIds.forEach((scopeId) => {
+                context.addScopeId(scopeId);
+              });
             });
           }
         }
@@ -55002,7 +54886,7 @@ var require_parameterUtils = __commonJS({
       ParamKind2[ParamKind2["Keyword"] = 2] = "Keyword";
       ParamKind2[ParamKind2["ExpandedArgs"] = 3] = "ExpandedArgs";
     })(ParamKind || (exports2.ParamKind = ParamKind = {}));
-    function getParamListDetails(type) {
+    function getParamListDetails(type, options) {
       const result = {
         firstPositionOrKeywordIndex: 0,
         positionParamCount: 0,
@@ -55062,7 +54946,7 @@ var require_parameterUtils = __commonJS({
         }
       };
       type.shared.parameters.forEach((param, index) => {
-        var _a, _b;
+        var _a, _b, _c;
         if (param.category === 1) {
           const paramType = types_1.FunctionType.getParamType(type, index);
           if (param.name && (0, types_1.isUnpackedClass)(paramType) && paramType.priv.tupleTypeArgs) {
@@ -55130,8 +55014,9 @@ var require_parameterUtils = __commonJS({
               const defaultParamType = !entry.isRequired ? specializedParamType : void 0;
               addVirtualParam(types_1.FunctionParam.create(0, specializedParamType, types_1.FunctionParamFlags.TypeDeclared, name, defaultParamType), index, specializedParamType, defaultParamType);
             });
-            if (paramType.shared.typedDictEntries.extraItems) {
-              addVirtualParam(types_1.FunctionParam.create(2, paramType.shared.typedDictEntries.extraItems.valueType, types_1.FunctionParamFlags.TypeDeclared, "kwargs"), index, paramType.shared.typedDictEntries.extraItems.valueType);
+            const extraItemsType = ((_a = paramType.shared.typedDictEntries.extraItems) == null ? void 0 : _a.valueType) ?? types_1.AnyType.create();
+            if (!(0, types_1.isNever)(extraItemsType) && !(options == null ? void 0 : options.disallowExtraKwargsForTd)) {
+              addVirtualParam(types_1.FunctionParam.create(2, extraItemsType, types_1.FunctionParamFlags.TypeDeclared, "kwargs"), index, extraItemsType);
               result.kwargsIndex = result.params.length - 1;
             }
             result.hasUnpackedTypedDict = true;
@@ -55154,7 +55039,7 @@ var require_parameterUtils = __commonJS({
             index,
             /* typeOverride */
             void 0,
-            ((_a = type.priv.specializedTypes) == null ? void 0 : _a.parameterDefaultTypes) ? (_b = type.priv.specializedTypes) == null ? void 0 : _b.parameterDefaultTypes[index] : void 0
+            ((_b = type.priv.specializedTypes) == null ? void 0 : _b.parameterDefaultTypes) ? (_c = type.priv.specializedTypes) == null ? void 0 : _c.parameterDefaultTypes[index] : void 0
           );
         }
       });
@@ -55336,31 +55221,33 @@ var require_typedDicts = __commonJS({
       }
       if (usingDictSyntax) {
         const argsToConsider = argList.slice(2);
+        let sawClosedOrExtraItems = false;
         for (const arg of argsToConsider) {
           if (((_a = arg.name) == null ? void 0 : _a.d.value) === "total" || ((_b = arg.name) == null ? void 0 : _b.d.value) === "closed") {
             if (!arg.valueExpression || arg.valueExpression.nodeType !== 14 || !(arg.valueExpression.d.constType === 15 || arg.valueExpression.d.constType === 33)) {
               evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictBoolParam().format({ name: arg.name.d.value }), arg.valueExpression || errorNode);
             } else if (arg.name.d.value === "total" && arg.valueExpression.d.constType === 15) {
               classType.shared.flags |= 32;
-            } else if (arg.name.d.value === "closed" && arg.valueExpression.d.constType === 33) {
-              if (AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
+            } else if (arg.name.d.value === "closed" && AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
+              if (arg.valueExpression.d.constType === 33) {
                 classType.shared.flags |= 8 | 16;
               }
+              if (sawClosedOrExtraItems) {
+                evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), arg.valueExpression || errorNode);
+              }
+              sawClosedOrExtraItems = true;
             }
-          } else if (((_c = arg.name) == null ? void 0 : _c.d.value) === "extra_items") {
+          } else if (((_c = arg.name) == null ? void 0 : _c.d.value) === "extra_items" && AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures) {
             classType.shared.typedDictExtraItemsExpr = arg.valueExpression;
             classType.shared.flags |= 16;
+            if (sawClosedOrExtraItems) {
+              evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), arg.valueExpression || errorNode);
+            }
+            sawClosedOrExtraItems = true;
           } else {
             evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typedDictExtraArgs(), arg.valueExpression || errorNode);
           }
         }
-        if (types_1.ClassType.isTypedDictMarkedClosed(classType) && classType.shared.typedDictExtraItemsExpr) {
-          const arg = argsToConsider.find((arg2) => {
-            var _a2;
-            return ((_a2 = arg2.name) == null ? void 0 : _a2.d.value) === "extra_items";
-          });
-          evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), (arg == null ? void 0 : arg.valueExpression) ?? errorNode);
-        }
       }
       synthesizeTypedDictClassMethods(evaluator, errorNode, classType);
       if (((_d = errorNode.parent) == null ? void 0 : _d.nodeType) === 3 && className) {
@@ -55666,6 +55553,23 @@ var require_typedDicts = __commonJS({
             true
           ));
         }
+        if (types_1.ClassType.isTypedDictEffectivelyClosed(classType)) {
+          if (!(0, types_1.isNever)(extraEntriesInfo.valueType)) {
+            popOverloads.push(...createPopMethods(
+              strType,
+              extraEntriesInfo.valueType,
+              /* isEntryRequired */
+              false
+            ));
+          }
+        } else {
+          popOverloads.push(...createPopMethods(
+            strType,
+            evaluator.getObjectType(),
+            /* isEntryRequired */
+            false
+          ));
+        }
         symbolTable.set("get", symbol_1.Symbol.createWithType(4, types_1.OverloadedType.create(getOverloads)));
         if (popOverloads.length > 0) {
           symbolTable.set("pop", symbol_1.Symbol.createWithType(4, types_1.OverloadedType.create(popOverloads)));
@@ -56435,6 +56339,7 @@ var require_constructorTransform = __commonJS({
       return void 0;
     }
     function applyPartialTransformToFunction(evaluator, errorNode, argList, partialCallMemberType, origFunctionType) {
+      var _a;
       const paramMap = /* @__PURE__ */ new Map();
       const paramListDetails = (0, parameterUtils_1.getParamListDetails)(origFunctionType);
       let argumentErrors = false;
@@ -56503,8 +56408,8 @@ var require_constructorTransform = __commonJS({
           }
         } else {
           const matchingParam = paramListDetails.params.find((paramInfo) => {
-            var _a;
-            return paramInfo.param.name === ((_a = arg.name) == null ? void 0 : _a.d.value) && paramInfo.kind !== parameterUtils_1.ParamKind.Positional;
+            var _a2;
+            return paramInfo.param.name === ((_a2 = arg.name) == null ? void 0 : _a2.d.value) && paramInfo.kind !== parameterUtils_1.ParamKind.Positional;
           });
           if (!matchingParam) {
             if (paramListDetails.kwargsIndex === void 0) {
@@ -56616,7 +56521,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) : specializedFunctionType.priv.inferredReturnType;
+      newCallMemberType.shared.declaredReturnType = specializedFunctionType.shared.declaredReturnType ? types_1.FunctionType.getEffectiveReturnType(specializedFunctionType) : (_a = specializedFunctionType.priv.inferredReturnType) == null ? void 0 : _a.type;
       newCallMemberType.shared.declaration = partialCallMemberType.shared.declaration;
       newCallMemberType.shared.typeVarScopeId = specializedFunctionType.shared.typeVarScopeId;
       return { returnType: newCallMemberType, isTypeIncomplete: false, argumentErrors };
@@ -56772,7 +56677,7 @@ var require_constructors = __commonJS({
       }
       if (!newMethodReturnType || isDefaultNewMethod(newMethodTypeResult == null ? void 0 : newMethodTypeResult.type)) {
         newMethodReturnType = types_1.ClassType.cloneAsInstance(type);
-      } else if ((0, types_1.isAnyOrUnknown)(newMethodReturnType)) {
+      } else if ((0, types_1.isUnknown)(newMethodReturnType) || newMethodTypeResult && (0, types_1.isAny)(newMethodTypeResult.type)) {
         newMethodReturnType = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstance(type), new constraintSolution_1.ConstraintSolution(), {
           replaceUnsolved: {
             scopeIds: (0, typeUtils_1.getTypeVarScopeIds)(type),
@@ -57280,6 +57185,7 @@ var require_constructors = __commonJS({
       return skipInitCheck;
     }
     function isDefaultNewMethod(newMethod) {
+      var _a;
       if (!newMethod || !(0, types_1.isFunction)(newMethod)) {
         return false;
       }
@@ -57290,7 +57196,7 @@ var require_constructors = __commonJS({
       if (params[0].category !== 1 || params[1].category !== 2) {
         return false;
       }
-      const returnType = newMethod.shared.declaredReturnType ?? newMethod.priv.inferredReturnType;
+      const returnType = newMethod.shared.declaredReturnType ?? ((_a = newMethod.priv.inferredReturnType) == null ? void 0 : _a.type);
       if (!returnType || !(0, types_1.isTypeVar)(returnType) || !types_1.TypeVarType.isSelf(returnType)) {
         return false;
       }
@@ -60223,17 +60129,23 @@ var require_typeGuards = __commonJS({
         void 0,
         (referenceSubtype) => {
           return (0, typeUtils_1.mapSubtypes)(elementType, (elementSubtype) => {
-            var _a, _b;
+            var _a, _b, _c;
             if ((0, types_1.isAnyOrUnknown)(elementSubtype)) {
               return referenceSubtype;
             }
-            if (evaluator.assignType(referenceSubtype, elementSubtype)) {
+            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)) {
               return (0, typeUtils_1.stripTypeForm)((0, typeUtils_1.addConditionToType)(elementSubtype, (_a = referenceSubtype.props) == null ? void 0 : _a.condition));
             }
-            if (evaluator.assignType(elementSubtype, referenceSubtype)) {
+            if ((0, types_1.isClassInstance)(referenceSubtype) && ((0, typeUtils_1.isLiteralType)(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));
             }
-            return void 0;
+            if ((0, types_1.isInstantiableClass)(elementSubtype) && !elementSubtype.priv.includeSubclasses && evaluator.assignType(referenceSubtype, elementSubtype)) {
+              return (0, typeUtils_1.stripTypeForm)((0, typeUtils_1.addConditionToType)(elementSubtype, (_c = referenceSubtype.props) == null ? void 0 : _c.condition));
+            }
+            return referenceSubtype;
           });
         }
       );
@@ -65745,19 +65657,31 @@ var require_protocols = __commonJS({
       });
       if (typesAreConsistent && destType.shared.typeParams.length > 0) {
         const genericProtocolType = types_1.ClassType.specialize(destType, void 0);
-        const specializedProtocolType = evaluator.solveAndApplyConstraints(genericProtocolType, protocolConstraints);
-        if (destType.priv.typeArgs) {
-          if (!evaluator.assignTypeArgs(destType, specializedProtocolType, diag, constraints, flags, recursionCount)) {
-            typesAreConsistent = false;
-          }
-        } else if (constraints) {
-          for (const typeParam of destType.shared.typeParams) {
-            const typeArgEntry = protocolConstraints.getMainConstraintSet().getTypeVar(typeParam);
-            if (typeArgEntry) {
-              constraints.copyBounds(typeArgEntry);
+        const constraintSets = protocolConstraints.getConstraintSets();
+        let srcConstraints = protocolConstraints;
+        let destConstraints = constraints;
+        constraintSets.forEach((constraintSet) => {
+          if (constraintSets.length > 1) {
+            srcConstraints = protocolConstraints.cloneWithSignature(constraintSet.getScopeIds());
+            destConstraints = constraints == null ? void 0 : constraints.cloneWithSignature(constraintSet.getScopeIds());
+          }
+          const specializedProtocolType = evaluator.solveAndApplyConstraints(genericProtocolType, srcConstraints);
+          if (destType.priv.typeArgs) {
+            if (!evaluator.assignTypeArgs(destType, specializedProtocolType, diag, destConstraints, flags, recursionCount)) {
+              typesAreConsistent = false;
+            }
+          } else if (destConstraints) {
+            for (const typeParam of destType.shared.typeParams) {
+              const typeArgEntry = constraintSet.getTypeVar(typeParam);
+              if (typeArgEntry) {
+                destConstraints.copyBounds(typeArgEntry);
+              }
             }
           }
-        }
+          if (constraintSets.length > 1 && destConstraints) {
+            constraints == null ? void 0 : constraints.addConstraintSets(destConstraints.getConstraintSets());
+          }
+        });
       }
       return typesAreConsistent;
     }
@@ -67352,7 +67276,7 @@ var require_codeFlowEngine = __commonJS({
           false
         );
         if (returnType) {
-          if ((0, types_1.isClassInstance)(returnType) && types_1.ClassType.isBuiltIn(returnType, "Coroutine") && returnType.priv.typeArgs && returnType.priv.typeArgs.length >= 3) {
+          if ((0, types_1.isClassInstance)(returnType) && types_1.ClassType.isBuiltIn(returnType, ["Coroutine", "CoroutineType"]) && returnType.priv.typeArgs && returnType.priv.typeArgs.length >= 3) {
             if ((0, types_1.isNever)(returnType.priv.typeArgs[2]) && isCallAwaited) {
               return true;
             }
@@ -67411,7 +67335,7 @@ var require_codeFlowEngine = __commonJS({
             if (exitType && (0, types_1.isFunction)(exitType) && exitType.shared.declaredReturnType) {
               let returnType = exitType.shared.declaredReturnType;
               if (isAsync) {
-                if ((0, types_1.isClassInstance)(returnType) && types_1.ClassType.isBuiltIn(returnType, "Coroutine") && returnType.priv.typeArgs && returnType.priv.typeArgs.length >= 3) {
+                if ((0, types_1.isClassInstance)(returnType) && types_1.ClassType.isBuiltIn(returnType, ["Coroutine", "CoroutineType"]) && returnType.priv.typeArgs && returnType.priv.typeArgs.length >= 3) {
                   returnType = returnType.priv.typeArgs[2];
                 }
               }
@@ -69560,6 +69484,7 @@ var require_typePrinter = __commonJS({
     exports2.isLiteralValueTruncated = isLiteralValueTruncated;
     exports2.printLiteralValueTruncated = printLiteralValueTruncated;
     exports2.printLiteralValue = printLiteralValue;
+    exports2.getPrintTypeFlags = getPrintTypeFlags;
     var collectionUtils_1 = require_collectionUtils();
     var debug_1 = require_debug();
     var parameterUtils_1 = require_parameterUtils();
@@ -70407,6 +70332,25 @@ var require_typePrinter = __commonJS({
         return false;
       }
     };
+    function getPrintTypeFlags(configOptions) {
+      let flags = 0;
+      if (configOptions.diagnosticRuleSet.printUnknownAsAny) {
+        flags |= 1;
+      }
+      if (configOptions.diagnosticRuleSet.omitConditionalConstraint) {
+        flags |= 64;
+      }
+      if (configOptions.diagnosticRuleSet.omitTypeArgsIfUnknown) {
+        flags |= 2;
+      }
+      if (configOptions.diagnosticRuleSet.omitUnannotatedParamType) {
+        flags |= 4;
+      }
+      if (configOptions.diagnosticRuleSet.pep604Printing) {
+        flags |= 8;
+      }
+      return flags;
+    }
   }
 });
 
@@ -70465,6 +70409,7 @@ var require_typeEvaluator = __commonJS({
     var constraintTracker_1 = require_constraintTracker();
     var constructors_1 = require_constructors();
     var dataClasses_1 = require_dataClasses();
+    var declaration_1 = require_declaration();
     var declarationUtils_1 = require_declarationUtils();
     var decorators_1 = require_decorators();
     var enums_1 = require_enums();
@@ -70489,6 +70434,7 @@ 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],
@@ -70519,7 +70465,8 @@ var require_typeEvaluator = __commonJS({
     var maxEntriesToUseForInference = 64;
     var maxDeclarationsToUseForInference = 64;
     var maxEffectiveTypeEvaluationAttempts = 16;
-    var maxOverloadArgTypeExpansionCount = 64;
+    var maxTotalOverloadArgTypeExpansionCount = 256;
+    var maxSingleOverloadArgTypeExpansionCount = 64;
     var maxInferFunctionReturnRecursionCount = 12;
     var maxRecursiveTypeAliasRecursionCount = 10;
     var maxTypedDeclsPerSymbol = 16;
@@ -70546,11 +70493,21 @@ var require_typeEvaluator = __commonJS({
       const signatureTrackerStack = [];
       let prefetched;
       function runWithCancellationToken(token, callback) {
+        const oldToken = cancellationToken;
+        let result = void 0;
         try {
           cancellationToken = token;
-          return callback();
+          result = callback();
+          if (!(0, core_1.isThenable)(result)) {
+            return result;
+          }
+          return result.finally(() => {
+            cancellationToken = oldToken;
+          });
         } finally {
-          cancellationToken = void 0;
+          if (!(0, core_1.isThenable)(result)) {
+            cancellationToken = oldToken;
+          }
         }
       }
       function checkForCancellation() {
@@ -70886,7 +70843,7 @@ var require_typeEvaluator = __commonJS({
               0
               /* AssignTypeFlags.Default */
             )) {
-              typeResult.typeErrors = true;
+              typeResult = { ...typeResult, typeErrors: true };
               typeResult.expectedTypeDiagAddendum = diag;
               diag.addTextRange(node);
             }
@@ -71680,7 +71637,7 @@ var require_typeEvaluator = __commonJS({
             usage,
             /* diag */
             void 0,
-            flags | 512,
+            flags | 512 | 4096,
             objectType,
             recursionCount
           );
@@ -71697,7 +71654,7 @@ var require_typeEvaluator = __commonJS({
         }
         let subDiag;
         if (!skipObjectTypeLookup) {
-          let effectiveFlags = flags;
+          let effectiveFlags = flags | 4096;
           if (objectTypeIsInstantiable) {
             effectiveFlags |= 16 | 512 | 1024;
             effectiveFlags &= ~32;
@@ -72801,6 +72758,9 @@ var require_typeEvaluator = __commonJS({
                   sourceEntryTypes.splice(unboundedIndex, 0, typeToReplicate);
                 }
               }
+              if (sourceEntryTypes.length > targetTypes.length) {
+                sourceEntryTypes.splice(unboundedIndex, 1);
+              }
             }
             if (targetUnpackIndex >= 0) {
               if (sourceEntryTypes.length > targetTypes.length) {
@@ -73159,12 +73119,10 @@ var require_typeEvaluator = __commonJS({
             break;
           }
           case 56: {
-            if (target.d.expr.nodeType === 38) {
-              assignTypeToNameNode(target.d.expr, {
-                type: getBuiltInObject(target.d.expr, "list", [typeResult.type]),
-                isIncomplete: typeResult.isIncomplete
-              }, ignoreEmptyContainers, srcExpr);
-            }
+            assignTypeToExpression(target.d.expr, {
+              type: getBuiltInObject(target.d.expr, "list", [typeResult.type]),
+              isIncomplete: typeResult.isIncomplete
+            }, srcExpr, ignoreEmptyContainers, allowAssignmentToFinalVar, expectedTypeDiagAddendum);
             break;
           }
           case 0: {
@@ -76683,7 +76641,7 @@ var require_typeEvaluator = __commonJS({
             });
           }
           expandedArgTypes = expandArgTypes(contextFreeArgTypes, expandedArgTypes);
-          if (!expandedArgTypes || expandedArgTypes.length > maxOverloadArgTypeExpansionCount) {
+          if (!expandedArgTypes || expandedArgTypes.length > maxTotalOverloadArgTypeExpansionCount) {
             break;
           }
         }
@@ -76736,11 +76694,11 @@ var require_typeEvaluator = __commonJS({
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
           if ((0, types_1.isClassInstance)(subtype)) {
             const expandedLiteralTypes = (0, typeGuards_1.enumerateLiteralsForType)(evaluatorInterface, subtype);
-            if (expandedLiteralTypes) {
+            if (expandedLiteralTypes && expandedLiteralTypes.length <= maxSingleOverloadArgTypeExpansionCount) {
               (0, collectionUtils_1.appendArray)(expandedTypes, expandedLiteralTypes);
               return;
             }
-            const expandedTuples = (0, tuples_1.expandTuple)(subtype, maxOverloadArgTypeExpansionCount);
+            const expandedTuples = (0, tuples_1.expandTuple)(subtype, maxSingleOverloadArgTypeExpansionCount);
             if (expandedTuples) {
               (0, collectionUtils_1.appendArray)(expandedTypes, expandedTuples);
               return;
@@ -77277,7 +77235,7 @@ var require_typeEvaluator = __commonJS({
       function matchArgsToParams(errorNode, argList, typeResult, overloadIndex) {
         var _a, _b;
         const overload = typeResult.type;
-        const paramDetails = (0, parameterUtils_1.getParamListDetails)(overload);
+        const paramDetails = (0, parameterUtils_1.getParamListDetails)(overload, { disallowExtraKwargsForTd: true });
         const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(overload);
         let argIndex = 0;
         let matchedUnpackedListOfUnknownLength = false;
@@ -77388,7 +77346,7 @@ var require_typeEvaluator = __commonJS({
               }
             } else {
               let tooManyPositionals = false;
-              if (foundUnpackedListArg && argList[argIndex].argCategory === 1) {
+              if (argList[argIndex].argCategory === 1) {
                 const argType = getTypeOfArg(
                   argList[argIndex],
                   /* inferenceContext */
@@ -77396,8 +77354,6 @@ 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 {
-                  matchedUnpackedListOfUnknownLength = true;
                 }
               } else {
                 tooManyPositionals = true;
@@ -77469,6 +77425,9 @@ var require_typeEvaluator = __commonJS({
                 /* emitNotIterableError */
                 false
               )) == null ? void 0 : _a.type;
+              if (paramInfo.param.category === 1) {
+                matchedUnpackedListOfUnknownLength = true;
+              }
             }
             const funcArg = listElementType ? {
               argCategory: 0,
@@ -77657,8 +77616,8 @@ var require_typeEvaluator = __commonJS({
                     const kwargsParam = paramDetails.params[paramDetails.kwargsIndex];
                     validateArgTypeParams.push({
                       paramCategory: 2,
-                      paramType: kwargsParam.declaredType,
-                      requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(kwargsParam.declaredType),
+                      paramType: kwargsParam.type,
+                      requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(kwargsParam.type),
                       argument: {
                         argCategory: 2,
                         typeResult: { type: extraItemsType }
@@ -77882,23 +77841,20 @@ var require_typeEvaluator = __commonJS({
               const param = paramInfo.param;
               if (param.category === 0 && param.name) {
                 const entry = paramMap.get(param.name);
-                if (entry && entry.argsNeeded === 0 && entry.argsReceived === 0) {
-                  const defaultArgType = paramInfo.defaultType;
-                  if (defaultArgType && !(0, typeUtils_1.isEllipsisType)(defaultArgType) && (0, typeUtils_1.requiresSpecialization)(paramInfo.declaredType)) {
-                    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)
-                    });
-                  }
+                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)
+                  });
                 }
               }
             });
@@ -77965,7 +77921,7 @@ var require_typeEvaluator = __commonJS({
         }
         let relevance = 0;
         if (matchedUnpackedListOfUnknownLength) {
-          relevance--;
+          relevance++;
         }
         if (types_1.FunctionType.isBuiltIn(overload, ["isinstance", "issubclass"]) && validateArgTypeParams.length === 2) {
           validateArgTypeParams[1].isinstanceParam = true;
@@ -78901,6 +78857,12 @@ var require_typeEvaluator = __commonJS({
           addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasTypeMustBeAssigned(), errorNode);
           return void 0;
         }
+        const scope = ScopeUtils.getScopeForNode(errorNode);
+        if (scope) {
+          if (scope.type !== 3 && scope.type !== 4 && scope.type !== 5) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasTypeBadScope(), errorNode.parent.d.leftExpr);
+          }
+        }
         const nameNode = errorNode.parent.d.leftExpr;
         const firstArg = argList[0];
         if (firstArg.valueExpression && firstArg.valueExpression.nodeType === 48) {
@@ -79951,7 +79913,7 @@ var require_typeEvaluator = __commonJS({
           if (generatorTypeArgs) {
             return generatorTypeArgs.length >= 2 ? generatorTypeArgs[2] : types_1.UnknownType.create();
           }
-          if ((0, types_1.isClassInstance)(yieldFromSubtype) && types_1.ClassType.isBuiltIn(yieldFromSubtype, "Coroutine")) {
+          if ((0, types_1.isClassInstance)(yieldFromSubtype) && types_1.ClassType.isBuiltIn(yieldFromSubtype, ["Coroutine", "CoroutineType"])) {
             return types_1.UnknownType.create();
           }
           const iterableType = ((_a = getTypeOfIterable(
@@ -80102,7 +80064,9 @@ var require_typeEvaluator = __commonJS({
               void 0,
               (0, typeUtils_1.makeInferenceContext)(expectedReturnType)
             );
-            functionType.priv.inferredReturnType = returnTypeResult.type;
+            functionType.priv.inferredReturnType = {
+              type: returnTypeResult.type
+            };
             if (returnTypeResult.isIncomplete) {
               isIncomplete = true;
             }
@@ -81759,6 +81723,7 @@ var require_typeEvaluator = __commonJS({
           if (fileInfo.isStubFile) {
             exprFlags |= 4;
           }
+          let sawClosedOrExtraItems = false;
           node.d.arguments.forEach((arg) => {
             var _a, _b, _c;
             if (arg.d.argCategory === 2) {
@@ -81891,22 +81856,28 @@ var require_typeEvaluator = __commonJS({
                   addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictBoolParam().format({ name: arg.d.name.d.value }), arg.d.valueExpr);
                 } else if (arg.d.name.d.value === "total" && !constArgValue) {
                   classType.shared.flags |= 32;
-                } else if (arg.d.name.d.value === "closed" && constArgValue) {
-                  if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
+                } else if (arg.d.name.d.value === "closed" && AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
+                  if (constArgValue) {
                     classType.shared.flags |= 8 | 16;
                     if (classType.shared.typedDictExtraItemsExpr) {
                       addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
                     }
                   }
-                }
-              } else if (arg.d.name.d.value === "extra_items") {
-                if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
-                  classType.shared.typedDictExtraItemsExpr = arg.d.valueExpr;
-                  classType.shared.flags |= 16;
-                  if (types_1.ClassType.isTypedDictMarkedClosed(classType)) {
-                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
+                  if (sawClosedOrExtraItems) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), arg.d.valueExpr);
                   }
+                  sawClosedOrExtraItems = true;
                 }
+              } else if (arg.d.name.d.value === "extra_items" && AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
+                classType.shared.typedDictExtraItemsExpr = arg.d.valueExpr;
+                classType.shared.flags |= 16;
+                if (types_1.ClassType.isTypedDictMarkedClosed(classType)) {
+                  addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
+                }
+                if (sawClosedOrExtraItems) {
+                  addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), arg.d.valueExpr);
+                }
+                sawClosedOrExtraItems = true;
               } else {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictInitsubclassParameter().format({ name: arg.d.name.d.value }), arg);
               }
@@ -82990,7 +82961,9 @@ 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 = createAwaitableReturnType(node, getInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType));
+          awaitableFunctionType.priv.inferredReturnType = {
+            type: createAwaitableReturnType(node, getInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType))
+          };
         }
         return awaitableFunctionType;
       }
@@ -83017,7 +82990,7 @@ var require_typeEvaluator = __commonJS({
           }
         }
         if (!awaitableReturnType || !isGenerator) {
-          const awaitableType = getTypingType(node, useCoroutine ? "Coroutine" : "Awaitable");
+          const awaitableType = useCoroutine ? getTypesType(node, "CoroutineType") : getTypingType(node, "Awaitable");
           if (awaitableType && (0, types_1.isInstantiableClass)(awaitableType)) {
             awaitableReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(awaitableType, useCoroutine ? [types_1.AnyType.create(), types_1.AnyType.create(), returnType] : [returnType]));
           } else {
@@ -83122,7 +83095,7 @@ var require_typeEvaluator = __commonJS({
                       if (yieldNode.nodeType === 61) {
                         isYieldResultUsed = true;
                         const iteratorTypeResult = getTypeOfExpression(yieldNode.d.expr);
-                        if ((0, types_1.isClassInstance)(iteratorTypeResult.type) && types_1.ClassType.isBuiltIn(iteratorTypeResult.type, "Coroutine")) {
+                        if ((0, types_1.isClassInstance)(iteratorTypeResult.type) && types_1.ClassType.isBuiltIn(iteratorTypeResult.type, ["Coroutine", "CoroutineType"])) {
                           const yieldType = iteratorTypeResult.type.priv.typeArgs && iteratorTypeResult.type.priv.typeArgs.length > 0 ? iteratorTypeResult.type.priv.typeArgs[0] : types_1.UnknownType.create();
                           inferredYieldTypes.push(yieldType);
                           useAwaitableGenerator = true;
@@ -85662,6 +85635,13 @@ var require_typeEvaluator = __commonJS({
           }
           declsToConsider.push(resolvedDecl);
         });
+        if (declsToConsider.every((decl) => (0, declaration_1.isVariableDeclaration)(decl) && ParseTreeUtils.isNodeContainedWithinNodeType(
+          decl.node,
+          5
+          /* ParseNodeType.AugmentedAssignment */
+        ))) {
+          declsToConsider.splice(0);
+        }
         const result = getTypeOfSymbolForDecls(symbol, declsToConsider, effectiveTypeCacheKey);
         result.includesVariableDecl = includesVariableDecl;
         result.includesIllegalTypeAliasDecl = includesIllegalTypeAliasDecl;
@@ -85847,8 +85827,8 @@ var require_typeEvaluator = __commonJS({
         if (types_1.FunctionType.isOverloaded(type) && !types_1.FunctionType.isSynthesizedMethod(type)) {
           return types_1.UnknownType.create();
         }
-        if (type.priv.inferredReturnType) {
-          returnType = type.priv.inferredReturnType;
+        if (type.priv.inferredReturnType && !type.priv.inferredReturnType.isIncomplete) {
+          returnType = type.priv.inferredReturnType.type;
         } else {
           if (types_1.FunctionType.isInstanceMethod(type) && type.shared.name === "__init__") {
             returnType = getNoneType();
@@ -85881,9 +85861,7 @@ var require_typeEvaluator = __commonJS({
             typeVarScopes.push(type.shared.methodClass.shared.typeVarScopeId);
           }
           returnType = (0, typeUtils_1.makeTypeVarsFree)(returnType, typeVarScopes);
-          if (!isIncomplete) {
-            type.priv.inferredReturnType = returnType;
-          }
+          type.priv.inferredReturnType = { type: returnType, isIncomplete };
         }
         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;
@@ -86088,13 +86066,6 @@ var require_typeEvaluator = __commonJS({
             if (!(0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, destType, srcType, diag, constraints, flags, recursionCount)) {
               return false;
             }
-            if (types_1.ClassType.isFinal(destType) !== types_1.ClassType.isFinal(srcType)) {
-              diag == null ? void 0 : diag.addMessage(localize_1.LocAddendum.typedDictFinalMismatch().format({
-                sourceType: printType((0, typeUtils_1.convertToInstance)(srcType)),
-                destType: printType((0, typeUtils_1.convertToInstance)(destType))
-              }));
-              return false;
-            }
             if ((flags & 1) !== 0) {
               return (0, typedDicts_1.assignTypedDictToTypedDict)(
                 evaluatorInterface,
@@ -86713,6 +86684,18 @@ var require_typeEvaluator = __commonJS({
             }
           }
           let concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
+          if (types_1.ClassType.isBuiltIn(destType, "TypeForm")) {
+            const destTypeArg = destType.priv.typeArgs && destType.priv.typeArgs.length > 0 ? destType.priv.typeArgs[0] : types_1.UnknownType.create();
+            let srcTypeArg;
+            if ((0, types_1.isClassInstance)(concreteSrcType) && types_1.ClassType.isBuiltIn(concreteSrcType, "type")) {
+              srcTypeArg = concreteSrcType;
+            } else if ((0, types_1.isInstantiableClass)(concreteSrcType)) {
+              srcTypeArg = (0, typeUtils_1.convertToInstance)(concreteSrcType);
+            }
+            if (srcTypeArg) {
+              return assignType(destTypeArg, srcTypeArg, diag, constraints, flags, recursionCount);
+            }
+          }
           if ((0, types_1.isClass)(concreteSrcType) && types_1.TypeBase.isInstance(concreteSrcType)) {
             if (!destType.priv.isUnpacked && concreteSrcType.priv.isUnpacked && concreteSrcType.priv.tupleTypeArgs) {
               return assignType(destType, (0, typeUtils_1.combineTupleTypeArgs)(concreteSrcType.priv.tupleTypeArgs), diag, constraints, flags, recursionCount);
@@ -86839,7 +86822,7 @@ var require_typeEvaluator = __commonJS({
             const typeVarSignatures = [];
             overloads.forEach((overload) => {
               const overloadScopeId = (0, typeUtils_1.getTypeVarScopeId)(overload) ?? "";
-              const constraintsClone = constraints == null ? void 0 : constraints.cloneWithSignature(overloadScopeId);
+              const constraintsClone = constraints == null ? void 0 : constraints.cloneWithSignature([overloadScopeId]);
               if (assignType(
                 destType,
                 overload,
@@ -86989,6 +86972,9 @@ var require_typeEvaluator = __commonJS({
         if ((0, types_1.isTypeSame)(srcType, destType, {}, recursionCount)) {
           return true;
         }
+        if ((flags & 16) !== 0 && srcType.priv.subtypes.some((subtype) => (0, types_1.isAnyOrUnknown)(subtype))) {
+          return false;
+        }
         let sortedSrcTypes = (0, typeUtils_1.sortTypes)(srcType.priv.subtypes);
         let matchedSomeSubtypes = false;
         if ((0, types_1.isUnion)(destType)) {
@@ -87239,6 +87225,109 @@ var require_typeEvaluator = __commonJS({
           recursionCount
         );
       }
+      function isTypeComparable(leftType, rightType) {
+        var _a, _b;
+        if ((0, types_1.isAnyOrUnknown)(leftType) || (0, types_1.isAnyOrUnknown)(rightType)) {
+          return true;
+        }
+        if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
+          return false;
+        }
+        if ((0, types_1.isModule)(leftType) || (0, types_1.isModule)(rightType)) {
+          return (0, types_1.isTypeSame)(leftType, rightType, { ignoreConditions: true });
+        }
+        const isLeftCallable = (0, types_1.isFunction)(leftType) || (0, types_1.isOverloaded)(leftType);
+        const isRightCallable = (0, types_1.isFunction)(rightType) || (0, types_1.isOverloaded)(rightType);
+        if (isLeftCallable !== isRightCallable) {
+          return false;
+        }
+        if ((0, types_1.isInstantiableClass)(leftType) || (0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, "type")) {
+          if ((0, types_1.isInstantiableClass)(rightType) || (0, types_1.isClassInstance)(rightType) && types_1.ClassType.isBuiltIn(rightType, "type")) {
+            const genericLeftType = types_1.ClassType.specialize(
+              leftType,
+              /* typeArgs */
+              void 0
+            );
+            const genericRightType = types_1.ClassType.specialize(
+              rightType,
+              /* typeArgs */
+              void 0
+            );
+            if (assignType(genericLeftType, genericRightType) || assignType(genericRightType, genericLeftType)) {
+              return true;
+            }
+          }
+          const metaclass = leftType.shared.effectiveMetaclass;
+          if (metaclass && (0, types_1.isClass)(metaclass)) {
+            if ((0, typeUtils_1.lookUpClassMember)(
+              metaclass,
+              "__eq__",
+              4
+              /* MemberAccessFlags.SkipObjectBaseClass */
+            )) {
+              return true;
+            }
+          }
+          return false;
+        }
+        if ((0, types_1.isClassInstance)(leftType)) {
+          if ((0, types_1.isClass)(rightType)) {
+            const genericLeftType = types_1.ClassType.specialize(
+              leftType,
+              /* typeArgs */
+              void 0
+            );
+            const genericRightType = types_1.ClassType.specialize(
+              rightType,
+              /* typeArgs */
+              void 0
+            );
+            if (assignType(genericLeftType, genericRightType) || assignType(genericRightType, genericLeftType)) {
+              return true;
+            }
+            if (types_1.ClassType.isBuiltIn(leftType) && types_1.ClassType.isBuiltIn(rightType) && types_1.TypeBase.isInstance(rightType)) {
+              let boolType;
+              let intType;
+              if (types_1.ClassType.isBuiltIn(leftType, "bool") && types_1.ClassType.isBuiltIn(rightType, "int")) {
+                boolType = leftType;
+                intType = rightType;
+              } else if (types_1.ClassType.isBuiltIn(rightType, "bool") && types_1.ClassType.isBuiltIn(leftType, "int")) {
+                boolType = rightType;
+                intType = leftType;
+              }
+              if (boolType && intType) {
+                const intVal = (_a = intType.priv) == null ? void 0 : _a.literalValue;
+                if (intVal === void 0) {
+                  return true;
+                }
+                if (intVal !== 0 && intVal !== 1) {
+                  return false;
+                }
+                const boolVal = (_b = boolType.priv) == null ? void 0 : _b.literalValue;
+                if (boolVal === void 0) {
+                  return true;
+                }
+                return boolVal === (intVal === 1);
+              }
+              return false;
+            }
+          }
+          const eqMethod = (0, typeUtils_1.lookUpClassMember)(
+            types_1.ClassType.cloneAsInstantiable(leftType),
+            "__eq__",
+            4
+            /* MemberAccessFlags.SkipObjectBaseClass */
+          );
+          if (eqMethod) {
+            if (types_1.ClassType.isDataClass(leftType) && eqMethod.symbol.getSynthesizedType()) {
+              return false;
+            }
+            return true;
+          }
+          return false;
+        }
+        return true;
+      }
       function assignToUnionType(destType, srcType, diag, constraints, flags, recursionCount) {
         if (flags & 1) {
           let isIncompatible = false;
@@ -87414,17 +87503,23 @@ var require_typeEvaluator = __commonJS({
         for (const mroClass of objType.shared.mro) {
           if ((0, types_1.isClass)(mroClass) && types_1.ClassType.isProtocolClass(mroClass)) {
             for (const field of types_1.ClassType.getSymbolTable(mroClass)) {
-              if (field[0] !== "__call__" && !field[1].isIgnoredForProtocolMatch()) {
-                let fieldIsPartOfFunction = false;
-                if ((prefetched == null ? void 0 : prefetched.functionClass) && (0, types_1.isClass)(prefetched.functionClass)) {
-                  if (types_1.ClassType.getSymbolTable(prefetched.functionClass).has(field[0])) {
-                    fieldIsPartOfFunction = true;
-                  }
-                }
-                if (!fieldIsPartOfFunction) {
-                  return void 0;
+              const fieldName = field[0];
+              const fieldSymbol = field[1];
+              if (fieldName === "__call__" || fieldName === "__slots__") {
+                continue;
+              }
+              if (fieldSymbol.isIgnoredForProtocolMatch()) {
+                continue;
+              }
+              let fieldIsPartOfFunction = false;
+              if ((prefetched == null ? void 0 : prefetched.functionClass) && (0, types_1.isClass)(prefetched.functionClass)) {
+                if (types_1.ClassType.getSymbolTable(prefetched.functionClass).has(field[0])) {
+                  fieldIsPartOfFunction = true;
                 }
               }
+              if (!fieldIsPartOfFunction) {
+                return void 0;
+              }
             }
           }
         }
@@ -87594,6 +87689,7 @@ var require_typeEvaluator = __commonJS({
         const destPositionalCount = destParamDetails.firstKeywordOnlyIndex ?? destParamDetails.params.length;
         const srcPositionalCount = srcParamDetails.firstKeywordOnlyIndex ?? srcParamDetails.params.length;
         const positionalsToMatch = Math.min(destPositionalCount, srcPositionalCount);
+        const skippedPosParamIndices = [];
         for (let paramIndex = 0; paramIndex < positionalsToMatch; paramIndex++) {
           if (paramIndex === 0 && destType.shared.methodClass && (flags & 32768) !== 0) {
             if (types_1.FunctionType.isInstanceMethod(destType) || types_1.FunctionType.isClassMethod(destType)) {
@@ -87601,6 +87697,9 @@ var require_typeEvaluator = __commonJS({
             }
           }
           if (paramIndex === destParamDetails.argsIndex) {
+            if (!(0, types_1.isUnpackedTypeVarTuple)(destParamDetails.params[destParamDetails.argsIndex].type)) {
+              skippedPosParamIndices.push(paramIndex);
+            }
             continue;
           }
           const destParam = destParamDetails.params[paramIndex];
@@ -87664,6 +87763,9 @@ var require_typeEvaluator = __commonJS({
         }
         if (destPositionalCount < srcPositionalCount && !targetIncludesParamSpec) {
           for (let i = destPositionalCount; i < srcPositionalCount; i++) {
+            skippedPosParamIndices.push(i);
+          }
+          for (const i of skippedPosParamIndices) {
             if (destParamDetails.argsIndex !== void 0) {
               const destArgsType = destParamDetails.params[destParamDetails.argsIndex].type;
               const srcParamType = srcParamDetails.params[i].type;
@@ -87789,63 +87891,71 @@ var require_typeEvaluator = __commonJS({
           }
           if (srcStartOfNamed >= 0) {
             srcParamDetails.params.forEach((srcParamInfo, index) => {
-              if (index >= srcStartOfNamed) {
-                if (srcParamInfo.param.name && srcParamInfo.param.category === 0 && srcParamInfo.kind !== parameterUtils_1.ParamKind.Positional) {
-                  const destParamInfo = destParamMap.get(srcParamInfo.param.name);
-                  const paramDiag = diag == null ? void 0 : diag.createAddendum();
-                  const srcParamType = srcParamInfo.type;
-                  if (!destParamInfo) {
-                    if (destParamDetails.kwargsIndex === void 0 && !srcParamInfo.defaultType) {
-                      if (paramDiag) {
-                        paramDiag.addMessage(localize_1.LocAddendum.namedParamMissingInDest().format({
-                          name: srcParamInfo.param.name
-                        }));
-                      }
-                      canAssign = false;
-                    } else if (destParamDetails.kwargsIndex !== void 0) {
-                      if (!assignParam(destParamDetails.params[destParamDetails.kwargsIndex].type, srcParamType, destParamDetails.params[destParamDetails.kwargsIndex].index, diag == null ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
-                        canAssign = false;
-                      }
-                    } else if (srcParamInfo.defaultType) {
-                      const defaultArgType = srcParamInfo.defaultType ?? srcParamInfo.defaultType;
-                      if (defaultArgType && !assignType(srcParamInfo.type, defaultArgType, diag == null ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
-                        if ((flags & 32) === 0) {
-                          canAssign = false;
-                        }
-                      }
-                    }
-                  } else {
-                    const destParamType = destParamInfo.type;
-                    const specializedDestParamType = constraints ? solveAndApplyConstraints(destParamType, constraints) : destParamType;
-                    if (!assignParam(
-                      destParamInfo.type,
-                      srcParamType,
-                      /* paramIndex */
-                      void 0,
-                      paramDiag == null ? void 0 : paramDiag.createAddendum(),
-                      constraints,
-                      flags,
-                      recursionCount
-                    )) {
-                      if (paramDiag) {
-                        paramDiag.addMessage(localize_1.LocAddendum.namedParamTypeMismatch().format({
-                          name: srcParamInfo.param.name,
-                          sourceType: printType(specializedDestParamType),
-                          destType: printType(srcParamType)
-                        }));
-                      }
-                      canAssign = false;
-                    }
-                    if (destParamInfo.defaultType && !srcParamInfo.defaultType) {
-                      diag == null ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamDefaultMissing().format({
-                        name: srcParamInfo.param.name
-                      }));
+              if (index < srcStartOfNamed) {
+                return;
+              }
+              if (!srcParamInfo.param.name || srcParamInfo.param.category !== 0 || srcParamInfo.kind === parameterUtils_1.ParamKind.Positional) {
+                return;
+              }
+              const destParamInfo = destParamMap.get(srcParamInfo.param.name);
+              const paramDiag = diag == null ? void 0 : diag.createAddendum();
+              const srcParamType = srcParamInfo.type;
+              if (!destParamInfo) {
+                if (destParamDetails.kwargsIndex === void 0 && !srcParamInfo.defaultType) {
+                  if (paramDiag) {
+                    paramDiag.addMessage(localize_1.LocAddendum.namedParamMissingInDest().format({
+                      name: srcParamInfo.param.name
+                    }));
+                  }
+                  canAssign = false;
+                } else if (destParamDetails.kwargsIndex !== void 0) {
+                  if (!assignParam(destParamDetails.params[destParamDetails.kwargsIndex].type, srcParamType, destParamDetails.params[destParamDetails.kwargsIndex].index, diag == null ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
+                    canAssign = false;
+                  }
+                } else if (srcParamInfo.defaultType) {
+                  const defaultArgType = srcParamInfo.defaultType ?? srcParamInfo.defaultType;
+                  if (defaultArgType && !assignType(srcParamInfo.type, defaultArgType, diag == null ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
+                    if ((flags & 32) === 0) {
                       canAssign = false;
                     }
-                    destParamMap.delete(srcParamInfo.param.name);
                   }
                 }
+                return;
+              }
+              if (srcParamInfo.defaultType && destParamInfo.defaultType) {
+                if ((flags & 32) !== 0) {
+                  destParamMap.delete(srcParamInfo.param.name);
+                  return;
+                }
+              }
+              const destParamType = destParamInfo.type;
+              const specializedDestParamType = constraints ? solveAndApplyConstraints(destParamType, constraints) : destParamType;
+              if (!assignParam(
+                destParamInfo.type,
+                srcParamType,
+                /* paramIndex */
+                void 0,
+                paramDiag == null ? void 0 : paramDiag.createAddendum(),
+                constraints,
+                flags,
+                recursionCount
+              )) {
+                if (paramDiag) {
+                  paramDiag.addMessage(localize_1.LocAddendum.namedParamTypeMismatch().format({
+                    name: srcParamInfo.param.name,
+                    sourceType: printType(specializedDestParamType),
+                    destType: printType(srcParamType)
+                  }));
+                }
+                canAssign = false;
               }
+              if (destParamInfo.defaultType && !srcParamInfo.defaultType) {
+                diag == null ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamDefaultMissing().format({
+                  name: srcParamInfo.param.name
+                }));
+                canAssign = false;
+              }
+              destParamMap.delete(srcParamInfo.param.name);
             });
           }
           destParamMap.forEach((destParamInfo, paramName) => {
@@ -88603,25 +88713,35 @@ var require_typeEvaluator = __commonJS({
       }
       function partiallySpecializeBoundMethod(baseType, memberType, diag, recursionCount, firstParamType, stripFirstParam = true) {
         const constraints = new constraintTracker_1.ConstraintTracker();
-        if (firstParamType && memberType.shared.parameters.length > 0) {
-          const memberTypeFirstParam = memberType.shared.parameters[0];
-          const memberTypeFirstParamType = types_1.FunctionType.getParamType(memberType, 0);
-          if ((0, types_1.isTypeVar)(memberTypeFirstParamType) && memberTypeFirstParamType.shared.boundType && (0, types_1.isClassInstance)(memberTypeFirstParamType.shared.boundType) && types_1.ClassType.isProtocolClass(memberTypeFirstParamType.shared.boundType)) {
-            constraints.setBounds(memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType) ? (0, typeUtils_1.convertToInstance)(firstParamType) : firstParamType);
-          } else {
-            const subDiag = diag == null ? void 0 : diag.createAddendum();
-            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) {
-                  subDiag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({
-                    type: printType(firstParamType),
-                    methodName: memberType.shared.name || "<anonymous>",
-                    paramName: memberTypeFirstParam.name
-                  }));
+        if (firstParamType) {
+          if (memberType.shared.parameters.length > 0) {
+            const memberTypeFirstParam = memberType.shared.parameters[0];
+            const memberTypeFirstParamType = types_1.FunctionType.getParamType(memberType, 0);
+            if ((0, types_1.isTypeVar)(memberTypeFirstParamType) && memberTypeFirstParamType.shared.boundType && (0, types_1.isClassInstance)(memberTypeFirstParamType.shared.boundType) && types_1.ClassType.isProtocolClass(memberTypeFirstParamType.shared.boundType)) {
+              constraints.setBounds(memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType) ? (0, typeUtils_1.convertToInstance)(firstParamType) : firstParamType);
+            } else {
+              const subDiag = diag == null ? void 0 : diag.createAddendum();
+              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) {
+                    subDiag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({
+                      type: printType(firstParamType),
+                      methodName: memberType.shared.name || "<anonymous>",
+                      paramName: memberTypeFirstParam.name
+                    }));
+                  }
+                  return void 0;
                 }
-                return void 0;
               }
             }
+          } else {
+            const subDiag = diag == null ? void 0 : diag.createAddendum();
+            if (subDiag) {
+              subDiag.addMessage(localize_1.LocMessage.bindParamMissing().format({
+                methodName: memberType.shared.name || "<anonymous>"
+              }));
+            }
+            return void 0;
           }
         }
         getEffectiveReturnType(memberType);
@@ -88925,6 +89045,7 @@ var require_typeEvaluator = __commonJS({
         getCallSignatureInfo,
         getAbstractSymbols,
         narrowConstrainedTypeVar,
+        isTypeComparable,
         assignType,
         validateOverrideMethod,
         validateCallArgs,
@@ -89390,7 +89511,7 @@ var require_checker = __commonJS({
               this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedCallResult, localize_1.LocMessage.unusedCallResult().format({
                 type: this._evaluator.printType(returnType)
               }), node);
-              if ((0, types_1.isClassInstance)(returnType) && types_1.ClassType.isBuiltIn(returnType, "Coroutine")) {
+              if ((0, types_1.isClassInstance)(returnType) && types_1.ClassType.isBuiltIn(returnType, ["Coroutine", "CoroutineType"])) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedCoroutine, localize_1.LocMessage.unusedCoroutine(), node);
               }
             }
@@ -89548,7 +89669,7 @@ var require_checker = __commonJS({
         const yieldFromType = this._evaluator.getType(node.d.expr) || types_1.UnknownType.create();
         let yieldType;
         let sendType;
-        if ((0, types_1.isClassInstance)(yieldFromType) && types_1.ClassType.isBuiltIn(yieldFromType, "Coroutine")) {
+        if ((0, types_1.isClassInstance)(yieldFromType) && types_1.ClassType.isBuiltIn(yieldFromType, ["Coroutine", "CoroutineType"])) {
           yieldType = types_1.UnknownType.create();
         } else {
           yieldType = ((_a = this._evaluator.getTypeOfIterable(
@@ -89802,6 +89923,7 @@ var require_checker = __commonJS({
           node.d.targets.forEach((name) => {
             this._evaluator.getType(name);
             this.walk(name);
+            this._validateNonlocalTypeParam(name);
           });
         });
         return false;
@@ -90067,7 +90189,7 @@ var require_checker = __commonJS({
           if (!(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloaded)(subtype)) {
             isExprFunction = false;
           }
-          if (!(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isBuiltIn(subtype, "Coroutine")) {
+          if (!(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isBuiltIn(subtype, ["Coroutine", "CoroutineType"])) {
             isCoroutine = false;
           }
         });
@@ -90109,6 +90231,20 @@ var require_checker = __commonJS({
           this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnusedExpression, localize_1.LocMessage.unusedExpression(), node);
         }
       }
+      // Verifies that the target of a nonlocal statement is not a PEP 695-style
+      // TypeParameter. This situation results in a runtime exception.
+      _validateNonlocalTypeParam(node) {
+        const symbolWithScope = this._evaluator.lookUpSymbolRecursive(
+          node,
+          node.d.value,
+          /* honorCodeFlow */
+          false
+        );
+        if (!symbolWithScope || symbolWithScope.scope.type !== 0) {
+          return;
+        }
+        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.nonlocalTypeParam().format({ name: node.d.value }), node);
+      }
       _validateExhaustiveMatch(node) {
         if (this._fileInfo.diagnosticRuleSet.reportMatchNotExhaustive === "none") {
           return;
@@ -90225,7 +90361,7 @@ var require_checker = __commonJS({
               if (isComparable) {
                 return;
               }
-              if (this._isTypeComparable(leftSubtype, rightSubtype)) {
+              if (this._evaluator.isTypeComparable(leftSubtype, rightSubtype)) {
                 isComparable = true;
               }
               return rightSubtype;
@@ -90242,88 +90378,6 @@ var require_checker = __commonJS({
           }
         }
       }
-      // Determines whether the two types are potentially comparable -- i.e.
-      // their types overlap in such a way that it makes sense for them to
-      // be compared with an == or != operator.
-      _isTypeComparable(leftType, rightType) {
-        if ((0, types_1.isAnyOrUnknown)(leftType) || (0, types_1.isAnyOrUnknown)(rightType)) {
-          return true;
-        }
-        if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
-          return false;
-        }
-        if ((0, types_1.isModule)(leftType) || (0, types_1.isModule)(rightType)) {
-          return (0, types_1.isTypeSame)(leftType, rightType, { ignoreConditions: true });
-        }
-        const isLeftCallable = (0, types_1.isFunction)(leftType) || (0, types_1.isOverloaded)(leftType);
-        const isRightCallable = (0, types_1.isFunction)(rightType) || (0, types_1.isOverloaded)(rightType);
-        if (isLeftCallable !== isRightCallable) {
-          return false;
-        }
-        if ((0, types_1.isInstantiableClass)(leftType) || (0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, "type")) {
-          if ((0, types_1.isInstantiableClass)(rightType) || (0, types_1.isClassInstance)(rightType) && types_1.ClassType.isBuiltIn(rightType, "type")) {
-            const genericLeftType = types_1.ClassType.specialize(
-              leftType,
-              /* typeArgs */
-              void 0
-            );
-            const genericRightType = types_1.ClassType.specialize(
-              rightType,
-              /* typeArgs */
-              void 0
-            );
-            if (this._evaluator.assignType(genericLeftType, genericRightType) || this._evaluator.assignType(genericRightType, genericLeftType)) {
-              return true;
-            }
-          }
-          const metaclass = leftType.shared.effectiveMetaclass;
-          if (metaclass && (0, types_1.isClass)(metaclass)) {
-            if ((0, typeUtils_1.lookUpClassMember)(
-              metaclass,
-              "__eq__",
-              4
-              /* MemberAccessFlags.SkipObjectBaseClass */
-            )) {
-              return true;
-            }
-          }
-          return false;
-        }
-        if ((0, types_1.isClassInstance)(leftType)) {
-          if ((0, types_1.isClass)(rightType)) {
-            const genericLeftType = types_1.ClassType.specialize(
-              leftType,
-              /* typeArgs */
-              void 0
-            );
-            const genericRightType = types_1.ClassType.specialize(
-              rightType,
-              /* typeArgs */
-              void 0
-            );
-            if (this._evaluator.assignType(genericLeftType, genericRightType) || this._evaluator.assignType(genericRightType, genericLeftType)) {
-              return true;
-            }
-            if (types_1.ClassType.isBuiltIn(leftType) && types_1.ClassType.isBuiltIn(rightType) && types_1.TypeBase.isInstance(rightType)) {
-              return false;
-            }
-          }
-          const eqMethod = (0, typeUtils_1.lookUpClassMember)(
-            types_1.ClassType.cloneAsInstantiable(leftType),
-            "__eq__",
-            4
-            /* MemberAccessFlags.SkipObjectBaseClass */
-          );
-          if (eqMethod) {
-            if (types_1.ClassType.isDataClass(leftType) && eqMethod.symbol.getSynthesizedType()) {
-              return false;
-            }
-            return true;
-          }
-          return false;
-        }
-        return true;
-      }
       // If the function is a generator, validates that its annotated return type
       // is appropriate for a generator.
       _validateGeneratorReturnType(node, functionType) {
@@ -90977,6 +91031,9 @@ var require_checker = __commonJS({
               }
             }
           }
+          if (!overloads.find((overload) => overload.shared.declaration === primaryDecl)) {
+            return;
+          }
           this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportNoOverloadImplementation, localize_1.LocMessage.overloadWithoutImplementation().format({
             name: primaryDecl.node.d.name.d.value
           }), primaryDecl.node.d.name);
@@ -93205,22 +93262,7 @@ var require_checker = __commonJS({
         }
         if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloaded)(baseType)) {
           const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-          let reportFinalMethodOverride = false;
-          if (!SymbolNameUtils.isPrivateName(memberName)) {
-            if ((0, types_1.isFunction)(baseType) && types_1.FunctionType.isFinal(baseType)) {
-              reportFinalMethodOverride = true;
-            } else if ((0, types_1.isOverloaded)(baseType)) {
-              const overloads = types_1.OverloadedType.getOverloads(baseType);
-              const impl = types_1.OverloadedType.getImplementation(baseType);
-              if (overloads.some((overload) => types_1.FunctionType.isFinal(overload))) {
-                reportFinalMethodOverride = true;
-              }
-              if (impl && (0, types_1.isFunction)(impl) && types_1.FunctionType.isFinal(impl)) {
-                reportFinalMethodOverride = true;
-              }
-            }
-          }
-          if (reportFinalMethodOverride) {
+          if (this._isFinalFunction(memberName, baseType)) {
             const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
             if (decl && decl.type === 5) {
               const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.finalMethodOverride().format({
@@ -93233,41 +93275,50 @@ var require_checker = __commonJS({
               }
             }
           }
+          if (this._isMethodExemptFromLsp(memberName) || SymbolNameUtils.isPrivateName(memberName) || types_1.ClassType.isTypedDictClass(childClassType)) {
+            return;
+          }
           if ((0, types_1.isFunction)(overrideType) || (0, types_1.isOverloaded)(overrideType)) {
             const enforceParamNameMatch = !SymbolNameUtils.isDunderName(memberName);
-            if (!this._isMethodExemptFromLsp(memberName) && !SymbolNameUtils.isPrivateName(memberName) && !types_1.ClassType.isTypedDictClass(childClassType)) {
-              if (!this._evaluator.validateOverrideMethod(baseType, overrideType, childClassType, diagAddendum, enforceParamNameMatch)) {
-                const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
-                if (decl) {
-                  const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.incompatibleMethodOverride().format({
-                    name: memberName,
-                    className: baseClass.shared.name
-                  }) + diagAddendum.getString(), (0, declarationUtils_1.getNameNodeForDeclaration)(decl) ?? decl.node);
-                  const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
-                  if (diag && origDecl) {
-                    diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
-                  }
-                }
-              }
+            if (this._evaluator.validateOverrideMethod(baseType, overrideType, childClassType, diagAddendum, enforceParamNameMatch)) {
+              return;
             }
-          } else if (!(0, types_1.isAnyOrUnknown)(overrideType)) {
-            if (!types_1.ClassType.isBuiltIn(baseClass, "_TypedDict")) {
-              const decls = overrideSymbol.getDeclarations();
-              if (decls.length > 0) {
-                const lastDecl = decls[decls.length - 1];
-                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.methodOverridden().format({
-                  name: memberName,
-                  className: baseClass.shared.name,
-                  type: this._evaluator.printType(overrideType)
-                }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
-                const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
-                if (diag && origDecl) {
-                  diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
-                }
-              }
+            const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
+            if (!decl) {
+              return;
+            }
+            const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.incompatibleMethodOverride().format({
+              name: memberName,
+              className: baseClass.shared.name
+            }) + diagAddendum.getString(), (0, declarationUtils_1.getNameNodeForDeclaration)(decl) ?? decl.node);
+            const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
+            if (diag && origDecl) {
+              diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
+            }
+            return;
+          }
+          if (!(0, types_1.isAnyOrUnknown)(overrideType)) {
+            if (types_1.ClassType.isBuiltIn(baseClass, "_TypedDict")) {
+              return;
+            }
+            const decls = overrideSymbol.getDeclarations();
+            if (decls.length === 0) {
+              return;
+            }
+            const lastDecl = decls[decls.length - 1];
+            const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.methodOverridden().format({
+              name: memberName,
+              className: baseClass.shared.name,
+              type: this._evaluator.printType(overrideType)
+            }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
+            const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
+            if (diag && origDecl) {
+              diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
             }
           }
-        } else if ((0, typeUtils_1.isProperty)(baseType)) {
+          return;
+        }
+        if ((0, typeUtils_1.isProperty)(baseType)) {
           if (!(0, typeUtils_1.isProperty)(overrideType)) {
             const decls = overrideSymbol.getDeclarations();
             if (decls.length > 0 && overrideSymbol.isClassMember()) {
@@ -93280,114 +93331,134 @@ var require_checker = __commonJS({
           } else {
             this._validatePropertyOverride(baseClass, childClassType, baseType, overrideType, overrideSymbol, memberName);
           }
-        } else {
-          if (this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride !== "none") {
-            const decls = overrideSymbol.getDeclarations();
-            if (decls.length > 0) {
-              const lastDecl = decls[decls.length - 1];
-              const primaryDecl = decls[0];
-              let isInvariant = (primaryDecl == null ? void 0 : primaryDecl.type) === 1 && !primaryDecl.isFinal;
-              if (types_1.ClassType.isDataClassFrozen(baseClass) && baseClass.shared.dataClassEntries) {
-                const dataclassEntry = baseClass.shared.dataClassEntries.find((entry) => entry.name === memberName);
-                if (dataclassEntry) {
-                  isInvariant = false;
-                }
-              }
-              let overriddenTDEntry;
-              let overrideTDEntry;
-              if (!overrideSymbol.isIgnoredForProtocolMatch()) {
-                if (baseClass.shared.typedDictEntries) {
-                  overriddenTDEntry = baseClass.shared.typedDictEntries.knownItems.get(memberName) ?? baseClass.shared.typedDictEntries.extraItems ?? (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, baseClass);
-                  if (overriddenTDEntry == null ? void 0 : overriddenTDEntry.isReadOnly) {
-                    isInvariant = false;
-                  }
-                }
-                if (childClassType.shared.typedDictEntries) {
-                  overrideTDEntry = childClassType.shared.typedDictEntries.knownItems.get(memberName) ?? childClassType.shared.typedDictEntries.extraItems ?? (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, childClassType);
-                }
-              }
-              let diagAddendum = new diagnostic_1.DiagnosticAddendum();
-              if (!this._evaluator.assignType(
-                baseType,
-                overrideType,
-                diagAddendum,
-                /* constraints */
-                void 0,
-                isInvariant ? 1 : 0
-                /* AssignTypeFlags.Default */
-              )) {
-                if (isInvariant) {
-                  diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                  diagAddendum.addMessage(localize_1.LocAddendum.overrideIsInvariant());
-                  diagAddendum.createAddendum().addMessage(localize_1.LocAddendum.overrideInvariantMismatch().format({
-                    overrideType: this._evaluator.printType(overrideType),
-                    baseType: this._evaluator.printType(baseType)
-                  }));
-                }
-                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.symbolOverridden().format({
-                  name: memberName,
-                  className: baseClass.shared.name
-                }) + diagAddendum.getString(), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
-                const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
-                if (diag && origDecl) {
-                  diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
-                }
-              } else if (overriddenTDEntry && overrideTDEntry) {
-                let isRequiredCompatible = true;
-                if (overriddenTDEntry.isReadOnly) {
-                  isRequiredCompatible = overrideTDEntry.isRequired || !overriddenTDEntry.isRequired;
-                } else {
-                  isRequiredCompatible = overrideTDEntry.isRequired === overriddenTDEntry.isRequired;
-                }
-                if (!isRequiredCompatible) {
-                  const message = overrideTDEntry.isRequired ? localize_1.LocMessage.typedDictFieldRequiredRedefinition : localize_1.LocMessage.typedDictFieldNotRequiredRedefinition;
-                  this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message().format({ name: memberName }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
-                }
-                if (!overriddenTDEntry.isReadOnly && overrideTDEntry.isReadOnly) {
-                  this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictFieldReadOnlyRedefinition().format({
-                    name: memberName
-                  }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
-                }
-              }
-              const isBaseVarFinal = this._evaluator.isFinalVariable(baseClassAndSymbol.symbol);
-              const overrideFinalVarDecl = decls.find((d) => this._evaluator.isFinalVariableDeclaration(d));
-              if (!isBaseVarFinal && overrideFinalVarDecl) {
-                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.variableFinalOverride().format({
-                  name: memberName,
-                  className: baseClass.shared.name
-                }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
-                if (diag) {
-                  diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), overrideFinalVarDecl.uri, overrideFinalVarDecl.range);
-                }
-              }
-              const isBaseClassVar = baseClassAndSymbol.symbol.isClassVar();
-              let isClassVar = overrideSymbol.isClassVar();
-              if (isBaseClassVar && !isClassVar) {
-                if (!overrideSymbol.hasTypedDeclarations()) {
-                  isClassVar = true;
-                }
-                if (overrideSymbol.getTypedDeclarations().every(
-                  (decl) => decl.type === 6
-                  /* DeclarationType.Class */
-                )) {
-                  isClassVar = true;
-                }
-              }
-              const ignoreTypedDictOverride = types_1.ClassType.isTypedDictClass(childClassType) && !isClassVar;
-              if (isBaseClassVar !== isClassVar && !ignoreTypedDictOverride) {
-                const unformattedMessage = overrideSymbol.isClassVar() ? localize_1.LocMessage.classVarOverridesInstanceVar() : localize_1.LocMessage.instanceVarOverridesClassVar();
-                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, unformattedMessage.format({
-                  name: memberName,
-                  className: baseClass.shared.name
-                }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
-                const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
-                if (diag && origDecl) {
-                  diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
-                }
+          return;
+        }
+        if (this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride !== "none") {
+          const decls = overrideSymbol.getDeclarations();
+          if (decls.length === 0) {
+            return;
+          }
+          const lastDecl = decls[decls.length - 1];
+          const primaryDecl = decls[0];
+          let isInvariant = (primaryDecl == null ? void 0 : primaryDecl.type) === 1 && !primaryDecl.isFinal;
+          if (types_1.ClassType.isDataClassFrozen(baseClass) && baseClass.shared.dataClassEntries) {
+            const dataclassEntry = baseClass.shared.dataClassEntries.find((entry) => entry.name === memberName);
+            if (dataclassEntry) {
+              isInvariant = false;
+            }
+          }
+          let overriddenTDEntry;
+          let overrideTDEntry;
+          if (!overrideSymbol.isIgnoredForProtocolMatch()) {
+            if (baseClass.shared.typedDictEntries) {
+              overriddenTDEntry = baseClass.shared.typedDictEntries.knownItems.get(memberName) ?? baseClass.shared.typedDictEntries.extraItems ?? (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, baseClass);
+              if (overriddenTDEntry == null ? void 0 : overriddenTDEntry.isReadOnly) {
+                isInvariant = false;
               }
             }
+            if (childClassType.shared.typedDictEntries) {
+              overrideTDEntry = childClassType.shared.typedDictEntries.knownItems.get(memberName) ?? childClassType.shared.typedDictEntries.extraItems ?? (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, childClassType);
+            }
+          }
+          let diagAddendum = new diagnostic_1.DiagnosticAddendum();
+          if (!this._evaluator.assignType(
+            baseType,
+            overrideType,
+            diagAddendum,
+            /* constraints */
+            void 0,
+            isInvariant ? 1 : 0
+            /* AssignTypeFlags.Default */
+          )) {
+            if (isInvariant) {
+              diagAddendum = new diagnostic_1.DiagnosticAddendum();
+              diagAddendum.addMessage(localize_1.LocAddendum.overrideIsInvariant());
+              diagAddendum.createAddendum().addMessage(localize_1.LocAddendum.overrideInvariantMismatch().format({
+                overrideType: this._evaluator.printType(overrideType),
+                baseType: this._evaluator.printType(baseType)
+              }));
+            }
+            const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.symbolOverridden().format({
+              name: memberName,
+              className: baseClass.shared.name
+            }) + diagAddendum.getString(), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
+            const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
+            if (diag && origDecl) {
+              diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
+            }
+          } else if (overriddenTDEntry && overrideTDEntry) {
+            let isRequiredCompatible = true;
+            if (overriddenTDEntry.isReadOnly) {
+              isRequiredCompatible = overrideTDEntry.isRequired || !overriddenTDEntry.isRequired;
+            } else {
+              isRequiredCompatible = overrideTDEntry.isRequired === overriddenTDEntry.isRequired;
+            }
+            if (!isRequiredCompatible) {
+              const message = overrideTDEntry.isRequired ? localize_1.LocMessage.typedDictFieldRequiredRedefinition : localize_1.LocMessage.typedDictFieldNotRequiredRedefinition;
+              this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message().format({ name: memberName }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
+            }
+            if (!overriddenTDEntry.isReadOnly && overrideTDEntry.isReadOnly) {
+              this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictFieldReadOnlyRedefinition().format({
+                name: memberName
+              }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
+            }
+          }
+          const isBaseVarFinal = this._evaluator.isFinalVariable(baseClassAndSymbol.symbol);
+          const overrideFinalVarDecl = decls.find((d) => this._evaluator.isFinalVariableDeclaration(d));
+          if (!isBaseVarFinal && overrideFinalVarDecl) {
+            const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.variableFinalOverride().format({
+              name: memberName,
+              className: baseClass.shared.name
+            }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
+            if (diag) {
+              diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), overrideFinalVarDecl.uri, overrideFinalVarDecl.range);
+            }
+          }
+          const isBaseClassVar = baseClassAndSymbol.symbol.isClassVar();
+          let isClassVar = overrideSymbol.isClassVar();
+          if (isBaseClassVar && !isClassVar) {
+            if (!overrideSymbol.hasTypedDeclarations()) {
+              isClassVar = true;
+            }
+            if (overrideSymbol.getTypedDeclarations().every(
+              (decl) => decl.type === 6
+              /* DeclarationType.Class */
+            )) {
+              isClassVar = true;
+            }
+          }
+          const ignoreTypedDictOverride = types_1.ClassType.isTypedDictClass(childClassType) && !isClassVar;
+          if (isBaseClassVar !== isClassVar && !ignoreTypedDictOverride) {
+            const unformattedMessage = overrideSymbol.isClassVar() ? localize_1.LocMessage.classVarOverridesInstanceVar() : localize_1.LocMessage.instanceVarOverridesClassVar();
+            const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, unformattedMessage.format({
+              name: memberName,
+              className: baseClass.shared.name
+            }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
+            const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
+            if (diag && origDecl) {
+              diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
+            }
+          }
+        }
+      }
+      _isFinalFunction(name, type) {
+        if (SymbolNameUtils.isPrivateName(name)) {
+          return false;
+        }
+        if ((0, types_1.isFunction)(type) && types_1.FunctionType.isFinal(type)) {
+          return true;
+        }
+        if ((0, types_1.isOverloaded)(type)) {
+          const overloads = types_1.OverloadedType.getOverloads(type);
+          const impl = types_1.OverloadedType.getImplementation(type);
+          if (overloads.some((overload) => types_1.FunctionType.isFinal(overload))) {
+            return true;
+          }
+          if (impl && (0, types_1.isFunction)(impl) && types_1.FunctionType.isFinal(impl)) {
+            return true;
           }
         }
+        return false;
       }
       _validatePropertyOverride(baseClassType, childClassType, baseType, childType, overrideSymbol, memberName) {
         const propMethodInfo = [
@@ -93431,6 +93502,14 @@ var require_checker = __commonJS({
                 }
               }
               return;
+            } else if (this._isFinalFunction(methodName, baseClassPropMethod)) {
+              const decl2 = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
+              if (decl2 && decl2.type === 5) {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.finalMethodOverride().format({
+                  name: memberName,
+                  className: baseClassType.shared.name
+                }), decl2.node.d.name);
+              }
             }
             const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, childClassType, this._evaluator.getTypeClassType());
             if (!(0, types_1.isFunction)(subclassMethodType)) {
@@ -94428,6 +94507,7 @@ var require_sourceFile = __commonJS({
         this._writableData.isCheckingNeeded = true;
         this._writableData.isBindingNeeded = true;
         this._writableData.moduleSymbolTable = void 0;
+        this._writableData.lineCount = void 0;
         this._fireFileDirtyEvent();
       }
       markReanalysisRequired(forceRebinding) {
@@ -94447,6 +94527,9 @@ var require_sourceFile = __commonJS({
       getClientVersion() {
         return this._writableData.clientDocumentVersion;
       }
+      getRange() {
+        return { start: { line: 0, character: 0 }, end: { line: this._writableData.lineCount ?? 0, character: 0 } };
+      }
       getOpenFileContents() {
         return this._writableData.clientDocumentContents;
       }
@@ -94587,6 +94670,7 @@ var require_sourceFile = __commonJS({
             this._writableData.typeIgnoreLines = parseFileResults.tokenizerOutput.typeIgnoreLines;
             this._writableData.typeIgnoreAll = parseFileResults.tokenizerOutput.typeIgnoreAll;
             this._writableData.pyrightIgnoreLines = parseFileResults.tokenizerOutput.pyrightIgnoreLines;
+            this._writableData.lineCount = parseFileResults.tokenizerOutput.lines.length;
             if (this._writableData.clientDocumentContents !== void 0) {
               this._writableData.tokenizerOutput = parseFileResults.tokenizerOutput;
             }
@@ -94694,7 +94778,7 @@ var require_sourceFile = __commonJS({
           this._recomputeDiagnostics(configOptions);
         });
       }
-      check(configOptions, importResolver, evaluator, sourceMapper, dependentFiles) {
+      check(configOptions, importLookup, importResolver, evaluator, sourceMapper, dependentFiles) {
         (0, debug_1.assert)(!this.isParseRequired(), `Check called before parsing: state=${this._writableData.debugPrint()}`);
         (0, debug_1.assert)(!this.isBindingRequired(), `Check called before binding: state=${this._writableData.debugPrint()}`);
         (0, debug_1.assert)(!this._writableData.isBindingInProgress, "Check called while binding in progress");
@@ -99450,11 +99534,13 @@ var require_parser = __commonJS({
             }
             continue;
           }
-          if (this._consumeTokensUntilType([
-            26
-            /* TokenType.FStringEnd */
-          ])) {
-            this._getNextToken();
+          if (nextToken.type !== 2) {
+            if (this._consumeTokensUntilType([
+              26
+              /* TokenType.FStringEnd */
+            ])) {
+              this._getNextToken();
+            }
           }
           this._addSyntaxError(nextToken.type === 18 ? localize_1.LocMessage.formatStringBrace() : localize_1.LocMessage.stringUnterminated(), nextToken);
           break;
@@ -115552,10 +115638,13 @@ var TestFrameworkWalker = class extends import_parseTreeWalker3.ParseTreeWalker
     this.testFramework = testFramework;
   }
   visitFunction(node) {
+    var _a;
     if (node.d.name.d.value.startsWith("test_")) {
       if (node.parent && (0, import_parseTreeUtils2.printParseNodeType)(node.parent.nodeType) === "Suite") {
-        const parentSuiteNode = node.parent;
-        if (parentSuiteNode.parent && (0, import_parseTreeUtils2.printParseNodeType)(parentSuiteNode.parent.nodeType) === "Class") {
+        let fullyQualifiedTestName = "";
+        let currentNode = node;
+        let parentSuiteNode = currentNode == null ? void 0 : currentNode.parent;
+        while (parentSuiteNode.parent && (0, import_parseTreeUtils2.printParseNodeType)(parentSuiteNode.parent.nodeType) === "Class") {
           const classNode = parentSuiteNode.parent;
           let combineString = void 0;
           if (this.testFramework === "unittest") {
@@ -115563,12 +115652,15 @@ var TestFrameworkWalker = class extends import_parseTreeWalker3.ParseTreeWalker
           } else if (this.testFramework === "pytest") {
             combineString = "::";
           }
-          this.featureItems.push({
-            value: classNode.d.name.d.value + combineString + node.d.name.d.value,
-            startOffset: node.start,
-            endOffset: node.start + node.length - 1
-          });
+          fullyQualifiedTestName = classNode.d.name.d.value + combineString + fullyQualifiedTestName;
+          currentNode = (_a = currentNode == null ? void 0 : currentNode.parent) == null ? void 0 : _a.parent;
+          parentSuiteNode = currentNode == null ? void 0 : currentNode.parent;
         }
+        this.featureItems.push({
+          value: fullyQualifiedTestName + node.d.name.d.value,
+          startOffset: node.start,
+          endOffset: node.start + node.length - 1
+        });
       } else {
         if (this.testFramework === "pytest") {
           this.featureItems.push({
@@ -115599,9 +115691,23 @@ function parse(source) {
 // src/commands.ts
 var terminal;
 var framework = import_coc3.workspace.getConfiguration("pyright").get("testing.provider", "unittest");
+function pythonSupportsPathFinder(pythonPath) {
+  try {
+    const pythonProcess = child_process2.spawnSync(
+      pythonPath,
+      ["-c", "from sys import version_info; exit(0) if (version_info[0] >= 3 and version_info[1] >= 4) else exit(1)"],
+      { encoding: "utf8" }
+    );
+    if (pythonProcess.error) return false;
+    return pythonProcess.status === 0;
+  } catch (ex) {
+    return false;
+  }
+}
 function validPythonModule(pythonPath, moduleName) {
+  const pythonArgs = pythonSupportsPathFinder(pythonPath) ? ["-c", `from importlib.machinery import PathFinder; assert PathFinder.find_spec("${moduleName}") is not None`] : ["-m", moduleName, "--help"];
   try {
-    const pythonProcess = child_process2.spawnSync(pythonPath, ["-m", moduleName, "--help"], { encoding: "utf8" });
+    const pythonProcess = child_process2.spawnSync(pythonPath, pythonArgs, { encoding: "utf8" });
     if (pythonProcess.error) return false;
     return pythonProcess.status === 0;
   } catch (ex) {