@zzzen/pyright-internal 1.2.0-dev.20240407 → 1.2.0-dev.20240421

package/dist/localization/package.nls.es.json

@@ -17,8 +17,10 @@
         "abstractMethodInvocation": "No se puede llamar al método \"{method}\" porque es abstracto y no se ha implementado.",
         "annotatedParamCountMismatch": "El recuento de anotaciones del parámetro no coincide: se esperaba {expected}, pero se recibió {received}",
         "annotatedTypeArgMissing": "Se espera un argumento de tipo y una o más anotaciones para \"Anotado\".",
+        "annotationBytesString": "Type annotations cannot use bytes string literals",
         "annotationFormatString": "Las anotaciones de tipo no pueden utilizar literales de cadena de formato (cadenas f)",
         "annotationNotSupported": "No se admite la anotación de tipo para esta declaración",
+        "annotationRawString": "Type annotations cannot use raw string literals",
         "annotationSpansStrings": "Las anotaciones de tipo no pueden abarcar varios literales de cadena",
         "annotationStringEscape": "Las anotaciones de tipo no pueden contener caracteres de escape",
         "argAssignment": "Argumento de tipo \"{argType}\" no puede ser asignado a parámetro de tipo \"{paramType}\"",
@@ -104,7 +106,7 @@
         "dataClassFieldWithDefault": "Los campos sin valores predeterminados no pueden aparecer después de los campos con valores predeterminados",
         "dataClassFieldWithPrivateName": "El campo Dataclass no puede utilizar un nombre privado",
         "dataClassFieldWithoutAnnotation": "El campo Dataclass sin anotación de tipo provocará una excepción en tiempo de ejecución",
-        "dataClassPostInitParamCount": "Dataclass __post_init__ recuento de parámetros incorrecto; el número de campos InitVar es {esperado}.",
+        "dataClassPostInitParamCount": "Dataclass __post_init__ recuento de parámetros incorrecto; el número de campos InitVar es {expected}.",
         "dataClassPostInitType": "El tipo de parámetro del método __post_init__ de la clase de datos no coincide con el del campo \"{fieldName}\".",
         "dataClassSlotsOverwrite": "__slots__ ya está definido en la clase",
         "dataClassTransformExpectedBoolLiteral": "Expresión esperada que se evalúa estáticamente como True o False",
@@ -255,7 +257,7 @@
         "initVarNotAllowed": "\"InitVar\" no se permite en este contexto",
         "instanceMethodSelfParam": "Los métodos de instancia deben tomar un parámetro \"auto\"",
         "instanceVarOverridesClassVar": "La variable de instancia \"{name}\" invalida la variable de clase del mismo nombre en la clase \"{className}\"",
-        "instantiateAbstract": "No se puede instanciar la clase abstracta \"{tipo}\"",
+        "instantiateAbstract": "No se puede instanciar la clase abstracta \"{type}\"",
         "instantiateProtocol": "No se puede crear una instancia de la clase de protocolo \"{type}\"",
         "internalBindError": "Se ha producido un error interno al vincular el archivo \"{file}\": {message}",
         "internalParseError": "Se ha producido un error interno al procesar el archivo \"{file}\": {message}",
@@ -275,6 +277,7 @@
         "listAssignmentMismatch": "La expresión con el tipo \"{type}\" no puede asignarse a la lista de destino",
         "listInAnnotation": "Expresión de lista no permitida en anotación de tipo",
         "literalEmptyArgs": "Se esperaban uno o varios argumentos de tipo después de \"Literal\"",
+        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
         "literalNotAllowed": "\"Literal\" no se puede usar en este contexto sin un argumento de tipo",
         "literalNotCallable": "El tipo literal no puede instanciarse",
         "literalUnsupportedType": "Los argumentos de tipo para \"Literal\" deben ser None, un valor literal (int, bool, str, o bytes), o un valor enum",
@@ -597,7 +600,7 @@
         "unpackedDictArgumentNotMapping": "La expresión del argumento después de ** debe ser un mapeo con un tipo de clave \"str\".",
         "unpackedDictSubscriptIllegal": "El operador de desempaquetado del diccionario en el subíndice no está permitido",
         "unpackedSubscriptIllegal": "El operador de desempaquetado en el subíndice requiere Python 3.11 o posterior.",
-        "unpackedTypeVarTupleExpected": "Se espera un TypeVarTuple desempaquetado; use Unpack[{nombre1}] o *{name2}",
+        "unpackedTypeVarTupleExpected": "Se espera un TypeVarTuple desempaquetado; use Unpack[{name1}] o *{name2}",
         "unpackedTypedDictArgument": "No se puede emparejar el argumento TypedDict desempaquetado con los parámetros",
         "unreachableCode": "El código es inalcanzable",
         "unreachableExcept": "La cláusula Excepto es inalcanzable porque la excepción ya está administrada",
@@ -667,7 +670,7 @@
         "keyUndefined": "\"{name}\" no es una clave definida en \"{type}\"",
         "kwargsParamMissing": "El parámetro \"**{paramName}\" no tiene ningún parámetro correspondiente.",
         "listAssignmentMismatch": "El tipo \"{type}\" es incompatible con la lista de objetivos",
-        "literalAssignmentMismatch": "\"{sourceType}\" no puede asignarse al tipo \"{tipoDest}\"",
+        "literalAssignmentMismatch": "\"{sourceType}\" no puede asignarse al tipo \"{destType}\"",
         "matchIsNotExhaustiveHint": "Si no se pretende un tratamiento exhaustivo, agregue \"case _: pass\"",
         "matchIsNotExhaustiveType": "Tipo no manejado: \"{type}\"",
         "memberAssignment": "La expresión de tipo \"{type}\" no se puede asignar al miembro \"{name}\" de la clase \"{classType}\"",
@@ -784,6 +787,7 @@
         "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",
         "uninitializedAbstractVariable": "La variable de instancia \"{name}\" está definida en la clase base abstracta \"{classType} \" pero no inicializada.",

package/dist/localization/package.nls.fr.json

@@ -17,8 +17,10 @@
         "abstractMethodInvocation": "Désolé, nous n’avons pas pu appeler la méthode « {method} », car elle est abstraite et non implémentée",
         "annotatedParamCountMismatch": "Non-concordance du nombre d'annotations de paramètre : attendu {expected} mais reçu {received}",
         "annotatedTypeArgMissing": "Un argument de type et une ou plusieurs annotations sont attendus pour « Annotation »",
+        "annotationBytesString": "Type annotations cannot use bytes string literals",
         "annotationFormatString": "Les annotations de type ne peuvent pas utiliser de littéraux de chaîne de format (f-strings)",
         "annotationNotSupported": "Annotation de type non prise en charge pour cette instruction",
+        "annotationRawString": "Type annotations cannot use raw string literals",
         "annotationSpansStrings": "Les annotations de type ne peuvent pas s'étendre sur plusieurs littéraux de chaîne",
         "annotationStringEscape": "Les annotations de type ne peuvent pas contenir de caractères d'échappement",
         "argAssignment": "Impossible d’affecter l’argument de type « {argType} » au paramètre de type « {paramType} »",
@@ -89,7 +91,7 @@
         "concatenateParamSpecMissing": "Le dernier argument de type pour « Concatener » doit être un ParamSpec ou bien « ... »",
         "concatenateTypeArgsMissing": "\"Concaténation\" nécessite au moins deux arguments de type",
         "conditionalOperandInvalid": "Opérande conditionnel non valide de type \"{type}\"",
-        "constantRedefinition": "\"{nom}\" est constant (car il est en majuscule) et ne peut pas être redéfini",
+        "constantRedefinition": "\"{name}\" est constant (car il est en majuscule) et ne peut pas être redéfini",
         "constructorNoArgs": "Aucun argument attendu pour le constructeur « {type} »",
         "constructorParametersMismatch": "Non-concordance entre la signature de __new__ et __init__ dans la classe \"{classType}\"",
         "containmentAlwaysFalse": "L'expression sera toujours évaluée à False car les types \"{leftType}\" et \"{rightType}\" ne se chevauchent pas",
@@ -275,6 +277,7 @@
         "listAssignmentMismatch": "Impossible d’affecter l’expression de type « {type} » à la liste cible",
         "listInAnnotation": "Expression de liste non autorisée dans l’annotation de type",
         "literalEmptyArgs": "Attendu un ou plusieurs arguments de type après \"Literal\"",
+        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
         "literalNotAllowed": "\"Littéral\" ne peut pas être utilisé dans ce contexte sans argument de type",
         "literalNotCallable": "Impossible d’instancier le type littéral",
         "literalUnsupportedType": "Les arguments de type pour « Literal » doivent être None, une valeur littérale (int, bool, str ou bytes) ou une valeur enum",
@@ -480,7 +483,7 @@
         "typeArgsMissingForAlias": "Arguments de type attendus pour l’alias de type générique « {name} »",
         "typeArgsMissingForClass": "Arguments de type attendus pour la classe générique \"{name}\"",
         "typeArgsTooFew": "Trop peu d’arguments de type fournis pour « {name} » ; {expected} attendu, mais {received} reçu",
-        "typeArgsTooMany": "Trop d'arguments de type fournis pour \"{name}\" ; attendu {attendu} mais reçu {reçu}",
+        "typeArgsTooMany": "Trop d'arguments de type fournis pour \"{name}\" ; attendu {expected} mais reçu {received}",
         "typeAssignmentMismatch": "Impossible d’affecter l’expression de type « {sourceType} » au type déclaré « {destType} »",
         "typeAssignmentMismatchWildcard": "Le symbole d’importation « {name} » a le type « {sourceType} », qui ne peut pas être affecté au type déclaré « {destType} »",
         "typeCallNotAllowed": "l’appel type() ne doit pas être utilisé dans l’annotation de type",
@@ -628,7 +631,7 @@
         "argParam": "L’argument correspond au paramètre « {paramName} »",
         "argParamFunction": "L’argument correspond au paramètre « {paramName} » dans la fonction « {functionName} »",
         "argsParamMissing": "Le paramètre \"*{paramName}\" n'a pas de paramètre correspondant",
-        "argsPositionOnly": "Non-concordance des paramètres de position uniquement ; attendu {attendu} mais reçu {reçu}",
+        "argsPositionOnly": "Non-concordance des paramètres de position uniquement ; attendu {expected} mais reçu {received}",
         "argumentType": "Le type d’argument est « {type} »",
         "argumentTypes": "Types d'argument : ({types})",
         "assignToNone": "Le type ne peut pas être affecté au type « None »",
@@ -758,7 +761,7 @@
         "typeIncompatible": "« {sourceType} » n’est pas compatible avec « {destType} »",
         "typeNotClass": "« {type} » n’est pas une classe",
         "typeNotStringLiteral": "\"{type}\" n'est pas un littéral de chaîne",
-        "typeOfSymbol": "Le type de \"{nom}\" est \"{type}\"",
+        "typeOfSymbol": "Le type de \"{name}\" est \"{type}\"",
         "typeParamSpec": "Le type « {type} » n’est pas compatible avec ParamSpec « {name} »",
         "typeUnsupported": "Le type « {type} » n’est pas pris en charge",
         "typeVarDefaultOutOfScope": "La variable de type « {name} » n’est pas dans l’étendue",
@@ -784,6 +787,7 @@
         "typedDictFieldTypeMismatch": "Le type « {type} » n'est pas attribuable à l’élément « {name} »",
         "typedDictFieldUndefined": "« {name} » est un élément non défini dans le type « {type} »",
         "typedDictFinalMismatch": "« {sourceType} » n’est pas compatible avec « {destType} » en raison d’une incompatibilité de @final",
+        "typedDictKeyAccess": "Utilisez [« {name} »] pour référencer l’élément dans TypedDict",
         "typedDictNotAllowed": "TypedDict ne peut pas être utilisé pour les vérifications d’instance ou de classe",
         "unhashableType": "Le type \"{type}\" n'est pas hachable",
         "uninitializedAbstractVariable": "La variable d’instance « {name} » est définie dans la classe de base abstraite « {classType} » mais n’est pas initialisée",

package/dist/localization/package.nls.it.json

@@ -17,8 +17,10 @@
         "abstractMethodInvocation": "Impossibile chiamare il metodo \"{method}\" perché è astratto e non implementato",
         "annotatedParamCountMismatch": "Numero di annotazioni dei parametro non corrispondente: previsto {expected} ma ricevuto {received}",
         "annotatedTypeArgMissing": "Previsto un argomento di tipo e una o più annotazioni per \"Annotato\"",
+        "annotationBytesString": "Type annotations cannot use bytes string literals",
         "annotationFormatString": "Le annotazioni di tipo non possono usare valori letterali stringa di formato (stringhe f)",
         "annotationNotSupported": "Annotazione di tipo non supportata per questa istruzione",
+        "annotationRawString": "Type annotations cannot use raw string literals",
         "annotationSpansStrings": "Le annotazioni di tipo non possono estendersi su più valori letterali stringa",
         "annotationStringEscape": "Le annotazioni di tipo non possono contenere caratteri di escape",
         "argAssignment": "Non è possibile assegnare l'argomento di tipo \"{argType}\" al parametro di tipo \"{paramType}\"",
@@ -275,6 +277,7 @@
         "listAssignmentMismatch": "Non è possibile assegnare l'espressione con tipo \"{type}\" all'elenco di destinazione",
         "listInAnnotation": "Espressione elenco non consentita nell'annotazione di tipo",
         "literalEmptyArgs": "Previsto uno o più argomenti tipo dopo \"Valore letterale\"",
+        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
         "literalNotAllowed": "Non è possibile usare \"Literal\" in questo contesto senza un argomento tipo",
         "literalNotCallable": "Non è possibile creare un'istanza del tipo letterale",
         "literalUnsupportedType": "Gli argomenti di tipo per \"Literal\" devono essere None, un valore letterale (int, bool, str o bytes) o un valore di enumerazione",
@@ -717,7 +720,7 @@
         "overrideParamNameExtra": "Parametro \"{name}\" mancante nella base",
         "overrideParamNameMissing": "Parametro \"{name}\" mancante nell'override",
         "overrideParamNamePositionOnly": "Mancata corrispondenza del parametro {index}: il parametro di base \"{baseName}\" è un parametro di parola chiave, il parametro di override è di sola posizione",
-        "overrideParamNoDefault": "Parametro \"{name}\" non corrispondente: il parametro di base ha un valore di argomento predefinito, il parametro di override non è",
+        "overrideParamNoDefault": "Parametro \"{index}\" non corrispondente: il parametro di base ha un valore di argomento predefinito, il parametro di override non è",
         "overrideParamType": "Tipo di parametro {index} non corrispondente: il parametro di base è di tipo \"{baseType}\", il parametro di override è di tipo \"{overrideType}\"",
         "overridePositionalParamCount": "Numero di parametri posizionali non corrispondente. Il metodo di base ne ha {baseCount}, ma l'override ne ha {overrideCount}",
         "overrideReturnType": "Tipo restituito non corrispondente: il metodo di base restituisce il tipo \"{baseType}\", l'override restituisce il tipo \"{overrideType}\"",
@@ -784,6 +787,7 @@
         "typedDictFieldTypeMismatch": "Il tipo \"{type}\" non può essere assegnato all’elemento \"{name}\"",
         "typedDictFieldUndefined": "\"{name}\" è un elemento non definito nel tipo \"{type}\"",
         "typedDictFinalMismatch": "\"{sourceType}\" non è compatibile con \"{destType}\" a causa di una @final mancata corrispondenza",
+        "typedDictKeyAccess": "Usare [\"{name}\"] per fare riferimento all'elemento in TypedDict",
         "typedDictNotAllowed": "Non è possibile usare TypedDict per i controlli di istanze o classi",
         "unhashableType": "Il tipo \"{type}\" non è hashable",
         "uninitializedAbstractVariable": "La variabile di istanza \"{name}\" è definita nella classe di base astratta \"{classType}\" ma non è inizializzata",

package/dist/localization/package.nls.ja.json

@@ -17,8 +17,10 @@
         "abstractMethodInvocation": "メソッド \"{method}\" は抽象メソッドであり、実装されていないため、呼び出すことができません",
         "annotatedParamCountMismatch": "パラメーター注釈数の不一致: {expected} が必要ですが、{received} を受信しました",
         "annotatedTypeArgMissing": "\"Annotationed\" には 1 つの型引数と 1 つ以上の注釈が必要です",
+        "annotationBytesString": "Type annotations cannot use bytes string literals",
         "annotationFormatString": "型注釈では、書式指定文字列リテラル (f 文字列) を使用できません",
         "annotationNotSupported": "このステートメントでは型注釈はサポートされていません",
+        "annotationRawString": "Type annotations cannot use raw string literals",
         "annotationSpansStrings": "型注釈を複数の文字列リテラルにまたがることはできません",
         "annotationStringEscape": "型注釈にエスケープ文字を含めることはできません",
         "argAssignment": "型 \"{argType}\" の引数を型 \"{paramType}\" のパラメーターに割り当てることはできません",
@@ -275,6 +277,7 @@
         "listAssignmentMismatch": "型 \"{type}\" の式をターゲット リストに割り当てることはできません",
         "listInAnnotation": "型注釈ではリスト式は使用できません",
         "literalEmptyArgs": "\"Literal\" の後に 1 つ以上の型引数が必要です",
+        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
         "literalNotAllowed": "\"Literal\" は、型引数なしでこのコンテキストでは使用できません",
         "literalNotCallable": "リテラル型をインスタンス化できません",
         "literalUnsupportedType": "\"Literal\" の型引数は None、リテラル値 (int、bool、str、または bytes)、または列挙型の値である必要があります",
@@ -784,6 +787,7 @@
         "typedDictFieldTypeMismatch": "型 \"{type}\" は、アイテム \"{name}\" に割り当てできません",
         "typedDictFieldUndefined": "\"{name}\" は型 \"{type}\" の未定義のアイテムです",
         "typedDictFinalMismatch": "@final が一致しないため、\"{sourceType}\" は \"{destType}\" と互換性がありません",
+        "typedDictKeyAccess": "[\"{name}\"] を使用して TypedDict の項目を参照する",
         "typedDictNotAllowed": "TypedDict はインスタンスまたはクラスのチェックには使用できません",
         "unhashableType": "型 \"{type}\" はハッシュ可能ではありません",
         "uninitializedAbstractVariable": "インスタンス変数 \"{name}\" は抽象基本クラス \"{classType}\" で定義されていますが、初期化されていません",

package/dist/localization/package.nls.ko.json

@@ -17,8 +17,10 @@
         "abstractMethodInvocation": "메서드 \"{method}\"은(는) 추상적이고 구현되지 않았으므로 호출할 수 없습니다.",
         "annotatedParamCountMismatch": "매개 변수 주석 개수가 일치하지 않습니다. {expected}이)(가) 필요하지만 {received}을(를) 받았습니다.",
         "annotatedTypeArgMissing": "\"Annotated\"에 대해 하나의 형식 인수와 하나 이상의 주석이 필요합니다.",
+        "annotationBytesString": "Type annotations cannot use bytes string literals",
         "annotationFormatString": "형식 주석은 형식 문자열 리터럴(f-문자열)을 사용할 수 없습니다.",
         "annotationNotSupported": "이 문에는 형식 주석이 지원되지 않습니다.",
+        "annotationRawString": "Type annotations cannot use raw string literals",
         "annotationSpansStrings": "형식 주석은 여러 문자열 리터럴에 걸쳐 있을 수 없습니다.",
         "annotationStringEscape": "형식 주석에는 이스케이프 문자를 사용할 수 없습니다.",
         "argAssignment": "\"{argType}\" 형식의 인수를 \"{paramType}\" 형식의 매개 변수에 할당할 수 없습니다.",
@@ -275,6 +277,7 @@
         "listAssignmentMismatch": "형식이 \"{type}\"인 식을 대상 목록에 할당할 수 없습니다.",
         "listInAnnotation": "형식 주석에는 목록 식을 사용할 수 없습니다.",
         "literalEmptyArgs": "‘Literal’ 뒤에 하나 이상의 형식 인수가 필요합니다.",
+        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
         "literalNotAllowed": "형식 인수가 없으면 이 컨텍스트에서 \"Literal\"을 사용할 수 없습니다.",
         "literalNotCallable": "리터럴 형식은 인스턴스화할 수 없습니다.",
         "literalUnsupportedType": "\"Literal\"의 형식 인수는 None, 리터럴 값(int, bool, str 또는 bytes) 또는 열거형 값이어야 합니다.",
@@ -496,8 +499,8 @@
         "typeNotSpecializable": "‘{type}’ 형식을 특수화할 수 없습니다.",
         "typeNotSubscriptable": "\"{type}\" 형식의 개체를 첨자할 수 없습니다.",
         "typeNotSupportBinaryOperator": "‘{operator}’ 연산자는 ‘{leftType}’ 및 ‘{rightType}’ 형식에 대해 지원되지 않습니다.",
-        "typeNotSupportBinaryOperatorBidirectional": "예상 형식이 ‘{expectedType}’인 경우 ‘{type}’ 형식에 대해 ‘{operator}’ 연산자가 지원되지 않습니다.",
-        "typeNotSupportUnaryOperator": "‘None‘에 대해 ’{operator}‘ 연산자가 지원되지 않습니다.",
+        "typeNotSupportBinaryOperatorBidirectional": "예상 형식이 ‘{expectedType}’인 경우 ‘{leftType}’ 및 ‘{rightType}’ 형식에 대해 ‘{operator}’ 연산자가 지원되지 않습니다.",
+        "typeNotSupportUnaryOperator": "‘{type}’‘에 대해 ’{operator}‘ 연산자가 지원되지 않습니다.",
         "typeNotSupportUnaryOperatorBidirectional": "예상 형식이 \"{expectedType}\" 경우 형식 \"{type}\"에 대해 연산자 \"{operator}\"이(가) 지원되지 않습니다.",
         "typeNotUsableWith": "\"{type}\" 형식의 개체는 {method}을(를) 구현하지 않으므로 \"with\"와 함께 사용할 수 없습니다.",
         "typeParameterBoundNotAllowed": "바운드 또는 제약 조건은 가변 인자 형식 매개 변수 또는 ParamSpec와 함께 사용할 수 없습니다.",
@@ -718,7 +721,7 @@
         "overrideParamNameMissing": "재정의에 ‘{name}’ 매개 변수가 없습니다.",
         "overrideParamNamePositionOnly": "매개 변수 {index} 불일치: 기본 매개 변수 \"{baseName}\"은(는) 키워드 매개 변수이며 재정의 매개 변수는 위치 전용임",
         "overrideParamNoDefault": "{index} 매개 변수가 불일치합니다. 기본 매개 변수에 기본 인수 값이 있습니다. 재정의 매개 변수에는 없습니다.",
-        "overrideParamType": "‘{name}’ 매개 변수 형식이 일치하지 않습니다. 기본 매개 변수는 형식이 ‘{baseType}’, 재정의 매개 변수는 형식이 ‘{overrideType}’입니다.",
+        "overrideParamType": "‘{index}’ 매개 변수 형식이 일치하지 않습니다. 기본 매개 변수는 형식이 ‘{baseType}’, 재정의 매개 변수는 형식이 ‘{overrideType}’입니다.",
         "overridePositionalParamCount": "위치 매개 변수 개수가 일치하지 않습니다. 기본 메서드에 {baseCount}개가 있지만 재정의에는 {overrideCount}개가 있습니다.",
         "overrideReturnType": "반환 형식 불일치: 기본 메서드는 \"{baseType}\" 형식을 반환하고 재정의는 \"{overrideType}\" 형식을 반환합니다.",
         "overrideType": "기본 클래스는 형식을 \"{type}\"으로 정의합니다.",
@@ -784,6 +787,7 @@
         "typedDictFieldTypeMismatch": "\"{type}\" 형식은 \"{name}\" 항목에 할당할 수 없습니다.",
         "typedDictFieldUndefined": "\"{name}\"은(는) \"{type}\" 형식의 정의되지 않은 항목입니다.",
         "typedDictFinalMismatch": "@final 불일치로 인해 \"{sourceType}\"이(가) \"{destType}\"과(와) 호환되지 않습니다.",
+        "typedDictKeyAccess": "TypedDict에서 항목을 참조하려면 [\"{name}\"]을(를) 사용하세요.",
         "typedDictNotAllowed": "TypedDict는 인스턴스 또는 클래스 검사에 사용할 수 없습니다.",
         "unhashableType": "‘{type}’ 형식을 해시할 수 없습니다.",
         "uninitializedAbstractVariable": "인스턴스 변수 \"{name}\"이(가) 추상 기본 클래스 \"{classType}\"에 정의되어 있지만 초기화되지 않았습니다.",

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

@@ -17,8 +17,10 @@
         "abstractMethodInvocation": "Nie można wywołać metody „{method}”, ponieważ jest abstrakcyjna i niezaimplementowana",
         "annotatedParamCountMismatch": "Niezgodność liczby adnotacji parametru; oczekiwano {expected}, a uzyskano {received}",
         "annotatedTypeArgMissing": "Oczekiwano jednego argumentu typu i co najmniej jednej adnotacji dla wartości „Annotated”",
+        "annotationBytesString": "Type annotations cannot use bytes string literals",
         "annotationFormatString": "Adnotacje typu nie mogą używać literałów ciągów formatu (f-strings)",
         "annotationNotSupported": "Adnotacja typu nie jest obsługiwana dla tej instrukcji",
+        "annotationRawString": "Type annotations cannot use raw string literals",
         "annotationSpansStrings": "Adnotacje typu nie mogą obejmować wielu literałów ciągów",
         "annotationStringEscape": "Adnotacje typu nie mogą zawierać znaków ucieczki",
         "argAssignment": "Argumentu typu „{argType}” nie można przypisać do parametru typu „{paramType}”",
@@ -257,9 +259,9 @@
         "instanceVarOverridesClassVar": "Zmienna wystąpienia „{name}” zastępuje zmienną klasy o tej samej nazwie w klasie „{className}”",
         "instantiateAbstract": "Nie można utworzyć wystąpienia klasy abstrakcyjnej „{type}”",
         "instantiateProtocol": "Nie można utworzyć wystąpienia klasy protokołu typu „{type}”",
-        "internalBindError": "Wystąpił błąd wewnętrzny podczas wiązania pliku „{plik}”: {message}",
-        "internalParseError": "Wystąpił błąd wewnętrzny podczas analizowania pliku „{plik}”: {message}",
-        "internalTypeCheckingError": "Wystąpił błąd wewnętrzny podczas sprawdzania typu pliku „{plik}”: {message}",
+        "internalBindError": "Wystąpił błąd wewnętrzny podczas wiązania pliku „{file}”: {message}",
+        "internalParseError": "Wystąpił błąd wewnętrzny podczas analizowania pliku „{file}”: {message}",
+        "internalTypeCheckingError": "Wystąpił błąd wewnętrzny podczas sprawdzania typu pliku „{file}”: {message}",
         "invalidIdentifierChar": "Nieprawidłowy znak w identyfikatorze",
         "invalidStubStatement": "Instrukcja nie ma znaczenia w pliku zastępczym typu",
         "invalidTokenChars": "Nieprawidłowy znak „{text}” w tokenie",
@@ -275,6 +277,7 @@
         "listAssignmentMismatch": "Wyrażenia typu „{type}” nie można przypisać do listy docelowej",
         "listInAnnotation": "Wyrażenie listy jest niedozwolone w adnotacji typu",
         "literalEmptyArgs": "Oczekiwano co najmniej jednego argumentu typu po wartości „Literal”",
+        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
         "literalNotAllowed": "„Literał” nie może być używany w tym kontekście bez argumentu typu",
         "literalNotCallable": "Nie można utworzyć wystąpienia typu literału",
         "literalUnsupportedType": "Argumenty typu dla elementu „Literal” muszą mieć wartość Brak, wartość literału (int, bool, str lub bytes) lub wartość wyliczenia",
@@ -784,6 +787,7 @@
         "typedDictFieldTypeMismatch": "Nie można przypisać typu „{type}” do elementu „{name}”",
         "typedDictFieldUndefined": "Nazwa „{name}” jest niezdefiniowanym elementem w typie „{type}”",
         "typedDictFinalMismatch": "Typ „{sourceType}” jest niezgodny z typem „{destType}” z powodu niezgodności @final",
+        "typedDictKeyAccess": "Użyj elementu [\"{name}\"], aby odwołać się do elementu w TypedDict",
         "typedDictNotAllowed": "Funkcja TypedDict nie może być używana do sprawdzania wystąpień lub klas",
         "unhashableType": "Typ „{type}” nie jest wartością skrótu",
         "uninitializedAbstractVariable": "zmienna wystąpienia „{name}” jest zdefiniowana w abstrakcyjnej klasie bazowej „{classType}” ale nie została zainicjowana",

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

@@ -17,8 +17,10 @@
         "abstractMethodInvocation": "O método \"{method}\" não pode ser chamado porque é abstrato e não está implementado",
         "annotatedParamCountMismatch": "Incompatibilidade de contagem de anotações de parâmetro: esperado {expected}, mas recebido {received}",
         "annotatedTypeArgMissing": "Esperava-se um argumento de tipo e uma ou mais anotações para \"Annotated\"",
+        "annotationBytesString": "Type annotations cannot use bytes string literals",
         "annotationFormatString": "As anotações de tipo não podem usar literais de cadeia de caracteres de formato (cadeias de caracteres f)",
         "annotationNotSupported": "Anotação de tipo sem suporte para esta instrução",
+        "annotationRawString": "Type annotations cannot use raw string literals",
         "annotationSpansStrings": "Anotações de tipo não podem abranger vários literais de cadeia de caracteres",
         "annotationStringEscape": "Anotações de tipo não podem conter caracteres de escape",
         "argAssignment": "O argumento do tipo \"{argType}\" não pode ser atribuído ao parâmetro do tipo \"{paramType}\"",
@@ -275,6 +277,7 @@
         "listAssignmentMismatch": "A expressão com o tipo \"{type}\" não pode ser atribuída à lista de destino",
         "listInAnnotation": "Expressão de lista não permitida na anotação de tipo",
         "literalEmptyArgs": "Um ou mais argumentos de tipo esperados após \"Literal\"",
+        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
         "literalNotAllowed": "\"Literal\" não pode ser usado nesse contexto sem um argumento de tipo",
         "literalNotCallable": "O tipo literal não pode ser instanciado",
         "literalUnsupportedType": "Os argumentos de tipo para \"Literal\" devem ser None, um valor literal (int, bool, str ou bytes) ou um valor de enumeração",
@@ -784,6 +787,7 @@
         "typedDictFieldTypeMismatch": "O tipo \"{type}\" não é atribuível ao item \"{name}\"",
         "typedDictFieldUndefined": "\"{name}\" é um item indefinido no tipo \"{type}\"",
         "typedDictFinalMismatch": "\"{sourceType}\" é incompatível com \"{destType}\" devido a uma @final incompatível",
+        "typedDictKeyAccess": "Usar [\"{name}\"] para fazer referência ao item em TypedDict",
         "typedDictNotAllowed": "TypedDict não pode ser usado para verificações de instância ou de classe",
         "unhashableType": "O tipo \"{type}\" não é pode fazer hash",
         "uninitializedAbstractVariable": "A variável de instância \"{name}\" está definida na classe base abstrata \"{classType}\", mas não foi inicializada",

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

@@ -17,8 +17,10 @@
         "abstractMethodInvocation": "[fE8MD][นั้Mëthøð \"{mëthøð}\" çæññøt þë çællëð þëçæµsë ït ïs æþstræçt æñð µñïmplëmëñtëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğนั้ढूँ]",
         "annotatedParamCountMismatch": "[VZvZc][นั้Pæræmëtër æññøtætïøñ çøµñt mïsmætçh: ëxpëçtëð {ëxpëçtëð} þµt rëçëïvëð {rëçëïvëð}Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
         "annotatedTypeArgMissing": "[mTgtG][นั้Ëxpëçtëð øñë tÿpë ærgµmëñt æñð øñë ør mørë æññøtætïøñs før \"Æññøtætëð\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまนั้ढूँ]",
+        "annotationBytesString": "[W1g86][นั้Tÿpë æññøtætïøñs çæññøt µsë þÿtës strïñg lïtërælsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]",
         "annotationFormatString": "[zaI8H][นั้Tÿpë æññøtætïøñs çæññøt µsë førmæt strïñg lïtëræls (f-strïñgs)Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]",
         "annotationNotSupported": "[xYlM8][นั้Tÿpë æññøtætïøñ ñøt sµppørtëð før thïs stætëmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]",
+        "annotationRawString": "[WOMum][นั้Tÿpë æññøtætïøñs çæññøt µsë ræw strïñg lïtërælsẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]",
         "annotationSpansStrings": "[6Gg9x][นั้Tÿpë æññøtætïøñs çæññøt spæñ mµltïplë strïñg lïtërælsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]",
         "annotationStringEscape": "[MQdsm][นั้Tÿpë æññøtætïøñs çæññøt çøñtæïñ ësçæpë çhæræçtërsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]",
         "argAssignment": "[7pdVt][นั้Ærgµmëñt øf tÿpë \"{ærgTÿpë}\" çæññøt þë æssïgñëð tø pæræmëtër øf tÿpë \"{pæræmTÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]",
@@ -275,6 +277,7 @@
         "listAssignmentMismatch": "[DZh64][นั้Ëxprëssïøñ wïth tÿpë \"{tÿpë}\" çæññøt þë æssïgñëð tø tærgët lïstẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]",
         "listInAnnotation": "[i5U8t][นั้£ïst ëxprëssïøñ ñøt ælløwëð ïñ tÿpë æññøtætïøñẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
         "literalEmptyArgs": "[VkrFm][นั้Ëxpëçtëð øñë ør mørë tÿpë ærgµmëñts æftër \"£ïtëræl\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂҰนั้ढूँ]",
+        "literalNamedUnicodeEscape": "[8cbe7][นั้Ñæmëð µñïçøðë ësçæpë sëqµëñçës ærë ñøt sµppørtëð ïñ \"£ïtëræl\" strïñg æññøtætïøñsẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
         "literalNotAllowed": "[FAk6E][นั้\"£ïtëræl\" çæññøt þë µsëð ïñ thïs çøñtëxt wïthøµt æ tÿpë ærgµmëñtẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]",
         "literalNotCallable": "[C75sx][นั้£ïtëræl tÿpë çæññøt þë ïñstæñtïætëðẤğ倪İЂҰक्र्तिृまนั้ढूँ]",
         "literalUnsupportedType": "[10Yse][นั้Tÿpë ærgµmëñts før \"£ïtëræl\" mµst þë Ñøñë, æ lïtëræl vælµë (ïñt, þøøl, str, ør þÿtës), ør æñ ëñµm vælµëẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृนั้ढूँ]",
@@ -784,6 +787,7 @@
         "typedDictFieldTypeMismatch": "[XYIBH][นั้Tÿpë \"{tÿpë}\" ïs ñøt æssïgñæþlë tø ïtëm \"{ñæmë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İЂนั้ढूँ]",
         "typedDictFieldUndefined": "[UsDC9][นั้\"{ñæmë}\" ïs æñ µñðëfïñëð ïtëm ïñ tÿpë \"{tÿpë}\"Ấğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
         "typedDictFinalMismatch": "[tFb04][นั้\"{søµrçëTÿpë}\" ïs ïñçømpætïþlë wïth \"{ðëstTÿpë}\" þëçæµsë øf æ @fïñæl mïsmætçhẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪นั้ढूँ]",
+        "typedDictKeyAccess": "[67DLq][นั้Üsë [\"{ñæmë}\"] tø rëfërëñçë ïtëm ïñ TÿpëðÐïçtẤğ倪İЂҰक्र्तिृまẤğ倪İนั้ढूँ]",
         "typedDictNotAllowed": "[eTsPP][นั้TÿpëðÐïçt çæññøt þë µsëð før ïñstæñçë ør çlæss çhëçksẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्นั้ढूँ]",
         "unhashableType": "[IJEeq][นั้Tÿpë \"{tÿpë}\" ïs ñøt hæshæþlëẤğ倪İЂҰक्र्तिृนั้ढूँ]",
         "uninitializedAbstractVariable": "[uDuHt][นั้Ïñstæñçë værïæþlë \"{ñæmë}\" ïs ðëfïñëð ïñ æþstræçt þæsë çlæss \"{çlæssTÿpë}\" þµt ñøt ïñïtïælïzëðẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्तिृまẤğ倪İЂҰक्र्นั้ढूँ]",

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

@@ -17,8 +17,10 @@
         "abstractMethodInvocation": "Невозможно вызвать метод \"{method}\", так как он является абстрактным и нереализованным",
         "annotatedParamCountMismatch": "Несоответствие числа аннотаций параметра: ожидается {expected}, но получено {received}",
         "annotatedTypeArgMissing": "Для \"Annotated\" ожидается один аргумент типа и одна или несколько заметок типа",
+        "annotationBytesString": "Type annotations cannot use bytes string literals",
         "annotationFormatString": "В заметках типа не могут использоваться строковые литералы формата (f-строки)",
         "annotationNotSupported": "Заметка типа не поддерживается для этой инструкции",
+        "annotationRawString": "Type annotations cannot use raw string literals",
         "annotationSpansStrings": "Заметки с типом не могут охватывать несколько строковых литералов",
         "annotationStringEscape": "Заметки с типом не могут содержать escape-символы",
         "argAssignment": "Аргумент типа \"{argType}\" нельзя присвоить параметру типа \"{paramType}\"",
@@ -275,6 +277,7 @@
         "listAssignmentMismatch": "Выражение с типом \"{type}\" нельзя присвоить целевому списку",
         "listInAnnotation": "Списочное выражение не разрешено в заметке типа",
         "literalEmptyArgs": "Ожидается один или несколько аргументов типа после \"Literal\"",
+        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
         "literalNotAllowed": "Невозможно использовать \"Literal\" в этом контексте без аргумента типа",
         "literalNotCallable": "Не удается создать экземпляр типа литерала",
         "literalUnsupportedType": "Аргументы типа для \"Literal\" должны иметь значение None, литеральное значение (int, bool, str или bytes) или значение перечислимого типа",
@@ -690,7 +693,7 @@
         "missingSetter": "Отсутствует метод установки свойств",
         "namedParamMissingInDest": "В целевом объекте отсутствует параметр ключевого слова \"{name}\"",
         "namedParamMissingInSource": "В источнике нет параметра ключевого слова \"{name}\"",
-        "namedParamTypeMismatch": "Параметр ключевого слова {index} типа \"{sourceType}\" нельзя присвоить типу \"{destType}\"",
+        "namedParamTypeMismatch": "Параметр ключевого слова {name} типа \"{sourceType}\" нельзя присвоить типу \"{destType}\"",
         "namedTupleNotAllowed": "NamedTuple не может использоваться для проверок экземпляров или классов",
         "newMethodLocation": "Метод __new__ определен в классе \"{type}\"",
         "newMethodSignature": "Сигнатура метода __new__ требует \"{type}\"",
@@ -784,6 +787,7 @@
         "typedDictFieldTypeMismatch": "Тип \"{type}\" нельзя присвоить полю \"{name}\"",
         "typedDictFieldUndefined": "Элемент \"{name}\" не определен в типе \"{type}\"",
         "typedDictFinalMismatch": "\"{sourceType}\" несовместим с \"{destType}\" из-за несоответствия окончательности",
+        "typedDictKeyAccess": "Использовать [\"{name}\"] для ссылки на элемент в TypedDict",
         "typedDictNotAllowed": "TypedDict не может использоваться для проверок экземпляров или классов",
         "unhashableType": "Тип \"{type}\" не является хэшируемым",
         "uninitializedAbstractVariable": "Переменная экземпляра \"{name}\" определена в абстрактном базовом классе \"{classType}\", но не инициализирована",

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

@@ -17,12 +17,14 @@
         "abstractMethodInvocation": "\"{method}\" metodu soyut veya uygulanmamış olduğundan çağrılamaz",
         "annotatedParamCountMismatch": "Parametre ek açıklama sayısı uyuşmazlığı: {expected} bekleniyordu ancak {received} alındı",
         "annotatedTypeArgMissing": "\"Annotated\" için bir tür bağımsız değişkeni ve bir veya daha fazla ek açıklama bekleniyordu",
+        "annotationBytesString": "Type annotations cannot use bytes string literals",
         "annotationFormatString": "Tür ek açıklamaları biçim dizesi sabit değerlerini (f-strings) kullanamaz",
         "annotationNotSupported": "Tür ek açıklaması bu deyim için desteklenmiyor",
+        "annotationRawString": "Type annotations cannot use raw string literals",
         "annotationSpansStrings": "Tür ek açıklamaları birden çok dize sabit değerine yayılamaz",
         "annotationStringEscape": "Tür ek açıklamaları kaçış karakterleri içeremez",
-        "argAssignment": "\"{argType}\" türünde bağımsız değişken, \"{paramName}\" türündeki parametreye atanamaz",
-        "argAssignmentFunction": "\"{argType}\" türünde bağımsız değişken, \"{functionName}\" işlevi içinde \"{paramName}\" türündeki parametreye atanamaz",
+        "argAssignment": "\"{argType}\" türünde bağımsız değişken, \"{paramType}\" türündeki parametreye atanamaz",
+        "argAssignmentFunction": "\"{argType}\" türünde bağımsız değişken, \"{functionName}\" işlevi içinde \"{paramType}\" türündeki parametreye atanamaz",
         "argAssignmentParam": "\"{argType}\" türünde bağımsız değişken, \"{paramName}\" türündeki \"{paramType}\" parametresine atanamaz",
         "argAssignmentParamFunction": "\"{argType}\" türünde bağımsız değişken, \"{functionName}\" işlevi içinde \"{paramName}\" türündeki \"{paramType}\" parametresine atanamaz",
         "argMissingForParam": "{name} parametresi için bağımsız değişken eksik",
@@ -275,6 +277,7 @@
         "listAssignmentMismatch": "\"{type}\" türündeki ifade hedef listesine atanamaz",
         "listInAnnotation": "Tür ek açıklamasında liste ifadesi kullanılamaz",
         "literalEmptyArgs": "\"Literal\" sonrasında bir veya daha fazla tür bağımsız değişkeni bekleniyordu",
+        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
         "literalNotAllowed": "\"Değişmez değer\" bir tür bağımsız değişken olmadan bu bağlamda kullanılamaz",
         "literalNotCallable": "Değişmez tür örneği oluşturulamıyor",
         "literalUnsupportedType": "\"Literal\" için tür bağımsız değişkenleri None, bir sabit değer (int, bool, str veya bytes) veya bir sabit listesi değeri olmalıdır",
@@ -784,6 +787,7 @@
         "typedDictFieldTypeMismatch": "\"{type}\" türü \"{name}\" öğesine atanamaz",
         "typedDictFieldUndefined": "\"{name}\", \"{type}\" türündeki tanımsız bir öğedir",
         "typedDictFinalMismatch": "\"{sourceType}\" @final uyumsuzluğu nedeniyle \"{destType}\" ile uyumsuz",
+        "typedDictKeyAccess": "TypedDict’te öğeye başvurmak için [\"{name}\"] değerini kullanın",
         "typedDictNotAllowed": "TypedDict örnek veya sınıf kontrolleri için kullanılamaz",
         "unhashableType": "\"{type}\" türü karmalanabilir değil",
         "uninitializedAbstractVariable": "\"{name}\" örnek değişkeni, \"{classType}\" soyut temel sınıfında tanımlandı ancak başlatılmadı",

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

@@ -17,8 +17,10 @@
         "abstractMethodInvocation": "无法调用方法“{method}”，因为它是抽象的且未实施",
         "annotatedParamCountMismatch": "参数批注计数不匹配: 应为 {expected}，但收到 {received}",
         "annotatedTypeArgMissing": "“Annotated”应为一个类型参数和一个或多个批注",
+        "annotationBytesString": "Type annotations cannot use bytes string literals",
         "annotationFormatString": "类型批注不能使用格式字符串文本 (f 字符串)",
         "annotationNotSupported": "此语句不支持类型批注",
+        "annotationRawString": "Type annotations cannot use raw string literals",
         "annotationSpansStrings": "类型批注不能跨越多个字符串文本",
         "annotationStringEscape": "类型批注不能包含转义字符",
         "argAssignment": "无法将“{argType}”类型的参数分配给“{paramType}”类型的参数",
@@ -275,6 +277,7 @@
         "listAssignmentMismatch": "无法将 \"{type}\" 类型的表达式分配给目标列表",
         "listInAnnotation": "类型批注中不允许使用列表表达式",
         "literalEmptyArgs": "“Literal”后应有一个或多个类型参数",
+        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
         "literalNotAllowed": "如果没有类型参数，则 \"Literal\" 不能用于此上下文",
         "literalNotCallable": "无法实例化文本类型",
         "literalUnsupportedType": "“Literal” 的类型参数必须是 None、int、bool、str 或 bytes)(文本值，或者是枚举值",
@@ -496,7 +499,7 @@
         "typeNotSpecializable": "无法专用化类型“{type}”",
         "typeNotSubscriptable": "类型为“{type}”的对象不可下标",
         "typeNotSupportBinaryOperator": "类型“{leftType}”和“{rightType}”不支持运算符“{operator}”",
-        "typeNotSupportBinaryOperatorBidirectional": "预期类型为 \"{expectedType}\"时，类型\"{type}\"不支持运算符\"{operator}\"",
+        "typeNotSupportBinaryOperatorBidirectional": "预期类型为“{expectedType}”时，类型“{leftType}”和“{rightType}”不支持运算符“{operator}”",
         "typeNotSupportUnaryOperator": "类型“{type}”不支持运算符“{operator}”",
         "typeNotSupportUnaryOperatorBidirectional": "预期类型为 \"{expectedType}\"时，类型\"{type}\"不支持运算符\"{operator}\"",
         "typeNotUsableWith": "\"{type}\"类型的对象不能与 “with” 一起使用，因为它未实现{method}",
@@ -784,6 +787,7 @@
         "typedDictFieldTypeMismatch": "类型“{type}”不可分配给项“{name}”",
         "typedDictFieldUndefined": "“{name}”是类型“{type}”中的未定义项",
         "typedDictFinalMismatch": "\"{sourceType}\"与\"{destType}\"不兼容，因为@final不匹配",
+        "typedDictKeyAccess": "使用 [\"{name}\"] 引用 TypedDict 中的项",
         "typedDictNotAllowed": "不能对实例或类检查使用 TypedDict",
         "unhashableType": "类型“{type}”不可哈希",
         "uninitializedAbstractVariable": "实例变量“{name}”在抽象基类“{classType}”中定义，但未初始化",

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

@@ -17,8 +17,10 @@
         "abstractMethodInvocation": "無法呼叫方法 \"{method}\"，因為它是抽象且未執行",
         "annotatedParamCountMismatch": "參數註釋計數不符: 應為 {expected}，但收到 {received}",
         "annotatedTypeArgMissing": "預期 \"Annotated\" 有一個類型引數和一或多個註釋",
+        "annotationBytesString": "Type annotations cannot use bytes string literals",
         "annotationFormatString": "類型註釋不能使用格式字串常值 (f-strings)",
         "annotationNotSupported": "此陳述式不支援類型註釋",
+        "annotationRawString": "Type annotations cannot use raw string literals",
         "annotationSpansStrings": "型別註釋無法跨越多個字串常值",
         "annotationStringEscape": "型別註釋不可包含逸出字元",
         "argAssignment": "類型 \"{argType}\" 的引數不能指派至類型 \"{paramType}\" 的參數",
@@ -275,6 +277,7 @@
         "listAssignmentMismatch": "類型 \"{type}\" 的運算式不能指派至目標清單",
         "listInAnnotation": "類型註釋中不允許清單運算式",
         "literalEmptyArgs": "\"Literal\" 後面應有一或多個型別引數",
+        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
         "literalNotAllowed": "沒有類型參數，\"Literal\" 不能在此內容中使用",
         "literalNotCallable": "常值類型不能具現化",
         "literalUnsupportedType": "\"Literal\" 的類型引數必須是 None、常值 (int、bool、str 或 bytes) 或列舉值",
@@ -784,6 +787,7 @@
         "typedDictFieldTypeMismatch": "型別 \"{type}\" 無法指派給項目 \"{name}\"",
         "typedDictFieldUndefined": "\"{name}\" 是型別 \"{type}\" 中未定義的項目",
         "typedDictFinalMismatch": "\"{sourceType}\" 與 \"{destType}\" 不相容，因為@final 不符",
+        "typedDictKeyAccess": "使用 [\"{name}\"] 參考 TypedDict 中的項目",
         "typedDictNotAllowed": "執行個體或類別檢查無法使用 TypedDict",
         "unhashableType": "型別 \"{type}\" 無法雜湊",
         "uninitializedAbstractVariable": "執行個體變數 \"{name}\" 在抽象基底類別 \"{classType}\" 中定義，但未初始化",

package/dist/parser/parser.js

@@ -3255,7 +3255,7 @@ class Parser {
                 doubleStarExpression = this._parseExpression(/* allowUnpack */ false);
             }
             else {
-                keyExpression = this._parseTestOrStarExpression(/* allowAssignmentExpression */ true);
+                keyExpression = this._parseTestOrStarExpression(/* allowAssignmentExpression */ false);
                 if (this._consumeTokenIfType(10 /* TokenType.Colon */)) {
                     valueExpression = this._parseTestExpression(/* allowAssignmentExpression */ false);
                 }
@@ -3829,7 +3829,8 @@ class Parser {
                         this._addSyntaxError(localize_1.LocMessage.annotationStringEscape(), stringNode);
                     }
                 }
-                else {
+                else if ((stringToken.flags & (8 /* StringTokenFlags.Raw */ | 32 /* StringTokenFlags.Bytes */ | 64 /* StringTokenFlags.Format */)) ===
+                    0) {
                     const parser = new Parser();
                     const parseResults = parser.parseTextExpression(this._fileContents, tokenOffset + prefixLength, unescapedString.length, this._parseOptions, 1 /* ParseTextMode.VariableAnnotation */, (stringNode.strings[0].token.flags & 4 /* StringTokenFlags.Triplicate */) !== 0 ? 1 : 0, this._typingSymbolAliases);
                     if (parseResults.diagnostics.length === 0 ||