@zzzen/pyright-internal 1.2.0-dev.20240428 → 1.2.0-dev.20240512

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

@@ -17,10 +17,10 @@
         "abstractMethodInvocation": "无法调用方法“{method}”，因为它是抽象的且未实施",
         "annotatedParamCountMismatch": "参数批注计数不匹配: 应为 {expected}，但收到 {received}",
         "annotatedTypeArgMissing": "“Annotated”应为一个类型参数和一个或多个批注",
-        "annotationBytesString": "Type annotations cannot use bytes string literals",
+        "annotationBytesString": "类型批注不能使用字节字符串文本",
         "annotationFormatString": "类型批注不能使用格式字符串文本 (f 字符串)",
         "annotationNotSupported": "此语句不支持类型批注",
-        "annotationRawString": "Type annotations cannot use raw string literals",
+        "annotationRawString": "类型批注不能使用原始字符串文本",
         "annotationSpansStrings": "类型批注不能跨越多个字符串文本",
         "annotationStringEscape": "类型批注不能包含转义字符",
         "argAssignment": "无法将“{argType}”类型的参数分配给“{paramType}”类型的参数",
@@ -103,6 +103,7 @@
         "dataClassBaseClassNotFrozen": "冻结类不能从未冻结的类继承",
         "dataClassConverterFunction": "类型“{argType}”的参数不是类型为“{fieldType}”的字段“{fieldName}”的有效转换器",
         "dataClassConverterOverloads": "“{funcName}”的重载不是类型为“{fieldType}”的字段“{fieldName}”的有效转换器",
+        "dataClassFieldInheritedDefault": "“{fieldName}”替代同名字段，但缺少默认值",
         "dataClassFieldWithDefault": "没有默认值的字段不能出现在具有默认值的字段之后",
         "dataClassFieldWithPrivateName": "数据类字段不能使用专用名称",
         "dataClassFieldWithoutAnnotation": "不带类型批注的数据类字段将导致运行时异常",
@@ -188,7 +189,7 @@
         "expectedIn": "应为 \"in\"",
         "expectedInExpr": "\"in\"后应为表达式",
         "expectedIndentedBlock": "应为缩进块",
-        "expectedMemberName": "应为“.”后的成员名称。",
+        "expectedMemberName": "\".\" 后应为属性名称",
         "expectedModuleName": "预期模块名称",
         "expectedNameAfterAs": "\"as\" 后应有符号名",
         "expectedNamedParameter": "关键字参数必须跟在 “*” 之后",
@@ -251,6 +252,7 @@
         "incompatibleMethodOverride": "方法“{name}”以不兼容的方式替代类“{className}”",
         "inconsistentIndent": "取消缩进量与以前的缩进不匹配",
         "inconsistentTabs": "缩进中制表符和空格的使用不一致",
+        "initMethodSelfParamTypeVar": "\"__init__\" 方法 “self” 参数的类型批注不能包含类范围的类型变量",
         "initMustReturnNone": "“__init__”的返回类型必须为 None",
         "initSubclassCallFailed": "__init_subclass__ 方法的关键字参数不正确",
         "initSubclassClsParam": "__init_subclass__替代应采用“cls”参数",
@@ -277,16 +279,16 @@
         "listAssignmentMismatch": "无法将 \"{type}\" 类型的表达式分配给目标列表",
         "listInAnnotation": "类型批注中不允许使用列表表达式",
         "literalEmptyArgs": "“Literal”后应有一个或多个类型参数",
-        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
+        "literalNamedUnicodeEscape": "“文本”字符串批注不支持已命名的 unicode 转义序列",
         "literalNotAllowed": "如果没有类型参数，则 \"Literal\" 不能用于此上下文",
         "literalNotCallable": "无法实例化文本类型",
         "literalUnsupportedType": "“Literal” 的类型参数必须是 None、int、bool、str 或 bytes)(文本值，或者是枚举值",
         "matchIncompatible": "匹配语句需要 Python 3.10 或更高版本",
         "matchIsNotExhaustive": "match 语句中的事例不会彻底处理所有值",
         "maxParseDepthExceeded": "超出最大分析深度;将表达式分解为较小的子表达式",
-        "memberAccess": "无法存取类型“{type}”的成员“{name}”",
-        "memberDelete": "无法删除类型\"{type}\"的成员\"{name}\"",
-        "memberSet": "无法为类型“{type}”分配成员“{name}”",
+        "memberAccess": "无法访问类“{type}”的属性“{name}”",
+        "memberDelete": "无法删除类“{type}”的属性“{name}”",
+        "memberSet": "无法为类“{type}”的属性“{name}”赋值。",
         "metaclassConflict": "派生类的元类必须是其所有基类的元类的子类",
         "metaclassDuplicate": "只能提供一个元类",
         "metaclassIsGeneric": "元类不能是泛型",
@@ -298,7 +300,7 @@
         "missingSuperCall": "方法“{methodName}”在父类中不调用同名方法",
         "moduleAsType": "模块不能用作类型",
         "moduleNotCallable": "模块不可调用",
-        "moduleUnknownMember": "“{memberName}”不是模块“{moduleName}”的已知成员",
+        "moduleUnknownMember": "“{memberName}”不是模块“{moduleName}”的已知属性",
         "namedExceptAfterCatchAll": "在 catch-all(除子句外)后不能出现命名的 except 子句",
         "namedParamAfterParamSpecArgs": "关键字参数“{name}”不能出现在 ParamSpec args 参数之后的签名中",
         "namedTupleEmptyName": "命名元组中的名称不能为空",
@@ -332,7 +334,7 @@
         "noneNotSubscriptable": "类型为“None”的对象不可下标",
         "noneNotUsableWith": "类型为“None”的对象不能与“with”一起使用",
         "noneOperator": "“None”不支持运算符\"{operator}\"",
-        "noneUnknownMember": "“{name}”不是“None”的已知成员",
+        "noneUnknownMember": "“{name}”不是 \"None\" 的已知属性",
         "notRequiredArgCount": "“NotRequired” 之后应为单个类型参数",
         "notRequiredNotInTypedDict": "此上下文中不允许使用“NotRequired”",
         "objectNotCallable": "类型为“{type}”的对象不可调用",
@@ -363,18 +365,18 @@
         "paramAnnotationMissing": "参数“{name}”缺少类型批注",
         "paramAssignmentMismatch": "无法将\"{sourceType}\"类型的表达式分配给\"{paramType}\"类型的参数",
         "paramNameMissing": "没有名为“{name}”的参数",
-        "paramSpecArgsKwargsUsage": "ParamSpec 的“args”和“kwargs”成员必须同时出现在函数签名中",
+        "paramSpecArgsKwargsUsage": "ParamSpec 的 \"args\" 和 \"kwargs\" 属性必须同时出现在函数签名中",
         "paramSpecArgsMissing": "缺少 ParamSpec“{type}”的参数",
-        "paramSpecArgsUsage": "ParamSpec 的 “args” 成员仅在与 *args 参数一起使用时有效",
+        "paramSpecArgsUsage": "ParamSpec 的 \"args\" 属性仅在与 *args 参数一起使用时有效",
         "paramSpecAssignedName": "必须将 ParamSpec 分配给名为“{name}”的变量",
         "paramSpecContext": "此上下文中不允许使用 ParamSpec",
         "paramSpecDefaultNotTuple": "ParamSpec 的默认值应为省略号、元组表达式或 ParamSpec",
         "paramSpecFirstArg": "ParamSpec 作为第一个参数的预期名称",
-        "paramSpecKwargsUsage": "ParamSpec 的“kwargs”成员仅在与 **kwargs 参数一起使用时有效",
+        "paramSpecKwargsUsage": "ParamSpec 的 \"kwargs\" 属性仅在与 **kwargs 参数一起使用时有效",
         "paramSpecNotUsedByOuterScope": "ParamSpec“{name}”在此上下文中没有意义",
         "paramSpecScopedToReturnType": "ParamSpec \"{name}\"在返回类型内的作用域为可调用，不能在函数体中引用",
         "paramSpecUnknownArg": "ParamSpec 不支持多个参数",
-        "paramSpecUnknownMember": "“{name}”不是 ParamSpec 的已知成员",
+        "paramSpecUnknownMember": "“{name}”不是 ParamSpec 的已知属性",
         "paramSpecUnknownParam": "“{name}”是 ParamSpec 的未知参数",
         "paramTypeCovariant": "不能在参数类型中使用协变类型变量",
         "paramTypePartiallyUnknown": "参数\"{paramName}\"的类型部分未知",
@@ -418,7 +420,7 @@
         "returnMissing": "所声明的返回类型为“{returnType}”的函数必须在所有代码路径上返回值",
         "returnOutsideFunction": "“return”只能在函数中使用",
         "returnTypeContravariant": "逆变类型变量不能用于返回类型",
-        "returnTypeMismatch": "无法将类型“{exprType}”的表达式分配给返回类型“{returnType}”",
+        "returnTypeMismatch": "类型“{exprType}”的表达式与返回类型“{returnType}”不兼容",
         "returnTypePartiallyUnknown": "返回类型“{returnType}”部分未知",
         "returnTypeUnknown": "返回类型未知",
         "revealLocalsArgs": "“reveal_locals”调用应没有参数",
@@ -484,8 +486,8 @@
         "typeArgsMissingForClass": "泛型类“{name}”的预期类型参数",
         "typeArgsTooFew": "为“{name}”提供的类型参数太少；应为 {expected}，但收到 {received}",
         "typeArgsTooMany": "为“{name}”提供的类型参数太多；应为 {expected}，但收到 {received}",
-        "typeAssignmentMismatch": "无法将类型“{sourceType}”的表达式分配给声明的类型“{destType}”",
-        "typeAssignmentMismatchWildcard": "导入符号“{name}”的类型为“{sourceType}”，无法将其分配给声明的类型“{destType}”",
+        "typeAssignmentMismatch": "类型“{sourceType}”的表达式与声明的类型“{destType}”不兼容",
+        "typeAssignmentMismatchWildcard": "导入符号“{name}”的类型“{sourceType}”与声明的类型“{destType}”不兼容",
         "typeCallNotAllowed": "type() 调用不应用于类型批注",
         "typeCheckOnly": "“{name}”标记为 @type_check_only，并且只能在类型注释中使用",
         "typeCommentDeprecated": "已弃用类型注释；请改用类型批注",
@@ -520,7 +522,7 @@
         "typeVarDefaultIllegal": "类型变量默认类型需要 Python 3.13 或更高版本",
         "typeVarDefaultInvalidTypeVar": "类型参数“{name}”的默认类型是指超出范围的一个或多个类型变量",
         "typeVarFirstArg": "TypeVar 作为第一个参数的预期名称",
-        "typeVarNoMember": "TypeVar \"{type}\"没有成员\"{name}\"",
+        "typeVarNoMember": "TypeVar“{type}”没有属性“{name}”",
         "typeVarNotSubscriptable": "TypeVar“{type}”不可下标",
         "typeVarNotUsedByOuterScope": "类型变量“{name}”在此上下文中没有意义",
         "typeVarPossiblyUnsolvable": "如果调用方没有为参数提供参数\"{param}\"，则类型变量\"{name}\"可能无法解析",
@@ -634,7 +636,7 @@
         "argsPositionOnly": "仅位置参数不匹配；应为 {expected}，但收到 {received}",
         "argumentType": "参数类型为“{type}”",
         "argumentTypes": "参数类型:({types})",
-        "assignToNone": "无法将类型分配给类型“None”",
+        "assignToNone": "类型与 \"None\" 不兼容",
         "asyncHelp": "是否表示“async with”?",
         "baseClassIncompatible": "基类“{baseClass}”与类型“{type}”不兼容",
         "baseClassIncompatibleSubclass": "基类“{baseClass}”派生自与类型“{type}”不兼容的“{subclass}”",
@@ -670,30 +672,30 @@
         "keyUndefined": "“{name}”不是“{type}”中定义的密钥",
         "kwargsParamMissing": "参数“**{paramName}”没有相应的参数",
         "listAssignmentMismatch": "类型“{type}”与目标列表不兼容",
-        "literalAssignmentMismatch": "无法将“{sourceType}”分配给类型“{destType}”",
+        "literalAssignmentMismatch": "“{sourceType}”与类型“{destType}”不兼容",
         "matchIsNotExhaustiveHint": "如果未进行详尽处理，请添加\"case _: pass\"",
         "matchIsNotExhaustiveType": "未处理的类型: \"{type}\"",
-        "memberAssignment": "无法将\"{type}\"类型的表达式分配给类\"{classType}\"的成员\"{name}\"",
+        "memberAssignment": "无法将类型“{type}”的表达式分配给类“{classType}”的属性“{name}”",
         "memberIsAbstract": "未实现“{type}.{name}”",
         "memberIsAbstractMore": "还有 {count} 个...",
         "memberIsClassVarInProtocol": "“{name}”在协议中定义为 ClassVar",
         "memberIsFinalInProtocol": "\"{name}\"在协议中标记为 Final",
-        "memberIsInitVar": "成员“{name}”是仅初始字段",
+        "memberIsInitVar": "“{name}”是仅限 init 的字段",
         "memberIsInvariant": "“{name}”是固定的，因为它是可变的",
         "memberIsNotClassVarInClass": "“{name}”必须定义为 ClassVar 才能与协议兼容",
         "memberIsNotClassVarInProtocol": "“{name}”未在协议中定义为 ClassVar",
         "memberIsNotFinalInProtocol": "“{name}”未在协议中标记为 Final",
         "memberIsWritableInProtocol": "“{name}”在协议中是可写入的",
-        "memberSetClassVar": "无法通过类实例分配成员“{name}”，因为它是 ClassVar",
+        "memberSetClassVar": "无法通过类实例分配属性“{name}”，因为它是 ClassVar",
         "memberTypeMismatch": "\"{name}\"是不兼容的类型",
-        "memberUnknown": "成员\"{name}\"未知",
+        "memberUnknown": "属性“{name}”未知",
         "metaclassConflict": "元类“{metaclass1}”与“{metaclass2}”存在冲突",
         "missingDeleter": "缺少属性 deleter方法",
         "missingGetter": "缺少属性 getter 方法",
         "missingSetter": "缺少属性 setter 方法",
         "namedParamMissingInDest": "源中缺少关键字参数 \"{name}\"",
         "namedParamMissingInSource": "源中缺少关键字参数“{name}”",
-        "namedParamTypeMismatch": "无法将\"{sourceType}\"类型的关键字参数\"{name}\"分配给类型\"{destType}\"",
+        "namedParamTypeMismatch": "类型为“{sourceType}”的关键字参数“{name}”与类型“{destType}”不兼容",
         "namedTupleNotAllowed": "不能对实例或类检查使用 NamedTuple",
         "newMethodLocation": "__new__方法已在类“{type}”中定义",
         "newMethodSignature": "__new__的签名为“{type}”",
@@ -725,7 +727,7 @@
         "overridePositionalParamCount": "位置参数计数不匹配；基方法具有 {baseCount}，但替代具有 {overrideCount}",
         "overrideReturnType": "返回类型不匹配:基方法返回类型\"{baseType}\"，替代返回类型\"{overrideType}\"",
         "overrideType": "基类将类型定义为\"{type}\"",
-        "paramAssignment": "参数 {index}: 无法将类型“{sourceType}”分配给类型“{destType}”",
+        "paramAssignment": "参数 {index}: 类型“{sourceType}”与类型“{destType}”不兼容",
         "paramSpecMissingInOverride": "替代方法中缺少 ParamSpec 参数",
         "paramType": "参数类型为“{paramType}”",
         "privateImportFromPyTypedSource": "改为从\"{module}\"导入",
@@ -755,7 +757,7 @@
         "tupleSizeMismatch": "元组大小不匹配；应为 {expected}，但收到 {received}",
         "tupleSizeMismatchIndeterminateDest": "元组大小不匹配；应为 {expected} 或更多，但收到 {received}",
         "typeAliasInstanceCheck": "使用 \"type\" 语句创建的类型别名不能与实例和类检查一起使用",
-        "typeAssignmentMismatch": "无法将类型“{sourceType}”分配给类型“{destType}”",
+        "typeAssignmentMismatch": "类型“{sourceType}”与类型“{destType}”不兼容",
         "typeBound": "类型\"{sourceType}\"与类型变量\"{destType}\"的绑定类型\"{name}\"不兼容",
         "typeConstrainedTypeVar": "类型\"{type}\"与受约束的类型变量\"{name}\"不兼容",
         "typeIncompatible": "“{sourceType}”与“{destType}”不兼容",

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

@@ -17,10 +17,10 @@
         "abstractMethodInvocation": "無法呼叫方法 \"{method}\"，因為它是抽象且未執行",
         "annotatedParamCountMismatch": "參數註釋計數不符: 應為 {expected}，但收到 {received}",
         "annotatedTypeArgMissing": "預期 \"Annotated\" 有一個類型引數和一或多個註釋",
-        "annotationBytesString": "Type annotations cannot use bytes string literals",
+        "annotationBytesString": "類型註釋無法使用位元組字串常值",
         "annotationFormatString": "類型註釋不能使用格式字串常值 (f-strings)",
         "annotationNotSupported": "此陳述式不支援類型註釋",
-        "annotationRawString": "Type annotations cannot use raw string literals",
+        "annotationRawString": "類型註釋無法使用原始字串常值",
         "annotationSpansStrings": "型別註釋無法跨越多個字串常值",
         "annotationStringEscape": "型別註釋不可包含逸出字元",
         "argAssignment": "類型 \"{argType}\" 的引數不能指派至類型 \"{paramType}\" 的參數",
@@ -103,6 +103,7 @@
         "dataClassBaseClassNotFrozen": "凍結的類別不能從未凍結的類別繼承",
         "dataClassConverterFunction": "類型 \"{argType}\" 的引數不是類型 \"{fieldType}\" 欄位 \"{fieldName}\" 的有效轉換程式",
         "dataClassConverterOverloads": "\"{funcName}\" 沒有任何多載是類型 \"{fieldType}\" 欄位 \"{fieldName}\" 的有效轉換程式",
+        "dataClassFieldInheritedDefault": "\"{fieldName}\" 覆寫相同名稱的欄位，但缺少預設值",
         "dataClassFieldWithDefault": "沒有預設值的欄位無法出現在具有預設值的欄位後面",
         "dataClassFieldWithPrivateName": "Dataclass 欄位不能使用私人名稱",
         "dataClassFieldWithoutAnnotation": "沒有型別註釋的 Dataclass 欄位會造成執行階段例外狀況",
@@ -188,7 +189,7 @@
         "expectedIn": "預期為 \"in\"",
         "expectedInExpr": "\"in\" 後預期為運算式",
         "expectedIndentedBlock": "預期為縮排區塊",
-        "expectedMemberName": "\".\" 後預期為成員名稱。",
+        "expectedMemberName": "\".\" 後面應該接著屬性名稱。",
         "expectedModuleName": "應為模組名稱",
         "expectedNameAfterAs": "\"as\" 後面應有符號名稱",
         "expectedNamedParameter": "關鍵字參數必須接著 \"*\"",
@@ -251,6 +252,7 @@
         "incompatibleMethodOverride": "方法 \"{name}\" 會以不相容的方式覆寫類別 \"{className}\"",
         "inconsistentIndent": "取消縮排量與先前縮排不符",
         "inconsistentTabs": "在縮排中使用 Tab 字元和空格不一致",
+        "initMethodSelfParamTypeVar": "\"__init__\" 方法之 \"self\" 參數的類型註釋不得包含類別範圍的類型變數",
         "initMustReturnNone": "\"__init__\" 的傳回類型必須為 None",
         "initSubclassCallFailed": "__init_subclass__ 方法不正確的關鍵字引數",
         "initSubclassClsParam": "__init_subclass__ 覆寫應接受 \"cls\" 參數",
@@ -277,16 +279,16 @@
         "listAssignmentMismatch": "類型 \"{type}\" 的運算式不能指派至目標清單",
         "listInAnnotation": "類型註釋中不允許清單運算式",
         "literalEmptyArgs": "\"Literal\" 後面應有一或多個型別引數",
-        "literalNamedUnicodeEscape": "Named unicode escape sequences are not supported in \"Literal\" string annotations",
+        "literalNamedUnicodeEscape": "\"Literal\" 字串常值中不支援具名 Unicode 逸出序列",
         "literalNotAllowed": "沒有類型參數，\"Literal\" 不能在此內容中使用",
         "literalNotCallable": "常值類型不能具現化",
         "literalUnsupportedType": "\"Literal\" 的類型引數必須是 None、常值 (int、bool、str 或 bytes) 或列舉值",
         "matchIncompatible": "比對陳述式需要 Python 3.10 或更新版本",
         "matchIsNotExhaustive": "match 陳述式內的案例並未完整處理所有值",
         "maxParseDepthExceeded": "超過剖析深度上限; 將運算式分成較小的子運算式",
-        "memberAccess": "不能存取類型 \"{type}\" 的成員 \"{name}\"",
-        "memberDelete": "不能刪除類型 \"{type}\" 的成員 \"{name}\"",
-        "memberSet": "無法指派型別 \"{type}\" 的成員 \"{name}\"",
+        "memberAccess": "無法存取類別 \"{type}\" 的屬性 \"{name}\"",
+        "memberDelete": "無法刪除類別 \"{type}\" 的屬性 \"{name}\"",
+        "memberSet": "無法指派至類別 \"{type}\" 的屬性 \"{name}\"",
         "metaclassConflict": "衍生類別的變換類型必須是其所有基底類別的變換類型的子類別",
         "metaclassDuplicate": "只能提供一個變換類型",
         "metaclassIsGeneric": "變換類型不能是一般",
@@ -298,7 +300,7 @@
         "missingSuperCall": "方法 \"{methodName}\" 未呼叫父類別中相同名稱的方法",
         "moduleAsType": "模組不能當作型別來使用",
         "moduleNotCallable": "模組無法呼叫",
-        "moduleUnknownMember": "\"{memberName}\" 不是模組 \"{moduleName}\" 的已知成員",
+        "moduleUnknownMember": "\"{memberName}\" 不是模組 \"{moduleName}\" 的已知屬性",
         "namedExceptAfterCatchAll": "catch-all except 子句後面不能出現具名 except 子句",
         "namedParamAfterParamSpecArgs": "關鍵字參數 \"{name}\" 不能在簽章中出現在 ParamSpec args 參數之後",
         "namedTupleEmptyName": "具名元組內的名稱不可為空白",
@@ -332,7 +334,7 @@
         "noneNotSubscriptable": "型別 \"None\" 的物件不能下標",
         "noneNotUsableWith": "類型 \"None\" 的物件不能與 \"with\" 搭配使用",
         "noneOperator": "\"None\" 不支援運算子 \"{operator}\"",
-        "noneUnknownMember": "\"{name}\" 不是 \"None\" 的已知成員",
+        "noneUnknownMember": "\"{name}\" 不是 \"None\" 的已知屬性",
         "notRequiredArgCount": "預期 \"NotRequired\" 之後為單一類型引數",
         "notRequiredNotInTypedDict": "此內容中不允許 \"NotRequired\"",
         "objectNotCallable": "類型 \"{type}\" 的物件無法呼叫",
@@ -363,18 +365,18 @@
         "paramAnnotationMissing": "參數 \"{name}\" 遺漏了型別註釋",
         "paramAssignmentMismatch": "無法將型別 \"{sourceType}\" 的運算式指派給型別 \"{paramType}\" 的參數",
         "paramNameMissing": "沒有名為 \"{name}\" 的參數",
-        "paramSpecArgsKwargsUsage": "ParamSpec 的 \"args\" 和 \"kwargs\" 成員都必須出現在函式簽章內",
+        "paramSpecArgsKwargsUsage": "ParamSpec 的 \"args\" 和 \"kwargs\" 屬性都必須出現在函式簽章內",
         "paramSpecArgsMissing": "ParamSpec \"{type}\" 的引數遺失",
-        "paramSpecArgsUsage": "只有搭配 *args 參數使用時，ParamSpec 的 \"args\" 成員才有效",
+        "paramSpecArgsUsage": "只有搭配 *args 參數使用時，ParamSpec 的 \"args\" 屬性才有效",
         "paramSpecAssignedName": "ParamSpec 必須指派至名為 \"{name}\" 的變數",
         "paramSpecContext": "此內容中不允許 ParamSpec",
         "paramSpecDefaultNotTuple": "ParamSpec 的預設值必須是省略符號、元組運算式或 ParamSpec",
         "paramSpecFirstArg": "應以 ParamSpec 的名稱作為第一個引數",
-        "paramSpecKwargsUsage": "ParamSpec 的 \"kwargs\" 成員只有在與 **kwargs 參數搭配使用時有效",
+        "paramSpecKwargsUsage": "只有搭配 **kwargs 參數使用時，ParamSpec 的 \"kwargs\" 屬性才有效",
         "paramSpecNotUsedByOuterScope": "ParamSpec \"{name}\" 在此內容中沒有意義",
         "paramSpecScopedToReturnType": "ParamSpec \"{name}\" 的範圍為傳回型別內的可呼叫項目，無法在函式主體中參考",
         "paramSpecUnknownArg": "ParamSpec 不支援一個以上的引數",
-        "paramSpecUnknownMember": "\"{name}\" 不是 ParamSpec 的已知成員",
+        "paramSpecUnknownMember": "\"{name}\" 不是 ParamSpec 的已知屬性",
         "paramSpecUnknownParam": "\"{name}\" 對 ParamSpec 是未知的參數",
         "paramTypeCovariant": "不能在參數類型中使用共變數類型變數",
         "paramTypePartiallyUnknown": "參數 \"{paramName}\" 的類型部分未知",
@@ -418,7 +420,7 @@
         "returnMissing": "宣告類型為 \"{returnType}\" 的函式必須在所有程式碼路徑上傳回值",
         "returnOutsideFunction": "\"return\" 只能在函式內使用",
         "returnTypeContravariant": "逆變數型別變數不能用在傳回型別中",
-        "returnTypeMismatch": "類型 \"{exprType}\" 的運算式不能指派至傳回類型 \"{returnType}\"",
+        "returnTypeMismatch": "類型 \"{exprType}\" 的運算式與傳回型別 \"{returnType}\" 不相容",
         "returnTypePartiallyUnknown": "傳回類型 \"{returnType}\" 部分未知",
         "returnTypeUnknown": "傳回類型未知",
         "revealLocalsArgs": "\"reveal_locals\" 呼叫不應有任何引數",
@@ -484,8 +486,8 @@
         "typeArgsMissingForClass": "應為一般類別 \"{name}\" 的型別引數",
         "typeArgsTooFew": "為 \"{name}\" 提供太少類型引數; 預期為 {expected} 但收到 {received}",
         "typeArgsTooMany": "已為 \"{name}\" 提供太多型別引數; 應為 {expected} 但收到 {received}",
-        "typeAssignmentMismatch": "類型 \"{sourceType}\" 的運算式不能指派至宣告的類型 \"{destType}\"",
-        "typeAssignmentMismatchWildcard": "匯入符號 \"{name}\" 具有類型 \"{sourceType}\"，無法指派給宣告的類型 \"{destType}\"",
+        "typeAssignmentMismatch": "類型 \"{sourceType}\" 的運算式與宣告的類型 \"{destType}\" 不相容",
+        "typeAssignmentMismatchWildcard": "匯入符號 \"{name}\" 具有類型 \"{sourceType}\"，與宣告的類型 \"{destType}\" 不相容",
         "typeCallNotAllowed": "不應在類型註釋中使用 type() 呼叫",
         "typeCheckOnly": "\"{name}\" 已標示為 @type_check_only，只能在型別註釋中使用",
         "typeCommentDeprecated": "使用類型註解已取代; 請改為使用類型註釋",
@@ -520,7 +522,7 @@
         "typeVarDefaultIllegal": "型別變數預設型別需要 Python 3.13 或較新的版本",
         "typeVarDefaultInvalidTypeVar": "類型參數 \"{name}\" 的預設類型參考不在範圍的一或多個類型變數",
         "typeVarFirstArg": "預期為 TypeVar 的名稱作為第一個引數",
-        "typeVarNoMember": "TypeVar \"{type}\" 沒有成員 \"{name}\"",
+        "typeVarNoMember": "TypeVar \"{type}\" 沒有屬性 \"{name}\"",
         "typeVarNotSubscriptable": "TypeVar \"{type}\" 不能下標",
         "typeVarNotUsedByOuterScope": "類型變數 \"{name}\" 在此內容中沒有意義",
         "typeVarPossiblyUnsolvable": "如果呼叫者未提供參數 \"{param}\" 的引數，則型別變數 \"{name}\" 可能無法解析",
@@ -634,7 +636,7 @@
         "argsPositionOnly": "僅限位置的參數不符; 應為 {expected}，但收到 {received}",
         "argumentType": "引數類型為 \"{type}\"",
         "argumentTypes": "引數型別: ({types})",
-        "assignToNone": "類型不能指派至類型 \"None\"",
+        "assignToNone": "類型與 \"None\" 不相容",
         "asyncHelp": "您是指 \"async with\" 嗎?",
         "baseClassIncompatible": "基底類別 \"{baseClass}\" 與類型 \"{type}\" 不相容",
         "baseClassIncompatibleSubclass": "基底類別 \"{baseClass}\" 衍生自與類型 \"{type}\" 不相容的 \"{subclass}\"",
@@ -670,30 +672,30 @@
         "keyUndefined": "\"{name}\" 不是 \"{type}\" 中定義的金鑰",
         "kwargsParamMissing": "參數 \"**{paramName}\" 沒有對應的參數",
         "listAssignmentMismatch": "類型 \"{type}\" 與目標清單不相容",
-        "literalAssignmentMismatch": "\"{sourceType}\" 不能指派至類型 \"{destType}\"",
+        "literalAssignmentMismatch": "\"{sourceType}\" 與類型 \"{destType}\" 不相容",
         "matchIsNotExhaustiveHint": "如果不需要徹底處理，請新增 \"case _: pass\"",
         "matchIsNotExhaustiveType": "未處理的類型: \"{type}\"",
-        "memberAssignment": "無法將型別 \"{type}\" 的運算式指派給類別 \"{classType}\" 的成員 \"{name}\"",
+        "memberAssignment": "無法將型別 \"{type}\" 的運算式指派給類別 \"{classType}\" 的屬性 \"{name}\"",
         "memberIsAbstract": "\"{type}.{name}\" 未實作",
         "memberIsAbstractMore": "和其他 {count} 人...",
         "memberIsClassVarInProtocol": "\"{name}\" 定義為通訊協定中的 ClassVar",
         "memberIsFinalInProtocol": "\"{name}\" 在通訊協定中標示為 Final",
-        "memberIsInitVar": "成員 \"{name}\" 是僅限初始化的欄位",
+        "memberIsInitVar": "\"{name}\" 是僅限初始化的欄位",
         "memberIsInvariant": "\"{name}\" 為不變數，因為它可變動",
         "memberIsNotClassVarInClass": "\"{name}\" 必須定義為 ClassVar，才能與通訊協定相容",
         "memberIsNotClassVarInProtocol": "\"{name}\" 未定義為通訊協定中的 ClassVar",
         "memberIsNotFinalInProtocol": "\"{name}\" 未在通訊協定中標示為 Final",
         "memberIsWritableInProtocol": "\"{name}\" 在通訊協定中是可寫入的",
-        "memberSetClassVar": "無法透過類別執行個體指派成員 \"{name}\"，因為它是 ClassVar",
+        "memberSetClassVar": "無法透過類別執行個體指派屬性 \"{name}\"，因為它是 ClassVar",
         "memberTypeMismatch": "\"{name}\" 是不相容的類型",
-        "memberUnknown": "成員 \"{name}\" 未知",
+        "memberUnknown": "屬性 \"{name}\" 不明",
         "metaclassConflict": "Metaclass「{metaclass1}」與「{metaclass2}」衝突",
         "missingDeleter": "屬性 deleter 方法遺失",
         "missingGetter": "屬性 getter 方法遺失",
         "missingSetter": "遺漏了屬性 setter 方法",
         "namedParamMissingInDest": "目的地中遺失關鍵字參數 \"{name}\"",
         "namedParamMissingInSource": "來源中遺漏了關鍵字參數 \"{name}\"",
-        "namedParamTypeMismatch": "類型 \"{sourceType}\" 的關鍵字參數 \"{name}\" 不能指派至類型 \"{destType}\"",
+        "namedParamTypeMismatch": "類型 \"{sourceType}\" 的關鍵字參數 \"{name}\" 與類型 \"{destType}\" 不相容",
         "namedTupleNotAllowed": "執行個體或類別檢查無法使用 NamedTuple",
         "newMethodLocation": "__new__ 方法於類別 \"{type}\" 中定義",
         "newMethodSignature": "__new__ 的簽章為 \"{type}\"",
@@ -725,7 +727,7 @@
         "overridePositionalParamCount": "位置參數計數不相符; 基底方法有 {baseCount} 個，但覆寫有 {overrideCount} 個",
         "overrideReturnType": "傳回類型不符: 基底方法會傳回類型 \"{baseType}\"，覆寫會傳回類型 \"{overrideType}\"",
         "overrideType": "基底類別會將類型定義為 \"{type}\"",
-        "paramAssignment": "參數 {index}: 類型 \"{sourceType}\" 不能指派至類型 \"{destType}\"",
+        "paramAssignment": "參數 {index}: 類型 \"{sourceType}\" 與類型 \"{destType}\" 不相容",
         "paramSpecMissingInOverride": "覆寫方法中遺漏了 ParamSpec 參數",
         "paramType": "參數類型為 \"{paramType}\"",
         "privateImportFromPyTypedSource": "改為從 \"{module}\" 匯入",
@@ -755,7 +757,7 @@
         "tupleSizeMismatch": "元組大小不符; 預期為 {expected}，但收到 {received}",
         "tupleSizeMismatchIndeterminateDest": "元組大小不符; 預期為 {expected} 或其他，但收到 {received}",
         "typeAliasInstanceCheck": "使用 \"type\" 陳述式建立的類型別名不能搭配執行個體和類別檢查使用",
-        "typeAssignmentMismatch": "類型 \"{sourceType}\" 不能指派至類型 \"{destType}\"",
+        "typeAssignmentMismatch": "類型 \"{sourceType}\" 與類型 \"{destType}\" 不相容",
         "typeBound": "類型 \"{sourceType}\" 與類型變數 \"{name}\" 的繫結類型 \"{destType}\" 不相容",
         "typeConstrainedTypeVar": "類型 \"{type}\" 與限制類型變數 \"{name}\" 不相容",
         "typeIncompatible": "\"{sourceType}\" 與 \"{destType}\" 不相容",

package/dist/parser/tokenizer.js

@@ -344,11 +344,17 @@ class Tokenizer {
                         this._cs.advance(2);
                     }
                     this._addLineRange();
+                    if (this._tokens.length > 0 && this._tokens[this._tokens.length - 1].type === 2 /* TokenType.NewLine */) {
+                        this._readIndentationAfterNewLine();
+                    }
                     return true;
                 }
-                else if (this._cs.nextChar === 10 /* Char.LineFeed */) {
+                if (this._cs.nextChar === 10 /* Char.LineFeed */) {
                     this._cs.advance(2);
                     this._addLineRange();
+                    if (this._tokens.length > 0 && this._tokens[this._tokens.length - 1].type === 2 /* TokenType.NewLine */) {
+                        this._readIndentationAfterNewLine();
+                    }
                     return true;
                 }
                 return this._handleInvalid();