python2ts 1.2.0 → 1.3.0

package/dist/{chunk-MEHQCUVO.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;
@@ -412,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) {
@@ -422,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;
@@ -478,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("'''");
 }
@@ -561,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] ?? "";
@@ -589,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";
@@ -1043,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) {
@@ -1435,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})`;
@@ -1453,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})`;
@@ -1470,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") {
@@ -1518,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) {
@@ -1529,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) {
@@ -1687,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;
@@ -1734,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);
@@ -1998,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);
@@ -2049,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;
@@ -2276,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 "";
@@ -2397,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;
@@ -2435,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;
@@ -2453,7 +2676,7 @@ ${baseIndent}}`;
   if (exceptBodies.length > 0) {
     const firstExcept = exceptBodies[0];
     if (firstExcept) {
-      const catchVar = firstExcept.varName || "e";
+      const catchVar = firstExcept.varName ?? "e";
       let catchBody = transformBody(firstExcept.body, ctx);
       const isEmpty = !catchBody.trim();
       if (isEmpty) {
@@ -2477,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);
@@ -2532,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);
@@ -2622,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 });
@@ -2644,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");
 }
@@ -2720,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;
@@ -2746,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;
@@ -2757,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}"`;
     }
   }
@@ -2796,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 {
@@ -2871,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;
@@ -2881,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;
@@ -3252,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;
@@ -3263,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;
@@ -3606,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 "[]";
@@ -3614,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";
   }
@@ -3833,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++) {
@@ -3917,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}`);
         }
@@ -4016,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);
@@ -4058,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;
@@ -4078,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;
@@ -4804,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-MEHQCUVO.js.map

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   transpileAsync
-} from "../chunk-MEHQCUVO.js";
+} from "../chunk-LNOL3BMB.js";
 
 // src/cli/index.ts
 import { parseArgs } from "util";
@@ -113,4 +113,3 @@ main().catch((error) => {
   console.error(`Unexpected error: ${String(error)}`);
   process.exit(1);
 });
-//# sourceMappingURL=index.js.map

package/dist/index.js

@@ -12,7 +12,7 @@ import {
   transpile,
   transpileAsync,
   walkTree
-} from "./chunk-MEHQCUVO.js";
+} from "./chunk-LNOL3BMB.js";
 export {
   debugTree,
   formatCode,
@@ -28,4 +28,3 @@ export {
   transpileAsync,
   walkTree
 };
-//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "python2ts",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "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": "1.0.2"
+    "pythonlib": "2.0.0"
   },
   "devDependencies": {
     "tsup": "^8.5.1",