python2ts 1.1.0 → 1.3.0

package/dist/{chunk-65ZOMVMA.js → chunk-LNOL3BMB.js}

@@ -214,7 +214,48 @@ var PYTHON_TO_JS_NAMES = {
   // core module
   // ============================================================================
   floordiv: "floorDiv",
-  divmod: "divMod"
+  divmod: "divMod",
+  // ============================================================================
+  // hashlib module
+  // ============================================================================
+  pbkdf2_hmac: "pbkdf2Hmac",
+  compare_digest: "compareDigest",
+  file_digest: "fileDigest",
+  new: "newHash",
+  // ============================================================================
+  // pathlib module (Path methods)
+  // ============================================================================
+  read_text: "readText",
+  write_text: "writeText",
+  read_bytes: "readBytes",
+  write_bytes: "writeBytes",
+  is_file: "isFile",
+  is_dir: "isDir",
+  is_symlink: "isSymlink",
+  symlink_to: "symlinkTo",
+  link_to: "linkTo",
+  // ============================================================================
+  // shutil module
+  // ============================================================================
+  copy2: "copy2",
+  copytree: "copytree",
+  rmtree: "rmtree",
+  disk_usage: "diskUsage",
+  copymode: "copyMode",
+  copystat: "copyStat",
+  copyfile: "copyFile",
+  get_terminal_size: "getTerminalSize",
+  // ============================================================================
+  // tempfile module
+  // ============================================================================
+  mkstemp: "mkstemp",
+  mkdtemp: "mkdtemp",
+  gettempdir: "getTempDir",
+  // ============================================================================
+  // glob module
+  // ============================================================================
+  iglob: "iglob",
+  rglob: "rglob"
 };
 function toJsName(pythonName) {
   return PYTHON_TO_JS_NAMES[pythonName] ?? pythonName;
@@ -253,6 +294,23 @@ function declareVariable(ctx, name) {
     currentScope.add(name);
   }
 }
+function stripOuterParens(code) {
+  const trimmed = code.trim();
+  if (trimmed.startsWith("(") && trimmed.endsWith(")")) {
+    const inner = trimmed.slice(1, -1);
+    if (/(?<![!=<>])=(?!=)/.test(inner)) {
+      return code;
+    }
+    let depth = 0;
+    for (let i = 0; i < trimmed.length; i++) {
+      if (trimmed[i] === "(") depth++;
+      else if (trimmed[i] === ")") depth--;
+      if (depth === 0 && i < trimmed.length - 1) return code;
+    }
+    return inner;
+  }
+  return code;
+}
 function containsYield(node) {
   if (node.name === "YieldStatement" || node.name === "YieldExpression") {
     return true;
@@ -395,7 +453,7 @@ function transformPythonType(node, ctx) {
   }
 }
 function extractTypeAnnotation(typeDef, ctx) {
-  if (!typeDef || typeDef.name !== "TypeDef") return null;
+  if (typeDef?.name !== "TypeDef") return null;
   const children = getChildren(typeDef);
   const typeNode = children.find((c) => c.name !== ":" && c.name !== "->");
   if (typeNode) {
@@ -405,7 +463,7 @@ function extractTypeAnnotation(typeDef, ctx) {
 }
 function extractTypeModifiers(typeDef, ctx) {
   const result = { isFinal: false, isClassVar: false };
-  if (!typeDef || typeDef.name !== "TypeDef") return result;
+  if (typeDef?.name !== "TypeDef") return result;
   const children = getChildren(typeDef);
   const typeNode = children.find((c) => c.name !== ":" && c.name !== "->");
   if (!typeNode) return result;
@@ -461,7 +519,7 @@ function isDocstringNode(node, ctx) {
   if (node.name !== "ExpressionStatement") return false;
   const children = getChildren(node);
   const firstChild = children[0];
-  if (!firstChild || firstChild.name !== "String") return false;
+  if (firstChild?.name !== "String") return false;
   const text = getNodeText(firstChild, ctx.source);
   return text.startsWith('"""') || text.startsWith("'''");
 }
@@ -544,7 +602,7 @@ function parseDocstring(content) {
         descriptionLines.push(trimmed);
         break;
       case "params": {
-        const googleMatch = trimmed.match(/^(\w+)\s*(?:\([^)]*\))?\s*:\s*(.*)$/);
+        const googleMatch = /^(\w+)\s*(?:\([^)]*\))?\s*:\s*(.*)$/.exec(trimmed);
         if (googleMatch) {
           flushParam();
           currentParamName = googleMatch[1] ?? "";
@@ -572,7 +630,7 @@ function parseDocstring(content) {
         break;
       }
       case "throws": {
-        const throwsMatch = trimmed.match(/^(\w+)\s*:\s*(.*)$/);
+        const throwsMatch = /^(\w+)\s*:\s*(.*)$/.exec(trimmed);
         if (throwsMatch) {
           flushThrows();
           currentThrowsType = throwsMatch[1] ?? "Error";
@@ -1026,7 +1084,7 @@ function isChainedComparison(node) {
   if (node.name !== "BinaryExpression") return false;
   const children = getChildren(node);
   const op = children[1];
-  if (!op || op.name !== "CompareOp") return false;
+  if (op?.name !== "CompareOp") return false;
   return true;
 }
 function extractRightOperand(node, ctx) {
@@ -1076,7 +1134,7 @@ function transformConditionalExpression(node, ctx) {
     const condition = exprs[1];
     const falseExpr = exprs[2];
     if (trueExpr && condition && falseExpr) {
-      const condCode = transformNode(condition, ctx);
+      const condCode = stripOuterParens(transformNode(condition, ctx));
       const trueCode = transformNode(trueExpr, ctx);
       const falseCode = transformNode(falseExpr, ctx);
       return `(${condCode} ? ${trueCode} : ${falseCode})`;
@@ -1418,6 +1476,52 @@ function transformCallExpression(node, ctx) {
     case "capwords":
       ctx.usesRuntime.add("string/capWords");
       return `capWords(${args})`;
+    // glob module - async functions (direct import)
+    case "glob":
+      ctx.usesRuntime.add("glob/glob");
+      return `await glob(${args})`;
+    case "iglob":
+      ctx.usesRuntime.add("glob/iglob");
+      return `await iglob(${args})`;
+    case "rglob":
+      ctx.usesRuntime.add("glob/rglob");
+      return `await rglob(${args})`;
+    // shutil module - async functions (direct import)
+    case "copy":
+      ctx.usesRuntime.add("shutil/copy");
+      return `await copy(${args})`;
+    case "copy2":
+      ctx.usesRuntime.add("shutil/copy2");
+      return `await copy2(${args})`;
+    case "copytree":
+      ctx.usesRuntime.add("shutil/copytree");
+      return `await copytree(${args})`;
+    case "move":
+      ctx.usesRuntime.add("shutil/move");
+      return `await move(${args})`;
+    case "rmtree":
+      ctx.usesRuntime.add("shutil/rmtree");
+      return `await rmtree(${args})`;
+    case "which":
+      ctx.usesRuntime.add("shutil/which");
+      return `await which(${args})`;
+    // tempfile module - async functions (direct import)
+    case "mkstemp":
+      ctx.usesRuntime.add("tempfile/mkstemp");
+      return `await mkstemp(${args})`;
+    case "mkdtemp":
+      ctx.usesRuntime.add("tempfile/mkdtemp");
+      return `await mkdtemp(${args})`;
+    case "NamedTemporaryFile":
+      ctx.usesRuntime.add("tempfile/NamedTemporaryFile");
+      return `await NamedTemporaryFile.create(${args})`;
+    case "TemporaryDirectory":
+      ctx.usesRuntime.add("tempfile/TemporaryDirectory");
+      return `await TemporaryDirectory.create(${args})`;
+    // pathlib module
+    case "Path":
+      ctx.usesRuntime.add("pathlib/Path");
+      return `new Path(${args})`;
     /* v8 ignore next 3 -- pass-through for user-defined functions @preserve */
     default:
       return `${transformNode(callee, ctx)}(${args})`;
@@ -1436,9 +1540,10 @@ function transformModuleCall(calleeName, args, ctx) {
       inf: "inf",
       nan: "nan"
     };
-    if (funcName in mathConstants) {
+    const mathConstant = mathConstants[funcName];
+    if (mathConstant !== void 0) {
       ctx.usesRuntime.add(`math/${funcName}`);
-      return mathConstants[funcName];
+      return mathConstant;
     }
     ctx.usesRuntime.add(`math/${funcName}`);
     return `${funcName}(${args})`;
@@ -1453,14 +1558,45 @@ function transformModuleCall(calleeName, args, ctx) {
     return `${funcName}(${args})`;
   }
   if (moduleName === "os") {
+    const asyncPathFuncs = [
+      "exists",
+      "isfile",
+      "isdir",
+      "islink",
+      "realpath",
+      "getsize",
+      "getmtime",
+      "getatime",
+      "getctime"
+    ];
+    const asyncOsFuncs = [
+      "listdir",
+      "mkdir",
+      "makedirs",
+      "remove",
+      "unlink",
+      "rmdir",
+      "removedirs",
+      "rename",
+      "renames",
+      "replace",
+      "walk",
+      "stat"
+    ];
     if (funcName.startsWith("path.")) {
       const pathFuncName = funcName.slice(5);
       const jsPathFunc = toJsName(pathFuncName);
       ctx.usesRuntime.add("os/path");
+      if (asyncPathFuncs.includes(pathFuncName.toLowerCase())) {
+        return `await path.${jsPathFunc}(${args})`;
+      }
       return `path.${jsPathFunc}(${args})`;
     }
     const jsName = toJsName(funcName);
     ctx.usesRuntime.add(`os/${jsName}`);
+    if (asyncOsFuncs.includes(funcName.toLowerCase())) {
+      return `await ${jsName}(${args})`;
+    }
     return `${jsName}(${args})`;
   }
   if (moduleName === "datetime") {
@@ -1501,6 +1637,67 @@ function transformModuleCall(calleeName, args, ctx) {
     }
     return `${funcName}(${args})`;
   }
+  if (moduleName === "hashlib") {
+    const jsName = toJsName(funcName);
+    ctx.usesRuntime.add(`hashlib/${jsName}`);
+    if (["pbkdf2_hmac", "scrypt", "compare_digest", "file_digest"].includes(funcName)) {
+      const asyncJsName = toJsName(funcName);
+      return `await ${asyncJsName}(${args})`;
+    }
+    return `${jsName}(${args})`;
+  }
+  if (moduleName === "shutil") {
+    const asyncShutilFuncs = [
+      "copy",
+      "copy2",
+      "copytree",
+      "move",
+      "rmtree",
+      "which",
+      "disk_usage",
+      "copymode",
+      "copystat",
+      "copyfile"
+    ];
+    const jsName = toJsName(funcName);
+    ctx.usesRuntime.add(`shutil/${jsName}`);
+    if (asyncShutilFuncs.includes(funcName.toLowerCase())) {
+      return `await ${jsName}(${args})`;
+    }
+    return `${jsName}(${args})`;
+  }
+  if (moduleName === "glob") {
+    const asyncGlobFuncs = ["glob", "iglob", "rglob"];
+    const jsName = toJsName(funcName);
+    ctx.usesRuntime.add(`glob/${jsName}`);
+    if (asyncGlobFuncs.includes(funcName.toLowerCase())) {
+      return `await ${jsName}(${args})`;
+    }
+    return `${jsName}(${args})`;
+  }
+  if (moduleName === "tempfile") {
+    const asyncTempfileFuncs = ["mkstemp", "mkdtemp"];
+    const jsName = toJsName(funcName);
+    ctx.usesRuntime.add(`tempfile/${jsName}`);
+    if (funcName === "NamedTemporaryFile") {
+      return `await NamedTemporaryFile.create(${args})`;
+    }
+    if (funcName === "TemporaryDirectory") {
+      return `await TemporaryDirectory.create(${args})`;
+    }
+    if (asyncTempfileFuncs.includes(funcName.toLowerCase())) {
+      return `await ${jsName}(${args})`;
+    }
+    return `${jsName}(${args})`;
+  }
+  if (moduleName === "pathlib") {
+    const jsName = toJsName(funcName);
+    ctx.usesRuntime.add(`pathlib/${jsName}`);
+    if (funcName === "Path") {
+      return `new Path(${args})`;
+    }
+    return `${jsName}(${args})`;
+  }
   return null;
 }
 function transformMethodCall(callee, args, ctx) {
@@ -1512,6 +1709,29 @@ function transformMethodCall(callee, args, ctx) {
   if (obj.name === "MemberExpression") {
     return null;
   }
+  if (obj.name === "VariableName") {
+    const objName = getNodeText(obj, ctx.source);
+    const knownModules = [
+      "shutil",
+      "glob",
+      "tempfile",
+      "pathlib",
+      "os",
+      "math",
+      "random",
+      "json",
+      "datetime",
+      "re",
+      "string",
+      "functools",
+      "itertools",
+      "collections",
+      "hashlib"
+    ];
+    if (knownModules.includes(objName)) {
+      return null;
+    }
+  }
   const objCode = transformNode(obj, ctx);
   const methodName = getNodeText(methodNode, ctx.source);
   switch (methodName) {
@@ -1670,6 +1890,26 @@ function transformMethodCall(callee, args, ctx) {
     case "issuperset":
       ctx.usesRuntime.add("set");
       return `set.issuperset(${objCode}, ${args})`;
+    // Hash object methods (hashlib) - async
+    case "digest":
+      return `await ${objCode}.digest()`;
+    case "hexdigest":
+      return `await ${objCode}.hexdigest()`;
+    // Path object methods (pathlib) - async
+    // Only handle snake_case methods that are unique to Path
+    case "is_file":
+    case "is_dir":
+    case "is_symlink":
+    case "read_text":
+    case "write_text":
+    case "read_bytes":
+    case "write_bytes":
+    case "symlink_to":
+    case "link_to":
+    case "iterdir": {
+      const jsMethod = toJsName(methodName);
+      return `await ${objCode}.${jsMethod}(${args})`;
+    }
     /* v8 ignore next 2 -- unknown method, let caller handle @preserve */
     default:
       return null;
@@ -1717,7 +1957,7 @@ function transformArgList(node, ctx) {
     }
     if (item.name === "VariableName") {
       const nextItem = items[i + 1];
-      if (nextItem && nextItem.name === "AssignOp") {
+      if (nextItem?.name === "AssignOp") {
         const valueItem = items[i + 2];
         if (valueItem) {
           const name = getNodeText(item, ctx.source);
@@ -1931,7 +2171,7 @@ function transformIfStatement(node, ctx) {
       const condition = children[i + 1];
       const body = children.find((c, idx) => idx > i && c.name === "Body");
       if (condition && body) {
-        const condCode = transformNode(condition, ctx);
+        const condCode = stripOuterParens(transformNode(condition, ctx));
         const bodyCode = transformBody(body, ctx);
         parts.push(`if (${condCode}) {
 ${bodyCode}
@@ -1941,7 +2181,7 @@ ${bodyCode}
       const condition = children[i + 1];
       const body = children.find((c, idx) => idx > i + 1 && c.name === "Body");
       if (condition && body) {
-        const condCode = transformNode(condition, ctx);
+        const condCode = stripOuterParens(transformNode(condition, ctx));
         const bodyCode = transformBody(body, ctx);
         parts.push(` else if (${condCode}) {
 ${bodyCode}
@@ -1967,7 +2207,7 @@ function transformWhileStatement(node, ctx) {
   );
   const body = children.find((c) => c.name === "Body");
   if (!condition || !body) return getNodeText(node, ctx.source);
-  const condCode = transformNode(condition, ctx);
+  const condCode = stripOuterParens(transformNode(condition, ctx));
   const bodyCode = transformBody(body, ctx);
   return `while (${condCode}) {
 ${bodyCode}
@@ -1981,8 +2221,8 @@ function transformMatchStatement(node, ctx) {
     if (child.name === "match" || child.name === ":") continue;
     if (child.name === "MatchBody") {
       matchBody = child;
-    } else if (!subject) {
-      subject = child;
+    } else {
+      subject ??= child;
     }
   }
   if (!subject || !matchBody) return getNodeText(node, ctx.source);
@@ -2032,8 +2272,8 @@ function transformMatchAsIfElse(subjectCode, clauses, ctx) {
         body = child;
       } else if (child.name === "Guard") {
         guard = child;
-      } else if (!pattern) {
-        pattern = child;
+      } else {
+        pattern ??= child;
       }
     }
     if (!pattern || !body) continue;
@@ -2259,8 +2499,8 @@ function transformMatchClause(node, ctx, indent) {
     if (child.name === "case" || child.name === ":") continue;
     if (child.name === "Body") {
       body = child;
-    } else if (!pattern) {
-      pattern = child;
+    } else {
+      pattern ??= child;
     }
   }
   if (!pattern || !body) return "";
@@ -2380,7 +2620,7 @@ function transformTryStatement(node, ctx) {
     }
     if (child.name === "try") {
       const nextBody = children[i + 1];
-      if (nextBody && nextBody.name === "Body") {
+      if (nextBody?.name === "Body") {
         tryBody = nextBody;
         i += 2;
         continue;
@@ -2418,7 +2658,7 @@ function transformTryStatement(node, ctx) {
     }
     if (child.name === "finally") {
       const nextBody = children[i + 1];
-      if (nextBody && nextBody.name === "Body") {
+      if (nextBody?.name === "Body") {
         finallyBody = nextBody;
         i += 2;
         continue;
@@ -2436,14 +2676,21 @@ ${baseIndent}}`;
   if (exceptBodies.length > 0) {
     const firstExcept = exceptBodies[0];
     if (firstExcept) {
-      const catchVar = firstExcept.varName || "e";
-      const catchBody = transformBody(firstExcept.body, ctx);
+      const catchVar = firstExcept.varName ?? "e";
+      let catchBody = transformBody(firstExcept.body, ctx);
+      const isEmpty = !catchBody.trim();
+      if (isEmpty) {
+        const innerIndent = "  ".repeat(ctx.indentLevel + 1);
+        const exceptionComment = firstExcept.type ? ` - ${firstExcept.type} expected` : "";
+        catchBody = `${innerIndent}// Intentionally empty${exceptionComment}`;
+      }
+      const catchClause = isEmpty && !firstExcept.varName ? "catch" : `catch (${catchVar})`;
       if (exceptBodies.length === 1 && !firstExcept.type) {
-        result += ` catch (${catchVar}) {
+        result += ` ${catchClause} {
 ${catchBody}
 ${baseIndent}}`;
       } else if (exceptBodies.length === 1) {
-        result += ` catch (${catchVar}) {
+        result += ` ${catchClause} {
 ${catchBody}
 ${baseIndent}}`;
       } else {
@@ -2453,7 +2700,7 @@ ${baseIndent}}`;
           const exc = exceptBodies[idx];
           if (!exc) continue;
           const excBodyCode = transformBody(exc.body, ctx);
-          const excVar = exc.varName || catchVar;
+          const excVar = exc.varName ?? catchVar;
           if (exc.type) {
             const condition = idx === 0 ? "if" : "} else if";
             const mappedType = mapExceptionType(exc.type);
@@ -2508,7 +2755,7 @@ function mapExceptionType(pythonType) {
     NameError: "ReferenceError",
     SyntaxError: "SyntaxError"
   };
-  return mapping[pythonType] || "Error";
+  return mapping[pythonType] ?? "Error";
 }
 function transformRaiseStatement(node, ctx) {
   const children = getChildren(node);
@@ -2598,9 +2845,9 @@ function transformSimpleImport(children, ctx) {
       const moduleName = getNodeText(child, ctx.source);
       let alias = null;
       const nextChild = children[i + 1];
-      if (nextChild && nextChild.name === "as") {
+      if (nextChild?.name === "as") {
         const aliasChild = children[i + 2];
-        if (aliasChild && aliasChild.name === "VariableName") {
+        if (aliasChild?.name === "VariableName") {
           alias = getNodeText(aliasChild, ctx.source);
           i += 3;
           names.push({ module: moduleName, alias });
@@ -2620,7 +2867,7 @@ function transformSimpleImport(children, ctx) {
     return "";
   }
   return filteredNames.map(({ module, alias }) => {
-    const importName = alias || module;
+    const importName = alias ?? module;
     return `import * as ${importName} from "${module}"`;
   }).join("\n");
 }
@@ -2696,9 +2943,9 @@ function transformFromImport(children, ctx) {
       if (child.name === "VariableName") {
         const name = getNodeText(child, ctx.source);
         const nextChild = children[i + 1];
-        if (nextChild && nextChild.name === "as") {
+        if (nextChild?.name === "as") {
           const aliasChild = children[i + 2];
-          if (aliasChild && aliasChild.name === "VariableName") {
+          if (aliasChild?.name === "VariableName") {
             imports.push({ name, alias: getNodeText(aliasChild, ctx.source) });
             i += 2;
             continue;
@@ -2722,7 +2969,7 @@ function transformFromImport(children, ctx) {
     if (moduleName) {
       modulePath += moduleName;
     } else if (imports.length > 0) {
-      modulePath += imports[0]?.name || "";
+      modulePath += imports[0]?.name ?? "";
     }
   } else {
     modulePath = moduleName;
@@ -2733,7 +2980,7 @@ function transformFromImport(children, ctx) {
   if (relativeDots > 0 && !moduleName && imports.length === 1) {
     const imp = imports[0];
     if (imp) {
-      const importName = imp.alias || imp.name;
+      const importName = imp.alias ?? imp.name;
       return `import * as ${importName} from "${modulePath}"`;
     }
   }
@@ -2772,9 +3019,9 @@ function transformWithStatement(node, ctx) {
       const expr = child;
       let varName = null;
       const nextChild = children[i + 1];
-      if (nextChild && nextChild.name === "as") {
+      if (nextChild?.name === "as") {
         const varChild = children[i + 2];
-        if (varChild && varChild.name === "VariableName") {
+        if (varChild?.name === "VariableName") {
           varName = getNodeText(varChild, ctx.source);
           i += 3;
         } else {
@@ -2847,7 +3094,7 @@ function extractParamNames(node, source) {
     }
     if (child.name === "*" || getNodeText(child, source) === "*") {
       const nextChild = children[i + 1];
-      if (nextChild && nextChild.name === "VariableName") {
+      if (nextChild?.name === "VariableName") {
         names.push(getNodeText(nextChild, source));
         i += 2;
         continue;
@@ -2857,7 +3104,7 @@ function extractParamNames(node, source) {
     }
     if (child.name === "**" || getNodeText(child, source) === "**") {
       const nextChild = children[i + 1];
-      if (nextChild && nextChild.name === "VariableName") {
+      if (nextChild?.name === "VariableName") {
         names.push(getNodeText(nextChild, source));
         i += 2;
         continue;
@@ -3228,7 +3475,7 @@ function transformMethodParamListImpl(node, ctx, includeTypes) {
     isFirstParam = false;
     if (child.name === "*" || getNodeText(child, ctx.source) === "*") {
       const nextChild = children[i + 1];
-      if (nextChild && nextChild.name === "VariableName") {
+      if (nextChild?.name === "VariableName") {
         const name = getNodeText(nextChild, ctx.source);
         params.push(`...${name}`);
         i += 2;
@@ -3239,7 +3486,7 @@ function transformMethodParamListImpl(node, ctx, includeTypes) {
     }
     if (child.name === "**" || getNodeText(child, ctx.source) === "**") {
       const nextChild = children[i + 1];
-      if (nextChild && nextChild.name === "VariableName") {
+      if (nextChild?.name === "VariableName") {
         const name = getNodeText(nextChild, ctx.source);
         params.push(name);
         i += 2;
@@ -3582,7 +3829,7 @@ function parseDataclassFieldFromExpression(node, ctx) {
 }
 function parseFieldDefaultFactory(callNode, ctx) {
   const text = getNodeText(callNode, ctx.source);
-  const factoryMatch = text.match(/default_factory\s*=\s*(\w+)/);
+  const factoryMatch = /default_factory\s*=\s*(\w+)/.exec(text);
   if (factoryMatch) {
     const factory = factoryMatch[1];
     if (factory === "list") return "[]";
@@ -3590,7 +3837,7 @@ function parseFieldDefaultFactory(callNode, ctx) {
     if (factory === "set") return "new Set()";
     if (factory) return `${factory}()`;
   }
-  const defaultMatch = text.match(/default\s*=\s*([^,)]+)/);
+  const defaultMatch = /default\s*=\s*([^,)]+)/.exec(text);
   if (defaultMatch) {
     return defaultMatch[1]?.trim() ?? "undefined";
   }
@@ -3809,9 +4056,8 @@ function parseEnumMember(node, ctx) {
 function checkSequentialEnum(members) {
   if (members.length === 0) return true;
   if (members.some((m) => m.value === "auto")) return true;
-  const numericMembers = members.filter((m) => m.numericValue !== null);
-  if (numericMembers.length !== members.length) return false;
-  const values = numericMembers.map((m) => m.numericValue);
+  const values = members.map((m) => m.numericValue).filter((v) => v !== null);
+  if (values.length !== members.length) return false;
   const firstValue = values[0];
   if (firstValue === void 0) return false;
   for (let i = 1; i < values.length; i++) {
@@ -3893,7 +4139,7 @@ function transformProtocol(className, parentClasses, body, ctx) {
           members.push(`${memberIndent}${sig}`);
         }
       } else if (child.name === "ExpressionStatement" || child.name === "AssignStatement") {
-        const field = parseDataclassFieldFromExpression(child, ctx) || parseDataclassFieldFromAssignment(child, ctx);
+        const field = parseDataclassFieldFromExpression(child, ctx) ?? parseDataclassFieldFromAssignment(child, ctx);
         if (field) {
           members.push(`${memberIndent}${field.name}: ${field.tsType}`);
         }
@@ -3992,18 +4238,18 @@ function transformParamList(node, ctx) {
   let i = 0;
   const parseParam = (startIndex) => {
     const child = children[startIndex];
-    if (!child || child.name !== "VariableName") return null;
+    if (child?.name !== "VariableName") return null;
     const nameCode = getNodeText(child, ctx.source);
     let tsType = null;
     let defaultValue = null;
     let offset = 1;
     const nextChild = children[startIndex + 1];
-    if (nextChild && nextChild.name === "TypeDef") {
+    if (nextChild?.name === "TypeDef") {
       tsType = extractTypeAnnotation(nextChild, ctx);
       offset = 2;
     }
     const afterType = children[startIndex + offset];
-    if (afterType && afterType.name === "AssignOp") {
+    if (afterType?.name === "AssignOp") {
       const defaultValChild = children[startIndex + offset + 1];
       if (defaultValChild) {
         defaultValue = transformNode(defaultValChild, ctx);
@@ -4034,10 +4280,10 @@ function transformParamList(node, ctx) {
     }
     if (child.name === "*" || getNodeText(child, ctx.source) === "*") {
       const nextChild = children[i + 1];
-      if (nextChild && nextChild.name === "VariableName") {
+      if (nextChild?.name === "VariableName") {
         const name = getNodeText(nextChild, ctx.source);
         const typeChild = children[i + 2];
-        if (typeChild && typeChild.name === "TypeDef") {
+        if (typeChild?.name === "TypeDef") {
           const tsType = extractTypeAnnotation(typeChild, ctx);
           restParam = tsType ? `...${name}: ${tsType}[]` : `...${name}`;
           i += 3;
@@ -4054,7 +4300,7 @@ function transformParamList(node, ctx) {
     }
     if (child.name === "**" || getNodeText(child, ctx.source) === "**") {
       const nextChild = children[i + 1];
-      if (nextChild && nextChild.name === "VariableName") {
+      if (nextChild?.name === "VariableName") {
         kwargsParam = getNodeText(nextChild, ctx.source);
         i += 2;
         continue;
@@ -4511,6 +4757,11 @@ function transformYieldStatement(node, ctx) {
 
 // src/generator/index.ts
 import * as prettier from "prettier";
+import { ESLint } from "eslint";
+import tseslint from "typescript-eslint";
+import { writeFileSync, readFileSync, mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
 var defaultOptions = {
   includeRuntime: true,
   runtimeImportPath: "pythonlib"
@@ -4655,9 +4906,81 @@ function buildRuntimeImports(usedFunctions, basePath) {
 function transpile(python, options = {}) {
   return generate(python, options).code;
 }
+function createEslintConfig(tempDir) {
+  return {
+    cwd: tempDir,
+    fix: true,
+    overrideConfigFile: true,
+    overrideConfig: [
+      // TypeScript-ESLint strict + stylistic presets (type-checked)
+      ...tseslint.configs.strictTypeChecked,
+      ...tseslint.configs.stylisticTypeChecked,
+      // Custom configuration
+      {
+        files: ["**/*.ts"],
+        languageOptions: {
+          parserOptions: {
+            projectService: true,
+            tsconfigRootDir: tempDir
+          }
+        },
+        rules: {
+          // ESLint core rules (auto-fixable, not in typescript-eslint presets)
+          "prefer-const": "error",
+          "prefer-arrow-callback": "error",
+          "prefer-template": "error",
+          "prefer-rest-params": "error",
+          "prefer-spread": "error",
+          curly: "error",
+          "no-lonely-if": "error",
+          // Disable rules that don't make sense for generated code
+          "@typescript-eslint/explicit-function-return-type": "off",
+          "@typescript-eslint/explicit-module-boundary-types": "off",
+          "@typescript-eslint/no-explicit-any": "off",
+          "@typescript-eslint/no-unsafe-assignment": "off",
+          "@typescript-eslint/no-unsafe-member-access": "off",
+          "@typescript-eslint/no-unsafe-call": "off",
+          "@typescript-eslint/no-unsafe-return": "off",
+          "@typescript-eslint/no-unsafe-argument": "off"
+        }
+      }
+    ]
+  };
+}
+async function applyTypedEslintFixes(code) {
+  const tempDir = mkdtempSync(join(tmpdir(), "python2ts-"));
+  try {
+    const tsconfigPath = join(tempDir, "tsconfig.json");
+    writeFileSync(
+      tsconfigPath,
+      JSON.stringify({
+        compilerOptions: {
+          target: "ES2024",
+          module: "ESNext",
+          moduleResolution: "bundler",
+          strict: true,
+          skipLibCheck: true,
+          noEmit: true
+        },
+        include: ["*.ts"]
+      })
+    );
+    const tempFile = join(tempDir, "output.ts");
+    writeFileSync(tempFile, code);
+    const eslint = new ESLint(createEslintConfig(tempDir));
+    const results = await eslint.lintFiles(["output.ts"]);
+    if (results.length > 0 && results[0]?.output) {
+      return results[0].output;
+    }
+    return readFileSync(tempFile, "utf-8");
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
 async function formatCode(code) {
   try {
-    return await prettier.format(code, prettierOptions);
+    const eslintFixed = await applyTypedEslintFixes(code);
+    return await prettier.format(eslintFixed, prettierOptions);
   } catch {
     return code;
   }
@@ -4703,4 +5026,3 @@ export {
 /* v8 ignore next -- bare yield statement @preserve */
 /* v8 ignore next 2 -- fallback for future/unknown runtime functions @preserve */
 /* v8 ignore start -- async wrappers tested via CLI @preserve */
-//# sourceMappingURL=chunk-65ZOMVMA.js.map