@zzzen/pyright-internal 1.2.0-dev.20241215 → 1.2.0-dev.20241222

package/dist/localization/package.nls.pl.json

@@ -59,7 +59,9 @@
         "baseClassVariableTypeIncompatible": "Klasy bazowe dla klasy „{classType}” definiują zmienną „{name}” w niezgodny sposób",
         "binaryOperationNotAllowed": "Operator binarny nie jest dozwolony w wyrażeniu typu",
         "bindTypeMismatch": "Nie można powiązać metody „{methodName}”, ponieważ nie można przypisać typu „{type}” do parametru „{paramName}”",
+        "breakInExceptionGroup": "„break” nie jest dozwolone w bloku „except*”",
         "breakOutsideLoop": "Wartość „break” może być używana tylko w pętli",
+        "bytesUnsupportedEscape": "Nieobsługiwana sekwencja ucieczki w literałach bytes",
         "callableExtraArgs": "Oczekiwano tylko dwóch argumentów typu „Callable”",
         "callableFirstArg": "Oczekiwano listy typów parametrów lub znaków „...”",
         "callableNotInstantiable": "Nie można utworzyć wystąpienia typu „{type}”",
@@ -96,6 +98,7 @@
         "constructorParametersMismatch": "Niezgodność między sygnaturą „__new__” i „__init__” w klasie „{classType}”",
         "containmentAlwaysFalse": "Warunek zawsze będzie miał wartość False, ponieważ typy „{leftType}” i „{rightType}” nie nakładają się na siebie",
         "containmentAlwaysTrue": "Warunek zawsze będzie miał wartość „True”, ponieważ typy „{leftType}” i „{rightType}” nie nakładają się na siebie",
+        "continueInExceptionGroup": "„continue” nie jest dozwolone w bloku „except*”",
         "continueOutsideLoop": "Wartość „continue” może być używana tylko w pętli",
         "coroutineInConditionalExpression": "Wyrażenie warunkowe odwołuje się do koprocedury, która zawsze wyznacza wartość True",
         "dataClassBaseClassFrozen": "Klasa niezablokowana nie może dziedziczyć po klasie zablokowanej",
@@ -156,6 +159,8 @@
         "enumMemberDelete": "Nie można usunąć składowej Enum \"{name}\"",
         "enumMemberSet": "Nie można przypisać składowej Enum „{name}”",
         "enumMemberTypeAnnotation": "Adnotacje typu nie są dozwolone dla składowych enum",
+        "exceptGroupMismatch": "Instrukcja Try nie może zawierać jednocześnie „except” i „except*”",
+        "exceptGroupRequiresType": "Składnia grupy wyjątków (\"except*\") wymaga typu wyjątku",
         "exceptionGroupIncompatible": "Składnia grupy wyjątków („except*”) wymaga języka Python w wersji 3.11 lub nowszej",
         "exceptionGroupTypeIncorrect": "Typ wyjątku w wyrażeniu except* nie może pochodzić z grupy BaseGroupException",
         "exceptionTypeIncorrect": "Typ „{type}” nie pochodzi od parametru BaseException",
@@ -425,6 +430,7 @@
         "requiredArgCount": "Oczekiwano jednego argumentu typu po wartości „Required”",
         "requiredNotInTypedDict": "Element „Required” jest niedozwolony w tym kontekście",
         "returnInAsyncGenerator": "Instrukcja „return” z wartością jest niedozwolona w generatorze asynchronicznym",
+        "returnInExceptionGroup": "„return” nie jest dozwolone w bloku „except*”",
         "returnMissing": "Funkcja z zadeklarowanym typem zwracanym „{returnType}” musi zwracać wartość we wszystkich ścieżkach kodu",
         "returnOutsideFunction": "Instrukcja „return” może być używana tylko w ramach funkcji",
         "returnTypeContravariant": "Kontrawariantna zmienna typu nie może być używana w zwracanym typie",

package/dist/localization/package.nls.pt-br.json

@@ -59,7 +59,9 @@
         "baseClassVariableTypeIncompatible": "Classes base para a classe \"{classType}\" definem a variável \"{name}\" de maneira incompatível",
         "binaryOperationNotAllowed": "Operador binário não permitido na expressão de tipo",
         "bindTypeMismatch": "Não foi possível associar o método \"{methodName}\" porque \"{type}\" não é atribuível ao parâmetro \"{paramName}\"",
+        "breakInExceptionGroup": "\"break\" não é permitido em um bloco \"except*\"",
         "breakOutsideLoop": "\"break\" só pode ser usado dentro de um loop",
+        "bytesUnsupportedEscape": "Sequência de escape sem suporte em literal de bytes",
         "callableExtraArgs": "Esperava-se apenas dois argumentos de tipo para \"Callable\"",
         "callableFirstArg": "Lista de tipos de parâmetro esperado ou \"...\"",
         "callableNotInstantiable": "Não é possível criar uma instância do tipo \"{type}\"",
@@ -96,6 +98,7 @@
         "constructorParametersMismatch": "Incompatibilidade entre a assinatura de __new__ e __init__ na classe \"{classType}\"",
         "containmentAlwaysFalse": "A expressão sempre será avaliada como False, pois os tipos \"{leftType}\" e \"{rightType}\" não têm sobreposição",
         "containmentAlwaysTrue": "A expressão sempre será avaliada como True, pois os tipos \"{leftType}\" e \"{rightType}\" não têm sobreposição",
+        "continueInExceptionGroup": "\"continue\" não é permitido em um bloco \"except*\"",
         "continueOutsideLoop": "\"continue\" só pode ser usado dentro de um loop",
         "coroutineInConditionalExpression": "A expressão condicional faz referência à corrotina, que sempre é avaliada como True",
         "dataClassBaseClassFrozen": "Uma classe não congelada não pode herdar de uma classe congelada",
@@ -156,6 +159,8 @@
         "enumMemberDelete": "O membro Enum \"{name}\" não pode ser excluído",
         "enumMemberSet": "O membro Enum \"{name}\" não pode ser atribuído",
         "enumMemberTypeAnnotation": "Anotações de tipo não são permitidas para membros de enumeração",
+        "exceptGroupMismatch": "A instrução Try não pode incluir \"except\" e \"except*\"",
+        "exceptGroupRequiresType": "A sintaxe do grupo de exceção (\"except*\") requer um tipo de exceção",
         "exceptionGroupIncompatible": "A sintaxe do grupo de exceção (\"except*\") requer o Python 3.11 ou mais recente",
         "exceptionGroupTypeIncorrect": "O tipo de exceção em except* não pode derivar de BaseGroupException",
         "exceptionTypeIncorrect": "\"{type}\" não deriva de BaseException",
@@ -425,6 +430,7 @@
         "requiredArgCount": "Argumento de tipo único esperado após \"Required\"",
         "requiredNotInTypedDict": "\"Required\" não é permitido neste contexto",
         "returnInAsyncGenerator": "A instrução return com valor não é permitida no gerador async",
+        "returnInExceptionGroup": "\"return\" não é permitido em um bloco \"except*\"",
         "returnMissing": "Função com tipo de retorno declarado \"{returnType}\" deve retornar valor em todos os caminhos de código",
         "returnOutsideFunction": "\"return\" só pode ser usado dentro de uma função",
         "returnTypeContravariant": "A variável de tipo contravariante não pode ser usada no tipo de retorno",

package/dist/localization/package.nls.qps-ploc.json

@@ -59,7 +59,9 @@
         "baseClassVariableTypeIncompatible": "[YmxlD][นั้ßæsë çlæssës før çlæss \"{çlæssTÿpë}\" ðëfïñë værïæþlë \"{ñæmë}\" ïñ ïñçømpætïþlë wæÿẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
         "binaryOperationNotAllowed": "[1lzlz][นั้ßïñærÿ øpërætør ñøt ælløwëð ïñ tÿpë ëxprëssïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
         "bindTypeMismatch": "[x4sbf][นั้Çøµlð ñøt þïñð mëthøð \"{mëthøðÑæmë}\" þëçæµsë \"{tÿpë}\" ïs ñøt æssïgñæþlë tø pæræmëtër \"{pæræmÑæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]",
+        "breakInExceptionGroup": "[Kwoku][นั้\"break\" ïs ñøt ælløwëð ïñ æñ \"except*\" þløçkẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
         "breakOutsideLoop": "[Ca4Ip][นั้\"break\" çæñ þë µsëð øñlÿ wïthïñ æ løøpẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]",
+        "bytesUnsupportedEscape": "[TxAaf][นั้Üñsµppørtëð ësçæpë sëqµëñçë ïñ bytes lïtërælẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
         "callableExtraArgs": "[M3UIb][นั้Ëxpëçtëð øñlÿ twø tÿpë ærgµmëñts tø \"Callable\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
         "callableFirstArg": "[W1wTU][นั้Ëxpëçtëð pæræmëtër tÿpë lïst ør \"...\"Ấğ倪İЂҰक्र्तिृまẤนั้ढूँ]",
         "callableNotInstantiable": "[sJ0Q8][นั้Çæññøt ïñstæñtïætë tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृนั้ढूँ]",
@@ -96,6 +98,7 @@
         "constructorParametersMismatch": "[WWloK][นั้Mïsmætçh þëtwëëñ sïgñætµrë øf __new__ æñð __init__ ïñ çlæss \"{çlæssTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]",
         "containmentAlwaysFalse": "[e6PIv][นั้Ëxprëssïøñ wïll ælwæÿs ëvælµætë tø False sïñçë thë tÿpës \"{lëftTÿpë}\" æñð \"{rïghtTÿpë}\" hævë ñø øvërlæpẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]",
         "containmentAlwaysTrue": "[8OhUO][นั้Ëxprëssïøñ wïll ælwæÿs ëvælµætë tø True sïñçë thë tÿpës \"{lëftTÿpë}\" æñð \"{rïghtTÿpë}\" hævë ñø øvërlæpẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]",
+        "continueInExceptionGroup": "[h1tNi][นั้\"continue\" ïs ñøt ælløwëð ïñ æñ \"except*\" þløçkẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]",
         "continueOutsideLoop": "[6ACvd][นั้\"continue\" çæñ þë µsëð øñlÿ wïthïñ æ løøpẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]",
         "coroutineInConditionalExpression": "[ygK2r][นั้Çøñðïtïøñæl ëxprëssïøñ rëfërëñçës çørøµtïñë whïçh ælwæÿs ëvælµætës tø TrueẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]",
         "dataClassBaseClassFrozen": "[jjiw4][นั้Æ ñøñ-frøzëñ çlæss çæññøt ïñhërït frøm æ çlæss thæt ïs frøzëñẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]",
@@ -156,6 +159,8 @@
         "enumMemberDelete": "[5wmRY][นั้Enum mëmþër \"{ñæmë}\" çæññøt þë ðëlëtëðẤğ倪İЂҰक्र्तिृまẤนั้ढूँ]",
         "enumMemberSet": "[mBLro][นั้Enum mëmþër \"{ñæmë}\" çæññøt þë æssïgñëðẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]",
         "enumMemberTypeAnnotation": "[z8FaL][นั้Tÿpë æññøtætïøñs ærë ñøt ælløwëð før enum mëmþërsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]",
+        "exceptGroupMismatch": "[XbzjN][นั้Trÿ stætëmëñt çæññøt ïñçlµðë þøth \"except\" æñð \"except*\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]",
+        "exceptGroupRequiresType": "[740wj][นั้Ëxçëptïøñ grøµp sÿñtæx (\"except*\") rëqµïrës æñ ëxçëptïøñ tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]",
         "exceptionGroupIncompatible": "[d0SLP][นั้Ëxçëptïøñ grøµp sÿñtæx (\"except*\") rëqµïrës Pÿthøñ 3.11 ør ñëwërẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]",
         "exceptionGroupTypeIncorrect": "[Kanvz][นั้Ëxçëptïøñ tÿpë ïñ except* çæññøt ðërïvë frøm BaseGroupExceptionẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]",
         "exceptionTypeIncorrect": "[G7AZt][นั้\"{tÿpë}\" ðøës ñøt ðërïvë frøm BaseExceptionẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]",
@@ -425,6 +430,7 @@
         "requiredArgCount": "[aZX4z][นั้Ëxpëçtëð æ sïñglë tÿpë ærgµmëñt æftër \"Required\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]",
         "requiredNotInTypedDict": "[TArW6][นั้\"Required\" ïs ñøt ælløwëð ïñ thïs çøñtëxtẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]",
         "returnInAsyncGenerator": "[qb5pt][นั้Rëtµrñ stætëmëñt wïth vælµë ïs ñøt ælløwëð ïñ async gëñërætørẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]",
+        "returnInExceptionGroup": "[wRRjc][นั้\"return\" ïs ñøt ælløwëð ïñ æñ \"except*\" þløçkẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
         "returnMissing": "[kPevK][นั้Fµñçtïøñ wïth ðëçlærëð rëtµrñ tÿpë \"{rëtµrñTÿpë}\" mµst rëtµrñ vælµë øñ æll çøðë pæthsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]",
         "returnOutsideFunction": "[O4SJp][นั้\"return\" çæñ þë µsëð øñlÿ wïthïñ æ fµñçtïøñẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]",
         "returnTypeContravariant": "[KkMhh][นั้Çøñtræværïæñt tÿpë værïæþlë çæññøt þë µsëð ïñ rëtµrñ tÿpëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]",

package/dist/localization/package.nls.ru.json

@@ -59,7 +59,9 @@
         "baseClassVariableTypeIncompatible": "Базовые классы класса \"{classType}\" определяют переменную \"{name}\" несовместимым способом",
         "binaryOperationNotAllowed": "Бинарный оператор нельзя использовать в выражении типа",
         "bindTypeMismatch": "Не удалось привязать метод \"{methodName}\", \"{type}\" не может быть назначен параметру \"{paramName}\"",
+        "breakInExceptionGroup": "Запрещено наличие \"break\" в блоке \"except*\"",
         "breakOutsideLoop": "\"break\" можно использовать только внутри цикла",
+        "bytesUnsupportedEscape": "Неподдерживаемая escape-последовательность в литерале bytes",
         "callableExtraArgs": "В \"Callable\" ожидается только два аргумента типа",
         "callableFirstArg": "Ожидается список типов параметров или \"...\"",
         "callableNotInstantiable": "Невозможно создать экземпляр типа \"{type}\"",
@@ -96,6 +98,7 @@
         "constructorParametersMismatch": "Несоответствие подписи __new__ и __init__ в классе \"{classType}\"",
         "containmentAlwaysFalse": "Выражение всегда будет оцениваться как False, так как типы \"{leftType}\" и \"{rightType}\" не перекрываются",
         "containmentAlwaysTrue": "Выражение всегда будет оцениваться как True, так как типы \"{leftType}\" и \"{rightType}\" не перекрываются",
+        "continueInExceptionGroup": "Запрещено наличие \"continue\" в блоке \"except*\"",
         "continueOutsideLoop": "Ключевое слово \"continue\" можно использовать только внутри цикла",
         "coroutineInConditionalExpression": "Условное выражение ссылается на сопрограмму, которая всегда возвращает значение True",
         "dataClassBaseClassFrozen": "Незафиксированный класс не может наследоваться от зафиксированного класса",
@@ -156,6 +159,8 @@
         "enumMemberDelete": "Не удается удалить элемент Enum \"{name}\"",
         "enumMemberSet": "Не удается назначить элемент Enum \"{name}\"",
         "enumMemberTypeAnnotation": "Аннотации типов не разрешены для элементов enum",
+        "exceptGroupMismatch": "Оператор Try не может одновременно включать \"except\" и \"except*\"",
+        "exceptGroupRequiresType": "Для синтаксиса группы исключений (\"except*\") требуется тип исключения",
         "exceptionGroupIncompatible": "Синтаксис группы исключений (\"except*\") можно использовать в Python версии не ранее 3.11",
         "exceptionGroupTypeIncorrect": "Тип исключения в except* не может быть производным от BaseGroupException",
         "exceptionTypeIncorrect": "\"{type}\" не является производным от BaseException",
@@ -425,6 +430,7 @@
         "requiredArgCount": "Ожидается один аргумент типа после \"Required\"",
         "requiredNotInTypedDict": "Использование \"Required\" в этом контексте не допускается",
         "returnInAsyncGenerator": "Оператор return со значением не допускается в генераторе async",
+        "returnInExceptionGroup": "Запрещено наличие \"return\" в блоке \"except*\"",
         "returnMissing": "Функция с объявленным типом возвращаемого значения \"{returnType}\" должна возвращать значение во всех путях кода",
         "returnOutsideFunction": "\"return\" можно использовать только внутри функции",
         "returnTypeContravariant": "Переменная контравариантного типа не может использоваться в возвращаемом типе",

package/dist/localization/package.nls.tr.json

@@ -59,7 +59,9 @@
         "baseClassVariableTypeIncompatible": "\"{classType}\" sınıfı için temel sınıflar, \"{name}\" değişkenini uyumsuz bir şekilde tanımlıyor",
         "binaryOperationNotAllowed": "Tür ifadesinde ikili işleç kullanılamaz",
         "bindTypeMismatch": "\"{type}\", \"{paramName}\" parametresine atanamadığından \"{methodName}\" metodu bağlanamadı",
+        "breakInExceptionGroup": "\"except*\" bloğunda \"break\" kullanılamaz",
         "breakOutsideLoop": "\"break\" yalnızca bir döngü içinde kullanılabilir",
+        "bytesUnsupportedEscape": "bytes sabit değerinde desteklenmeyen kaçış dizisi",
         "callableExtraArgs": "\"Callable\" için yalnızca iki tür bağımsız değişkeni bekleniyordu",
         "callableFirstArg": "Parametre türü listesi veya \"...\" bekleniyordu",
         "callableNotInstantiable": "\"{type}\" türünün örneği oluşturulamıyor",
@@ -96,6 +98,7 @@
         "constructorParametersMismatch": "\"{classType}\" sınıfındaki __new__ ve __init__ imzaları arasında uyuşmazlık var",
         "containmentAlwaysFalse": "\"{leftType}\" türleri ve \"{rightType}\" türleri çakışmadığından ifade her zaman False olarak değerlendirilir",
         "containmentAlwaysTrue": "\"{leftType}\" türleri ve \"{rightType}\" türleri çakışmadığından ifade her zaman True olarak değerlendirilir",
+        "continueInExceptionGroup": "\"except*\" bloğunda \"continue\" kullanılamaz",
         "continueOutsideLoop": "\"continue\" yalnızca bir döngü içinde kullanılabilir",
         "coroutineInConditionalExpression": "Koşullu ifade, her zaman True olarak değerlendirilen eş yordama başvurur",
         "dataClassBaseClassFrozen": "Dondurulmuş olmayan bir sınıf dondurulmuş bir sınıftan devralamaz",
@@ -156,6 +159,8 @@
         "enumMemberDelete": "Enum üyesi \"{name}\" silinemiyor",
         "enumMemberSet": "Enum üyesi \"{name}\" atanamıyor",
         "enumMemberTypeAnnotation": "Type annotations are not allowed for enum members",
+        "exceptGroupMismatch": "Try ifadesi hem \"except*\" hem de \"except\" içeremez",
+        "exceptGroupRequiresType": "Özel durum grubu söz dizimi (\"except*\") biri özel durum türü gerektirir",
         "exceptionGroupIncompatible": "Özel durum grubu söz dizimi (\"except*\") için Python 3.11 veya daha yeni bir sürümü gerekiyor",
         "exceptionGroupTypeIncorrect": "except* altındaki özel durum türü BaseGroupException değerinden türetilemiyor",
         "exceptionTypeIncorrect": "\"{type}\", BaseException türevi değil",
@@ -425,6 +430,7 @@
         "requiredArgCount": "\"Required\" sonrasında tek bir tür bağımsız değişken bekleniyordu",
         "requiredNotInTypedDict": "Bu bağlamda \"Required\" kullanımına izin verilmiyor",
         "returnInAsyncGenerator": "Return statement with value is not allowed in async generator",
+        "returnInExceptionGroup": "\"except*\" bloğunda \"return\" kullanılamaz",
         "returnMissing": "Bildirilen \"{returnType}\" döndürme türüne sahip işlev, tüm kod yollarında değer döndürmelidir",
         "returnOutsideFunction": "\"return\" yalnızca bir işlev içinde kullanılabilir",
         "returnTypeContravariant": "Değişken karşıtı tür değişkeni dönüş türünde kullanılamaz",

package/dist/localization/package.nls.zh-cn.json

@@ -59,7 +59,9 @@
         "baseClassVariableTypeIncompatible": "类“{classType}”的基类以不兼容的方式定义变量“{name}”",
         "binaryOperationNotAllowed": "类型表达式中不允许使用二元运算符",
         "bindTypeMismatch": "无法绑定方法“{methodName}”，因为“{type}”不能分配给参数“{paramName}”",
+        "breakInExceptionGroup": "\"except*\" 块中不允许 \"break\"",
         "breakOutsideLoop": "“break”只能在循环中使用",
+        "bytesUnsupportedEscape": "bytes 文本中不受支持的转义序列",
         "callableExtraArgs": "\"Callable\"应只有两个类型参数",
         "callableFirstArg": "应为参数类型列表或“...”",
         "callableNotInstantiable": "无法实例化类型“{type}”",
@@ -96,6 +98,7 @@
         "constructorParametersMismatch": "类“{classType}”中__new__和__init__的签名不匹配",
         "containmentAlwaysFalse": "表达式的计算结果始终为 False，因为类型“{leftType}”和“{rightType}”没有重叠",
         "containmentAlwaysTrue": "表达式的计算结果始终为 True，因为类型“{leftType}”和“{rightType}”没有重叠",
+        "continueInExceptionGroup": "\"except*\" 块中不允许 \"continue\"",
         "continueOutsideLoop": "“continue”只能在循环中使用",
         "coroutineInConditionalExpression": "始终计算结果为 True 的条件表达式引用协同例程",
         "dataClassBaseClassFrozen": "非冻结类不能从已冻结类继承",
@@ -156,6 +159,8 @@
         "enumMemberDelete": "无法删除 Enum 成员 \"{name}\"",
         "enumMemberSet": "无法分配 Enum 成员 \"{name}\"",
         "enumMemberTypeAnnotation": "enum 成员不允许使用类型批注",
+        "exceptGroupMismatch": "Try 语句不能同时包含 \"except\" 和 \"except*\"",
+        "exceptGroupRequiresType": "异常组语法(\"except*\")需要异常类型",
         "exceptionGroupIncompatible": "异常组语法 (\"except*\") 需要 Python 3.11 或更高版本",
         "exceptionGroupTypeIncorrect": "except* 中的异常类型不能派生自 BaseGroupException",
         "exceptionTypeIncorrect": "\"{type}\" 不是派生自 BaseException",
@@ -425,6 +430,7 @@
         "requiredArgCount": "\"Required\"后应为单个类型参数",
         "requiredNotInTypedDict": "此上下文中不允许使用\"Required\"",
         "returnInAsyncGenerator": "async 生成器中不允许使用具有值的 return 语句",
+        "returnInExceptionGroup": "\"except*\" 块中不允许 \"return\"",
         "returnMissing": "所声明的返回类型为“{returnType}”的函数必须在所有代码路径上返回值",
         "returnOutsideFunction": "“return”只能在函数中使用",
         "returnTypeContravariant": "逆变类型变量不能用于返回类型",

package/dist/localization/package.nls.zh-tw.json

@@ -59,7 +59,9 @@
         "baseClassVariableTypeIncompatible": "類別 \"{classType}\" 的基底類別以不相容的方式定義變數 \"{name}\"",
         "binaryOperationNotAllowed": "類型運算式中不允許二元運算子",
         "bindTypeMismatch": "無法繫結方法 \"{methodName}\"，因為 \"{type}\" 無法指派給參數 \"{paramName}\"",
+        "breakInExceptionGroup": "\"except*\" 區塊中不允許 \"break\"",
         "breakOutsideLoop": "\"break\" 只能在迴圈內使用",
+        "bytesUnsupportedEscape": "bytes 常值中不支援的逸出序列",
         "callableExtraArgs": "預期 \"Callable\" 只有兩個類型引數",
         "callableFirstArg": "預期為參數類型清單或 \"...\"",
         "callableNotInstantiable": "不能具現化類型 \"{type}\"",
@@ -96,6 +98,7 @@
         "constructorParametersMismatch": "類別 \"{classType}\" 中__new__與__init__的簽章不相符",
         "containmentAlwaysFalse": "運算式一律會評估為 False，因為型別 \"{leftType}\" 和 \"{rightType}\" 沒有重疊",
         "containmentAlwaysTrue": "運算式一律會評估為 True，因為型別 \"{leftType}\" 和 \"{rightType}\" 沒有重疊",
+        "continueInExceptionGroup": "\"except*\" 區塊中不允許 \"continue\"",
         "continueOutsideLoop": "\"continue\" 只能在 loop 內使用",
         "coroutineInConditionalExpression": "條件運算式參考協同程式，一律評估為 True",
         "dataClassBaseClassFrozen": "未凍結的類別無法繼承已凍結的類別",
@@ -156,6 +159,8 @@
         "enumMemberDelete": "Enum member \"{name}\" cannot be deleted",
         "enumMemberSet": "Enum member \"{name}\" cannot be assigned",
         "enumMemberTypeAnnotation": "Type annotations are not allowed for enum members",
+        "exceptGroupMismatch": "Try 陳述式不能同時包含 \"except\" 與 “except*”",
+        "exceptGroupRequiresType": "例外狀況群組語法 (\"except*\") 需要例外狀況類型",
         "exceptionGroupIncompatible": "例外群組語法 (\"except*\") 需要 Python 3.11 或更新版本",
         "exceptionGroupTypeIncorrect": "except* 中的例外狀況類型不能衍生自 BaseGroupException",
         "exceptionTypeIncorrect": "\"{type}\" 不是衍生自 BaseException",
@@ -425,6 +430,7 @@
         "requiredArgCount": "\"Required\" 後面應有單一型別引數",
         "requiredNotInTypedDict": "此內容中不允許 \"Required\"",
         "returnInAsyncGenerator": "Return statement with value is not allowed in async generator",
+        "returnInExceptionGroup": "\"except*\" 區塊中不允許 \"return\"",
         "returnMissing": "宣告類型為 \"{returnType}\" 的函式必須在所有程式碼路徑上傳回值",
         "returnOutsideFunction": "\"return\" 只能在函式內使用",
         "returnTypeContravariant": "逆變數型別變數不能用在傳回型別中",

package/dist/parser/parser.js

@@ -2064,9 +2064,8 @@ class Parser {
             }
             else {
                 importFromNode.d.imports.forEach((imp) => {
-                    var _a;
                     if (typingSymbolsOfInterest.some((s) => s === imp.d.name.d.value)) {
-                        this._typingSymbolAliases.set(((_a = imp.d.alias) === null || _a === void 0 ? void 0 : _a.d.value) || imp.d.name.d.value, imp.d.name.d.value);
+                        this._typingSymbolAliases.set(imp.d.alias?.d.value || imp.d.name.d.value, imp.d.name.d.value);
                     }
                 });
             }
@@ -2077,7 +2076,6 @@ class Parser {
     // dotted_as_names: dotted_as_name (',' dotted_as_name)*
     // dotted_as_name: dotted_name ['as' NAME]
     _parseImportStatement() {
-        var _a;
         const importToken = this._getKeywordToken(21 /* KeywordType.Import */);
         const importNode = parseNodes_1.ImportNode.create(importToken);
         while (true) {
@@ -2125,7 +2123,7 @@ class Parser {
             if (modName.d.nameParts.length === 1) {
                 const firstNamePartValue = modName.d.nameParts[0].d.value;
                 if (firstNamePartValue === 'typing' || firstNamePartValue === 'typing_extensions') {
-                    this._typingImportAliases.push(((_a = importAsNode.d.alias) === null || _a === void 0 ? void 0 : _a.d.value) || firstNamePartValue);
+                    this._typingImportAliases.push(importAsNode.d.alias?.d.value || firstNamePartValue);
                 }
             }
             if (!this._consumeTokenIfType(12 /* TokenType.Comma */)) {
@@ -2140,10 +2138,9 @@ class Parser {
     // ('.' | '...')* dotted_name | ('.' | '...')+
     // dotted_name: NAME ('.' NAME)*
     _parseDottedModuleName(allowJustDots = false) {
-        var _a;
         const moduleNameNode = parseNodes_1.ModuleNameNode.create(this._peekToken());
         while (true) {
-            const token = (_a = this._getTokenIfType(19 /* TokenType.Ellipsis */)) !== null && _a !== void 0 ? _a : this._getTokenIfType(20 /* TokenType.Dot */);
+            const token = this._getTokenIfType(19 /* TokenType.Ellipsis */) ?? this._getTokenIfType(20 /* TokenType.Dot */);
             if (token) {
                 if (token.type === 19 /* TokenType.Ellipsis */) {
                     moduleNameNode.d.leadingDots += 3;
@@ -2757,7 +2754,6 @@ class Parser {
     // atom_expr: ['await'] atom trailer*
     // trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
     _parseAtomExpression() {
-        var _a, _b, _c;
         let awaitToken;
         if (this._peekKeywordType() === 4 /* KeywordType.Await */) {
             awaitToken = this._getKeywordToken(4 /* KeywordType.Await */);
@@ -2805,7 +2801,7 @@ class Parser {
                     isArgListTerminated = true;
                 }
                 this._isParsingTypeAnnotation = wasParsingTypeAnnotation;
-                const maxDepth = (_a = this._maxChildDepthMap.get(atomExpression.id)) !== null && _a !== void 0 ? _a : 0;
+                const maxDepth = this._maxChildDepthMap.get(atomExpression.id) ?? 0;
                 if (maxDepth >= maxChildNodeDepth) {
                     atomExpression = parseNodes_1.ErrorNode.create(callNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
                     this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), atomExpression);
@@ -2842,7 +2838,7 @@ class Parser {
                     // case because it creates problems for the completion provider.
                     this._handleExpressionParseError(6 /* ErrorExpressionCategory.MissingIndexCloseBracket */, localize_1.LocMessage.expectedCloseBracket(), startOfTrailerToken, indexNode);
                 }
-                const maxDepth = (_b = this._maxChildDepthMap.get(atomExpression.id)) !== null && _b !== void 0 ? _b : 0;
+                const maxDepth = this._maxChildDepthMap.get(atomExpression.id) ?? 0;
                 if (maxDepth >= maxChildNodeDepth) {
                     atomExpression = parseNodes_1.ErrorNode.create(indexNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
                     this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), atomExpression);
@@ -2859,7 +2855,7 @@ class Parser {
                     return this._handleExpressionParseError(7 /* ErrorExpressionCategory.MissingMemberAccessName */, localize_1.LocMessage.expectedMemberName(), startOfTrailerToken, atomExpression, [8 /* TokenType.Keyword */]);
                 }
                 const memberAccessNode = parseNodes_1.MemberAccessNode.create(atomExpression, parseNodes_1.NameNode.create(memberName));
-                const maxDepth = (_c = this._maxChildDepthMap.get(atomExpression.id)) !== null && _c !== void 0 ? _c : 0;
+                const maxDepth = this._maxChildDepthMap.get(atomExpression.id) ?? 0;
                 if (maxDepth >= maxChildNodeDepth) {
                     atomExpression = parseNodes_1.ErrorNode.create(memberAccessNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
                     this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), atomExpression);
@@ -3179,8 +3175,7 @@ class Parser {
     // child node can be passed to help the completion provider determine
     // what to do.
     _handleExpressionParseError(category, errorMsg, targetToken, childNode, additionalStopTokens) {
-        var _a;
-        this._addSyntaxError(errorMsg, targetToken !== null && targetToken !== void 0 ? targetToken : this._peekToken());
+        this._addSyntaxError(errorMsg, targetToken ?? this._peekToken());
         const stopTokens = [2 /* TokenType.NewLine */];
         if (additionalStopTokens) {
             (0, collectionUtils_1.appendArray)(stopTokens, additionalStopTokens);
@@ -3189,7 +3184,7 @@ class Parser {
         // Sibling nodes in parse tree shouldn't overlap each other.
         const nextToken = this._peekToken();
         const initialRange = stopTokens.some((k) => nextToken.type === k)
-            ? (_a = targetToken !== null && targetToken !== void 0 ? targetToken : childNode) !== null && _a !== void 0 ? _a : textRange_1.TextRange.create(nextToken.start, /* length */ 0)
+            ? targetToken ?? childNode ?? textRange_1.TextRange.create(nextToken.start, /* length */ 0)
             : nextToken;
         const expr = parseNodes_1.ErrorNode.create(initialRange, category, childNode);
         this._consumeTokensUntilType(stopTokens);
@@ -3225,7 +3220,6 @@ class Parser {
     // ('(' [yield_expr | testlist_comp] ')'
     // testlist_comp: (test | star_expr) (comp_for | (',' (test | star_expr))* [','])
     _parseTupleAtom() {
-        var _a;
         const startParen = this._getNextToken();
         (0, debug_1.assert)(startParen.type === 13 /* TokenType.OpenParenthesis */);
         const yieldExpr = this._tryParseYieldExpression();
@@ -3242,7 +3236,7 @@ class Parser {
         const tupleOrExpression = this._makeExpressionOrTuple(exprListResult, /* enclosedInParens */ true);
         (0, parseNodes_1.extendRange)(tupleOrExpression, startParen);
         if (this._peekTokenType() !== 14 /* TokenType.CloseParenthesis */) {
-            return this._handleExpressionParseError(8 /* ErrorExpressionCategory.MissingTupleCloseParen */, localize_1.LocMessage.expectedCloseParen(), startParen, (_a = exprListResult.parseError) !== null && _a !== void 0 ? _a : tupleOrExpression);
+            return this._handleExpressionParseError(8 /* ErrorExpressionCategory.MissingTupleCloseParen */, localize_1.LocMessage.expectedCloseParen(), startParen, exprListResult.parseError ?? tupleOrExpression);
         }
         else {
             (0, parseNodes_1.extendRange)(tupleOrExpression, this._getNextToken());
@@ -3252,13 +3246,12 @@ class Parser {
     // '[' [testlist_comp] ']'
     // testlist_comp: (test | star_expr) (comp_for | (',' (test | star_expr))* [','])
     _parseListAtom() {
-        var _a;
         const startBracket = this._getNextToken();
         (0, debug_1.assert)(startBracket.type === 15 /* TokenType.OpenBracket */);
         const exprListResult = this._parseTestListWithComprehension(/* isGenerator */ false);
         const closeBracket = this._peekToken();
         if (!this._consumeTokenIfType(16 /* TokenType.CloseBracket */)) {
-            return this._handleExpressionParseError(9 /* ErrorExpressionCategory.MissingListCloseBracket */, localize_1.LocMessage.expectedCloseBracket(), startBracket, (_a = exprListResult.parseError) !== null && _a !== void 0 ? _a : _createList());
+            return this._handleExpressionParseError(9 /* ErrorExpressionCategory.MissingListCloseBracket */, localize_1.LocMessage.expectedCloseBracket(), startBracket, exprListResult.parseError ?? _createList());
         }
         return _createList();
         function _createList() {
@@ -3476,7 +3469,6 @@ class Parser {
     // augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' |
     //             '<<=' | '>>=' | '**=' | '//=')
     _parseExpressionStatement() {
-        var _a, _b;
         let leftExpr = this._parseTestOrStarListAsExpression(
         /* allowAssignmentExpression */ false, 
         /* allowMultipleUnpack */ false, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.LocMessage.expectedExpr());
@@ -3504,9 +3496,10 @@ class Parser {
             if (isTypeAliasDeclaration) {
                 this._isParsingTypeAnnotation = true;
             }
-            const rightExpr = (_a = this._tryParseYieldExpression()) !== null && _a !== void 0 ? _a : this._parseTestOrStarListAsExpression(
-            /* allowAssignmentExpression */ false, 
-            /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.LocMessage.expectedAssignRightHandExpr());
+            const rightExpr = this._tryParseYieldExpression() ??
+                this._parseTestOrStarListAsExpression(
+                /* allowAssignmentExpression */ false, 
+                /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.LocMessage.expectedAssignRightHandExpr());
             this._isParsingTypeAnnotation = wasParsingTypeAnnotation;
             return parseNodes_1.AssignmentNode.create(leftExpr, rightExpr);
         }
@@ -3516,9 +3509,10 @@ class Parser {
         }
         if (tokenizer_1.Tokenizer.isOperatorAssignment(this._peekOperatorType())) {
             const operatorToken = this._getNextToken();
-            const rightExpr = (_b = this._tryParseYieldExpression()) !== null && _b !== void 0 ? _b : this._parseTestOrStarListAsExpression(
-            /* allowAssignmentExpression */ false, 
-            /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.LocMessage.expectedBinaryRightHandExpr());
+            const rightExpr = this._tryParseYieldExpression() ??
+                this._parseTestOrStarListAsExpression(
+                /* allowAssignmentExpression */ false, 
+                /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.LocMessage.expectedBinaryRightHandExpr());
             this._reportConditionalErrorForStarTupleElement(rightExpr, pythonVersion_1.pythonVersion3_9);
             // Make a shallow copy of the dest expression but give it a new ID.
             const destExpr = Object.assign({}, leftExpr);
@@ -3528,15 +3522,15 @@ class Parser {
         return leftExpr;
     }
     _parseChainAssignments(leftExpr) {
-        var _a;
         // Make a list of assignment targets.
         const assignmentTargets = [leftExpr];
         let rightExpr;
         while (true) {
             rightExpr =
-                (_a = this._tryParseYieldExpression()) !== null && _a !== void 0 ? _a : this._parseTestOrStarListAsExpression(
-                /* allowAssignmentExpression */ false, 
-                /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.LocMessage.expectedAssignRightHandExpr());
+                this._tryParseYieldExpression() ??
+                    this._parseTestOrStarListAsExpression(
+                    /* allowAssignmentExpression */ false, 
+                    /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.LocMessage.expectedAssignRightHandExpr());
             if (rightExpr.nodeType === 0 /* ParseNodeType.Error */) {
                 break;
             }
@@ -3637,7 +3631,7 @@ class Parser {
         if (stringToken.flags & 65536 /* StringTokenFlags.Unterminated */) {
             this._addSyntaxError(localize_1.LocMessage.stringUnterminated(), stringToken);
         }
-        if (unescapedResult === null || unescapedResult === void 0 ? void 0 : unescapedResult.nonAsciiInBytes) {
+        if (unescapedResult?.nonAsciiInBytes) {
             this._addSyntaxError(localize_1.LocMessage.stringNonAsciiBytes(), stringToken);
         }
         if (stringToken.flags & 64 /* StringTokenFlags.Format */) {
@@ -3721,14 +3715,14 @@ class Parser {
         (0, parseNodes_1.extendRange)(functionNode, functionAnnotation);
     }
     _parseFStringReplacementField(fieldExpressions, middleTokens, formatExpressions, nestingDepth = 0) {
-        var _a;
         let nextToken = this._getNextToken();
         // The caller should have already confirmed that the next token is an open brace.
         (0, debug_1.assert)(nextToken.type === 17 /* TokenType.OpenCurlyBrace */);
         // Consume the expression.
-        const expr = (_a = this._tryParseYieldExpression()) !== null && _a !== void 0 ? _a : this._parseTestOrStarListAsExpression(
-        /* allowAssignmentExpression */ true, 
-        /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.LocMessage.expectedExpr());
+        const expr = this._tryParseYieldExpression() ??
+            this._parseTestOrStarListAsExpression(
+            /* allowAssignmentExpression */ true, 
+            /* allowMultipleUnpack */ true, 2 /* ErrorExpressionCategory.MissingExpression */, () => localize_1.LocMessage.expectedExpr());
         fieldExpressions.push(expr);
         if (expr.nodeType === 0 /* ParseNodeType.Error */) {
             return false;
@@ -3839,13 +3833,12 @@ class Parser {
         return parseNodes_1.FormatStringNode.create(startToken, endToken, middleTokens, fieldExpressions, formatExpressions);
     }
     _createBinaryOperationNode(leftExpression, rightExpression, operatorToken, operator) {
-        var _a, _b;
         const binaryNode = parseNodes_1.BinaryOperationNode.create(leftExpression, rightExpression, operatorToken, operator);
         // Determine if we're exceeding the max parse depth. If so, replace
         // the subnode with an error node. Otherwise we risk crashing in the binder
         // or type evaluator.
-        const leftMaxDepth = (_a = this._maxChildDepthMap.get(leftExpression.id)) !== null && _a !== void 0 ? _a : 0;
-        const rightMaxDepth = (_b = this._maxChildDepthMap.get(rightExpression.id)) !== null && _b !== void 0 ? _b : 0;
+        const leftMaxDepth = this._maxChildDepthMap.get(leftExpression.id) ?? 0;
+        const rightMaxDepth = this._maxChildDepthMap.get(rightExpression.id) ?? 0;
         if (leftMaxDepth >= maxChildNodeDepth || rightMaxDepth >= maxChildNodeDepth) {
             this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), binaryNode);
             return parseNodes_1.ErrorNode.create(binaryNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);
@@ -3854,12 +3847,11 @@ class Parser {
         return binaryNode;
     }
     _createUnaryOperationNode(operatorToken, expression, operator) {
-        var _a;
         const unaryNode = parseNodes_1.UnaryOperationNode.create(operatorToken, expression, operator);
         // Determine if we're exceeding the max parse depth. If so, replace
         // the subnode with an error node. Otherwise we risk crashing in the binder
         // or type evaluator.
-        const maxDepth = (_a = this._maxChildDepthMap.get(expression.id)) !== null && _a !== void 0 ? _a : 0;
+        const maxDepth = this._maxChildDepthMap.get(expression.id) ?? 0;
         if (maxDepth >= maxChildNodeDepth) {
             this._addSyntaxError(localize_1.LocMessage.maxParseDepthExceeded(), unaryNode);
             return parseNodes_1.ErrorNode.create(unaryNode, 15 /* ErrorExpressionCategory.MaxDepthExceeded */);