python2ts 1.0.0 → 1.2.0

package/dist/{chunk-VYG6GDWU.js → chunk-MEHQCUVO.js}

@@ -228,7 +228,9 @@ function createContext(source) {
     usesRuntime: /* @__PURE__ */ new Set(),
     scopeStack: [/* @__PURE__ */ new Set()],
     // Start with one global scope
-    definedClasses: /* @__PURE__ */ new Set()
+    definedClasses: /* @__PURE__ */ new Set(),
+    insideFunctionBody: 0,
+    hoistedImports: []
   };
 }
 function pushScope(ctx) {
@@ -251,6 +253,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;
@@ -512,23 +531,29 @@ function parseDocstring(content) {
       currentThrowsDesc = [];
     }
   };
-  for (const line of lines) {
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex] ?? "";
     const trimmed = line.trim();
-    if (/^(Args|Arguments|Parameters):$/i.test(trimmed)) {
+    if (/^-+$/.test(trimmed)) {
+      continue;
+    }
+    const nextLine = lines[lineIndex + 1]?.trim() ?? "";
+    const isNumpySection = /^-+$/.test(nextLine);
+    if (/^(Args|Arguments|Parameters):?$/i.test(trimmed) && (trimmed.endsWith(":") || isNumpySection)) {
       currentSection = "params";
       continue;
     }
-    if (/^(Returns?|Yields?):$/i.test(trimmed)) {
+    if (/^(Returns?|Yields?):?$/i.test(trimmed) && (trimmed.endsWith(":") || isNumpySection)) {
       flushParam();
       currentSection = "returns";
       continue;
     }
-    if (/^(Raises?|Throws?|Exceptions?):$/i.test(trimmed)) {
+    if (/^(Raises?|Throws?|Exceptions?):?$/i.test(trimmed) && (trimmed.endsWith(":") || isNumpySection)) {
       flushParam();
       currentSection = "throws";
       continue;
     }
-    if (/^[A-Z][a-z]+:$/.test(trimmed)) {
+    if (/^[A-Z][a-z]+:?$/.test(trimmed) && (trimmed.endsWith(":") || isNumpySection)) {
       continue;
     }
     switch (currentSection) {
@@ -540,14 +565,23 @@ function parseDocstring(content) {
         if (googleMatch) {
           flushParam();
           currentParamName = googleMatch[1] ?? "";
-          const desc = googleMatch[2] ?? "";
-          if (desc) currentParamDesc.push(desc);
+          const afterColon = googleMatch[2] ?? "";
+          const looksLikeType = /^[a-z_][a-z0-9_]*(?:\s+(?:of|or)\s+[a-z_][a-z0-9_]*)*$/i.test(
+            afterColon
+          );
+          if (afterColon && !looksLikeType) {
+            currentParamDesc.push(afterColon);
+          }
         } else if (currentParamName && trimmed) {
           currentParamDesc.push(trimmed);
         }
         break;
       }
       case "returns": {
+        const looksLikeType = /^[a-z_][a-z0-9_]*$/i.test(trimmed);
+        if (looksLikeType && returnsLines.length === 0) {
+          continue;
+        }
         const stripped = trimmed.replace(/^(?:\([^)]*\)|[^:]+):\s*/, "");
         if (stripped || trimmed) {
           returnsLines.push(stripped || trimmed);
@@ -561,6 +595,9 @@ function parseDocstring(content) {
           currentThrowsType = throwsMatch[1] ?? "Error";
           const desc = throwsMatch[2] ?? "";
           if (desc) currentThrowsDesc.push(desc);
+        } else if (/^[A-Z][a-zA-Z]*(?:Error|Exception|Warning)?$/.test(trimmed)) {
+          flushThrows();
+          currentThrowsType = trimmed;
         } else if (trimmed) {
           currentThrowsDesc.push(trimmed);
         }
@@ -626,7 +663,8 @@ function transform(input) {
   const code = transformNode(parseResult.tree.topNode, ctx);
   return {
     code,
-    usesRuntime: ctx.usesRuntime
+    usesRuntime: ctx.usesRuntime,
+    hoistedImports: ctx.hoistedImports
   };
 }
 function transformNode(node, ctx) {
@@ -755,7 +793,9 @@ function transformAssignStatement(node, ctx) {
   const assignOpIndex = children.findIndex((c) => c.name === "AssignOp" || c.name === "=");
   if (assignOpIndex === -1) return getNodeText(node, ctx.source);
   const typeDef = children.slice(0, assignOpIndex).find((c) => c.name === "TypeDef");
-  const targets = children.slice(0, assignOpIndex).filter((c) => c.name !== "," && c.name !== "TypeDef");
+  const beforeAssign = children.slice(0, assignOpIndex);
+  const hasTrailingComma = beforeAssign.some((c) => c.name === ",");
+  const targets = beforeAssign.filter((c) => c.name !== "," && c.name !== "TypeDef");
   const values = children.slice(assignOpIndex + 1).filter((c) => c.name !== ",");
   if (targets.length === 0 || values.length === 0) {
     return getNodeText(node, ctx.source);
@@ -777,7 +817,7 @@ function transformAssignStatement(node, ctx) {
       return `type ${aliasName} = ${aliasType}`;
     }
   }
-  if (targets.length === 1) {
+  if (targets.length === 1 && !hasTrailingComma) {
     const target = targets[0];
     if (!target) return getNodeText(node, ctx.source);
     if (target.name === "MemberExpression" && isSliceExpression(target)) {
@@ -913,9 +953,29 @@ function transformBinaryExpression(node, ctx) {
   if (children.length < 3) return getNodeText(node, ctx.source);
   const left = children[0];
   const op = children[1];
-  const right = children[2];
-  if (!left || !op || !right) return getNodeText(node, ctx.source);
+  if (!left || !op) return getNodeText(node, ctx.source);
   const opText = getNodeText(op, ctx.source);
+  if ((opText === "is" || opText === "not") && children.length >= 4) {
+    const secondOp = children[2];
+    const secondOpText = secondOp ? getNodeText(secondOp, ctx.source) : "";
+    if (opText === "is" && secondOpText === "not") {
+      const right2 = children[3];
+      if (!right2) return getNodeText(node, ctx.source);
+      const leftCode2 = transformNode(left, ctx);
+      const rightCode2 = transformNode(right2, ctx);
+      return `(${leftCode2} !== ${rightCode2})`;
+    }
+    if (opText === "not" && secondOpText === "in") {
+      const right2 = children[3];
+      if (!right2) return getNodeText(node, ctx.source);
+      const leftCode2 = transformNode(left, ctx);
+      const rightCode2 = transformNode(right2, ctx);
+      ctx.usesRuntime.add("contains");
+      return `!contains(${leftCode2}, ${rightCode2})`;
+    }
+  }
+  const right = children[2];
+  if (!right) return getNodeText(node, ctx.source);
   if (isComparisonOperator(opText) && isChainedComparison(left)) {
     const leftComparison = transformNode(left, ctx);
     const middleValue = extractRightOperand(left, ctx);
@@ -1033,7 +1093,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})`;
@@ -1246,6 +1306,15 @@ function transformCallExpression(node, ctx) {
     case "bin":
       ctx.usesRuntime.add("bin");
       return `bin(${args})`;
+    case "getattr":
+      ctx.usesRuntime.add("getattr");
+      return `getattr(${args})`;
+    case "hasattr":
+      ctx.usesRuntime.add("hasattr");
+      return `hasattr(${args})`;
+    case "setattr":
+      ctx.usesRuntime.add("setattr");
+      return `setattr(${args})`;
     // itertools functions
     case "chain":
       ctx.usesRuntime.add("itertools/chain");
@@ -1658,7 +1727,7 @@ function transformArgList(node, ctx) {
     if (item.name === "**" || item.name === "ArithOp" && getNodeText(item, ctx.source) === "**") {
       const nextItem = items[i + 1];
       if (nextItem) {
-        args.push(`...Object.entries(${transformNode(nextItem, ctx)})`);
+        kwArgs.push({ name: "__spread__", value: transformNode(nextItem, ctx) });
         i += 2;
         continue;
       }
@@ -1680,8 +1749,24 @@ function transformArgList(node, ctx) {
     i++;
   }
   if (kwArgs.length > 0) {
-    const kwArgsStr = kwArgs.map((kw) => `${kw.name}: ${kw.value}`).join(", ");
-    args.push(`{ ${kwArgsStr} }`);
+    const spreadKwargs = kwArgs.filter((kw) => kw.name === "__spread__");
+    const regularKwargs = kwArgs.filter((kw) => kw.name !== "__spread__");
+    if (regularKwargs.length > 0 && spreadKwargs.length > 0) {
+      const regularStr = regularKwargs.map((kw) => `${kw.name}: ${kw.value}`).join(", ");
+      const spreadStr = spreadKwargs.map((kw) => `...${kw.value}`).join(", ");
+      args.push(`{ ${spreadStr}, ${regularStr} }`);
+    } else if (spreadKwargs.length > 0) {
+      const firstSpread = spreadKwargs[0];
+      if (spreadKwargs.length === 1 && firstSpread) {
+        args.push(firstSpread.value);
+      } else {
+        const spreadStr = spreadKwargs.map((kw) => `...${kw.value}`).join(", ");
+        args.push(`{ ${spreadStr} }`);
+      }
+    } else {
+      const kwArgsStr = regularKwargs.map((kw) => `${kw.name}: ${kw.value}`).join(", ");
+      args.push(`{ ${kwArgsStr} }`);
+    }
   }
   return args.join(", ");
 }
@@ -1791,10 +1876,31 @@ function transformArrayExpression(node, ctx) {
 }
 function transformDictionaryExpression(node, ctx) {
   const children = getChildren(node);
-  const pairs = [];
   const items = children.filter(
     (c) => c.name !== "{" && c.name !== "}" && c.name !== "," && c.name !== ":"
   );
+  const keyNodes = [];
+  for (let i = 0; i < items.length; i += 2) {
+    const key = items[i];
+    if (key) keyNodes.push(key);
+  }
+  const allKeysValidForObjectLiteral = keyNodes.every(
+    (key) => key.name === "String" || key.name === "Number" || key.name === "VariableName"
+  );
+  if (!allKeysValidForObjectLiteral) {
+    const mapPairs = [];
+    for (let i = 0; i < items.length; i += 2) {
+      const key = items[i];
+      const value = items[i + 1];
+      if (key && value) {
+        const keyCode = transformNode(key, ctx);
+        const valueCode = transformNode(value, ctx);
+        mapPairs.push(`[${keyCode}, ${valueCode}]`);
+      }
+    }
+    return `new Map([${mapPairs.join(", ")}])`;
+  }
+  const pairs = [];
   for (let i = 0; i < items.length; i += 2) {
     const key = items[i];
     const value = items[i + 1];
@@ -1842,7 +1948,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}
@@ -1852,7 +1958,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}
@@ -1878,7 +1984,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}
@@ -2348,13 +2454,20 @@ ${baseIndent}}`;
     const firstExcept = exceptBodies[0];
     if (firstExcept) {
       const catchVar = firstExcept.varName || "e";
-      const catchBody = transformBody(firstExcept.body, ctx);
+      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 {
@@ -2480,11 +2593,17 @@ function isExceptionType(name) {
 function transformImportStatement(node, ctx) {
   const children = getChildren(node);
   const hasFrom = children.some((c) => c.name === "from");
+  let importCode;
   if (hasFrom) {
-    return transformFromImport(children, ctx);
+    importCode = transformFromImport(children, ctx);
   } else {
-    return transformSimpleImport(children, ctx);
+    importCode = transformSimpleImport(children, ctx);
+  }
+  if (ctx.insideFunctionBody > 0 && importCode) {
+    ctx.hoistedImports.push(importCode);
+    return "";
   }
+  return importCode;
 }
 function transformSimpleImport(children, ctx) {
   const names = [];
@@ -2736,9 +2855,64 @@ ${innerIndent}}`;
   }
   return result;
 }
-function transformBody(node, ctx, skipFirst = false) {
+function extractParamNames(node, source) {
+  const children = getChildren(node);
+  const names = [];
+  let i = 0;
+  while (i < children.length) {
+    const child = children[i];
+    if (!child) {
+      i++;
+      continue;
+    }
+    if (child.name === "(" || child.name === ")" || child.name === "," || child.name === "/" || child.name === ":") {
+      i++;
+      continue;
+    }
+    if (child.name === "*" || getNodeText(child, source) === "*") {
+      const nextChild = children[i + 1];
+      if (nextChild && nextChild.name === "VariableName") {
+        names.push(getNodeText(nextChild, source));
+        i += 2;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (child.name === "**" || getNodeText(child, source) === "**") {
+      const nextChild = children[i + 1];
+      if (nextChild && nextChild.name === "VariableName") {
+        names.push(getNodeText(nextChild, source));
+        i += 2;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (child.name === "VariableName") {
+      names.push(getNodeText(child, source));
+      i++;
+      continue;
+    }
+    if (child.name === "AssignParam" || child.name === "DefaultParam") {
+      const paramChildren = getChildren(child);
+      const name = paramChildren.find((c) => c.name === "VariableName");
+      if (name) {
+        names.push(getNodeText(name, source));
+      }
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return names;
+}
+function transformBody(node, ctx, skipFirst = false, predeclaredVars = []) {
   ctx.indentLevel++;
   pushScope(ctx);
+  for (const v of predeclaredVars) {
+    declareVariable(ctx, v);
+  }
   const children = getChildren(node);
   const indent = "  ".repeat(ctx.indentLevel);
   let filteredChildren = children.filter((child) => child.name !== ":");
@@ -2790,7 +2964,10 @@ function transformFunctionDefinition(node, ctx) {
   const indent = "  ".repeat(ctx.indentLevel);
   const { jsdoc, skipFirstStatement } = body ? extractDocstringFromBody(body, ctx, indent) : { jsdoc: null, skipFirstStatement: false };
   const params = paramList ? transformParamList(paramList, ctx) : "";
-  const bodyCode = body ? transformBody(body, ctx, skipFirstStatement) : "";
+  const paramNames = paramList ? extractParamNames(paramList, ctx.source) : [];
+  ctx.insideFunctionBody++;
+  const bodyCode = body ? transformBody(body, ctx, skipFirstStatement, paramNames) : "";
+  ctx.insideFunctionBody--;
   const isGenerator = body ? containsYield(body) : false;
   let returnType = "";
   if (returnTypeDef) {
@@ -2964,7 +3141,10 @@ function transformClassMethod(node, ctx, decorator) {
   }
   const { jsdoc, skipFirstStatement } = body ? extractDocstringFromBody(body, ctx, indent) : { jsdoc: null, skipFirstStatement: false };
   const params = paramList ? transformMethodParamList(paramList, ctx) : "";
-  const bodyCode = body ? transformClassMethodBody(body, ctx, skipFirstStatement) : "";
+  const paramNames = paramList ? extractParamNames(paramList, ctx.source).filter((n) => n !== "self" && n !== "cls") : [];
+  ctx.insideFunctionBody++;
+  const bodyCode = body ? transformClassMethodBody(body, ctx, skipFirstStatement, paramNames) : "";
+  ctx.insideFunctionBody--;
   const isGenerator = body ? containsYield(body) : false;
   const generatorStar = isGenerator ? "*" : "";
   if (methodName === "__init__") {
@@ -3125,8 +3305,12 @@ function transformMethodParamListImpl(node, ctx, includeTypes) {
   }
   return params.join(", ");
 }
-function transformClassMethodBody(node, ctx, skipFirst = false) {
+function transformClassMethodBody(node, ctx, skipFirst = false, predeclaredVars = []) {
   ctx.indentLevel++;
+  pushScope(ctx);
+  for (const v of predeclaredVars) {
+    declareVariable(ctx, v);
+  }
   const children = getChildren(node);
   const indent = "  ".repeat(ctx.indentLevel);
   let filteredChildren = children.filter((child) => child.name !== ":");
@@ -3152,6 +3336,7 @@ function transformClassMethodBody(node, ctx, skipFirst = false) {
     }
     return indent + transformed;
   }).filter((s) => s.trim() !== "");
+  popScope(ctx);
   ctx.indentLevel--;
   return statements.join("\n");
 }
@@ -3259,12 +3444,15 @@ function transformDecoratedStatement(node, ctx) {
     }
   }
   const params = paramList ? transformParamList(paramList, ctx) : "";
+  const paramNames = paramList ? extractParamNames(paramList, ctx.source) : [];
   if (decorators.length === 1 && decorators[0]?.name === "overload") {
     const returnType = extractMethodReturnType(funcDef, ctx);
     const returnTypeStr = returnType ? `: ${returnType === "null" ? "void" : returnType}` : "";
     return `function ${funcName}(${params})${returnTypeStr}`;
   }
-  const bodyCode = body ? transformBody(body, ctx) : "";
+  ctx.insideFunctionBody++;
+  const bodyCode = body ? transformBody(body, ctx, false, paramNames) : "";
+  ctx.insideFunctionBody--;
   let funcExpr = `function ${funcName}(${params}) {
 ${bodyCode}
 }`;
@@ -3821,16 +4009,50 @@ ${classDecl}` : classDecl;
 function transformParamList(node, ctx) {
   const children = getChildren(node);
   const params = [];
+  const kwOnlyParams = [];
   let restParam = null;
   let kwargsParam = null;
+  let inKeywordOnly = false;
   let i = 0;
+  const parseParam = (startIndex) => {
+    const child = children[startIndex];
+    if (!child || 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") {
+      tsType = extractTypeAnnotation(nextChild, ctx);
+      offset = 2;
+    }
+    const afterType = children[startIndex + offset];
+    if (afterType && afterType.name === "AssignOp") {
+      const defaultValChild = children[startIndex + offset + 1];
+      if (defaultValChild) {
+        defaultValue = transformNode(defaultValChild, ctx);
+        offset += 2;
+      }
+    }
+    return {
+      param: { name: nameCode, type: tsType, defaultValue },
+      consumed: offset
+    };
+  };
+  const formatParam = (p) => {
+    const typeAnnotation = p.type ? `: ${p.type}` : "";
+    if (p.defaultValue !== null) {
+      return `${p.name}${typeAnnotation} = ${p.defaultValue}`;
+    }
+    return `${p.name}${typeAnnotation}`;
+  };
   while (i < children.length) {
     const child = children[i];
     if (!child) {
       i++;
       continue;
     }
-    if (child.name === "(" || child.name === ")" || child.name === ",") {
+    if (child.name === "(" || child.name === ")" || child.name === "," || child.name === "/") {
       i++;
       continue;
     }
@@ -3847,16 +4069,17 @@ function transformParamList(node, ctx) {
           restParam = `...${name}`;
           i += 2;
         }
+        inKeywordOnly = true;
         continue;
       }
+      inKeywordOnly = true;
       i++;
       continue;
     }
     if (child.name === "**" || getNodeText(child, ctx.source) === "**") {
       const nextChild = children[i + 1];
       if (nextChild && nextChild.name === "VariableName") {
-        const name = getNodeText(nextChild, ctx.source);
-        kwargsParam = name;
+        kwargsParam = getNodeText(nextChild, ctx.source);
         i += 2;
         continue;
       }
@@ -3864,30 +4087,16 @@ function transformParamList(node, ctx) {
       continue;
     }
     if (child.name === "VariableName") {
-      const nameCode = getNodeText(child, ctx.source);
-      let typeAnnotation = "";
-      let offset = 1;
-      const nextChild = children[i + 1];
-      if (nextChild && nextChild.name === "TypeDef") {
-        const tsType = extractTypeAnnotation(nextChild, ctx);
-        if (tsType) {
-          typeAnnotation = `: ${tsType}`;
-        }
-        offset = 2;
-      }
-      const afterType = children[i + offset];
-      if (afterType && afterType.name === "AssignOp") {
-        const defaultValChild = children[i + offset + 1];
-        if (defaultValChild) {
-          const defaultCode = transformNode(defaultValChild, ctx);
-          params.push(`${nameCode}${typeAnnotation} = ${defaultCode}`);
-          i += offset + 2;
-          continue;
+      const result = parseParam(i);
+      if (result) {
+        if (inKeywordOnly) {
+          kwOnlyParams.push(result.param);
+        } else {
+          params.push(formatParam(result.param));
         }
+        i += result.consumed;
+        continue;
       }
-      params.push(`${nameCode}${typeAnnotation}`);
-      i += offset;
-      continue;
     }
     if (child.name === "AssignParam" || child.name === "DefaultParam") {
       const paramChildren = getChildren(child);
@@ -3897,12 +4106,15 @@ function transformParamList(node, ctx) {
       if (name) {
         const nameCode = getNodeText(name, ctx.source);
         const tsType = extractTypeAnnotation(typeDef, ctx);
-        const typeAnnotation = tsType ? `: ${tsType}` : "";
+        let defaultValue = null;
         if (defaultVal && name !== defaultVal && defaultVal.name !== "TypeDef") {
-          const defaultCode = transformNode(defaultVal, ctx);
-          params.push(`${nameCode}${typeAnnotation} = ${defaultCode}`);
+          defaultValue = transformNode(defaultVal, ctx);
+        }
+        const param = { name: nameCode, type: tsType, defaultValue };
+        if (inKeywordOnly) {
+          kwOnlyParams.push(param);
         } else {
-          params.push(`${nameCode}${typeAnnotation}`);
+          params.push(formatParam(param));
         }
       }
       i++;
@@ -3910,7 +4122,25 @@ function transformParamList(node, ctx) {
     }
     i++;
   }
-  if (kwargsParam && !restParam) {
+  if (kwOnlyParams.length > 0) {
+    const destructuredNames = [];
+    const typeProps = [];
+    const defaults = [];
+    for (const p of kwOnlyParams) {
+      destructuredNames.push(p.name);
+      const propType = p.type ?? "unknown";
+      typeProps.push(`${p.name}?: ${propType}`);
+      if (p.defaultValue !== null) {
+        defaults.push(`${p.name} = ${p.defaultValue}`);
+      } else {
+        defaults.push(p.name);
+      }
+    }
+    const destructure = `{ ${defaults.join(", ")} }`;
+    const typeAnnotation = `{ ${typeProps.join("; ")} }`;
+    params.push(`${destructure}: ${typeAnnotation} = {}`);
+  }
+  if (kwargsParam) {
     const kwargsType = ": Record<string, unknown>";
     params.push(`${kwargsParam}${kwargsType} = {}`);
   }
@@ -4051,15 +4281,29 @@ function transformDictComprehension(node, ctx) {
       continue;
     }
     if (item.name === "for" || item.name === "Keyword" && getNodeText(item, ctx.source) === "for") {
-      const varNode = clauseItems[i + 1];
-      const iterableNode = clauseItems[i + 3];
-      if (varNode && iterableNode) {
+      const variables = [];
+      let j = i + 1;
+      while (j < clauseItems.length) {
+        const currentItem = clauseItems[j];
+        if (currentItem?.name === "in" || currentItem && getNodeText(currentItem, ctx.source) === "in") {
+          break;
+        }
+        const varItem = clauseItems[j];
+        if (varItem && varItem.name !== ",") {
+          variables.push(transformNode(varItem, ctx));
+        }
+        j++;
+      }
+      const iterableNode = clauseItems[j + 1];
+      const firstVariable = variables[0];
+      if (variables.length > 0 && iterableNode && firstVariable) {
+        const variable = variables.length === 1 ? firstVariable : `[${variables.join(", ")}]`;
         clauses.push({
           type: "for",
-          variable: transformNode(varNode, ctx),
+          variable,
           iterable: transformNode(iterableNode, ctx)
         });
-        i += 4;
+        i = j + 2;
       } else {
         i++;
       }
@@ -4291,6 +4535,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"
@@ -4371,6 +4620,10 @@ function generate(input, options = {}) {
     runtimeImport = buildRuntimeImports(usedRuntimeFunctions, basePath);
   }
   let code = result.code;
+  if (result.hoistedImports.length > 0) {
+    const hoistedCode = result.hoistedImports.join("\n");
+    code = hoistedCode + "\n\n" + code;
+  }
   if (runtimeImport) {
     code = runtimeImport + "\n\n" + code;
   }
@@ -4431,9 +4684,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;
   }
@@ -4479,4 +4804,4 @@ 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-VYG6GDWU.js.map
+//# sourceMappingURL=chunk-MEHQCUVO.js.map