python2ts 1.4.2 → 1.4.3

package/dist/{chunk-5VZP7MNR.js → chunk-E5LEIMJI.js}

@@ -314,15 +314,12 @@ var JS_RESERVED_KEYWORDS = /* @__PURE__ */ new Set([
   "async",
   "await",
   "declare",
-  "from",
-  "get",
   "is",
   "module",
   "namespace",
-  "of",
   "require",
-  "set",
   "type"
+  // Note: 'get', 'set', 'from', 'of' are contextual keywords and valid as identifiers
 ]);
 function escapeReservedKeyword(name) {
   return JS_RESERVED_KEYWORDS.has(name) ? `_${name}` : name;
@@ -336,6 +333,7 @@ function createContext(source) {
     // Start with one global scope
     definedClasses: /* @__PURE__ */ new Set(),
     insideFunctionBody: 0,
+    insideTryBlock: 0,
     hoistedImports: []
   };
 }
@@ -1022,7 +1020,7 @@ function transformAssignStatement(node, ctx) {
       }
       return `${targetCode} = ${valueCode}`;
     } else {
-      const valuesCodes = values.map((v) => transformNode(v, ctx));
+      const valuesCodes = transformValuesWithSpread(values, ctx);
       if (needsDeclaration) {
         return `${declarationKeyword} ${targetCode}${typeAnnotation} = [${valuesCodes.join(", ")}]`;
       }
@@ -1044,10 +1042,32 @@ function transformAssignStatement(node, ctx) {
     const valueCode = transformNode(value, ctx);
     return allDeclaredAtAccessibleScope ? `${targetPattern} = ${valueCode}` : `let ${targetPattern} = ${valueCode}`;
   } else {
-    const valuesCodes = values.map((v) => transformNode(v, ctx));
+    const valuesCodes = transformValuesWithSpread(values, ctx);
     return allDeclaredAtAccessibleScope ? `${targetPattern} = [${valuesCodes.join(", ")}]` : `let ${targetPattern} = [${valuesCodes.join(", ")}]`;
   }
 }
+function transformValuesWithSpread(values, ctx) {
+  const result = [];
+  let i = 0;
+  while (i < values.length) {
+    const value = values[i];
+    if (!value) {
+      i++;
+      continue;
+    }
+    if (value.name === "*" || getNodeText(value, ctx.source) === "*") {
+      const nextValue = values[i + 1];
+      if (nextValue) {
+        result.push(`...${transformNode(nextValue, ctx)}`);
+        i += 2;
+        continue;
+      }
+    }
+    result.push(transformNode(value, ctx));
+    i++;
+  }
+  return result;
+}
 function extractVariableNames(nodes, source) {
   const names = [];
   for (const node of nodes) {
@@ -1095,46 +1115,80 @@ function transformSliceAssignment(target, values, ctx) {
   const bracketEnd = children.findIndex((c) => c.name === "]");
   if (bracketStart === -1 || bracketEnd === -1) return `/* slice assignment error */`;
   const sliceParts = children.slice(bracketStart + 1, bracketEnd);
-  let start;
-  let end;
-  let step;
+  const hasComma = sliceParts.some((p) => p.name === ",");
+  const firstValue = values[0];
+  const valuesCode = values.length === 1 && firstValue ? transformNode(firstValue, ctx) : `[${values.map((v) => transformNode(v, ctx)).join(", ")}]`;
+  if (hasComma) {
+    const dimensions = [];
+    let currentDim = [];
+    for (const part of sliceParts) {
+      if (part.name === ",") {
+        dimensions.push(currentDim);
+        currentDim = [];
+      } else {
+        currentDim.push(part);
+      }
+    }
+    dimensions.push(currentDim);
+    const dimCodes = dimensions.map((dim) => {
+      const hasColon = dim.some((p) => p.name === ":");
+      if (hasColon) {
+        const { start: start2, end: end2, step: step2 } = parseSliceDimension(dim, ctx);
+        return `ndarray.slice(${start2 ?? "undefined"}, ${end2 ?? "undefined"}${step2 ? `, ${step2}` : ""})`;
+      } else {
+        const indexParts = dim.filter((p) => p.name !== ":" && p.name !== ",");
+        if (indexParts.length > 0 && indexParts[0]) {
+          return transformNode(indexParts[0], ctx);
+        }
+        return "undefined";
+      }
+    });
+    ctx.usesRuntime.add("ndarray.set");
+    return `ndarray.set(${objCode}, [${dimCodes.join(", ")}], ${valuesCode})`;
+  }
+  const { start, end, step } = parseSliceDimension(sliceParts, ctx);
+  ctx.usesRuntime.add("list.sliceAssign");
+  return `list.sliceAssign(${objCode}, ${start ?? "undefined"}, ${end ?? "undefined"}, ${step ?? "undefined"}, ${valuesCode})`;
+}
+function parseSliceDimension(parts, ctx) {
   const colonIndices = [];
-  for (let i = 0; i < sliceParts.length; i++) {
-    if (sliceParts[i]?.name === ":") {
+  for (let i = 0; i < parts.length; i++) {
+    if (parts[i]?.name === ":") {
       colonIndices.push(i);
     }
   }
-  if (colonIndices.length >= 1) {
-    const beforeFirst = sliceParts.slice(0, colonIndices[0]);
-    if (beforeFirst.length > 0 && beforeFirst[0]?.name !== ":") {
-      start = beforeFirst.map((n) => transformNode(n, ctx)).join("");
+  if (colonIndices.length === 0) {
+    return {};
+  }
+  let start;
+  let end;
+  let step;
+  const firstColon = colonIndices[0] ?? 0;
+  const beforeFirst = parts.slice(0, firstColon);
+  if (beforeFirst.length > 0 && beforeFirst[0]?.name !== ":") {
+    start = beforeFirst.map((n) => transformNode(n, ctx)).join("");
+  }
+  const secondColon = colonIndices[1];
+  if (colonIndices.length === 1) {
+    const afterFirst = parts.slice(firstColon + 1);
+    if (afterFirst.length > 0) {
+      end = afterFirst.map((n) => transformNode(n, ctx)).join("");
     }
-    const firstColon = colonIndices[0] ?? 0;
-    const secondColon = colonIndices[1];
-    if (colonIndices.length === 1) {
-      const afterFirst = sliceParts.slice(firstColon + 1);
-      if (afterFirst.length > 0) {
-        end = afterFirst.map((n) => transformNode(n, ctx)).join("");
-      }
-    } else if (secondColon !== void 0) {
-      const betweenColons = sliceParts.slice(firstColon + 1, secondColon);
-      if (betweenColons.length > 0) {
-        end = betweenColons.map((n) => transformNode(n, ctx)).join("");
-      }
-      const afterSecond = sliceParts.slice(secondColon + 1);
-      if (afterSecond.length > 0) {
-        step = afterSecond.map((n) => transformNode(n, ctx)).join("");
-      }
+  } else if (secondColon !== void 0) {
+    const betweenColons = parts.slice(firstColon + 1, secondColon);
+    if (betweenColons.length > 0) {
+      end = betweenColons.map((n) => transformNode(n, ctx)).join("");
+    }
+    const afterSecond = parts.slice(secondColon + 1);
+    if (afterSecond.length > 0) {
+      step = afterSecond.map((n) => transformNode(n, ctx)).join("");
     }
   }
-  const firstValue = values[0];
-  const valuesCode = values.length === 1 && firstValue ? transformNode(firstValue, ctx) : `[${values.map((v) => transformNode(v, ctx)).join(", ")}]`;
-  ctx.usesRuntime.add("list.sliceAssign");
-  return `list.sliceAssign(${objCode}, ${start ?? "undefined"}, ${end ?? "undefined"}, ${step ?? "undefined"}, ${valuesCode})`;
+  return { start, end, step };
 }
 function transformAssignTarget(node, ctx) {
   if (node.name === "VariableName") {
-    return getNodeText(node, ctx.source);
+    return escapeReservedKeyword(getNodeText(node, ctx.source));
   } else if (node.name === "TupleExpression") {
     const children = getChildren(node);
     const elements = children.filter((c) => c.name !== "(" && c.name !== ")" && c.name !== ",");
@@ -1149,6 +1203,20 @@ function transformBinaryExpression(node, ctx) {
   const op = children[1];
   if (!left || !op) return getNodeText(node, ctx.source);
   const opText = getNodeText(op, ctx.source);
+  if ((opText === "-" || opText === "+") && left.name === "MemberExpression") {
+    const memberChildren = getChildren(left);
+    const numNode = memberChildren.find((c) => c.name === "Number");
+    const propNode = memberChildren.find((c) => c.name === "PropertyName");
+    const right2 = children[2];
+    if (numNode && propNode && right2?.name === "Number") {
+      const propName = getNodeText(propNode, ctx.source).toLowerCase();
+      if (propName === "e") {
+        const numText = getNodeText(numNode, ctx.source);
+        const expText = getNodeText(right2, ctx.source);
+        return `${numText}e${opText}${expText}`;
+      }
+    }
+  }
   if ((opText === "is" || opText === "not") && children.length >= 4) {
     const secondOp = children[2];
     const secondOpText = secondOp ? getNodeText(secondOp, ctx.source) : "";
@@ -1281,7 +1349,9 @@ function transformNamedExpression(node, ctx) {
 }
 function transformConditionalExpression(node, ctx) {
   const children = getChildren(node);
-  const exprs = children.filter((c) => c.name !== "if" && c.name !== "else" && c.name !== "Keyword");
+  const exprs = children.filter(
+    (c) => c.name !== "if" && c.name !== "else" && c.name !== "Keyword" && c.name !== "Comment"
+  );
   if (exprs.length >= 3) {
     const trueExpr = exprs[0];
     const condition = exprs[1];
@@ -1301,12 +1371,36 @@ function transformNumber(node, ctx) {
 }
 function transformString(node, ctx) {
   const text = getNodeText(node, ctx.source);
+  if (text.startsWith('b"') || text.startsWith("b'")) {
+    return text.slice(1);
+  }
+  if (text.startsWith('B"') || text.startsWith("B'")) {
+    return text.slice(1);
+  }
+  if (text.startsWith('br"') || text.startsWith("br'") || text.startsWith('rb"') || text.startsWith("rb'")) {
+    return text.slice(2);
+  }
+  if (text.startsWith('BR"') || text.startsWith("BR'") || text.startsWith('RB"') || text.startsWith("RB'")) {
+    return text.slice(2);
+  }
+  if (text.startsWith('Br"') || text.startsWith("Br'") || text.startsWith('rB"') || text.startsWith("rB'")) {
+    return text.slice(2);
+  }
+  if (text.startsWith('bR"') || text.startsWith("bR'") || text.startsWith('Rb"') || text.startsWith("Rb'")) {
+    return text.slice(2);
+  }
   if (text.startsWith('r"') || text.startsWith("r'")) {
     return text.slice(1);
   }
   if (text.startsWith('R"') || text.startsWith("R'")) {
     return text.slice(1);
   }
+  if (text.startsWith('u"') || text.startsWith("u'")) {
+    return text.slice(1);
+  }
+  if (text.startsWith('U"') || text.startsWith("U'")) {
+    return text.slice(1);
+  }
   if (text.startsWith('"""') || text.startsWith("'''")) {
     const content = text.slice(3, -3);
     return "`" + content.replace(/`/g, "\\`") + "`";
@@ -1337,18 +1431,22 @@ function transformFormatString(node, ctx) {
     let expr;
     let formatSpec;
     let conversion;
+    let selfDoc = false;
     for (const child of replChildren) {
       if (child.name === "{" || child.name === "}") continue;
       if (child.name === "FormatSpec") {
         formatSpec = getNodeText(child, ctx.source).slice(1);
       } else if (child.name === "FormatConversion") {
         conversion = getNodeText(child, ctx.source).slice(1);
+      } else if (child.name === "FormatSelfDoc") {
+        selfDoc = true;
       } else {
         expr = child;
       }
     }
     if (expr) {
       let exprCode = transformNode(expr, ctx);
+      const exprText = getNodeText(expr, ctx.source);
       if (conversion === "r") {
         exprCode = `repr(${exprCode})`;
         ctx.usesRuntime.add("repr");
@@ -1361,7 +1459,13 @@ function transformFormatString(node, ctx) {
       }
       if (formatSpec) {
         ctx.usesRuntime.add("format");
-        result += `\${format(${exprCode}, "${formatSpec}")}`;
+        if (selfDoc) {
+          result += `${exprText}=\${format(${exprCode}, "${formatSpec}")}`;
+        } else {
+          result += `\${format(${exprCode}, "${formatSpec}")}`;
+        }
+      } else if (selfDoc) {
+        result += `${exprText}=\${${exprCode}}`;
       } else {
         result += `\${${exprCode}}`;
       }
@@ -2110,12 +2214,16 @@ function transformMethodCall(callee, args, ctx) {
       ctx.usesRuntime.add("set");
       return `set.issuperset(${objCode}, ${args})`;
     // Hash object methods (hashlib) - async
+    // Skip if objCode is 'self' or 'this' - user-defined class, not a Hash object
     case "digest":
+      if (objCode === "self" || objCode === "this") return null;
       return `await ${objCode}.digest()`;
     case "hexdigest":
+      if (objCode === "self" || objCode === "this") return null;
       return `await ${objCode}.hexdigest()`;
     // Path object methods (pathlib) - async
     // Only handle snake_case methods that are unique to Path
+    // Skip if objCode is 'self' or 'this' - user-defined class, not a Path object
     case "is_file":
     case "is_dir":
     case "is_symlink":
@@ -2126,6 +2234,9 @@ function transformMethodCall(callee, args, ctx) {
     case "symlink_to":
     case "link_to":
     case "iterdir": {
+      if (objCode === "self" || objCode === "this") {
+        return null;
+      }
       const jsMethod = toJsName(methodName);
       return `await ${objCode}.${jsMethod}(${args})`;
     }
@@ -2136,7 +2247,9 @@ function transformMethodCall(callee, args, ctx) {
 }
 function transformArgList(node, ctx) {
   const children = getChildren(node);
-  const items = children.filter((c) => c.name !== "(" && c.name !== ")" && c.name !== "ArgList");
+  const items = children.filter(
+    (c) => c.name !== "(" && c.name !== ")" && c.name !== "ArgList" && c.name !== "Comment"
+  );
   const hasForKeyword = items.some(
     (c) => c.name === "for" || c.name === "Keyword" && getNodeText(c, ctx.source) === "for"
   );
@@ -2291,14 +2404,42 @@ function transformSliceFromMember(obj, children, ctx) {
     return `slice(${objCode})`;
   }
   const sliceElements = children.slice(bracketStart + 1, bracketEnd);
+  const hasComma = sliceElements.some((el) => el.name === ",");
+  if (hasComma) {
+    const dimensions = [];
+    let currentDim = [];
+    for (const el of sliceElements) {
+      if (el.name === ",") {
+        dimensions.push(currentDim);
+        currentDim = [];
+      } else {
+        currentDim.push(el);
+      }
+    }
+    dimensions.push(currentDim);
+    const dimSlices = dimensions.map((dimElements) => {
+      return parseSliceDimensionForSubscript(dimElements, ctx);
+    });
+    return `slice(${objCode}, ${dimSlices.join(", ")})`;
+  }
+  const parts = parseSliceParts(sliceElements, ctx);
+  return `slice(${objCode}, ${parts.join(", ")})`;
+}
+function parseSliceParts(elements, ctx) {
   const colonIndices = [];
-  sliceElements.forEach((el, i) => {
+  elements.forEach((el, i) => {
     if (el.name === ":") colonIndices.push(i);
   });
+  if (colonIndices.length === 0) {
+    if (elements.length > 0 && elements[0]) {
+      return [transformNode(elements[0], ctx)];
+    }
+    return ["undefined"];
+  }
   const parts = [];
   let lastIdx = 0;
   for (const colonIdx of colonIndices) {
-    const beforeColon = sliceElements.slice(lastIdx, colonIdx);
+    const beforeColon = elements.slice(lastIdx, colonIdx);
     if (beforeColon.length > 0 && beforeColon[0]) {
       parts.push(transformNode(beforeColon[0], ctx));
     } else {
@@ -2306,27 +2447,52 @@ function transformSliceFromMember(obj, children, ctx) {
     }
     lastIdx = colonIdx + 1;
   }
-  const afterLastColon = sliceElements.slice(lastIdx);
+  const afterLastColon = elements.slice(lastIdx);
   if (afterLastColon.length > 0 && afterLastColon[0] && afterLastColon[0].name !== ":") {
     parts.push(transformNode(afterLastColon[0], ctx));
   } else if (colonIndices.length > 0) {
     parts.push("undefined");
   }
-  if (colonIndices.length === 0) {
-    return `slice(${objCode})`;
+  return parts;
+}
+function parseSliceDimensionForSubscript(elements, ctx) {
+  const parts = parseSliceParts(elements, ctx);
+  if (parts.length === 1) {
+    return parts[0] ?? "undefined";
   }
-  return `slice(${objCode}, ${parts.join(", ")})`;
+  return `[${parts.join(", ")}]`;
 }
 function transformArrayExpression(node, ctx) {
   const children = getChildren(node);
-  const elements = children.filter((c) => c.name !== "[" && c.name !== "]" && c.name !== ",");
-  const elementCodes = elements.map((el) => transformNode(el, ctx));
+  const elementCodes = [];
+  let i = 0;
+  while (i < children.length) {
+    const child = children[i];
+    if (!child) {
+      i++;
+      continue;
+    }
+    if (child.name === "[" || child.name === "]" || child.name === "," || child.name === "Comment") {
+      i++;
+      continue;
+    }
+    if (child.name === "*" || getNodeText(child, ctx.source) === "*") {
+      const nextChild = children[i + 1];
+      if (nextChild && nextChild.name !== "," && nextChild.name !== "]") {
+        elementCodes.push(`...${transformNode(nextChild, ctx)}`);
+        i += 2;
+        continue;
+      }
+    }
+    elementCodes.push(transformNode(child, ctx));
+    i++;
+  }
   return `[${elementCodes.join(", ")}]`;
 }
 function transformDictionaryExpression(node, ctx) {
   const children = getChildren(node);
   const items = children.filter(
-    (c) => c.name !== "{" && c.name !== "}" && c.name !== "," && c.name !== ":"
+    (c) => c.name !== "{" && c.name !== "}" && c.name !== "," && c.name !== ":" && c.name !== "Comment"
   );
   const keyNodes = [];
   for (let i = 0; i < items.length; i += 2) {
@@ -2376,7 +2542,7 @@ function transformTupleExpression(node, ctx) {
       i++;
       continue;
     }
-    if (child.name === "(" || child.name === ")" || child.name === ",") {
+    if (child.name === "(" || child.name === ")" || child.name === "," || child.name === "Comment") {
       i++;
       continue;
     }
@@ -2832,10 +2998,23 @@ function transformForStatement(node, ctx) {
   }
   let varCode;
   if (varNodes.length === 1 && varNodes[0]) {
-    varCode = transformNode(varNodes[0], ctx);
+    const singleVar = varNodes[0];
+    if (singleVar.name === "TupleExpression") {
+      varCode = transformForLoopVar(singleVar, ctx);
+    } else {
+      varCode = transformNode(singleVar, ctx);
+    }
   } else {
     varCode = "[" + varNodes.map((v) => transformForLoopVar(v, ctx)).join(", ") + "]";
   }
+  const forLoopVarNames = extractForLoopVarNames(varNodes, ctx.source);
+  for (const varName of forLoopVarNames) {
+    declareVariable(ctx, varName);
+    const escapedName = escapeReservedKeyword(varName);
+    if (escapedName !== varName) {
+      declareVariable(ctx, escapedName);
+    }
+  }
   let iterableCode = transformNode(iterableNode, ctx);
   const bodyCode = transformBody(bodyNode, ctx);
   if (iterableNode.name === "VariableName" && !isAsync) {
@@ -2849,7 +3028,7 @@ ${bodyCode}
 }
 function transformForLoopVar(node, ctx) {
   if (node.name === "VariableName") {
-    return getNodeText(node, ctx.source);
+    return escapeReservedKeyword(getNodeText(node, ctx.source));
   } else if (node.name === "TupleExpression") {
     const children = getChildren(node);
     const elements = children.filter((c) => c.name !== "(" && c.name !== ")" && c.name !== ",");
@@ -2857,6 +3036,19 @@ function transformForLoopVar(node, ctx) {
   }
   return transformNode(node, ctx);
 }
+function extractForLoopVarNames(varNodes, source) {
+  const names = [];
+  for (const node of varNodes) {
+    if (node.name === "VariableName") {
+      names.push(getNodeText(node, source));
+    } else if (node.name === "TupleExpression") {
+      const children = getChildren(node);
+      const elements = children.filter((c) => c.name !== "(" && c.name !== ")" && c.name !== ",");
+      names.push(...extractForLoopVarNames(elements, source));
+    }
+  }
+  return names;
+}
 function transformTryStatement(node, ctx) {
   const children = getChildren(node);
   const baseIndent = "  ".repeat(ctx.indentLevel);
@@ -2921,7 +3113,9 @@ function transformTryStatement(node, ctx) {
   if (!tryBody) {
     return getNodeText(node, ctx.source);
   }
+  ctx.insideTryBlock++;
   const tryCode = transformBody(tryBody, ctx);
+  ctx.insideTryBlock--;
   let result = `try {
 ${tryCode}
 ${baseIndent}}`;
@@ -3013,7 +3207,7 @@ function transformRaiseStatement(node, ctx) {
   const children = getChildren(node);
   const exprNode = children.find((c) => c.name !== "raise");
   if (!exprNode) {
-    return "throw";
+    return "throw e";
   }
   const expr = transformNode(exprNode, ctx);
   if (exprNode.name === "CallExpression") {
@@ -3068,6 +3262,13 @@ function isExceptionType(name) {
 function transformImportStatement(node, ctx) {
   const children = getChildren(node);
   const hasFrom = children.some((c) => c.name === "from");
+  if (ctx.insideTryBlock > 0) {
+    if (hasFrom) {
+      return transformFromImportDynamic(children, ctx);
+    } else {
+      return transformSimpleImportDynamic(children, ctx);
+    }
+  }
   let importCode;
   if (hasFrom) {
     importCode = transformFromImport(children, ctx);
@@ -3123,6 +3324,92 @@ function transformSimpleImport(children, ctx) {
     return `import * as ${importName} from "${module}"`;
   }).join("\n");
 }
+function transformSimpleImportDynamic(children, ctx) {
+  const names = [];
+  let i = 0;
+  while (i < children.length) {
+    const child = children[i];
+    if (!child) {
+      i++;
+      continue;
+    }
+    if (child.name === "import" || child.name === ",") {
+      i++;
+      continue;
+    }
+    if (child.name === "VariableName") {
+      const moduleName = getNodeText(child, ctx.source);
+      let alias = null;
+      const nextChild = children[i + 1];
+      if (nextChild?.name === "as") {
+        const aliasChild = children[i + 2];
+        if (aliasChild?.name === "VariableName") {
+          alias = getNodeText(aliasChild, ctx.source);
+          i += 3;
+          names.push({ module: moduleName, alias });
+          continue;
+        }
+      }
+      names.push({ module: moduleName, alias: null });
+      i++;
+      continue;
+    }
+    i++;
+  }
+  const filteredNames = names.filter(
+    ({ module }) => !RUNTIME_MODULES.has(module) && !TYPING_MODULES.has(module)
+  );
+  if (filteredNames.length === 0) {
+    return "";
+  }
+  return filteredNames.map(({ module, alias }) => {
+    const importName = alias ?? module;
+    return `const ${importName} = await import("${module}")`;
+  }).join("\n");
+}
+function transformFromImportDynamic(children, ctx) {
+  let moduleName = "";
+  for (const child of children) {
+    if (child.name === "VariableName") {
+      const prevChild = children[children.indexOf(child) - 1];
+      if (prevChild?.name === "from" || prevChild?.name === ".") {
+        moduleName = getNodeText(child, ctx.source);
+        break;
+      }
+    }
+  }
+  if (TYPING_MODULES.has(moduleName) || RUNTIME_MODULES.has(moduleName)) {
+    return "";
+  }
+  const importedNames = [];
+  let afterImport = false;
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (!child) continue;
+    if (child.name === "import") {
+      afterImport = true;
+      continue;
+    }
+    if (afterImport && child.name === "VariableName") {
+      const name = getNodeText(child, ctx.source);
+      const nextChild = children[i + 1];
+      if (nextChild?.name === "as") {
+        const aliasChild = children[i + 2];
+        if (aliasChild?.name === "VariableName") {
+          importedNames.push({ name, alias: getNodeText(aliasChild, ctx.source) });
+          i += 2;
+          continue;
+        }
+      }
+      importedNames.push({ name, alias: null });
+    }
+  }
+  if (importedNames.length === 0) {
+    return "";
+  }
+  const bindings = importedNames.map(({ name, alias }) => alias ? `${name}: ${alias}` : name).join(", ");
+  return `const { ${bindings} } = await import("${moduleName}")`;
+}
 var TYPING_MODULES = /* @__PURE__ */ new Set([
   "typing",
   "typing_extensions",
@@ -3432,7 +3719,7 @@ function transformFunctionDefinition(node, ctx) {
     if (child.name === "async") {
       isAsync = true;
     } else if (child.name === "VariableName") {
-      funcName = getNodeText(child, ctx.source);
+      funcName = escapeReservedKeyword(getNodeText(child, ctx.source));
     } else if (child.name === "ParamList") {
       paramList = child;
     } else if (child.name === "Body") {
@@ -3507,7 +3794,8 @@ function transformClassDefinition(node, ctx) {
     if (firstParent === "Protocol") {
       return transformProtocol(className, parentClasses, body, ctx);
     }
-    if (firstParent === "ABC" || parentClasses.includes("ABC")) {
+    const isAbcClass = firstParent === "ABC" || firstParent === "abc.ABC" || parentClasses.includes("ABC") || parentClasses.includes("abc.ABC");
+    if (isAbcClass) {
       return transformAbstractClass(className, parentClasses, body, ctx, jsdoc);
     }
     const genericParams = extractGenericParams(parentClasses);
@@ -3564,6 +3852,10 @@ function transformClassBody(node, ctx, skipFirst = false) {
 function transformClassProperty(node, ctx, indent) {
   const children = getChildren(node);
   if (children.length < 2) return "";
+  const nodeText = getNodeText(node, ctx.source);
+  if (nodeText.includes(".__doc__")) {
+    return "";
+  }
   const assignOpIndex = children.findIndex((c) => c.name === "AssignOp" || c.name === "=");
   const typeDef = children.find((c) => c.name === "TypeDef");
   if (assignOpIndex === -1) {
@@ -3709,6 +4001,8 @@ function transformMethodParamListWithTypes(node, ctx) {
 function transformMethodParamListImpl(node, ctx, includeTypes) {
   const children = getChildren(node);
   const params = [];
+  let restParam = null;
+  let kwargsParam = null;
   let i = 0;
   let isFirstParam = true;
   while (i < children.length) {
@@ -3733,8 +4027,8 @@ function transformMethodParamListImpl(node, ctx, includeTypes) {
     if (child.name === "*" || getNodeText(child, ctx.source) === "*") {
       const nextChild = children[i + 1];
       if (nextChild?.name === "VariableName") {
-        const name = getNodeText(nextChild, ctx.source);
-        params.push(`...${name}`);
+        const name = escapeReservedKeyword(getNodeText(nextChild, ctx.source));
+        restParam = `...${name}`;
         i += 2;
         continue;
       }
@@ -3744,8 +4038,8 @@ function transformMethodParamListImpl(node, ctx, includeTypes) {
     if (child.name === "**" || getNodeText(child, ctx.source) === "**") {
       const nextChild = children[i + 1];
       if (nextChild?.name === "VariableName") {
-        const name = getNodeText(nextChild, ctx.source);
-        params.push(name);
+        const name = escapeReservedKeyword(getNodeText(nextChild, ctx.source));
+        kwargsParam = `${name}: Record<string, unknown> = {}`;
         i += 2;
         continue;
       }
@@ -3753,7 +4047,7 @@ function transformMethodParamListImpl(node, ctx, includeTypes) {
       continue;
     }
     if (child.name === "VariableName") {
-      const nameCode = getNodeText(child, ctx.source);
+      const nameCode = escapeReservedKeyword(getNodeText(child, ctx.source));
       let typeStr = "";
       let defaultStr = "";
       let consumed = 1;
@@ -3783,6 +4077,12 @@ function transformMethodParamListImpl(node, ctx, includeTypes) {
     }
     i++;
   }
+  if (kwargsParam) {
+    params.push(kwargsParam);
+  }
+  if (restParam) {
+    params.push(restParam);
+  }
   return params.join(", ");
 }
 function transformClassMethodBody(node, ctx, skipFirst = false, predeclaredVars = []) {
@@ -3955,7 +4255,7 @@ function transformDecoratedStatement(node, ctx) {
   let body = null;
   for (const child of funcChildren) {
     if (child.name === "VariableName") {
-      funcName = getNodeText(child, ctx.source);
+      funcName = escapeReservedKeyword(getNodeText(child, ctx.source));
     } else if (child.name === "ParamList") {
       paramList = child;
     } else if (child.name === "Body") {
@@ -4407,7 +4707,7 @@ ${members.join("\n")}
 }`;
 }
 function transformAbstractClass(className, parentClasses, body, ctx, jsdoc) {
-  const filteredParents = parentClasses.filter((p) => p !== "ABC");
+  const filteredParents = parentClasses.filter((p) => p !== "ABC" && p !== "abc.ABC");
   let classHeader = `abstract class ${className}`;
   const firstParent = filteredParents[0];
   if (firstParent) {
@@ -4759,9 +5059,9 @@ function parseComprehensionClauses(children, ctx) {
         let variable;
         const firstVarNode = varNodes[0];
         if (varNodes.length === 1 && firstVarNode) {
-          variable = transformNode(firstVarNode, ctx);
+          variable = transformForLoopVar(firstVarNode, ctx);
         } else {
-          variable = "[" + varNodes.map((v) => transformNode(v, ctx)).join(", ") + "]";
+          variable = "[" + varNodes.map((v) => transformForLoopVar(v, ctx)).join(", ") + "]";
         }
         clauses.push({
           type: "for",
@@ -4874,7 +5174,9 @@ function transformDictComprehension(node, ctx) {
 }
 function transformSetExpression(node, ctx) {
   const children = getChildren(node);
-  const elements = children.filter((c) => c.name !== "{" && c.name !== "}" && c.name !== ",");
+  const elements = children.filter(
+    (c) => c.name !== "{" && c.name !== "}" && c.name !== "," && c.name !== "Comment"
+  );
   ctx.usesRuntime.add("set");
   const elementCodes = elements.map((el) => transformNode(el, ctx));
   return `set([${elementCodes.join(", ")}])`;
@@ -5156,7 +5458,7 @@ var BUILTINS = /* @__PURE__ */ new Set([
   "input",
   "format"
 ]);
-var MODULE_NAMESPACES = /* @__PURE__ */ new Set(["string", "list", "dict", "set"]);
+var MODULE_NAMESPACES = /* @__PURE__ */ new Set(["string", "list", "dict", "set", "ndarray"]);
 function generate(input, options = {}) {
   const opts = { ...defaultOptions, ...options };
   const result = transform(input);
@@ -5345,7 +5647,6 @@ export {
 /* v8 ignore next -- defensive: checked exprs.length >= 3 above @preserve */
 /* v8 ignore next 4 -- defensive: items from parser are never null @preserve */
 /* v8 ignore next 3 -- defensive: subscript always has brackets @preserve */
-/* v8 ignore next 3 -- defensive: slice detection already checked for colons @preserve */
 /* v8 ignore next 2 -- del obj.attr edge case @preserve */
 /* v8 ignore next -- fallback for complex del targets @preserve */
 /* v8 ignore next -- bare yield statement @preserve */

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   transpileAsync
-} from "../chunk-5VZP7MNR.js";
+} from "../chunk-E5LEIMJI.js";
 
 // src/cli/index.ts
 import { parseArgs } from "util";

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Tree, SyntaxNode } from '@lezer/common';
+import { SyntaxNode, Tree } from '@lezer/common';
 
 interface ParseResult {
     tree: Tree;
@@ -82,6 +82,8 @@ interface TransformContext {
     isAbstractClass?: boolean;
     /** Depth counter for function bodies (0 = module level, 1+ = inside function) */
     insideFunctionBody: number;
+    /** Depth counter for try blocks (0 = not in try, 1+ = inside try block) */
+    insideTryBlock: number;
     /** Imports found inside function bodies that need to be hoisted to module level */
     hoistedImports: string[];
 }

package/dist/index.js

@@ -12,7 +12,7 @@ import {
   transpile,
   transpileAsync,
   walkTree
-} from "./chunk-5VZP7MNR.js";
+} from "./chunk-E5LEIMJI.js";
 export {
   debugTree,
   formatCode,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "python2ts",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "description": "AST-based Python to TypeScript transpiler. Convert Python code to clean, idiomatic TypeScript with full type preservation.",
   "homepage": "https://sebastian-software.github.io/python2ts/",
   "repository": {
@@ -53,7 +53,7 @@
     "eslint": "^9.39.2",
     "prettier": "^3.8.0",
     "typescript-eslint": "^8.53.1",
-    "pythonlib": "2.0.3"
+    "pythonlib": "2.0.4"
   },
   "devDependencies": {
     "tsup": "^8.5.1",