python2ts 0.1.0 → 0.2.1

package/dist/chunk-VYG6GDWU.js

@@ -0,0 +1,4482 @@
+// src/parser/index.ts
+import { parser } from "@lezer/python";
+function parse(source) {
+  const tree = parser.parse(source);
+  return { tree, source };
+}
+function getNodeText(node, source) {
+  return source.slice(node.from, node.to);
+}
+function getChildren(node) {
+  const children = [];
+  let child = node.firstChild;
+  while (child) {
+    children.push(child);
+    child = child.nextSibling;
+  }
+  return children;
+}
+function getChildByType(node, type) {
+  let child = node.firstChild;
+  while (child) {
+    if (child.name === type) {
+      return child;
+    }
+    child = child.nextSibling;
+  }
+  return null;
+}
+function getChildrenByType(node, type) {
+  const children = [];
+  let child = node.firstChild;
+  while (child) {
+    if (child.name === type) {
+      children.push(child);
+    }
+    child = child.nextSibling;
+  }
+  return children;
+}
+function walkTree(tree, callback) {
+  const cursor = tree.cursor();
+  do {
+    callback(cursor.node);
+  } while (cursor.next());
+}
+function debugTree(tree, source) {
+  const lines = [];
+  const cursor = tree.cursor();
+  let depth = 0;
+  do {
+    const indent = "  ".repeat(depth);
+    const text = source.slice(cursor.from, cursor.to).replace(/\n/g, "\\n");
+    const preview = text.length > 30 ? text.slice(0, 30) + "..." : text;
+    lines.push(`${indent}${cursor.name} [${String(cursor.from)}-${String(cursor.to)}] "${preview}"`);
+    if (cursor.firstChild()) {
+      depth++;
+    } else {
+      while (!cursor.nextSibling()) {
+        if (!cursor.parent()) break;
+        depth--;
+      }
+    }
+  } while (depth > 0 || cursor.nextSibling());
+  return lines.join("\n");
+}
+
+// src/transformer/name-mappings.ts
+var PYTHON_TO_JS_NAMES = {
+  // ============================================================================
+  // functools module
+  // ============================================================================
+  lru_cache: "lruCache",
+  cache_info: "cacheInfo",
+  cache_clear: "cacheClear",
+  partialmethod: "partialMethod",
+  singledispatch: "singleDispatch",
+  attrgetter: "attrGetter",
+  itemgetter: "itemGetter",
+  methodcaller: "methodCaller",
+  cmp_to_key: "cmpToKey",
+  total_ordering: "totalOrdering",
+  // ============================================================================
+  // itertools module
+  // ============================================================================
+  zip_longest: "zipLongest",
+  takewhile: "takeWhile",
+  dropwhile: "dropWhile",
+  filterfalse: "filterFalse",
+  combinations_with_replacement: "combinationsWithReplacement",
+  // ============================================================================
+  // collections module (deque methods)
+  // ============================================================================
+  appendleft: "appendLeft",
+  popleft: "popLeft",
+  extendleft: "extendLeft",
+  // ============================================================================
+  // datetime module
+  // ============================================================================
+  total_seconds: "totalSeconds",
+  fromtimestamp: "fromTimestamp",
+  fromisoformat: "fromIsoFormat",
+  fromordinal: "fromOrdinal",
+  toordinal: "toOrdinal",
+  isoweekday: "isoWeekday",
+  isocalendar: "isoCalendar",
+  isoformat: "isoFormat",
+  utcnow: "utcNow",
+  utcfromtimestamp: "utcFromTimestamp",
+  // ============================================================================
+  // random module
+  // ============================================================================
+  randint: "randInt",
+  randrange: "randRange",
+  betavariate: "betaVariate",
+  expovariate: "expoVariate",
+  gammavariate: "gammaVariate",
+  lognormvariate: "logNormVariate",
+  vonmisesvariate: "vonMisesVariate",
+  paretovariate: "paretoVariate",
+  weibullvariate: "weibullVariate",
+  normalvariate: "normalVariate",
+  // ============================================================================
+  // string module (constants)
+  // ============================================================================
+  ascii_lowercase: "asciiLowercase",
+  ascii_uppercase: "asciiUppercase",
+  ascii_letters: "asciiLetters",
+  hexdigits: "hexDigits",
+  octdigits: "octDigits",
+  // ============================================================================
+  // string module (methods)
+  // ============================================================================
+  safe_substitute: "safeSubstitute",
+  get_identifiers: "getIdentifiers",
+  capwords: "capWords",
+  startswith: "startsWith",
+  endswith: "endsWith",
+  isalpha: "isAlpha",
+  isdigit: "isDigit",
+  isalnum: "isAlnum",
+  isspace: "isSpace",
+  isupper: "isUpper",
+  islower: "isLower",
+  lstrip: "lStrip",
+  rstrip: "rStrip",
+  zfill: "zFill",
+  ljust: "lJust",
+  rjust: "rJust",
+  rpartition: "rPartition",
+  swapcase: "swapCase",
+  rfind: "rFind",
+  rindex: "rIndex",
+  rsplit: "rSplit",
+  // ============================================================================
+  // os module (constants)
+  // ============================================================================
+  altsep: "altSep",
+  pathsep: "pathSep",
+  linesep: "lineSep",
+  curdir: "curDir",
+  pardir: "parDir",
+  extsep: "extSep",
+  // ============================================================================
+  // os.path module
+  // ============================================================================
+  splitext: "splitExt",
+  extname: "extName",
+  isabs: "isAbs",
+  normpath: "normPath",
+  abspath: "absPath",
+  realpath: "realPath",
+  relpath: "relPath",
+  commonpath: "commonPath",
+  expanduser: "expandUser",
+  expandvars: "expandVars",
+  isfile: "isFile",
+  isdir: "isDir",
+  islink: "isLink",
+  getsize: "getSize",
+  getmtime: "getMtime",
+  getatime: "getAtime",
+  getctime: "getCtime",
+  // ============================================================================
+  // os module (functions)
+  // ============================================================================
+  getcwd: "getCwd",
+  getcwdb: "getCwdb",
+  listdir: "listDir",
+  makedirs: "makeDirs",
+  removedirs: "removeDirs",
+  // ============================================================================
+  // re module
+  // ============================================================================
+  groupdict: "groupDict",
+  groupindex: "groupIndex",
+  lastindex: "lastIndex",
+  lastgroup: "lastGroup",
+  fullmatch: "fullMatch",
+  findall: "findAll",
+  finditer: "findIter",
+  // ============================================================================
+  // dict module
+  // ============================================================================
+  setdefault: "setDefault",
+  popitem: "popItem",
+  fromkeys: "fromKeys",
+  // ============================================================================
+  // set module
+  // ============================================================================
+  issubset: "isSubset",
+  issuperset: "isSuperset",
+  isdisjoint: "isDisjoint",
+  // ============================================================================
+  // core module
+  // ============================================================================
+  floordiv: "floorDiv",
+  divmod: "divMod"
+};
+function toJsName(pythonName) {
+  return PYTHON_TO_JS_NAMES[pythonName] ?? pythonName;
+}
+
+// src/transformer/index.ts
+function createContext(source) {
+  return {
+    source,
+    indentLevel: 0,
+    usesRuntime: /* @__PURE__ */ new Set(),
+    scopeStack: [/* @__PURE__ */ new Set()],
+    // Start with one global scope
+    definedClasses: /* @__PURE__ */ new Set()
+  };
+}
+function pushScope(ctx) {
+  ctx.scopeStack.push(/* @__PURE__ */ new Set());
+}
+function popScope(ctx) {
+  if (ctx.scopeStack.length > 1) {
+    ctx.scopeStack.pop();
+  }
+}
+function isVariableDeclared(ctx, name) {
+  for (const scope of ctx.scopeStack) {
+    if (scope.has(name)) return true;
+  }
+  return false;
+}
+function declareVariable(ctx, name) {
+  const currentScope = ctx.scopeStack[ctx.scopeStack.length - 1];
+  if (currentScope) {
+    currentScope.add(name);
+  }
+}
+function containsYield(node) {
+  if (node.name === "YieldStatement" || node.name === "YieldExpression") {
+    return true;
+  }
+  if (node.name === "FunctionDefinition" || node.name === "LambdaExpression") {
+    return false;
+  }
+  for (const child of getChildren(node)) {
+    if (containsYield(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+var PYTHON_TO_TS_TYPES = {
+  str: "string",
+  int: "number",
+  float: "number",
+  bool: "boolean",
+  bytes: "Uint8Array",
+  None: "null",
+  Any: "any",
+  object: "object"
+};
+function transformPythonType(node, ctx) {
+  switch (node.name) {
+    case "VariableName": {
+      const typeName = getNodeText(node, ctx.source);
+      return PYTHON_TO_TS_TYPES[typeName] ?? typeName;
+    }
+    case "None":
+      return "null";
+    case "MemberExpression": {
+      const children = getChildren(node);
+      const baseType = children[0];
+      if (!baseType) return getNodeText(node, ctx.source);
+      const baseName = getNodeText(baseType, ctx.source);
+      const bracketStart = children.findIndex((c) => c.name === "[");
+      const bracketEnd = children.findIndex((c) => c.name === "]");
+      if (bracketStart === -1 || bracketEnd === -1) {
+        return PYTHON_TO_TS_TYPES[baseName] ?? baseName;
+      }
+      const rawTypeArgNodes = children.slice(bracketStart + 1, bracketEnd).filter((c) => c.name !== ",");
+      if (baseName === "Callable") {
+        return transformCallableType(rawTypeArgNodes, ctx);
+      }
+      const typeArgs = rawTypeArgNodes.map((c) => transformPythonType(c, ctx));
+      const first = typeArgs[0] ?? "unknown";
+      const second = typeArgs[1] ?? "unknown";
+      const last = typeArgs[typeArgs.length - 1] ?? "unknown";
+      switch (baseName) {
+        case "list":
+        case "List":
+          return typeArgs.length > 0 ? `${first}[]` : "unknown[]";
+        case "dict":
+        case "Dict":
+          return typeArgs.length >= 2 ? `Record<${first}, ${second}>` : "Record<string, unknown>";
+        case "set":
+        case "Set":
+          return typeArgs.length > 0 ? `Set<${first}>` : "Set<unknown>";
+        case "frozenset":
+        case "FrozenSet":
+          return typeArgs.length > 0 ? `ReadonlySet<${first}>` : "ReadonlySet<unknown>";
+        case "tuple":
+        case "Tuple":
+          return `[${typeArgs.join(", ")}]`;
+        case "Optional":
+          return typeArgs.length > 0 ? `${first} | null` : "unknown | null";
+        case "Union":
+          return typeArgs.join(" | ");
+        case "Final":
+          return typeArgs.length > 0 ? first : "unknown";
+        case "ClassVar":
+          return typeArgs.length > 0 ? first : "unknown";
+        // Callable is handled specially before the switch via transformCallableType
+        /* v8 ignore start -- rare typing module types @preserve */
+        case "Iterable":
+          return typeArgs.length > 0 ? `Iterable<${first}>` : "Iterable<unknown>";
+        case "Iterator":
+          return typeArgs.length > 0 ? `Iterator<${first}>` : "Iterator<unknown>";
+        case "Generator":
+          return typeArgs.length > 0 ? `Generator<${typeArgs.join(", ")}>` : "Generator<unknown>";
+        case "AsyncGenerator":
+          return typeArgs.length > 0 ? `AsyncGenerator<${typeArgs.join(", ")}>` : "AsyncGenerator<unknown>";
+        case "Awaitable":
+          return typeArgs.length > 0 ? `Promise<${first}>` : "Promise<unknown>";
+        case "Coroutine":
+          return typeArgs.length > 0 ? `Promise<${last}>` : "Promise<unknown>";
+        case "Type":
+          return typeArgs.length > 0 ? `new (...args: unknown[]) => ${first}` : "new (...args: unknown[]) => unknown";
+        /* v8 ignore stop */
+        /* v8 ignore start -- Literal type edge cases @preserve */
+        case "Literal": {
+          const literalValues = typeArgs.map((arg) => {
+            if (/^-?\d+(\.\d+)?$/.test(arg)) {
+              return arg;
+            }
+            if (arg.startsWith('"') || arg.startsWith("'")) {
+              return arg;
+            }
+            return `"${arg}"`;
+          });
+          return literalValues.join(" | ");
+        }
+        /* v8 ignore stop */
+        /* v8 ignore next 3 -- generic fallback for custom types @preserve */
+        default:
+          return typeArgs.length > 0 ? `${baseName}<${typeArgs.join(", ")}>` : baseName;
+      }
+    }
+    /* v8 ignore start -- rare type annotation patterns @preserve */
+    case "BinaryExpression": {
+      const children = getChildren(node);
+      const left = children[0];
+      const op = children[1];
+      const right = children[2];
+      if (op && getNodeText(op, ctx.source) === "|" && left && right) {
+        const leftType = transformPythonType(left, ctx);
+        const rightType = transformPythonType(right, ctx);
+        return `${leftType} | ${rightType}`;
+      }
+      return getNodeText(node, ctx.source);
+    }
+    case "String": {
+      const text = getNodeText(node, ctx.source);
+      return text.slice(1, -1);
+    }
+    case "TypeDef": {
+      const children = getChildren(node);
+      const typeNode = children.find((c) => c.name !== ":");
+      if (typeNode) {
+        return transformPythonType(typeNode, ctx);
+      }
+      return "unknown";
+    }
+    /* v8 ignore stop */
+    /* v8 ignore next 2 -- fallback for unhandled type nodes @preserve */
+    default:
+      return getNodeText(node, ctx.source);
+  }
+}
+function extractTypeAnnotation(typeDef, ctx) {
+  if (!typeDef || typeDef.name !== "TypeDef") return null;
+  const children = getChildren(typeDef);
+  const typeNode = children.find((c) => c.name !== ":" && c.name !== "->");
+  if (typeNode) {
+    return transformPythonType(typeNode, ctx);
+  }
+  return null;
+}
+function extractTypeModifiers(typeDef, ctx) {
+  const result = { isFinal: false, isClassVar: false };
+  if (!typeDef || typeDef.name !== "TypeDef") return result;
+  const children = getChildren(typeDef);
+  const typeNode = children.find((c) => c.name !== ":" && c.name !== "->");
+  if (!typeNode) return result;
+  if (typeNode.name === "MemberExpression") {
+    const typeChildren = getChildren(typeNode);
+    const baseType = typeChildren[0];
+    if (baseType) {
+      const baseName = getNodeText(baseType, ctx.source);
+      if (baseName === "Final") {
+        result.isFinal = true;
+      } else if (baseName === "ClassVar") {
+        result.isClassVar = true;
+      }
+    }
+  } else if (typeNode.name === "VariableName") {
+    const typeName = getNodeText(typeNode, ctx.source);
+    if (typeName === "Final") {
+      result.isFinal = true;
+    } else if (typeName === "ClassVar") {
+      result.isClassVar = true;
+    }
+  }
+  return result;
+}
+function transformCallableType(rawTypeArgNodes, ctx) {
+  if (rawTypeArgNodes.length < 2) {
+    return "(...args: unknown[]) => unknown";
+  }
+  const paramListNode = rawTypeArgNodes[0];
+  const returnTypeNode = rawTypeArgNodes[rawTypeArgNodes.length - 1];
+  let paramTypes = [];
+  if (paramListNode) {
+    const paramListChildren = getChildren(paramListNode);
+    const innerTypes = paramListChildren.filter(
+      (c) => c.name !== "[" && c.name !== "]" && c.name !== ","
+    );
+    if (innerTypes.length > 0) {
+      paramTypes = innerTypes.map((c) => transformPythonType(c, ctx));
+    }
+  }
+  const returnType = returnTypeNode ? transformPythonType(returnTypeNode, ctx) : "unknown";
+  if (paramListNode) {
+    const paramListChildren = getChildren(paramListNode);
+    const hasBrackets = paramListChildren.some((c) => c.name === "[" || c.name === "]");
+    if (hasBrackets) {
+      const params = paramTypes.map((t, i) => `arg${String(i)}: ${t}`).join(", ");
+      return `(${params}) => ${returnType}`;
+    }
+  }
+  return `(...args: unknown[]) => ${returnType}`;
+}
+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;
+  const text = getNodeText(firstChild, ctx.source);
+  return text.startsWith('"""') || text.startsWith("'''");
+}
+function extractDocstringContent(node, ctx) {
+  const children = getChildren(node);
+  const stringNode = children[0];
+  if (!stringNode) return "";
+  const text = getNodeText(stringNode, ctx.source);
+  let content = text;
+  if (content.startsWith('"""')) {
+    content = content.slice(3, -3);
+  } else if (content.startsWith("'''")) {
+    content = content.slice(3, -3);
+  }
+  content = content.replace(/\r\n/g, "\n").trim();
+  return content;
+}
+function parseDocstring(content) {
+  const result = {
+    description: "",
+    params: [],
+    returns: null,
+    throws: []
+  };
+  const lines = content.split("\n");
+  let currentSection = "description";
+  const descriptionLines = [];
+  let currentParamName = "";
+  let currentParamDesc = [];
+  let currentThrowsType = "";
+  let currentThrowsDesc = [];
+  const returnsLines = [];
+  const flushParam = () => {
+    if (currentParamName) {
+      result.params.push({
+        name: currentParamName,
+        description: currentParamDesc.join(" ").trim()
+      });
+      currentParamName = "";
+      currentParamDesc = [];
+    }
+  };
+  const flushThrows = () => {
+    if (currentThrowsType || currentThrowsDesc.length > 0) {
+      result.throws.push({
+        type: currentThrowsType || "Error",
+        description: currentThrowsDesc.join(" ").trim()
+      });
+      currentThrowsType = "";
+      currentThrowsDesc = [];
+    }
+  };
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^(Args|Arguments|Parameters):$/i.test(trimmed)) {
+      currentSection = "params";
+      continue;
+    }
+    if (/^(Returns?|Yields?):$/i.test(trimmed)) {
+      flushParam();
+      currentSection = "returns";
+      continue;
+    }
+    if (/^(Raises?|Throws?|Exceptions?):$/i.test(trimmed)) {
+      flushParam();
+      currentSection = "throws";
+      continue;
+    }
+    if (/^[A-Z][a-z]+:$/.test(trimmed)) {
+      continue;
+    }
+    switch (currentSection) {
+      case "description":
+        descriptionLines.push(trimmed);
+        break;
+      case "params": {
+        const googleMatch = trimmed.match(/^(\w+)\s*(?:\([^)]*\))?\s*:\s*(.*)$/);
+        if (googleMatch) {
+          flushParam();
+          currentParamName = googleMatch[1] ?? "";
+          const desc = googleMatch[2] ?? "";
+          if (desc) currentParamDesc.push(desc);
+        } else if (currentParamName && trimmed) {
+          currentParamDesc.push(trimmed);
+        }
+        break;
+      }
+      case "returns": {
+        const stripped = trimmed.replace(/^(?:\([^)]*\)|[^:]+):\s*/, "");
+        if (stripped || trimmed) {
+          returnsLines.push(stripped || trimmed);
+        }
+        break;
+      }
+      case "throws": {
+        const throwsMatch = trimmed.match(/^(\w+)\s*:\s*(.*)$/);
+        if (throwsMatch) {
+          flushThrows();
+          currentThrowsType = throwsMatch[1] ?? "Error";
+          const desc = throwsMatch[2] ?? "";
+          if (desc) currentThrowsDesc.push(desc);
+        } else if (trimmed) {
+          currentThrowsDesc.push(trimmed);
+        }
+        break;
+      }
+    }
+  }
+  flushParam();
+  flushThrows();
+  result.description = descriptionLines.join("\n").trim();
+  if (returnsLines.length > 0) {
+    result.returns = returnsLines.join(" ").trim();
+  }
+  return result;
+}
+function toJSDoc(parsed, indent) {
+  const lines = [];
+  lines.push(`${indent}/**`);
+  if (parsed.description) {
+    const descLines = parsed.description.split("\n");
+    for (const line of descLines) {
+      if (line.trim()) {
+        lines.push(`${indent} * ${line}`);
+      } else {
+        lines.push(`${indent} *`);
+      }
+    }
+  }
+  if (parsed.description && (parsed.params.length > 0 || parsed.returns || parsed.throws.length > 0)) {
+    lines.push(`${indent} *`);
+  }
+  for (const param of parsed.params) {
+    if (param.description) {
+      lines.push(`${indent} * @param ${param.name} - ${param.description}`);
+    } else {
+      lines.push(`${indent} * @param ${param.name}`);
+    }
+  }
+  if (parsed.returns) {
+    lines.push(`${indent} * @returns ${parsed.returns}`);
+  }
+  for (const t of parsed.throws) {
+    lines.push(`${indent} * @throws {${t.type}} ${t.description}`);
+  }
+  lines.push(`${indent} */`);
+  return lines.join("\n");
+}
+function extractDocstringFromBody(bodyNode, ctx, indent) {
+  const children = getChildren(bodyNode);
+  const statements = children.filter((c) => c.name !== ":");
+  const firstStatement = statements[0];
+  if (firstStatement && isDocstringNode(firstStatement, ctx)) {
+    const content = extractDocstringContent(firstStatement, ctx);
+    const parsed = parseDocstring(content);
+    const jsdoc = toJSDoc(parsed, indent);
+    return { jsdoc, skipFirstStatement: true };
+  }
+  return { jsdoc: null, skipFirstStatement: false };
+}
+function transform(input) {
+  const parseResult = typeof input === "string" ? parse(input) : input;
+  const ctx = createContext(parseResult.source);
+  const code = transformNode(parseResult.tree.topNode, ctx);
+  return {
+    code,
+    usesRuntime: ctx.usesRuntime
+  };
+}
+function transformNode(node, ctx) {
+  switch (node.name) {
+    case "Script":
+      return transformScript(node, ctx);
+    case "ExpressionStatement":
+      return transformExpressionStatement(node, ctx);
+    case "AssignStatement":
+      return transformAssignStatement(node, ctx);
+    case "BinaryExpression":
+      return transformBinaryExpression(node, ctx);
+    case "UnaryExpression":
+      return transformUnaryExpression(node, ctx);
+    case "ParenthesizedExpression":
+      return transformParenthesizedExpression(node, ctx);
+    case "NamedExpression":
+      return transformNamedExpression(node, ctx);
+    case "ConditionalExpression":
+      return transformConditionalExpression(node, ctx);
+    case "Number":
+      return transformNumber(node, ctx);
+    case "String":
+      return transformString(node, ctx);
+    case "FormatString":
+      return transformFormatString(node, ctx);
+    case "Boolean":
+      return transformBoolean(node, ctx);
+    case "None":
+      return "null";
+    case "VariableName":
+      return getNodeText(node, ctx.source);
+    case "CallExpression":
+      return transformCallExpression(node, ctx);
+    case "MemberExpression":
+      return transformMemberExpression(node, ctx);
+    case "ArrayExpression":
+      return transformArrayExpression(node, ctx);
+    case "ArrayComprehensionExpression":
+      return transformArrayComprehension(node, ctx);
+    case "DictionaryExpression":
+      return transformDictionaryExpression(node, ctx);
+    case "DictionaryComprehensionExpression":
+      return transformDictComprehension(node, ctx);
+    case "SetExpression":
+      return transformSetExpression(node, ctx);
+    case "SetComprehensionExpression":
+      return transformSetComprehension(node, ctx);
+    case "ComprehensionExpression":
+      return transformGeneratorExpression(node, ctx);
+    case "TupleExpression":
+      return transformTupleExpression(node, ctx);
+    case "IfStatement":
+      return transformIfStatement(node, ctx);
+    case "WhileStatement":
+      return transformWhileStatement(node, ctx);
+    case "ForStatement":
+      return transformForStatement(node, ctx);
+    case "PassStatement":
+      return "";
+    case "BreakStatement":
+      return "break";
+    case "ContinueStatement":
+      return "continue";
+    case "ReturnStatement":
+      return transformReturnStatement(node, ctx);
+    case "FunctionDefinition":
+      return transformFunctionDefinition(node, ctx);
+    case "ClassDefinition":
+      return transformClassDefinition(node, ctx);
+    case "DecoratedStatement":
+      return transformDecoratedStatement(node, ctx);
+    case "LambdaExpression":
+      return transformLambdaExpression(node, ctx);
+    case "Comment":
+      return transformComment(node, ctx);
+    case "TryStatement":
+      return transformTryStatement(node, ctx);
+    case "RaiseStatement":
+      return transformRaiseStatement(node, ctx);
+    case "ImportStatement":
+      return transformImportStatement(node, ctx);
+    case "AwaitExpression":
+      return transformAwaitExpression(node, ctx);
+    case "WithStatement":
+      return transformWithStatement(node, ctx);
+    case "MatchStatement":
+      return transformMatchStatement(node, ctx);
+    case "ScopeStatement":
+      return transformScopeStatement(node, ctx);
+    case "DeleteStatement":
+      return transformDeleteStatement(node, ctx);
+    case "AssertStatement":
+      return transformAssertStatement(node, ctx);
+    case "YieldStatement":
+      return transformYieldStatement(node, ctx);
+    /* v8 ignore next 2 -- fallback for unknown AST nodes @preserve */
+    default:
+      return getNodeText(node, ctx.source);
+  }
+}
+function transformScript(node, ctx) {
+  const children = getChildren(node);
+  const statements = children.filter((child) => child.name !== "Comment" || getNodeText(child, ctx.source).trim() !== "").map((child) => {
+    const transformed = transformNode(child, ctx);
+    if (transformed === "") {
+      return "";
+    }
+    if (child.name === "ExpressionStatement" || child.name === "AssignStatement" || child.name === "PassStatement" || child.name === "BreakStatement" || child.name === "ContinueStatement" || child.name === "ReturnStatement" || child.name === "RaiseStatement") {
+      return transformed + ";";
+    }
+    return transformed;
+  }).filter((s) => s.trim() !== "");
+  return statements.join("\n");
+}
+function transformExpressionStatement(node, ctx) {
+  const children = getChildren(node);
+  if (children.length === 0) return "";
+  const firstChild = children[0];
+  if (!firstChild) return "";
+  return transformNode(firstChild, ctx);
+}
+function transformAssignStatement(node, ctx) {
+  const children = getChildren(node);
+  if (children.length < 3) return getNodeText(node, ctx.source);
+  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 values = children.slice(assignOpIndex + 1).filter((c) => c.name !== ",");
+  if (targets.length === 0 || values.length === 0) {
+    return getNodeText(node, ctx.source);
+  }
+  if (values.length === 1 && values[0]?.name === "CallExpression") {
+    const callChildren = getChildren(values[0]);
+    const funcNode = callChildren.find((c) => c.name === "VariableName");
+    if (funcNode && getNodeText(funcNode, ctx.source) === "TypeVar") {
+      return "";
+    }
+  }
+  if (typeDef && targets.length === 1 && values.length === 1) {
+    const typeDefText = getNodeText(typeDef, ctx.source);
+    const target = targets[0];
+    const value = values[0];
+    if (typeDefText.includes("TypeAlias") && target && value) {
+      const aliasName = getNodeText(target, ctx.source);
+      const aliasType = transformPythonType(value, ctx);
+      return `type ${aliasName} = ${aliasType}`;
+    }
+  }
+  if (targets.length === 1) {
+    const target = targets[0];
+    if (!target) return getNodeText(node, ctx.source);
+    if (target.name === "MemberExpression" && isSliceExpression(target)) {
+      return transformSliceAssignment(target, values, ctx);
+    }
+    const targetCode = transformNode(target, ctx);
+    const tsType = extractTypeAnnotation(typeDef, ctx);
+    const typeAnnotation = tsType ? `: ${tsType}` : "";
+    const modifiers = extractTypeModifiers(typeDef, ctx);
+    let needsDeclaration = false;
+    if (target.name === "VariableName") {
+      const varName = getNodeText(target, ctx.source);
+      if (!isVariableDeclared(ctx, varName)) {
+        needsDeclaration = true;
+        declareVariable(ctx, varName);
+      }
+    }
+    const declarationKeyword = modifiers.isFinal ? "const" : "let";
+    if (values.length === 1) {
+      const value = values[0];
+      if (!value) return getNodeText(node, ctx.source);
+      const valueCode = transformNode(value, ctx);
+      if (needsDeclaration) {
+        return `${declarationKeyword} ${targetCode}${typeAnnotation} = ${valueCode}`;
+      }
+      return `${targetCode} = ${valueCode}`;
+    } else {
+      const valuesCodes = values.map((v) => transformNode(v, ctx));
+      if (needsDeclaration) {
+        return `${declarationKeyword} ${targetCode}${typeAnnotation} = [${valuesCodes.join(", ")}]`;
+      }
+      return `${targetCode} = [${valuesCodes.join(", ")}]`;
+    }
+  }
+  const targetCodes = targets.map((t) => transformAssignTarget(t, ctx));
+  const targetPattern = `[${targetCodes.join(", ")}]`;
+  const varNames = extractVariableNames(targets, ctx.source);
+  const allDeclaredAtAccessibleScope = varNames.every((v) => isVariableDeclared(ctx, v));
+  if (!allDeclaredAtAccessibleScope) {
+    varNames.forEach((v) => {
+      declareVariable(ctx, v);
+    });
+  }
+  if (values.length === 1) {
+    const value = values[0];
+    if (!value) return getNodeText(node, ctx.source);
+    const valueCode = transformNode(value, ctx);
+    return allDeclaredAtAccessibleScope ? `${targetPattern} = ${valueCode}` : `let ${targetPattern} = ${valueCode}`;
+  } else {
+    const valuesCodes = values.map((v) => transformNode(v, ctx));
+    return allDeclaredAtAccessibleScope ? `${targetPattern} = [${valuesCodes.join(", ")}]` : `let ${targetPattern} = [${valuesCodes.join(", ")}]`;
+  }
+}
+function extractVariableNames(nodes, source) {
+  const names = [];
+  for (const node of nodes) {
+    if (node.name === "VariableName") {
+      names.push(getNodeText(node, source));
+    } else if (node.name === "TupleExpression") {
+      const children = getChildren(node);
+      names.push(
+        ...extractVariableNames(
+          children.filter((c) => c.name !== "(" && c.name !== ")" && c.name !== ","),
+          source
+        )
+      );
+    }
+  }
+  return names;
+}
+function isSliceExpression(node) {
+  const children = getChildren(node);
+  return children.some((c) => c.name === ":");
+}
+function transformSliceAssignment(target, values, ctx) {
+  const children = getChildren(target);
+  const obj = children[0];
+  if (!obj) return `/* slice assignment error */`;
+  const objCode = transformNode(obj, ctx);
+  const bracketStart = children.findIndex((c) => c.name === "[");
+  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 colonIndices = [];
+  for (let i = 0; i < sliceParts.length; i++) {
+    if (sliceParts[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("");
+    }
+    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("");
+      }
+    }
+  }
+  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})`;
+}
+function transformAssignTarget(node, ctx) {
+  if (node.name === "VariableName") {
+    return getNodeText(node, ctx.source);
+  } else if (node.name === "TupleExpression") {
+    const children = getChildren(node);
+    const elements = children.filter((c) => c.name !== "(" && c.name !== ")" && c.name !== ",");
+    return "[" + elements.map((e) => transformAssignTarget(e, ctx)).join(", ") + "]";
+  }
+  return transformNode(node, ctx);
+}
+function transformBinaryExpression(node, ctx) {
+  const children = getChildren(node);
+  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);
+  const opText = getNodeText(op, ctx.source);
+  if (isComparisonOperator(opText) && isChainedComparison(left)) {
+    const leftComparison = transformNode(left, ctx);
+    const middleValue = extractRightOperand(left, ctx);
+    const rightCode2 = transformNode(right, ctx);
+    return `(${leftComparison} && (${middleValue} ${opText} ${rightCode2}))`;
+  }
+  const leftCode = transformNode(left, ctx);
+  const rightCode = transformNode(right, ctx);
+  switch (opText) {
+    case "//":
+      ctx.usesRuntime.add("floorDiv");
+      return `floorDiv(${leftCode}, ${rightCode})`;
+    case "**":
+      ctx.usesRuntime.add("pow");
+      return `pow(${leftCode}, ${rightCode})`;
+    case "%":
+      if (left.name === "String" || left.name === "FormatString") {
+        ctx.usesRuntime.add("sprintf");
+        return `sprintf(${leftCode}, ${rightCode})`;
+      }
+      ctx.usesRuntime.add("mod");
+      return `mod(${leftCode}, ${rightCode})`;
+    case "and":
+      return `(${leftCode} && ${rightCode})`;
+    case "or":
+      return `(${leftCode} || ${rightCode})`;
+    case "in":
+      ctx.usesRuntime.add("contains");
+      return `contains(${leftCode}, ${rightCode})`;
+    case "is":
+      return `(${leftCode} === ${rightCode})`;
+    case "+":
+      if (isArrayLiteral(left) && isArrayLiteral(right)) {
+        return `[...${leftCode}, ...${rightCode}]`;
+      }
+      return `(${leftCode} + ${rightCode})`;
+    case "*":
+      if (isStringOrArrayLiteral(left) && isNumberLiteral(right)) {
+        ctx.usesRuntime.add("repeatValue");
+        return `repeatValue(${leftCode}, ${rightCode})`;
+      }
+      if (isNumberLiteral(left) && isStringOrArrayLiteral(right)) {
+        ctx.usesRuntime.add("repeatValue");
+        return `repeatValue(${rightCode}, ${leftCode})`;
+      }
+      return `(${leftCode} * ${rightCode})`;
+    /* v8 ignore next 2 -- pass-through for standard operators @preserve */
+    default:
+      return `(${leftCode} ${opText} ${rightCode})`;
+  }
+}
+function isArrayLiteral(node) {
+  return node.name === "ArrayExpression";
+}
+function isStringOrArrayLiteral(node) {
+  return node.name === "String" || node.name === "ArrayExpression";
+}
+function isNumberLiteral(node) {
+  return node.name === "Number";
+}
+function isComparisonOperator(op) {
+  return ["<", ">", "<=", ">=", "==", "!="].includes(op);
+}
+function isChainedComparison(node) {
+  if (node.name !== "BinaryExpression") return false;
+  const children = getChildren(node);
+  const op = children[1];
+  if (!op || op.name !== "CompareOp") return false;
+  return true;
+}
+function extractRightOperand(node, ctx) {
+  const children = getChildren(node);
+  const right = children[2];
+  if (!right) return "";
+  return transformNode(right, ctx);
+}
+function transformUnaryExpression(node, ctx) {
+  const children = getChildren(node);
+  if (children.length < 2) return getNodeText(node, ctx.source);
+  const op = children[0];
+  const operand = children[1];
+  if (!op || !operand) return getNodeText(node, ctx.source);
+  const opText = getNodeText(op, ctx.source);
+  const operandCode = transformNode(operand, ctx);
+  switch (opText) {
+    case "not":
+      return `(!${operandCode})`;
+    /* v8 ignore next 2 -- pass-through for unary operators like - and + @preserve */
+    default:
+      return `(${opText}${operandCode})`;
+  }
+}
+function transformParenthesizedExpression(node, ctx) {
+  const children = getChildren(node);
+  const inner = children.find((c) => c.name !== "(" && c.name !== ")");
+  if (!inner) return "()";
+  return `(${transformNode(inner, ctx)})`;
+}
+function transformNamedExpression(node, ctx) {
+  const children = getChildren(node);
+  const varName = children.find((c) => c.name === "VariableName");
+  const value = children.find((c) => c.name !== "VariableName" && c.name !== "AssignOp");
+  if (!varName || !value) {
+    return getNodeText(node, ctx.source);
+  }
+  const name = getNodeText(varName, ctx.source);
+  const valueCode = transformNode(value, ctx);
+  return `${name} = ${valueCode}`;
+}
+function transformConditionalExpression(node, ctx) {
+  const children = getChildren(node);
+  const exprs = children.filter((c) => c.name !== "if" && c.name !== "else" && c.name !== "Keyword");
+  if (exprs.length >= 3) {
+    const trueExpr = exprs[0];
+    const condition = exprs[1];
+    const falseExpr = exprs[2];
+    if (trueExpr && condition && falseExpr) {
+      const condCode = transformNode(condition, ctx);
+      const trueCode = transformNode(trueExpr, ctx);
+      const falseCode = transformNode(falseExpr, ctx);
+      return `(${condCode} ? ${trueCode} : ${falseCode})`;
+    }
+  }
+  return getNodeText(node, ctx.source);
+}
+function transformNumber(node, ctx) {
+  const text = getNodeText(node, ctx.source);
+  return text.replace(/_/g, "");
+}
+function transformString(node, ctx) {
+  const text = getNodeText(node, ctx.source);
+  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('"""') || text.startsWith("'''")) {
+    const content = text.slice(3, -3);
+    return "`" + content.replace(/`/g, "\\`") + "`";
+  }
+  return text;
+}
+function transformFormatString(node, ctx) {
+  const text = getNodeText(node, ctx.source);
+  const children = getChildren(node);
+  const replacements = children.filter((c) => c.name === "FormatReplacement");
+  if (replacements.length === 0) {
+    let content;
+    if (text.startsWith('f"""') || text.startsWith("f'''")) {
+      content = text.slice(4, -3);
+    } else {
+      content = text.slice(2, -1);
+    }
+    content = content.replace(/\{\{/g, "{").replace(/\}\}/g, "}");
+    content = content.replace(/`/g, "\\`");
+    return "`" + content + "`";
+  }
+  let result = "`";
+  let pos = text.startsWith('f"""') || text.startsWith("f'''") ? 4 : 2;
+  for (const replacement of replacements) {
+    const staticText = text.slice(pos, replacement.from - node.from);
+    result += staticText.replace(/\{\{/g, "{").replace(/\}\}/g, "}").replace(/`/g, "\\`");
+    const replChildren = getChildren(replacement);
+    let expr;
+    let formatSpec;
+    let conversion;
+    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 {
+        expr = child;
+      }
+    }
+    if (expr) {
+      let exprCode = transformNode(expr, ctx);
+      if (conversion === "r") {
+        exprCode = `repr(${exprCode})`;
+        ctx.usesRuntime.add("repr");
+      } else if (conversion === "s") {
+        exprCode = `str(${exprCode})`;
+        ctx.usesRuntime.add("str");
+      } else if (conversion === "a") {
+        exprCode = `ascii(${exprCode})`;
+        ctx.usesRuntime.add("ascii");
+      }
+      if (formatSpec) {
+        ctx.usesRuntime.add("format");
+        result += `\${format(${exprCode}, "${formatSpec}")}`;
+      } else {
+        result += `\${${exprCode}}`;
+      }
+    }
+    pos = replacement.to - node.from;
+  }
+  const endPos = text.startsWith('f"""') || text.startsWith("f'''") ? text.length - 3 : text.length - 1;
+  const remainingText = text.slice(pos, endPos);
+  result += remainingText.replace(/\{\{/g, "{").replace(/\}\}/g, "}").replace(/`/g, "\\`");
+  result += "`";
+  return result;
+}
+function transformBoolean(node, ctx) {
+  const text = getNodeText(node, ctx.source);
+  return text === "True" ? "true" : "false";
+}
+function transformCallExpression(node, ctx) {
+  const children = getChildren(node);
+  const callee = children[0];
+  const argList = children.find((c) => c.name === "ArgList");
+  if (!callee) return getNodeText(node, ctx.source);
+  const calleeName = getNodeText(callee, ctx.source);
+  const args = argList ? transformArgList(argList, ctx) : "";
+  if (callee.name === "MemberExpression") {
+    const methodResult = transformMethodCall(callee, args, ctx);
+    if (methodResult !== null) {
+      return methodResult;
+    }
+    const moduleCallResult = transformModuleCall(calleeName, args, ctx);
+    if (moduleCallResult !== null) {
+      return moduleCallResult;
+    }
+  }
+  if (callee.name === "VariableName" && ctx.definedClasses.has(calleeName)) {
+    return `new ${calleeName}(${args})`;
+  }
+  switch (calleeName) {
+    case "print":
+      return `console.log(${args})`;
+    case "len":
+      ctx.usesRuntime.add("len");
+      return `len(${args})`;
+    case "range":
+      ctx.usesRuntime.add("range");
+      return `range(${args})`;
+    case "int":
+      ctx.usesRuntime.add("int");
+      return `int(${args})`;
+    case "float":
+      ctx.usesRuntime.add("float");
+      return `float(${args})`;
+    case "str":
+      ctx.usesRuntime.add("str");
+      return `str(${args})`;
+    case "bool":
+      ctx.usesRuntime.add("bool");
+      return `bool(${args})`;
+    case "abs":
+      ctx.usesRuntime.add("abs");
+      return `abs(${args})`;
+    case "min":
+      ctx.usesRuntime.add("min");
+      return `min(${args})`;
+    case "max":
+      ctx.usesRuntime.add("max");
+      return `max(${args})`;
+    case "sum":
+      ctx.usesRuntime.add("sum");
+      return `sum(${args})`;
+    case "list":
+      ctx.usesRuntime.add("list");
+      return `list(${args})`;
+    case "dict":
+      ctx.usesRuntime.add("dict");
+      return `dict(${args})`;
+    case "set":
+      ctx.usesRuntime.add("set");
+      return `set(${args})`;
+    case "tuple":
+      ctx.usesRuntime.add("tuple");
+      return `tuple(${args})`;
+    case "enumerate":
+      ctx.usesRuntime.add("enumerate");
+      return `enumerate(${args})`;
+    case "zip":
+      ctx.usesRuntime.add("zip");
+      return `zip(${args})`;
+    case "sorted":
+      ctx.usesRuntime.add("sorted");
+      return `sorted(${args})`;
+    case "reversed":
+      ctx.usesRuntime.add("reversed");
+      return `reversed(${args})`;
+    case "isinstance":
+      ctx.usesRuntime.add("isinstance");
+      return `isinstance(${args})`;
+    case "type":
+      ctx.usesRuntime.add("type");
+      return `type(${args})`;
+    case "input":
+      ctx.usesRuntime.add("input");
+      return `input(${args})`;
+    case "ord":
+      ctx.usesRuntime.add("ord");
+      return `ord(${args})`;
+    case "chr":
+      ctx.usesRuntime.add("chr");
+      return `chr(${args})`;
+    case "all":
+      ctx.usesRuntime.add("all");
+      return `all(${args})`;
+    case "any":
+      ctx.usesRuntime.add("any");
+      return `any(${args})`;
+    case "map":
+      ctx.usesRuntime.add("map");
+      return `map(${args})`;
+    case "filter":
+      ctx.usesRuntime.add("filter");
+      return `filter(${args})`;
+    case "repr":
+      ctx.usesRuntime.add("repr");
+      return `repr(${args})`;
+    case "round":
+      ctx.usesRuntime.add("round");
+      return `round(${args})`;
+    case "divmod":
+      ctx.usesRuntime.add("divmod");
+      return `divmod(${args})`;
+    case "hex":
+      ctx.usesRuntime.add("hex");
+      return `hex(${args})`;
+    case "oct":
+      ctx.usesRuntime.add("oct");
+      return `oct(${args})`;
+    case "bin":
+      ctx.usesRuntime.add("bin");
+      return `bin(${args})`;
+    // itertools functions
+    case "chain":
+      ctx.usesRuntime.add("itertools/chain");
+      return `chain(${args})`;
+    case "combinations":
+      ctx.usesRuntime.add("itertools/combinations");
+      return `combinations(${args})`;
+    case "permutations":
+      ctx.usesRuntime.add("itertools/permutations");
+      return `permutations(${args})`;
+    case "product":
+      ctx.usesRuntime.add("itertools/product");
+      return `product(${args})`;
+    case "cycle":
+      ctx.usesRuntime.add("itertools/cycle");
+      return `cycle(${args})`;
+    case "repeat":
+      ctx.usesRuntime.add("itertools/repeat");
+      return `repeat(${args})`;
+    case "islice":
+      ctx.usesRuntime.add("itertools/islice");
+      return `islice(${args})`;
+    case "takewhile":
+      ctx.usesRuntime.add("itertools/takeWhile");
+      return `takeWhile(${args})`;
+    case "dropwhile":
+      ctx.usesRuntime.add("itertools/dropWhile");
+      return `dropWhile(${args})`;
+    case "zip_longest":
+      ctx.usesRuntime.add("itertools/zipLongest");
+      return `zipLongest(${args})`;
+    case "compress":
+      ctx.usesRuntime.add("itertools/compress");
+      return `compress(${args})`;
+    case "filterfalse":
+      ctx.usesRuntime.add("itertools/filterFalse");
+      return `filterFalse(${args})`;
+    case "accumulate":
+      ctx.usesRuntime.add("itertools/accumulate");
+      return `accumulate(${args})`;
+    case "groupby":
+      ctx.usesRuntime.add("itertools/groupby");
+      return `groupby(${args})`;
+    case "count":
+      ctx.usesRuntime.add("itertools/count");
+      return `count(${args})`;
+    case "tee":
+      ctx.usesRuntime.add("itertools/tee");
+      return `tee(${args})`;
+    case "pairwise":
+      ctx.usesRuntime.add("itertools/pairwise");
+      return `pairwise(${args})`;
+    case "combinations_with_replacement":
+      ctx.usesRuntime.add("itertools/combinationsWithReplacement");
+      return `combinationsWithReplacement(${args})`;
+    // collections classes/functions
+    case "Counter":
+      ctx.usesRuntime.add("collections/Counter");
+      return `new Counter(${args})`;
+    case "defaultdict":
+      ctx.usesRuntime.add("collections/defaultdict");
+      return `defaultdict(${args})`;
+    case "deque":
+      ctx.usesRuntime.add("collections/deque");
+      return `new deque(${args})`;
+    // functools functions
+    case "partial":
+      ctx.usesRuntime.add("functools/partial");
+      return `partial(${args})`;
+    case "reduce":
+      ctx.usesRuntime.add("functools/reduce");
+      return `reduce(${args})`;
+    case "lru_cache":
+      ctx.usesRuntime.add("functools/lruCache");
+      return `lruCache(${args})`;
+    case "cache":
+      ctx.usesRuntime.add("functools/cache");
+      return `cache(${args})`;
+    case "wraps":
+      ctx.usesRuntime.add("functools/wraps");
+      return `wraps(${args})`;
+    case "cmp_to_key":
+      ctx.usesRuntime.add("functools/cmpToKey");
+      return `cmpToKey(${args})`;
+    case "total_ordering":
+      ctx.usesRuntime.add("functools/totalOrdering");
+      return `totalOrdering(${args})`;
+    // json functions
+    case "dumps":
+      ctx.usesRuntime.add("json/dumps");
+      return `dumps(${args})`;
+    case "loads":
+      ctx.usesRuntime.add("json/loads");
+      return `loads(${args})`;
+    case "dump":
+      ctx.usesRuntime.add("json/dump");
+      return `dump(${args})`;
+    case "load":
+      ctx.usesRuntime.add("json/load");
+      return `load(${args})`;
+    // datetime classes
+    case "datetime":
+      ctx.usesRuntime.add("datetime/datetime");
+      return `new datetime(${args})`;
+    case "date":
+      ctx.usesRuntime.add("datetime/date");
+      return `new date(${args})`;
+    case "time":
+      ctx.usesRuntime.add("datetime/time");
+      return `new time(${args})`;
+    case "timedelta":
+      ctx.usesRuntime.add("datetime/timedelta");
+      return `new timedelta(${args})`;
+    // string module
+    case "Template":
+      ctx.usesRuntime.add("string/Template");
+      return `new Template(${args})`;
+    case "capwords":
+      ctx.usesRuntime.add("string/capWords");
+      return `capWords(${args})`;
+    /* v8 ignore next 3 -- pass-through for user-defined functions @preserve */
+    default:
+      return `${transformNode(callee, ctx)}(${args})`;
+  }
+}
+function transformModuleCall(calleeName, args, ctx) {
+  const dotIndex = calleeName.indexOf(".");
+  if (dotIndex === -1) return null;
+  const moduleName = calleeName.slice(0, dotIndex);
+  const funcName = calleeName.slice(dotIndex + 1);
+  if (moduleName === "math") {
+    const mathConstants = {
+      pi: "pi",
+      e: "e",
+      tau: "tau",
+      inf: "inf",
+      nan: "nan"
+    };
+    if (funcName in mathConstants) {
+      ctx.usesRuntime.add(`math/${funcName}`);
+      return mathConstants[funcName];
+    }
+    ctx.usesRuntime.add(`math/${funcName}`);
+    return `${funcName}(${args})`;
+  }
+  if (moduleName === "random") {
+    const jsName = toJsName(funcName);
+    ctx.usesRuntime.add(`random/${jsName}`);
+    return `${jsName}(${args})`;
+  }
+  if (moduleName === "json") {
+    ctx.usesRuntime.add(`json/${funcName}`);
+    return `${funcName}(${args})`;
+  }
+  if (moduleName === "os") {
+    if (funcName.startsWith("path.")) {
+      const pathFuncName = funcName.slice(5);
+      const jsPathFunc = toJsName(pathFuncName);
+      ctx.usesRuntime.add("os/path");
+      return `path.${jsPathFunc}(${args})`;
+    }
+    const jsName = toJsName(funcName);
+    ctx.usesRuntime.add(`os/${jsName}`);
+    return `${jsName}(${args})`;
+  }
+  if (moduleName === "datetime") {
+    const jsName = toJsName(funcName);
+    ctx.usesRuntime.add(`datetime/${jsName}`);
+    if (["datetime", "date", "time", "timedelta"].includes(funcName)) {
+      return `new ${jsName}(${args})`;
+    }
+    return `${jsName}(${args})`;
+  }
+  if (moduleName === "re") {
+    const jsName = toJsName(funcName);
+    ctx.usesRuntime.add(`re/${jsName}`);
+    return `${jsName}(${args})`;
+  }
+  if (moduleName === "string") {
+    const jsName = toJsName(funcName);
+    ctx.usesRuntime.add(`string/${jsName}`);
+    if (funcName === "Template") {
+      return `new Template(${args})`;
+    }
+    return funcName.includes("(") ? `${jsName}(${args})` : jsName;
+  }
+  if (moduleName === "functools") {
+    const jsName = toJsName(funcName);
+    ctx.usesRuntime.add(`functools/${jsName}`);
+    return `${jsName}(${args})`;
+  }
+  if (moduleName === "itertools") {
+    const jsName = toJsName(funcName);
+    ctx.usesRuntime.add(`itertools/${jsName}`);
+    return `${jsName}(${args})`;
+  }
+  if (moduleName === "collections") {
+    ctx.usesRuntime.add(`collections/${funcName}`);
+    if (["Counter", "deque"].includes(funcName)) {
+      return `new ${funcName}(${args})`;
+    }
+    return `${funcName}(${args})`;
+  }
+  return null;
+}
+function transformMethodCall(callee, args, ctx) {
+  const children = getChildren(callee);
+  if (children.length < 2) return null;
+  const obj = children[0];
+  const methodNode = children[children.length - 1];
+  if (!obj || !methodNode) return null;
+  if (obj.name === "MemberExpression") {
+    return null;
+  }
+  const objCode = transformNode(obj, ctx);
+  const methodName = getNodeText(methodNode, ctx.source);
+  switch (methodName) {
+    // String case conversion
+    case "upper":
+      return `${objCode}.toUpperCase()`;
+    case "lower":
+      return `${objCode}.toLowerCase()`;
+    case "capitalize":
+      ctx.usesRuntime.add("string");
+      return `string.capitalize(${objCode})`;
+    case "title":
+      ctx.usesRuntime.add("string");
+      return `string.title(${objCode})`;
+    case "swapcase":
+      ctx.usesRuntime.add("string");
+      return `string.swapCase(${objCode})`;
+    case "casefold":
+      return `${objCode}.toLowerCase()`;
+    // String whitespace
+    case "strip":
+      return args ? `${objCode}.split(${args}).join("")` : `${objCode}.trim()`;
+    case "lstrip":
+      return args ? `${objCode}.replace(new RegExp('^[' + ${args} + ']+'), '')` : `${objCode}.trimStart()`;
+    case "rstrip":
+      return args ? `${objCode}.replace(new RegExp('[' + ${args} + ']+$'), '')` : `${objCode}.trimEnd()`;
+    // String search
+    case "startswith":
+      return `${objCode}.startsWith(${args})`;
+    case "endswith":
+      return `${objCode}.endsWith(${args})`;
+    case "find":
+      return `${objCode}.indexOf(${args})`;
+    case "rfind":
+      return `${objCode}.lastIndexOf(${args})`;
+    case "index":
+      ctx.usesRuntime.add("string");
+      return `string.index(${objCode}, ${args})`;
+    case "rindex":
+      ctx.usesRuntime.add("string");
+      return `string.rIndex(${objCode}, ${args})`;
+    case "count":
+      ctx.usesRuntime.add("string");
+      return `string.count(${objCode}, ${args})`;
+    // String testing
+    case "isalpha":
+      return `/^[a-zA-Z]+$/.test(${objCode})`;
+    case "isdigit":
+      return `/^[0-9]+$/.test(${objCode})`;
+    case "isalnum":
+      return `/^[a-zA-Z0-9]+$/.test(${objCode})`;
+    case "isspace":
+      return `/^\\s+$/.test(${objCode})`;
+    case "isupper":
+      return `(${objCode} === ${objCode}.toUpperCase() && ${objCode} !== ${objCode}.toLowerCase())`;
+    case "islower":
+      return `(${objCode} === ${objCode}.toLowerCase() && ${objCode} !== ${objCode}.toUpperCase())`;
+    // String modification
+    case "replace":
+      ctx.usesRuntime.add("string");
+      return `string.replace(${objCode}, ${args})`;
+    case "zfill":
+      ctx.usesRuntime.add("string");
+      return `string.zFill(${objCode}, ${args})`;
+    case "center":
+      ctx.usesRuntime.add("string");
+      return `string.center(${objCode}, ${args})`;
+    case "ljust":
+      return `${objCode}.padEnd(${args})`;
+    case "rjust":
+      return `${objCode}.padStart(${args})`;
+    // String split/join - join is special: "sep".join(arr) -> arr.join("sep")
+    case "join":
+      return `(${args}).join(${objCode})`;
+    case "split":
+      return args ? `${objCode}.split(${args})` : `${objCode}.split(/\\s+/)`;
+    case "rsplit":
+      ctx.usesRuntime.add("string");
+      return `string.rSplit(${objCode}, ${args})`;
+    case "splitlines":
+      return `${objCode}.split(/\\r?\\n/)`;
+    case "partition":
+      ctx.usesRuntime.add("string");
+      return `string.partition(${objCode}, ${args})`;
+    case "rpartition":
+      ctx.usesRuntime.add("string");
+      return `string.rPartition(${objCode}, ${args})`;
+    // String format method
+    case "format":
+      ctx.usesRuntime.add("strFormat");
+      return `strFormat(${objCode}, ${args})`;
+    // List methods
+    case "append":
+      return `${objCode}.push(${args})`;
+    case "extend":
+      return `${objCode}.push(...${args})`;
+    case "insert": {
+      const insertArgs = args.split(",");
+      const index = insertArgs[0] ?? "0";
+      const value = insertArgs.slice(1).join(",");
+      return `${objCode}.splice(${index}, 0, ${value})`;
+    }
+    case "remove":
+      ctx.usesRuntime.add("list");
+      return `list.remove(${objCode}, ${args})`;
+    case "pop":
+      if (!args) return `${objCode}.pop()`;
+      if (args.trim() === "0") return `${objCode}.shift()`;
+      return `${objCode}.splice(${args}, 1)[0]`;
+    case "clear":
+      return `${objCode}.length = 0`;
+    case "copy":
+      return `[...${objCode}]`;
+    case "reverse":
+      return `${objCode}.reverse()`;
+    case "sort":
+      ctx.usesRuntime.add("list");
+      return args ? `list.sort(${objCode}, ${args})` : `${objCode}.sort()`;
+    // Dict methods
+    case "keys":
+      return `Object.keys(${objCode})`;
+    case "values":
+      return `Object.values(${objCode})`;
+    case "items":
+      return `Object.entries(${objCode})`;
+    case "get":
+      ctx.usesRuntime.add("dict");
+      return `dict.get(${objCode}, ${args})`;
+    case "setdefault":
+      ctx.usesRuntime.add("dict");
+      return `dict.setdefault(${objCode}, ${args})`;
+    case "update":
+      return `Object.assign(${objCode}, ${args})`;
+    case "fromkeys":
+      ctx.usesRuntime.add("dict");
+      return `dict.fromkeys(${args})`;
+    // Set methods
+    case "add":
+      return `${objCode}.add(${args})`;
+    case "discard":
+      return `${objCode}.delete(${args})`;
+    case "union":
+      return `new Set([...${objCode}, ...${args}])`;
+    case "intersection":
+      ctx.usesRuntime.add("set");
+      return `set.intersection(${objCode}, ${args})`;
+    case "difference":
+      ctx.usesRuntime.add("set");
+      return `set.difference(${objCode}, ${args})`;
+    case "symmetric_difference":
+      ctx.usesRuntime.add("set");
+      return `set.symmetricDifference(${objCode}, ${args})`;
+    case "issubset":
+      ctx.usesRuntime.add("set");
+      return `set.issubset(${objCode}, ${args})`;
+    case "issuperset":
+      ctx.usesRuntime.add("set");
+      return `set.issuperset(${objCode}, ${args})`;
+    /* v8 ignore next 2 -- unknown method, let caller handle @preserve */
+    default:
+      return null;
+  }
+}
+function transformArgList(node, ctx) {
+  const children = getChildren(node);
+  const items = children.filter((c) => c.name !== "(" && c.name !== ")" && c.name !== "ArgList");
+  const hasForKeyword = items.some(
+    (c) => c.name === "for" || c.name === "Keyword" && getNodeText(c, ctx.source) === "for"
+  );
+  if (hasForKeyword) {
+    const nonCommaItems = items.filter((c) => c.name !== ",");
+    const { outputExpr, clauses } = parseComprehensionClauses(nonCommaItems, ctx);
+    return buildGeneratorChain(outputExpr, clauses);
+  }
+  const args = [];
+  const kwArgs = [];
+  let i = 0;
+  while (i < items.length) {
+    const item = items[i];
+    if (!item) {
+      i++;
+      continue;
+    }
+    if (item.name === ",") {
+      i++;
+      continue;
+    }
+    if (item.name === "*" || item.name === "ArithOp" && getNodeText(item, ctx.source) === "*") {
+      const nextItem = items[i + 1];
+      if (nextItem) {
+        args.push(`...${transformNode(nextItem, ctx)}`);
+        i += 2;
+        continue;
+      }
+    }
+    if (item.name === "**" || item.name === "ArithOp" && getNodeText(item, ctx.source) === "**") {
+      const nextItem = items[i + 1];
+      if (nextItem) {
+        args.push(`...Object.entries(${transformNode(nextItem, ctx)})`);
+        i += 2;
+        continue;
+      }
+    }
+    if (item.name === "VariableName") {
+      const nextItem = items[i + 1];
+      if (nextItem && nextItem.name === "AssignOp") {
+        const valueItem = items[i + 2];
+        if (valueItem) {
+          const name = getNodeText(item, ctx.source);
+          const value = transformNode(valueItem, ctx);
+          kwArgs.push({ name, value });
+          i += 3;
+          continue;
+        }
+      }
+    }
+    args.push(transformNode(item, ctx));
+    i++;
+  }
+  if (kwArgs.length > 0) {
+    const kwArgsStr = kwArgs.map((kw) => `${kw.name}: ${kw.value}`).join(", ");
+    args.push(`{ ${kwArgsStr} }`);
+  }
+  return args.join(", ");
+}
+function transformMemberExpression(node, ctx) {
+  const children = getChildren(node);
+  if (children.length < 2) return getNodeText(node, ctx.source);
+  const obj = children[0];
+  if (!obj) return getNodeText(node, ctx.source);
+  const hasOpenBracket = children.some((c) => c.name === "[");
+  if (hasOpenBracket) {
+    const objCode = transformNode(obj, ctx);
+    const text = getNodeText(node, ctx.source);
+    if (text.includes(":")) {
+      return transformSliceFromMember(obj, children, ctx);
+    }
+    const indexElements = children.filter((c) => c.name !== "[" && c.name !== "]" && c !== obj);
+    const index = indexElements[0];
+    if (!index) return `${objCode}[]`;
+    const indexCode = transformNode(index, ctx);
+    if (isNegativeIndexLiteral(index, ctx)) {
+      ctx.usesRuntime.add("at");
+      return `at(${objCode}, ${indexCode})`;
+    }
+    return `${objCode}[${indexCode}]`;
+  } else {
+    const prop = children[children.length - 1];
+    if (!prop) return getNodeText(node, ctx.source);
+    const objName = getNodeText(obj, ctx.source);
+    const propName = getNodeText(prop, ctx.source);
+    if (objName === "math") {
+      ctx.usesRuntime.add(`math/${propName}`);
+      return propName;
+    }
+    if (objName === "os") {
+      if (propName === "path") {
+        ctx.usesRuntime.add("os/path");
+        return "path";
+      }
+      ctx.usesRuntime.add(`os/${propName}`);
+      return propName;
+    }
+    if (objName === "string") {
+      ctx.usesRuntime.add(`string/${propName}`);
+      return propName;
+    }
+    if (objName === "re") {
+      ctx.usesRuntime.add(`re/${propName}`);
+      return propName;
+    }
+    if (objName === "datetime") {
+      ctx.usesRuntime.add(`datetime/${propName}`);
+      return propName;
+    }
+    const objCode = transformNode(obj, ctx);
+    const attrMap = {
+      __name__: "name",
+      __doc__: "undefined",
+      // JS functions don't have docstrings
+      __class__: "constructor",
+      __dict__: "this"
+      // Rough equivalent
+    };
+    const mappedProp = attrMap[propName] ?? propName;
+    return `${objCode}.${mappedProp}`;
+  }
+}
+function transformSliceFromMember(obj, children, ctx) {
+  ctx.usesRuntime.add("slice");
+  const objCode = transformNode(obj, ctx);
+  const bracketStart = children.findIndex((c) => c.name === "[");
+  const bracketEnd = children.findIndex((c) => c.name === "]");
+  if (bracketStart === -1 || bracketEnd === -1) {
+    return `slice(${objCode})`;
+  }
+  const sliceElements = children.slice(bracketStart + 1, bracketEnd);
+  const colonIndices = [];
+  sliceElements.forEach((el, i) => {
+    if (el.name === ":") colonIndices.push(i);
+  });
+  const parts = [];
+  let lastIdx = 0;
+  for (const colonIdx of colonIndices) {
+    const beforeColon = sliceElements.slice(lastIdx, colonIdx);
+    if (beforeColon.length > 0 && beforeColon[0]) {
+      parts.push(transformNode(beforeColon[0], ctx));
+    } else {
+      parts.push("undefined");
+    }
+    lastIdx = colonIdx + 1;
+  }
+  const afterLastColon = sliceElements.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 `slice(${objCode}, ${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));
+  return `[${elementCodes.join(", ")}]`;
+}
+function transformDictionaryExpression(node, ctx) {
+  const children = getChildren(node);
+  const pairs = [];
+  const items = children.filter(
+    (c) => c.name !== "{" && c.name !== "}" && c.name !== "," && c.name !== ":"
+  );
+  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);
+      if (key.name === "VariableName") {
+        pairs.push(`[${keyCode}]: ${valueCode}`);
+      } else {
+        pairs.push(`${keyCode}: ${valueCode}`);
+      }
+    }
+  }
+  return `{ ${pairs.join(", ")} }`;
+}
+function transformTupleExpression(node, ctx) {
+  const children = getChildren(node);
+  const elements = children.filter((c) => c.name !== "(" && c.name !== ")" && c.name !== ",");
+  ctx.usesRuntime.add("tuple");
+  const elementCodes = elements.map((el) => transformNode(el, ctx));
+  return `tuple(${elementCodes.join(", ")})`;
+}
+function isNegativeIndexLiteral(node, ctx) {
+  if (node.name === "UnaryExpression") {
+    const children = getChildren(node);
+    const hasMinusOp = children.some(
+      (c) => c.name === "ArithOp" && getNodeText(c, ctx.source) === "-"
+    );
+    const hasNumber = children.some((c) => c.name === "Number");
+    return hasMinusOp && hasNumber;
+  }
+  return false;
+}
+function transformIfStatement(node, ctx) {
+  const children = getChildren(node);
+  const parts = [];
+  let i = 0;
+  while (i < children.length) {
+    const child = children[i];
+    if (!child) {
+      i++;
+      continue;
+    }
+    if (child.name === "if" || child.name === "Keyword" && getNodeText(child, ctx.source) === "if") {
+      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 bodyCode = transformBody(body, ctx);
+        parts.push(`if (${condCode}) {
+${bodyCode}
+}`);
+      }
+    } else if (child.name === "elif" || child.name === "Keyword" && getNodeText(child, ctx.source) === "elif") {
+      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 bodyCode = transformBody(body, ctx);
+        parts.push(` else if (${condCode}) {
+${bodyCode}
+}`);
+      }
+    } else if (child.name === "else" || child.name === "Keyword" && getNodeText(child, ctx.source) === "else") {
+      const body = children.find((c, idx) => idx > i && c.name === "Body");
+      if (body) {
+        const bodyCode = transformBody(body, ctx);
+        parts.push(` else {
+${bodyCode}
+}`);
+      }
+    }
+    i++;
+  }
+  return parts.join("");
+}
+function transformWhileStatement(node, ctx) {
+  const children = getChildren(node);
+  const condition = children.find(
+    (c) => c.name !== "while" && c.name !== "Body" && c.name !== "Keyword" && c.name !== ":"
+  );
+  const body = children.find((c) => c.name === "Body");
+  if (!condition || !body) return getNodeText(node, ctx.source);
+  const condCode = transformNode(condition, ctx);
+  const bodyCode = transformBody(body, ctx);
+  return `while (${condCode}) {
+${bodyCode}
+}`;
+}
+function transformMatchStatement(node, ctx) {
+  const children = getChildren(node);
+  let subject = null;
+  let matchBody = null;
+  for (const child of children) {
+    if (child.name === "match" || child.name === ":") continue;
+    if (child.name === "MatchBody") {
+      matchBody = child;
+    } else if (!subject) {
+      subject = child;
+    }
+  }
+  if (!subject || !matchBody) return getNodeText(node, ctx.source);
+  const subjectCode = transformNode(subject, ctx);
+  const matchBodyChildren = getChildren(matchBody);
+  const clauseNodes = matchBodyChildren.filter((c) => c.name === "MatchClause");
+  const hasComplexPatterns = clauseNodes.some((clause) => {
+    const clauseChildren = getChildren(clause);
+    const pattern = clauseChildren.find(
+      (c) => c.name !== "case" && c.name !== ":" && c.name !== "Body" && c.name !== "Guard"
+    );
+    const hasGuard = clauseChildren.some((c) => c.name === "Guard");
+    if (hasGuard) return true;
+    if (!pattern) return false;
+    if (pattern.name === "SequencePattern" || pattern.name === "MappingPattern" || pattern.name === "ClassPattern" || pattern.name === "AsPattern") {
+      return true;
+    }
+    if (pattern.name === "OrPattern") {
+      const orChildren = getChildren(pattern);
+      return orChildren.some(
+        (c) => c.name === "SequencePattern" || c.name === "MappingPattern" || c.name === "ClassPattern" || c.name === "AsPattern"
+      );
+    }
+    return false;
+  });
+  if (hasComplexPatterns) {
+    return transformMatchAsIfElse(subjectCode, clauseNodes, ctx);
+  }
+  const clauses = transformMatchBody(matchBody, ctx);
+  return `switch (${subjectCode}) {
+${clauses}
+}`;
+}
+function transformMatchAsIfElse(subjectCode, clauses, ctx) {
+  const parts = [];
+  const indent = "  ".repeat(ctx.indentLevel);
+  for (let i = 0; i < clauses.length; i++) {
+    const clause = clauses[i];
+    if (!clause) continue;
+    const children = getChildren(clause);
+    let pattern = null;
+    let body = null;
+    let guard = null;
+    for (const child of children) {
+      if (child.name === "case" || child.name === ":") continue;
+      if (child.name === "Body") {
+        body = child;
+      } else if (child.name === "Guard") {
+        guard = child;
+      } else if (!pattern) {
+        pattern = child;
+      }
+    }
+    if (!pattern || !body) continue;
+    ctx.indentLevel++;
+    const bodyCode = transformBody(body, ctx);
+    ctx.indentLevel--;
+    const patternText = getNodeText(pattern, ctx.source);
+    const isWildcard = patternText === "_" || pattern.name === "CapturePattern" && patternText === "_";
+    let guardCondition = null;
+    if (guard) {
+      const guardChildren = getChildren(guard);
+      const guardExpr = guardChildren.find((c) => c.name !== "if");
+      if (guardExpr) {
+        let guardCode = transformNode(guardExpr, ctx);
+        if (pattern.name === "CapturePattern") {
+          const captureVar = getNodeText(pattern, ctx.source);
+          if (captureVar !== "_") {
+            const varRegex = new RegExp(`\\b${captureVar}\\b`, "g");
+            guardCode = guardCode.replace(varRegex, subjectCode);
+          }
+        }
+        guardCondition = guardCode;
+      }
+    }
+    if (isWildcard && !guardCondition) {
+      if (i === 0) {
+        parts.push(`${indent}${bodyCode.trim()}`);
+      } else {
+        parts.push(` else {
+${indent}  ${bodyCode.trim()}
+${indent}}`);
+      }
+    } else {
+      const { condition, bindings } = transformComplexPattern(pattern, subjectCode, ctx);
+      let fullCondition = condition;
+      if (guardCondition) {
+        if (condition === "true") {
+          fullCondition = guardCondition;
+        } else {
+          fullCondition = `${condition} && ${guardCondition}`;
+        }
+      }
+      const keyword = i === 0 ? "if" : " else if";
+      const bindingsCode = bindings.length > 0 ? `
+${indent}  ${bindings.join(`
+${indent}  `)}` : "";
+      parts.push(
+        `${keyword} (${fullCondition}) {${bindingsCode}
+${indent}  ${bodyCode.trim()}
+${indent}}`
+      );
+    }
+  }
+  return parts.join("");
+}
+function transformComplexPattern(pattern, subject, ctx) {
+  switch (pattern.name) {
+    case "SequencePattern":
+      return transformSequencePattern(pattern, subject, ctx);
+    case "MappingPattern":
+      return transformMappingPattern(pattern, subject, ctx);
+    case "ClassPattern":
+      return transformClassPattern(pattern, subject, ctx);
+    case "OrPattern":
+      return transformOrPattern(pattern, subject, ctx);
+    case "AsPattern":
+      return transformAsPattern(pattern, subject, ctx);
+    case "LiteralPattern": {
+      const children = getChildren(pattern);
+      const literal = children[0];
+      const value = literal ? transformNode(literal, ctx) : getNodeText(pattern, ctx.source);
+      return { condition: `${subject} === ${value}`, bindings: [] };
+    }
+    case "CapturePattern": {
+      const varName = getNodeText(pattern, ctx.source);
+      if (varName === "_") {
+        return { condition: "true", bindings: [] };
+      }
+      return { condition: "true", bindings: [`const ${varName} = ${subject};`] };
+    }
+    /* v8 ignore next 3 -- fallback for unknown match patterns @preserve */
+    default:
+      return { condition: `${subject} === ${getNodeText(pattern, ctx.source)}`, bindings: [] };
+  }
+}
+function transformSequencePattern(pattern, subject, ctx) {
+  const children = getChildren(pattern);
+  const elements = children.filter((c) => c.name !== "[" && c.name !== "]" && c.name !== ",");
+  const conditions = [`Array.isArray(${subject})`];
+  const bindings = [];
+  const hasStarred = elements.some((e) => e.name === "StarPattern");
+  if (!hasStarred) {
+    conditions.push(`${subject}.length === ${String(elements.length)}`);
+  }
+  elements.forEach((elem, idx) => {
+    const idxStr = String(idx);
+    if (elem.name === "CapturePattern") {
+      const varName = getNodeText(elem, ctx.source);
+      if (varName !== "_") {
+        bindings.push(`const ${varName} = ${subject}[${idxStr}];`);
+      }
+    } else if (elem.name === "LiteralPattern") {
+      const childNodes = getChildren(elem);
+      const literal = childNodes[0];
+      const value = literal ? transformNode(literal, ctx) : getNodeText(elem, ctx.source);
+      conditions.push(`${subject}[${idxStr}] === ${value}`);
+    }
+  });
+  return { condition: conditions.join(" && "), bindings };
+}
+function transformMappingPattern(pattern, subject, ctx) {
+  const children = getChildren(pattern);
+  const conditions = [`typeof ${subject} === "object"`, `${subject} !== null`];
+  const bindings = [];
+  let i = 0;
+  while (i < children.length) {
+    const child = children[i];
+    if (child?.name === "LiteralPattern" || child?.name === "String") {
+      const keyNode = child.name === "LiteralPattern" ? getChildren(child)[0] : child;
+      const key = keyNode ? transformNode(keyNode, ctx) : getNodeText(child, ctx.source);
+      const valuePattern = children[i + 2];
+      if (children[i + 1]?.name === ":" && valuePattern) {
+        conditions.push(`${key} in ${subject}`);
+        if (valuePattern.name === "CapturePattern") {
+          const varName = getNodeText(valuePattern, ctx.source);
+          if (varName !== "_") {
+            bindings.push(`const ${varName} = ${subject}[${key}];`);
+          }
+        } else if (valuePattern.name === "LiteralPattern") {
+          const valueChildren = getChildren(valuePattern);
+          const literal = valueChildren[0];
+          const value = literal ? transformNode(literal, ctx) : getNodeText(valuePattern, ctx.source);
+          conditions.push(`${subject}[${key}] === ${value}`);
+        }
+        i += 3;
+        continue;
+      }
+    }
+    i++;
+  }
+  return { condition: conditions.join(" && "), bindings };
+}
+function transformClassPattern(pattern, subject, ctx) {
+  const children = getChildren(pattern);
+  const className = children.find((c) => c.name === "VariableName");
+  const argList = children.find((c) => c.name === "PatternArgList");
+  const conditions = [];
+  const bindings = [];
+  if (className) {
+    const classNameText = getNodeText(className, ctx.source);
+    conditions.push(`${subject} instanceof ${classNameText}`);
+  }
+  if (argList) {
+    const argChildren = getChildren(argList);
+    for (const arg of argChildren) {
+      if (arg.name === "KeywordPattern") {
+        const kwChildren = getChildren(arg);
+        const attrName = kwChildren.find((c) => c.name === "VariableName");
+        const valuePattern = kwChildren.find(
+          (c) => c.name === "LiteralPattern" || c.name === "CapturePattern"
+        );
+        if (attrName && valuePattern) {
+          const attrNameText = getNodeText(attrName, ctx.source);
+          if (valuePattern.name === "LiteralPattern") {
+            const litChildren = getChildren(valuePattern);
+            const literal = litChildren[0];
+            const value = literal ? transformNode(literal, ctx) : getNodeText(valuePattern, ctx.source);
+            conditions.push(`${subject}.${attrNameText} === ${value}`);
+          } else if (valuePattern.name === "CapturePattern") {
+            const varName = getNodeText(valuePattern, ctx.source);
+            if (varName !== "_") {
+              bindings.push(`const ${varName} = ${subject}.${attrNameText};`);
+            }
+          }
+        }
+      }
+    }
+  }
+  return { condition: conditions.length > 0 ? conditions.join(" && ") : "true", bindings };
+}
+function transformOrPattern(pattern, subject, ctx) {
+  const children = getChildren(pattern);
+  const subPatterns = children.filter((c) => c.name !== "LogicOp");
+  const conditions = [];
+  for (const subPattern of subPatterns) {
+    const { condition } = transformComplexPattern(subPattern, subject, ctx);
+    conditions.push(condition);
+  }
+  return { condition: conditions.join(" || "), bindings: [] };
+}
+function transformAsPattern(pattern, subject, ctx) {
+  const children = getChildren(pattern);
+  const innerPattern = children.find(
+    (c) => c.name !== "as" && c.name !== "VariableName" && c.name !== "\u26A0"
+  );
+  const asName = children.find((c) => c.name === "VariableName");
+  if (!innerPattern) {
+    return { condition: "true", bindings: [] };
+  }
+  const { condition, bindings } = transformComplexPattern(innerPattern, subject, ctx);
+  if (asName) {
+    const varName = getNodeText(asName, ctx.source);
+    bindings.push(`const ${varName} = ${subject};`);
+  }
+  return { condition, bindings };
+}
+function transformMatchBody(node, ctx) {
+  const children = getChildren(node);
+  const clauses = [];
+  const indent = "  ".repeat(ctx.indentLevel + 1);
+  for (const child of children) {
+    if (child.name === "MatchClause") {
+      clauses.push(transformMatchClause(child, ctx, indent));
+    }
+  }
+  return clauses.join("\n");
+}
+function transformMatchClause(node, ctx, indent) {
+  const children = getChildren(node);
+  let pattern = null;
+  let body = null;
+  for (const child of children) {
+    if (child.name === "case" || child.name === ":") continue;
+    if (child.name === "Body") {
+      body = child;
+    } else if (!pattern) {
+      pattern = child;
+    }
+  }
+  if (!pattern || !body) return "";
+  const patternText = getNodeText(pattern, ctx.source);
+  ctx.indentLevel++;
+  const bodyCode = transformBody(body, ctx);
+  ctx.indentLevel--;
+  const bodyIndent = indent + "  ";
+  if (patternText === "_" || pattern.name === "CapturePattern") {
+    const captureVar = getNodeText(pattern, ctx.source);
+    if (captureVar === "_") {
+      return `${indent}default:
+${bodyIndent}${bodyCode.trim()}
+${bodyIndent}break;`;
+    }
+  }
+  if (pattern.name === "OrPattern") {
+    const orChildren = getChildren(pattern);
+    const subPatterns = orChildren.filter((c) => c.name !== "LogicOp");
+    const caseLabels = subPatterns.map((p) => {
+      const caseValue2 = transformMatchPatternSimple(p, ctx);
+      return `${indent}case ${caseValue2}:`;
+    });
+    return `${caseLabels.join("\n")}
+${bodyIndent}${bodyCode.trim()}
+${bodyIndent}break;`;
+  }
+  const caseValue = transformMatchPatternSimple(pattern, ctx);
+  return `${indent}case ${caseValue}:
+${bodyIndent}${bodyCode.trim()}
+${bodyIndent}break;`;
+}
+function transformMatchPatternSimple(node, ctx) {
+  switch (node.name) {
+    case "LiteralPattern": {
+      const children = getChildren(node);
+      const literal = children[0];
+      if (literal) {
+        return transformNode(literal, ctx);
+      }
+      return getNodeText(node, ctx.source);
+    }
+    case "CapturePattern":
+      return getNodeText(node, ctx.source);
+    /* v8 ignore next 2 -- fallback for unknown case patterns @preserve */
+    default:
+      return getNodeText(node, ctx.source);
+  }
+}
+function transformForStatement(node, ctx) {
+  const children = getChildren(node);
+  const isAsync = children.some(
+    (c) => c.name === "async" || c.name === "Keyword" && getNodeText(c, ctx.source) === "async"
+  );
+  const varNodes = [];
+  let iterableNode = null;
+  let bodyNode = null;
+  let foundFor = false;
+  let foundIn = false;
+  for (const child of children) {
+    if (child.name === "for" || child.name === "Keyword" && getNodeText(child, ctx.source) === "for") {
+      foundFor = true;
+    } else if (child.name === "in" || child.name === "Keyword" && getNodeText(child, ctx.source) === "in") {
+      foundIn = true;
+    } else if (child.name === "Body") {
+      bodyNode = child;
+    } else if (child.name !== ":" && child.name !== "Keyword" && child.name !== "," && child.name !== "async") {
+      if (foundFor && !foundIn) {
+        varNodes.push(child);
+      } else if (foundIn && !bodyNode) {
+        iterableNode = child;
+      }
+    }
+  }
+  if (varNodes.length === 0 || !iterableNode || !bodyNode) {
+    return getNodeText(node, ctx.source);
+  }
+  let varCode;
+  if (varNodes.length === 1 && varNodes[0]) {
+    varCode = transformNode(varNodes[0], ctx);
+  } else {
+    varCode = "[" + varNodes.map((v) => transformForLoopVar(v, ctx)).join(", ") + "]";
+  }
+  let iterableCode = transformNode(iterableNode, ctx);
+  const bodyCode = transformBody(bodyNode, ctx);
+  if (iterableNode.name === "VariableName" && !isAsync) {
+    ctx.usesRuntime.add("iter");
+    iterableCode = `iter(${iterableCode})`;
+  }
+  const forKeyword = isAsync ? "for await" : "for";
+  return `${forKeyword} (const ${varCode} of ${iterableCode}) {
+${bodyCode}
+}`;
+}
+function transformForLoopVar(node, ctx) {
+  if (node.name === "VariableName") {
+    return getNodeText(node, ctx.source);
+  } else if (node.name === "TupleExpression") {
+    const children = getChildren(node);
+    const elements = children.filter((c) => c.name !== "(" && c.name !== ")" && c.name !== ",");
+    return "[" + elements.map((e) => transformForLoopVar(e, ctx)).join(", ") + "]";
+  }
+  return transformNode(node, ctx);
+}
+function transformTryStatement(node, ctx) {
+  const children = getChildren(node);
+  const baseIndent = "  ".repeat(ctx.indentLevel);
+  let tryBody = null;
+  const exceptBodies = [];
+  let finallyBody = null;
+  let i = 0;
+  while (i < children.length) {
+    const child = children[i];
+    if (!child) {
+      i++;
+      continue;
+    }
+    if (child.name === "try") {
+      const nextBody = children[i + 1];
+      if (nextBody && nextBody.name === "Body") {
+        tryBody = nextBody;
+        i += 2;
+        continue;
+      }
+    }
+    if (child.name === "except") {
+      let exceptType = null;
+      let exceptVar = null;
+      let exceptBody = null;
+      let j = i + 1;
+      while (j < children.length) {
+        const next = children[j];
+        if (!next) break;
+        if (next.name === "Body") {
+          exceptBody = next;
+          j++;
+          break;
+        } else if (next.name === "VariableName") {
+          if (exceptType === null) {
+            exceptType = getNodeText(next, ctx.source);
+          } else {
+            exceptVar = getNodeText(next, ctx.source);
+          }
+        } else if (next.name === "as") {
+        } else if (next.name === "except" || next.name === "finally") {
+          break;
+        }
+        j++;
+      }
+      if (exceptBody) {
+        exceptBodies.push({ type: exceptType, varName: exceptVar, body: exceptBody });
+      }
+      i = j;
+      continue;
+    }
+    if (child.name === "finally") {
+      const nextBody = children[i + 1];
+      if (nextBody && nextBody.name === "Body") {
+        finallyBody = nextBody;
+        i += 2;
+        continue;
+      }
+    }
+    i++;
+  }
+  if (!tryBody) {
+    return getNodeText(node, ctx.source);
+  }
+  const tryCode = transformBody(tryBody, ctx);
+  let result = `try {
+${tryCode}
+${baseIndent}}`;
+  if (exceptBodies.length > 0) {
+    const firstExcept = exceptBodies[0];
+    if (firstExcept) {
+      const catchVar = firstExcept.varName || "e";
+      const catchBody = transformBody(firstExcept.body, ctx);
+      if (exceptBodies.length === 1 && !firstExcept.type) {
+        result += ` catch (${catchVar}) {
+${catchBody}
+${baseIndent}}`;
+      } else if (exceptBodies.length === 1) {
+        result += ` catch (${catchVar}) {
+${catchBody}
+${baseIndent}}`;
+      } else {
+        const innerIndent = "  ".repeat(ctx.indentLevel + 1);
+        let catchBodyCode = "";
+        for (let idx = 0; idx < exceptBodies.length; idx++) {
+          const exc = exceptBodies[idx];
+          if (!exc) continue;
+          const excBodyCode = transformBody(exc.body, ctx);
+          const excVar = exc.varName || catchVar;
+          if (exc.type) {
+            const condition = idx === 0 ? "if" : "} else if";
+            const mappedType = mapExceptionType(exc.type);
+            catchBodyCode += `${innerIndent}${condition} (${catchVar} instanceof ${mappedType}) {
+`;
+            if (excVar !== catchVar) {
+              catchBodyCode += `${innerIndent}  const ${excVar} = ${catchVar};
+`;
+            }
+            catchBodyCode += excBodyCode.split("\n").map((line) => "  " + line).join("\n");
+            catchBodyCode += "\n";
+          } else {
+            if (idx > 0) {
+              catchBodyCode += `${innerIndent}} else {
+`;
+            }
+            catchBodyCode += excBodyCode.split("\n").map((line) => "  " + line).join("\n");
+            catchBodyCode += "\n";
+          }
+        }
+        if (exceptBodies.some((e) => e.type)) {
+          catchBodyCode += `${innerIndent}}`;
+        }
+        result += ` catch (${catchVar}) {
+${catchBodyCode}${baseIndent}}`;
+      }
+    }
+  }
+  if (finallyBody) {
+    const finallyCode = transformBody(finallyBody, ctx);
+    result += ` finally {
+${finallyCode}
+${baseIndent}}`;
+  }
+  return result;
+}
+function mapExceptionType(pythonType) {
+  const mapping = {
+    Exception: "Error",
+    BaseException: "Error",
+    ValueError: "Error",
+    TypeError: "TypeError",
+    KeyError: "Error",
+    IndexError: "RangeError",
+    AttributeError: "Error",
+    RuntimeError: "Error",
+    StopIteration: "Error",
+    ZeroDivisionError: "Error",
+    FileNotFoundError: "Error",
+    IOError: "Error",
+    OSError: "Error",
+    NameError: "ReferenceError",
+    SyntaxError: "SyntaxError"
+  };
+  return mapping[pythonType] || "Error";
+}
+function transformRaiseStatement(node, ctx) {
+  const children = getChildren(node);
+  const exprNode = children.find((c) => c.name !== "raise");
+  if (!exprNode) {
+    return "throw";
+  }
+  const expr = transformNode(exprNode, ctx);
+  if (exprNode.name === "CallExpression") {
+    const callChildren = getChildren(exprNode);
+    const funcName = callChildren.find((c) => c.name === "VariableName");
+    if (funcName) {
+      const name = getNodeText(funcName, ctx.source);
+      if (isExceptionType(name)) {
+        const argList = callChildren.find((c) => c.name === "ArgList");
+        if (argList) {
+          const args = getChildren(argList).filter(
+            (c) => c.name !== "(" && c.name !== ")" && c.name !== ","
+          );
+          if (args.length > 0 && args[0]) {
+            const message = transformNode(args[0], ctx);
+            return `throw new Error(${message})`;
+          }
+        }
+        return "throw new Error()";
+      }
+    }
+  }
+  if (exprNode.name === "String") {
+    return `throw new Error(${expr})`;
+  }
+  return `throw ${expr}`;
+}
+function isExceptionType(name) {
+  const exceptionTypes = [
+    "Exception",
+    "BaseException",
+    "ValueError",
+    "TypeError",
+    "KeyError",
+    "IndexError",
+    "AttributeError",
+    "RuntimeError",
+    "StopIteration",
+    "ZeroDivisionError",
+    "FileNotFoundError",
+    "IOError",
+    "OSError",
+    "NameError",
+    "SyntaxError",
+    "AssertionError",
+    "NotImplementedError",
+    "ImportError",
+    "ModuleNotFoundError"
+  ];
+  return exceptionTypes.includes(name);
+}
+function transformImportStatement(node, ctx) {
+  const children = getChildren(node);
+  const hasFrom = children.some((c) => c.name === "from");
+  if (hasFrom) {
+    return transformFromImport(children, ctx);
+  } else {
+    return transformSimpleImport(children, ctx);
+  }
+}
+function transformSimpleImport(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 && nextChild.name === "as") {
+        const aliasChild = children[i + 2];
+        if (aliasChild && 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 `import * as ${importName} from "${module}"`;
+  }).join("\n");
+}
+var TYPING_MODULES = /* @__PURE__ */ new Set([
+  "typing",
+  "typing_extensions",
+  "collections.abc",
+  "__future__",
+  "abc"
+]);
+var RUNTIME_MODULES = /* @__PURE__ */ new Set([
+  "itertools",
+  "collections",
+  "math",
+  "random",
+  "json",
+  "os",
+  "datetime",
+  "re",
+  "string",
+  "functools"
+]);
+function transformFromImport(children, ctx) {
+  let preCheckModule = "";
+  for (const child of children) {
+    if (child.name === "VariableName") {
+      const prevChild = children[children.indexOf(child) - 1];
+      if (prevChild?.name === "from" || prevChild?.name === ".") {
+        preCheckModule = getNodeText(child, ctx.source);
+        break;
+      }
+    }
+  }
+  if (TYPING_MODULES.has(preCheckModule)) {
+    return "";
+  }
+  if (RUNTIME_MODULES.has(preCheckModule)) {
+    return "";
+  }
+  let moduleName = "";
+  let relativeDots = 0;
+  const imports = [];
+  let hasStar = false;
+  let phase = "from";
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (!child) continue;
+    if (child.name === "from") {
+      phase = "module";
+      continue;
+    }
+    if (child.name === ".") {
+      relativeDots++;
+      continue;
+    }
+    if (child.name === "Ellipsis") {
+      relativeDots += 3;
+      continue;
+    }
+    if (child.name === "import") {
+      phase = "names";
+      continue;
+    }
+    if (phase === "module" && child.name === "VariableName") {
+      moduleName = getNodeText(child, ctx.source);
+      continue;
+    }
+    if (phase === "names") {
+      if (child.name === "*") {
+        hasStar = true;
+        continue;
+      }
+      if (child.name === "VariableName") {
+        const name = getNodeText(child, ctx.source);
+        const nextChild = children[i + 1];
+        if (nextChild && nextChild.name === "as") {
+          const aliasChild = children[i + 2];
+          if (aliasChild && aliasChild.name === "VariableName") {
+            imports.push({ name, alias: getNodeText(aliasChild, ctx.source) });
+            i += 2;
+            continue;
+          }
+        }
+        imports.push({ name, alias: null });
+        continue;
+      }
+      if (child.name === ",") {
+        continue;
+      }
+    }
+  }
+  let modulePath = "";
+  if (relativeDots > 0) {
+    if (relativeDots === 1) {
+      modulePath = "./";
+    } else {
+      modulePath = "../".repeat(relativeDots - 1);
+    }
+    if (moduleName) {
+      modulePath += moduleName;
+    } else if (imports.length > 0) {
+      modulePath += imports[0]?.name || "";
+    }
+  } else {
+    modulePath = moduleName;
+  }
+  if (hasStar) {
+    return `import * as ${moduleName || "_"} from "${modulePath}"`;
+  }
+  if (relativeDots > 0 && !moduleName && imports.length === 1) {
+    const imp = imports[0];
+    if (imp) {
+      const importName = imp.alias || imp.name;
+      return `import * as ${importName} from "${modulePath}"`;
+    }
+  }
+  const importNames = imports.map(({ name, alias }) => alias ? `${name} as ${alias}` : name).join(", ");
+  return `import { ${importNames} } from "${modulePath}"`;
+}
+function transformAwaitExpression(node, ctx) {
+  const children = getChildren(node);
+  const exprNode = children.find((c) => c.name !== "await");
+  if (!exprNode) {
+    return "await";
+  }
+  return `await ${transformNode(exprNode, ctx)}`;
+}
+function transformWithStatement(node, ctx) {
+  const children = getChildren(node);
+  const isAsync = children.some((c) => c.name === "async");
+  const contextManagers = [];
+  let body = null;
+  let i = 0;
+  while (i < children.length) {
+    const child = children[i];
+    if (!child) {
+      i++;
+      continue;
+    }
+    if (child.name === "with" || child.name === "async" || child.name === ",") {
+      i++;
+      continue;
+    }
+    if (child.name === "Body") {
+      body = child;
+      break;
+    }
+    if (child.name !== "as" && child.name !== ":" && child.name !== "VariableName") {
+      const expr = child;
+      let varName = null;
+      const nextChild = children[i + 1];
+      if (nextChild && nextChild.name === "as") {
+        const varChild = children[i + 2];
+        if (varChild && varChild.name === "VariableName") {
+          varName = getNodeText(varChild, ctx.source);
+          i += 3;
+        } else {
+          i++;
+        }
+      } else {
+        i++;
+      }
+      contextManagers.push({ expr, varName });
+      continue;
+    }
+    i++;
+  }
+  if (contextManagers.length === 0 || !body) {
+    return getNodeText(node, ctx.source);
+  }
+  const bodyCode = transformBody(body, ctx);
+  let result = bodyCode;
+  for (let j = contextManagers.length - 1; j >= 0; j--) {
+    const cm = contextManagers[j];
+    if (!cm) continue;
+    const exprCode = transformNode(cm.expr, ctx);
+    const innerIndent = "  ".repeat(ctx.indentLevel + j);
+    const innerIndent2 = "  ".repeat(ctx.indentLevel + j + 1);
+    if (cm.varName) {
+      const assignment = `${innerIndent}const ${cm.varName} = ${exprCode};
+`;
+      const tryBlock = `${innerIndent}try {
+${result}
+${innerIndent}}`;
+      const finallyBlock = ` finally {
+${innerIndent2}${cm.varName}[Symbol.dispose]?.() ?? ${cm.varName}.close?.();
+${innerIndent}}`;
+      if (isAsync && j === 0) {
+        const asyncFinallyBlock = ` finally {
+${innerIndent2}await (${cm.varName}[Symbol.asyncDispose]?.() ?? ${cm.varName}[Symbol.dispose]?.() ?? ${cm.varName}.close?.());
+${innerIndent}}`;
+        result = assignment + tryBlock + asyncFinallyBlock;
+      } else {
+        result = assignment + tryBlock + finallyBlock;
+      }
+    } else {
+      const tempVar = j > 0 ? `_resource${String(j)}` : "_resource";
+      const assignment = `${innerIndent}const ${tempVar} = ${exprCode};
+`;
+      const tryBlock = `${innerIndent}try {
+${result}
+${innerIndent}}`;
+      const finallyBlock = ` finally {
+${innerIndent2}${tempVar}[Symbol.dispose]?.() ?? ${tempVar}.close?.();
+${innerIndent}}`;
+      result = assignment + tryBlock + finallyBlock;
+    }
+  }
+  return result;
+}
+function transformBody(node, ctx, skipFirst = false) {
+  ctx.indentLevel++;
+  pushScope(ctx);
+  const children = getChildren(node);
+  const indent = "  ".repeat(ctx.indentLevel);
+  let filteredChildren = children.filter((child) => child.name !== ":");
+  if (skipFirst && filteredChildren.length > 0) {
+    filteredChildren = filteredChildren.slice(1);
+  }
+  const statements = filteredChildren.map((child) => {
+    const transformed = transformNode(child, ctx);
+    if (transformed === "") {
+      return "";
+    }
+    if (child.name === "ExpressionStatement" || child.name === "AssignStatement" || child.name === "PassStatement" || child.name === "BreakStatement" || child.name === "ContinueStatement" || child.name === "ReturnStatement" || child.name === "RaiseStatement") {
+      return indent + transformed + ";";
+    }
+    return indent + transformed;
+  }).filter((s) => s.trim() !== "");
+  popScope(ctx);
+  ctx.indentLevel--;
+  return statements.join("\n");
+}
+function transformReturnStatement(node, ctx) {
+  const children = getChildren(node);
+  const value = children.find((c) => c.name !== "return" && c.name !== "Keyword");
+  if (!value) {
+    return "return";
+  }
+  return `return ${transformNode(value, ctx)}`;
+}
+function transformFunctionDefinition(node, ctx) {
+  const children = getChildren(node);
+  let isAsync = false;
+  let funcName = "";
+  let paramList = null;
+  let body = null;
+  let returnTypeDef = null;
+  for (const child of children) {
+    if (child.name === "async") {
+      isAsync = true;
+    } else if (child.name === "VariableName") {
+      funcName = getNodeText(child, ctx.source);
+    } else if (child.name === "ParamList") {
+      paramList = child;
+    } else if (child.name === "Body") {
+      body = child;
+    } else if (child.name === "TypeDef") {
+      returnTypeDef = child;
+    }
+  }
+  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 isGenerator = body ? containsYield(body) : false;
+  let returnType = "";
+  if (returnTypeDef) {
+    const typeChildren = getChildren(returnTypeDef);
+    const typeNode = typeChildren.find((c) => c.name !== ":" && c.name !== "->");
+    if (typeNode) {
+      const tsType = transformPythonType(typeNode, ctx);
+      returnType = `: ${tsType === "null" ? "void" : tsType}`;
+    }
+  }
+  const asyncPrefix = isAsync ? "async " : "";
+  const generatorStar = isGenerator ? "*" : "";
+  const funcDecl = `${asyncPrefix}function${generatorStar} ${funcName}(${params})${returnType} {
+${bodyCode}
+}`;
+  return jsdoc ? `${jsdoc}
+${funcDecl}` : funcDecl;
+}
+function transformClassDefinition(node, ctx) {
+  const children = getChildren(node);
+  let className = "";
+  const parentClasses = [];
+  let body = null;
+  for (const child of children) {
+    if (child.name === "VariableName") {
+      className = getNodeText(child, ctx.source);
+      ctx.definedClasses.add(className);
+    } else if (child.name === "ArgList") {
+      const argChildren = getChildren(child);
+      for (const argChild of argChildren) {
+        if (argChild.name === "VariableName") {
+          parentClasses.push(getNodeText(argChild, ctx.source));
+        } else if (argChild.name === "MemberExpression") {
+          parentClasses.push(getNodeText(argChild, ctx.source));
+        }
+      }
+    } else if (child.name === "Body") {
+      body = child;
+    }
+  }
+  const indent = "  ".repeat(ctx.indentLevel);
+  const { jsdoc, skipFirstStatement } = body ? extractDocstringFromBody(body, ctx, indent) : { jsdoc: null, skipFirstStatement: false };
+  let classHeader = `class ${className}`;
+  let multipleInheritanceWarning = "";
+  const firstParent = parentClasses[0];
+  if (firstParent) {
+    if (firstParent === "NamedTuple") {
+      return transformNamedTuple(className, body, ctx);
+    }
+    if (firstParent === "Enum" || firstParent === "IntEnum" || firstParent === "StrEnum") {
+      return transformEnum(className, firstParent, body, ctx);
+    }
+    if (firstParent === "TypedDict") {
+      const totalFalse = checkTypedDictTotalFalse(node, ctx);
+      return transformTypedDict(className, body, totalFalse, ctx);
+    }
+    if (firstParent === "Protocol") {
+      return transformProtocol(className, parentClasses, body, ctx);
+    }
+    if (firstParent === "ABC" || parentClasses.includes("ABC")) {
+      return transformAbstractClass(className, parentClasses, body, ctx, jsdoc);
+    }
+    const genericParams = extractGenericParams(parentClasses);
+    if (genericParams.length > 0) {
+      const filteredParents = parentClasses.filter((p) => !p.startsWith("Generic["));
+      return transformGenericClass(className, genericParams, filteredParents, body, ctx, jsdoc);
+    }
+    classHeader += ` extends ${firstParent}`;
+    if (parentClasses.length > 1) {
+      const ignoredParents = parentClasses.slice(1).join(", ");
+      multipleInheritanceWarning = `/* WARNING: Multiple inheritance not fully supported. Only extends ${firstParent}. Mixins needed for: ${ignoredParents} */
+`;
+    }
+  }
+  const bodyCode = body ? transformClassBody(body, ctx, skipFirstStatement) : "";
+  const classDecl = `${multipleInheritanceWarning}${classHeader} {
+${bodyCode}
+}`;
+  return jsdoc ? `${jsdoc}
+${classDecl}` : classDecl;
+}
+function transformClassBody(node, ctx, skipFirst = false) {
+  ctx.indentLevel++;
+  const children = getChildren(node);
+  const indent = "  ".repeat(ctx.indentLevel);
+  const members = [];
+  let filteredChildren = children.filter((c) => c.name !== ":");
+  if (skipFirst && filteredChildren.length > 0) {
+    filteredChildren = filteredChildren.slice(1);
+  }
+  for (const child of filteredChildren) {
+    if (child.name === "FunctionDefinition") {
+      members.push(transformClassMethod(child, ctx, null));
+    } else if (child.name === "DecoratedStatement") {
+      members.push(transformClassDecoratedMethod(child, ctx));
+    } else if (child.name === "AssignStatement") {
+      const transformed = transformClassProperty(child, ctx, indent);
+      if (transformed) {
+        members.push(transformed);
+      }
+    } else if (child.name === "ExpressionStatement") {
+      if (!isDocstringNode(child, ctx)) {
+        const transformed = transformNode(child, ctx);
+        if (transformed.trim()) {
+          members.push(indent + transformed + ";");
+        }
+      }
+    } else if (child.name === "PassStatement") {
+    }
+  }
+  ctx.indentLevel--;
+  return members.filter((m) => m.trim()).join("\n\n");
+}
+function transformClassProperty(node, ctx, indent) {
+  const children = getChildren(node);
+  if (children.length < 2) return "";
+  const assignOpIndex = children.findIndex((c) => c.name === "AssignOp" || c.name === "=");
+  const typeDef = children.find((c) => c.name === "TypeDef");
+  if (assignOpIndex === -1) {
+    const targets2 = children.filter((c) => c.name !== "," && c.name !== "TypeDef" && c.name !== ":");
+    const target2 = targets2[0];
+    if (!target2) return "";
+    const targetCode2 = transformNode(target2, ctx);
+    const tsType2 = extractTypeAnnotation(typeDef, ctx);
+    const typeAnnotation2 = tsType2 ? `: ${tsType2}` : "";
+    const modifiers2 = extractTypeModifiers(typeDef, ctx);
+    let prefix2 = "";
+    if (modifiers2.isClassVar) {
+      prefix2 = "static ";
+    }
+    if (modifiers2.isFinal) {
+      prefix2 += "readonly ";
+    }
+    return `${indent}${prefix2}${targetCode2}${typeAnnotation2};`;
+  }
+  const typeDefBeforeAssign = children.slice(0, assignOpIndex).find((c) => c.name === "TypeDef");
+  const targets = children.slice(0, assignOpIndex).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 "";
+  const target = targets[0];
+  if (!target) return "";
+  const targetCode = transformNode(target, ctx);
+  const tsType = extractTypeAnnotation(typeDefBeforeAssign, ctx);
+  const typeAnnotation = tsType ? `: ${tsType}` : "";
+  const modifiers = extractTypeModifiers(typeDefBeforeAssign, ctx);
+  let prefix = "";
+  if (modifiers.isClassVar) {
+    prefix = "static ";
+  }
+  if (modifiers.isFinal) {
+    prefix += "readonly ";
+  }
+  const value = values[0];
+  const valueCode = value ? transformNode(value, ctx) : "";
+  return `${indent}${prefix}${targetCode}${typeAnnotation} = ${valueCode};`;
+}
+function transformClassMethod(node, ctx, decorator) {
+  const children = getChildren(node);
+  const indent = "  ".repeat(ctx.indentLevel);
+  let methodName = "";
+  let paramList = null;
+  let body = null;
+  for (const child of children) {
+    if (child.name === "VariableName") {
+      methodName = getNodeText(child, ctx.source);
+    } else if (child.name === "ParamList") {
+      paramList = child;
+    } else if (child.name === "Body") {
+      body = child;
+    }
+  }
+  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 isGenerator = body ? containsYield(body) : false;
+  const generatorStar = isGenerator ? "*" : "";
+  if (methodName === "__init__") {
+    const methodDecl2 = `${indent}constructor(${params}) {
+${bodyCode}
+${indent}}`;
+    return jsdoc ? `${jsdoc}
+${methodDecl2}` : methodDecl2;
+  }
+  if (methodName === "__str__" || methodName === "__repr__") {
+    const methodDecl2 = `${indent}toString() {
+${bodyCode}
+${indent}}`;
+    return jsdoc ? `${jsdoc}
+${methodDecl2}` : methodDecl2;
+  }
+  let prefix = "";
+  if (decorator === "staticmethod" || decorator === "classmethod") {
+    prefix = "static ";
+  } else if (decorator === "property") {
+    prefix = "get ";
+  } else if (decorator === "setter") {
+    prefix = "set ";
+  } else if (decorator === "abstractmethod") {
+    const typedParams = paramList ? transformMethodParamListWithTypes(paramList, ctx) : "";
+    const returnType = extractMethodReturnType(node, ctx);
+    const returnTypeStr = returnType ? `: ${returnType === "null" ? "void" : returnType}` : "";
+    const methodDecl2 = `${indent}abstract ${methodName}(${typedParams})${returnTypeStr}`;
+    return jsdoc ? `${jsdoc}
+${methodDecl2}` : methodDecl2;
+  }
+  const methodDecl = `${indent}${prefix}${generatorStar}${methodName}(${params}) {
+${bodyCode}
+${indent}}`;
+  return jsdoc ? `${jsdoc}
+${methodDecl}` : methodDecl;
+}
+function extractMethodReturnType(node, ctx) {
+  const children = getChildren(node);
+  for (const child of children) {
+    if (child.name === "TypeDef") {
+      return extractTypeAnnotation(child, ctx);
+    }
+  }
+  return null;
+}
+function transformClassDecoratedMethod(node, ctx) {
+  const children = getChildren(node);
+  let decorator = null;
+  let funcDef = null;
+  for (const child of children) {
+    if (child.name === "Decorator") {
+      const decChildren = getChildren(child);
+      const varNames = decChildren.filter((c) => c.name === "VariableName");
+      const hasDot = decChildren.some((c) => c.name === ".");
+      if (varNames.length >= 2 && hasDot) {
+        const propName = varNames[varNames.length - 1];
+        if (propName) {
+          decorator = getNodeText(propName, ctx.source);
+        }
+      } else {
+        const nameNode = varNames[0];
+        if (nameNode) {
+          decorator = getNodeText(nameNode, ctx.source);
+        }
+      }
+    } else if (child.name === "FunctionDefinition") {
+      funcDef = child;
+    }
+  }
+  if (!funcDef) {
+    return getNodeText(node, ctx.source);
+  }
+  return transformClassMethod(funcDef, ctx, decorator);
+}
+function transformMethodParamList(node, ctx) {
+  return transformMethodParamListImpl(node, ctx, false);
+}
+function transformMethodParamListWithTypes(node, ctx) {
+  return transformMethodParamListImpl(node, ctx, true);
+}
+function transformMethodParamListImpl(node, ctx, includeTypes) {
+  const children = getChildren(node);
+  const params = [];
+  let i = 0;
+  let isFirstParam = true;
+  while (i < children.length) {
+    const child = children[i];
+    if (!child) {
+      i++;
+      continue;
+    }
+    if (child.name === "(" || child.name === ")" || child.name === ",") {
+      i++;
+      continue;
+    }
+    if (child.name === "VariableName" && isFirstParam) {
+      const name = getNodeText(child, ctx.source);
+      if (name === "self" || name === "cls") {
+        i++;
+        isFirstParam = false;
+        continue;
+      }
+    }
+    isFirstParam = false;
+    if (child.name === "*" || getNodeText(child, ctx.source) === "*") {
+      const nextChild = children[i + 1];
+      if (nextChild && nextChild.name === "VariableName") {
+        const name = getNodeText(nextChild, ctx.source);
+        params.push(`...${name}`);
+        i += 2;
+        continue;
+      }
+      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);
+        params.push(name);
+        i += 2;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (child.name === "VariableName") {
+      const nameCode = getNodeText(child, ctx.source);
+      let typeStr = "";
+      let defaultStr = "";
+      let consumed = 1;
+      const nextChild = children[i + 1];
+      if (nextChild?.name === "TypeDef" && includeTypes) {
+        const t = extractTypeAnnotation(nextChild, ctx);
+        if (t) typeStr = `: ${t}`;
+        consumed++;
+        const afterType = children[i + 2];
+        if (afterType?.name === "AssignOp") {
+          const defaultVal = children[i + 3];
+          if (defaultVal) {
+            defaultStr = ` = ${transformNode(defaultVal, ctx)}`;
+            consumed += 2;
+          }
+        }
+      } else if (nextChild?.name === "AssignOp") {
+        const defaultValChild = children[i + 2];
+        if (defaultValChild) {
+          defaultStr = ` = ${transformNode(defaultValChild, ctx)}`;
+          consumed += 2;
+        }
+      }
+      params.push(`${nameCode}${typeStr}${defaultStr}`);
+      i += consumed;
+      continue;
+    }
+    i++;
+  }
+  return params.join(", ");
+}
+function transformClassMethodBody(node, ctx, skipFirst = false) {
+  ctx.indentLevel++;
+  const children = getChildren(node);
+  const indent = "  ".repeat(ctx.indentLevel);
+  let filteredChildren = children.filter((child) => child.name !== ":");
+  if (skipFirst && filteredChildren.length > 0) {
+    filteredChildren = filteredChildren.slice(1);
+  }
+  const statements = filteredChildren.map((child) => {
+    let transformed;
+    if (child.name === "AssignStatement") {
+      transformed = transformClassAssignment(child, ctx);
+    } else {
+      transformed = transformNode(child, ctx);
+    }
+    if (transformed === "") {
+      return "";
+    }
+    transformed = transformed.replace(/\bself\./g, "this.");
+    transformed = transformed.replace(/\bcls\./g, "this.");
+    transformed = transformed.replace(/super\(\)\.__init__\(/g, "super(");
+    transformed = transformed.replace(/\bcls\(\)/g, "new this()");
+    if (child.name === "ExpressionStatement" || child.name === "AssignStatement" || child.name === "PassStatement" || child.name === "BreakStatement" || child.name === "ContinueStatement" || child.name === "ReturnStatement") {
+      return indent + transformed + ";";
+    }
+    return indent + transformed;
+  }).filter((s) => s.trim() !== "");
+  ctx.indentLevel--;
+  return statements.join("\n");
+}
+function transformClassAssignment(node, ctx) {
+  const children = getChildren(node);
+  if (children.length < 3) return getNodeText(node, ctx.source);
+  const assignOpIndex = children.findIndex((c) => c.name === "AssignOp" || c.name === "=");
+  if (assignOpIndex === -1) return getNodeText(node, ctx.source);
+  const targets = children.slice(0, assignOpIndex).filter((c) => c.name !== ",");
+  const values = children.slice(assignOpIndex + 1).filter((c) => c.name !== ",");
+  if (targets.length === 0 || values.length === 0) {
+    return getNodeText(node, ctx.source);
+  }
+  if (targets.length === 1) {
+    const target = targets[0];
+    if (!target) return getNodeText(node, ctx.source);
+    const targetCode = transformNode(target, ctx);
+    const isMemberAssignment = target.name === "MemberExpression";
+    if (values.length === 1) {
+      const value = values[0];
+      if (!value) return getNodeText(node, ctx.source);
+      if (isMemberAssignment) {
+        return `${targetCode} = ${transformNode(value, ctx)}`;
+      }
+      return `let ${targetCode} = ${transformNode(value, ctx)}`;
+    } else {
+      const valuesCodes = values.map((v) => transformNode(v, ctx));
+      if (isMemberAssignment) {
+        return `${targetCode} = [${valuesCodes.join(", ")}]`;
+      }
+      return `let ${targetCode} = [${valuesCodes.join(", ")}]`;
+    }
+  }
+  const targetCodes = targets.map((t) => transformAssignTarget(t, ctx));
+  const targetPattern = `[${targetCodes.join(", ")}]`;
+  if (values.length === 1) {
+    const value = values[0];
+    if (!value) return getNodeText(node, ctx.source);
+    return `let ${targetPattern} = ${transformNode(value, ctx)}`;
+  } else {
+    const valuesCodes = values.map((v) => transformNode(v, ctx));
+    return `let ${targetPattern} = [${valuesCodes.join(", ")}]`;
+  }
+}
+function transformDecoratedStatement(node, ctx) {
+  const children = getChildren(node);
+  const decorators = [];
+  let funcDef = null;
+  let classDef = null;
+  for (const child of children) {
+    if (child.name === "Decorator") {
+      const decChildren = getChildren(child);
+      let decoratorName = "";
+      let decoratorArgs = null;
+      const nameParts = [];
+      for (const decChild of decChildren) {
+        if (decChild.name === "VariableName") {
+          nameParts.push(getNodeText(decChild, ctx.source));
+        } else if (decChild.name === "MemberExpression") {
+          decoratorName = transformNode(decChild, ctx);
+        } else if (decChild.name === "ArgList") {
+          decoratorArgs = transformArgList(decChild, ctx);
+        } else if (decChild.name === "CallExpression") {
+          const callChildren = getChildren(decChild);
+          for (const callChild of callChildren) {
+            if (callChild.name === "VariableName") {
+              nameParts.push(getNodeText(callChild, ctx.source));
+            } else if (callChild.name === "MemberExpression") {
+              decoratorName = transformNode(callChild, ctx);
+            } else if (callChild.name === "ArgList") {
+              decoratorArgs = transformArgList(callChild, ctx);
+            }
+          }
+        }
+      }
+      if (nameParts.length > 0) {
+        decoratorName = nameParts.join(".");
+      }
+      if (decoratorName) {
+        decorators.push({ name: decoratorName, args: decoratorArgs });
+      }
+    } else if (child.name === "FunctionDefinition") {
+      funcDef = child;
+    } else if (child.name === "ClassDefinition") {
+      classDef = child;
+    }
+  }
+  if (classDef) {
+    return transformDecoratedClass(classDef, decorators, ctx);
+  }
+  if (!funcDef) {
+    return getNodeText(node, ctx.source);
+  }
+  const funcChildren = getChildren(funcDef);
+  let funcName = "";
+  let paramList = null;
+  let body = null;
+  for (const child of funcChildren) {
+    if (child.name === "VariableName") {
+      funcName = getNodeText(child, ctx.source);
+    } else if (child.name === "ParamList") {
+      paramList = child;
+    } else if (child.name === "Body") {
+      body = child;
+    }
+  }
+  const params = paramList ? transformParamList(paramList, ctx) : "";
+  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) : "";
+  let funcExpr = `function ${funcName}(${params}) {
+${bodyCode}
+}`;
+  for (let i = decorators.length - 1; i >= 0; i--) {
+    const dec = decorators[i];
+    if (!dec) continue;
+    if (dec.args !== null) {
+      funcExpr = `${dec.name}(${dec.args})(${funcExpr})`;
+    } else {
+      funcExpr = `${dec.name}(${funcExpr})`;
+    }
+  }
+  return `const ${funcName} = ${funcExpr}`;
+}
+function transformDecoratedClass(classDef, decorators, ctx) {
+  const dataclassDecorator = decorators.find(
+    (d) => d.name === "dataclass" || d.name === "dataclasses.dataclass"
+  );
+  if (dataclassDecorator) {
+    const otherDecorators = decorators.filter((d) => d !== dataclassDecorator);
+    const dataclassCode = transformDataclass(classDef, dataclassDecorator, ctx);
+    if (otherDecorators.length === 0) {
+      return dataclassCode;
+    }
+    const children = getChildren(classDef);
+    let className = "";
+    for (const child of children) {
+      if (child.name === "VariableName") {
+        className = getNodeText(child, ctx.source);
+        break;
+      }
+    }
+    let expr = dataclassCode;
+    for (let i = otherDecorators.length - 1; i >= 0; i--) {
+      const dec = otherDecorators[i];
+      if (!dec) continue;
+      if (dec.args !== null) {
+        expr = `${dec.name}(${dec.args})(${expr})`;
+      } else {
+        expr = `${dec.name}(${expr})`;
+      }
+    }
+    return `const ${className} = ${expr}`;
+  }
+  return transformGenericDecoratedClass(classDef, decorators, ctx);
+}
+function transformGenericDecoratedClass(classDef, decorators, ctx) {
+  const children = getChildren(classDef);
+  let className = "";
+  for (const child of children) {
+    if (child.name === "VariableName") {
+      className = getNodeText(child, ctx.source);
+      ctx.definedClasses.add(className);
+      break;
+    }
+  }
+  let classExpr = transformClassDefinition(classDef, ctx);
+  for (let i = decorators.length - 1; i >= 0; i--) {
+    const dec = decorators[i];
+    if (!dec) continue;
+    if (dec.args !== null) {
+      classExpr = `${dec.name}(${dec.args})(${classExpr})`;
+    } else {
+      classExpr = `${dec.name}(${classExpr})`;
+    }
+  }
+  return `const ${className} = ${classExpr}`;
+}
+function parseDataclassOptions(args) {
+  const options = {
+    frozen: false
+  };
+  if (!args) return options;
+  if (args.includes("frozen: true") || args.includes("frozen=True") || args.includes("frozen=true")) {
+    options.frozen = true;
+  }
+  return options;
+}
+function extractDataclassFields(body, ctx) {
+  const fields = [];
+  const children = getChildren(body);
+  for (const child of children) {
+    if (child.name === ":") continue;
+    if (child.name === "AssignStatement") {
+      const field = parseDataclassFieldFromAssignment(child, ctx);
+      if (field) fields.push(field);
+    } else if (child.name === "ExpressionStatement") {
+      const field = parseDataclassFieldFromExpression(child, ctx);
+      if (field) fields.push(field);
+    }
+  }
+  return fields;
+}
+function parseDataclassFieldFromAssignment(node, ctx) {
+  const children = getChildren(node);
+  let varName = null;
+  let typeDef = null;
+  let assignOpIndex = -1;
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (!child) continue;
+    if (child.name === "VariableName" && !varName) {
+      varName = child;
+    } else if (child.name === "TypeDef") {
+      typeDef = child;
+    } else if (child.name === "AssignOp" || child.name === "=") {
+      assignOpIndex = i;
+    }
+  }
+  if (!varName || !typeDef) {
+    return null;
+  }
+  const name = getNodeText(varName, ctx.source);
+  const tsType = extractTypeAnnotation(typeDef, ctx) ?? "unknown";
+  let hasDefault = false;
+  let defaultValue = null;
+  let isFieldFactory = false;
+  if (assignOpIndex !== -1) {
+    hasDefault = true;
+    const valueNodes = children.slice(assignOpIndex + 1).filter((c) => c.name !== ",");
+    const firstValue = valueNodes[0];
+    if (firstValue) {
+      if (firstValue.name === "CallExpression") {
+        const callText = getNodeText(firstValue, ctx.source);
+        if (callText.startsWith("field(")) {
+          isFieldFactory = true;
+          defaultValue = parseFieldDefaultFactory(firstValue, ctx);
+        } else {
+          defaultValue = transformNode(firstValue, ctx);
+        }
+      } else {
+        defaultValue = transformNode(firstValue, ctx);
+      }
+    }
+  }
+  return { name, tsType, hasDefault, defaultValue, isFieldFactory };
+}
+function parseDataclassFieldFromExpression(node, ctx) {
+  const children = getChildren(node);
+  for (const child of children) {
+    if (child.name === "VariableName") {
+      const typeDef = children.find((c) => c.name === "TypeDef");
+      if (typeDef) {
+        const name = getNodeText(child, ctx.source);
+        const tsType = extractTypeAnnotation(typeDef, ctx) ?? "unknown";
+        return { name, tsType, hasDefault: false, defaultValue: null, isFieldFactory: false };
+      }
+    }
+  }
+  return null;
+}
+function parseFieldDefaultFactory(callNode, ctx) {
+  const text = getNodeText(callNode, ctx.source);
+  const factoryMatch = text.match(/default_factory\s*=\s*(\w+)/);
+  if (factoryMatch) {
+    const factory = factoryMatch[1];
+    if (factory === "list") return "[]";
+    if (factory === "dict") return "{}";
+    if (factory === "set") return "new Set()";
+    if (factory) return `${factory}()`;
+  }
+  const defaultMatch = text.match(/default\s*=\s*([^,)]+)/);
+  if (defaultMatch) {
+    return defaultMatch[1]?.trim() ?? "undefined";
+  }
+  return "undefined";
+}
+function transformDataclass(classDef, decorator, ctx) {
+  const children = getChildren(classDef);
+  let className = "";
+  let body = null;
+  const parentClasses = [];
+  for (const child of children) {
+    if (child.name === "VariableName") {
+      className = getNodeText(child, ctx.source);
+      ctx.definedClasses.add(className);
+    } else if (child.name === "ArgList") {
+      const argChildren = getChildren(child);
+      const parentNodes = argChildren.filter((c) => c.name === "VariableName");
+      for (const parentNode of parentNodes) {
+        parentClasses.push(getNodeText(parentNode, ctx.source));
+      }
+    } else if (child.name === "Body") {
+      body = child;
+    }
+  }
+  const options = parseDataclassOptions(decorator.args);
+  const fields = body ? extractDataclassFields(body, ctx) : [];
+  const indent = "  ".repeat(ctx.indentLevel);
+  const { jsdoc } = body ? extractDocstringFromBody(body, ctx, indent) : { jsdoc: null };
+  return generateDataclassCode(className, parentClasses, fields, options, body, ctx, jsdoc);
+}
+function generateDataclassCode(className, parentClasses, fields, options, body, ctx, jsdoc) {
+  const memberIndent = "  ";
+  const bodyIndent = "    ";
+  const members = [];
+  for (const field of fields) {
+    const readonly = options.frozen ? "readonly " : "";
+    if (field.hasDefault && field.defaultValue !== null && !field.isFieldFactory) {
+      members.push(
+        `${memberIndent}${readonly}${field.name}: ${field.tsType} = ${field.defaultValue};`
+      );
+    } else {
+      members.push(`${memberIndent}${readonly}${field.name}: ${field.tsType};`);
+    }
+  }
+  const constructorParams = fields.map((f) => {
+    if (f.hasDefault && f.defaultValue !== null) {
+      return `${f.name}: ${f.tsType} = ${f.defaultValue}`;
+    }
+    return `${f.name}: ${f.tsType}`;
+  }).join(", ");
+  const constructorAssignments = fields.map((f) => `${bodyIndent}this.${f.name} = ${f.name};`).join("\n");
+  let constructorBody = "";
+  if (parentClasses.length > 0) {
+    constructorBody += `${bodyIndent}super();
+`;
+  }
+  constructorBody += constructorAssignments;
+  if (options.frozen) {
+    constructorBody += `
+${bodyIndent}Object.freeze(this);`;
+  }
+  members.push(
+    `
+${memberIndent}constructor(${constructorParams}) {
+${constructorBody}
+${memberIndent}}`
+  );
+  if (body) {
+    const methodMembers = extractNonFieldMembers(body, ctx, fields);
+    if (methodMembers.length > 0) {
+      members.push(...methodMembers);
+    }
+  }
+  let classHeader = `class ${className}`;
+  const firstParent = parentClasses[0];
+  if (firstParent) {
+    classHeader += ` extends ${firstParent}`;
+  }
+  const classCode = `${classHeader} {
+${members.join("\n")}
+}`;
+  if (jsdoc) {
+    return `${jsdoc}
+${classCode}`;
+  }
+  return classCode;
+}
+function extractNonFieldMembers(body, ctx, fields) {
+  const members = [];
+  const children = getChildren(body);
+  const fieldNames = new Set(fields.map((f) => f.name));
+  let skipFirst = false;
+  const firstChild = children.find((c) => c.name !== ":");
+  if (firstChild && isDocstringNode(firstChild, ctx)) {
+    skipFirst = true;
+  }
+  let isFirst = true;
+  for (const child of children) {
+    if (child.name === ":") continue;
+    if (isFirst && skipFirst) {
+      isFirst = false;
+      continue;
+    }
+    isFirst = false;
+    if (child.name === "AssignStatement" || child.name === "ExpressionStatement") {
+      const childChildren = getChildren(child);
+      const varName = childChildren.find((c) => c.name === "VariableName");
+      if (varName && fieldNames.has(getNodeText(varName, ctx.source))) {
+        continue;
+      }
+      const hasTypeDef = childChildren.some((c) => c.name === "TypeDef");
+      if (hasTypeDef) {
+        continue;
+      }
+    }
+    if (child.name === "FunctionDefinition") {
+      const methodName = getMethodName(child, ctx);
+      if (methodName !== "__init__") {
+        ctx.indentLevel++;
+        members.push("\n" + transformClassMethod(child, ctx, null));
+        ctx.indentLevel--;
+      }
+    } else if (child.name === "DecoratedStatement") {
+      ctx.indentLevel++;
+      members.push("\n" + transformClassDecoratedMethod(child, ctx));
+      ctx.indentLevel--;
+    }
+  }
+  return members;
+}
+function getMethodName(node, ctx) {
+  const children = getChildren(node);
+  for (const child of children) {
+    if (child.name === "VariableName") {
+      return getNodeText(child, ctx.source);
+    }
+  }
+  return "";
+}
+function transformNamedTuple(className, body, ctx) {
+  const fields = body ? extractDataclassFields(body, ctx) : [];
+  return generateDataclassCode(
+    className,
+    [],
+    // no parent classes in output
+    fields,
+    { frozen: true },
+    // always frozen
+    body,
+    ctx,
+    null
+    // jsdoc
+  );
+}
+function transformEnum(className, enumType, body, ctx) {
+  const members = extractEnumMembers(body, ctx);
+  if (members.length === 0) {
+    return `type ${className} = never`;
+  }
+  const allStrings = members.every((m) => m.isString);
+  if (enumType === "StrEnum" || allStrings) {
+    return generateStringUnionEnum(className, members);
+  }
+  const isSequential = checkSequentialEnum(members);
+  if (isSequential) {
+    return generateNameUnionEnum(className, members);
+  }
+  return generateConstObjectEnum(className, members);
+}
+function extractEnumMembers(body, ctx) {
+  if (!body) return [];
+  const members = [];
+  const children = getChildren(body);
+  for (const child of children) {
+    if (child.name === "AssignStatement") {
+      const member = parseEnumMember(child, ctx);
+      if (member) {
+        members.push(member);
+      }
+    }
+  }
+  return members;
+}
+function parseEnumMember(node, ctx) {
+  const children = getChildren(node);
+  let name = "";
+  let value = "";
+  let isString = false;
+  let numericValue = null;
+  for (const child of children) {
+    if (child.name === "VariableName" && !name) {
+      name = getNodeText(child, ctx.source);
+    } else if (child.name === "Number") {
+      value = getNodeText(child, ctx.source);
+      numericValue = parseFloat(value);
+      isString = false;
+    } else if (child.name === "String") {
+      const rawValue = getNodeText(child, ctx.source);
+      value = rawValue.slice(1, -1);
+      isString = true;
+    } else if (child.name === "CallExpression") {
+      const callText = getNodeText(child, ctx.source);
+      if (callText === "auto()") {
+        value = "auto";
+        numericValue = null;
+        isString = false;
+      } else {
+        value = callText;
+        isString = false;
+      }
+    }
+  }
+  if (!name) return null;
+  return { name, value, isString, numericValue };
+}
+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 firstValue = values[0];
+  if (firstValue === void 0) return false;
+  for (let i = 1; i < values.length; i++) {
+    if (values[i] !== firstValue + i) return false;
+  }
+  return true;
+}
+function generateStringUnionEnum(className, members) {
+  const values = members.map((m) => `"${m.value}"`).join(" | ");
+  return `type ${className} = ${values}`;
+}
+function generateNameUnionEnum(className, members) {
+  const names = members.map((m) => `"${m.name}"`).join(" | ");
+  return `type ${className} = ${names}`;
+}
+function generateConstObjectEnum(className, members) {
+  const entries = members.map((m) => `  ${m.name}: ${m.value}`).join(",\n");
+  return `const ${className} = {
+${entries}
+} as const
+type ${className} = typeof ${className}[keyof typeof ${className}]`;
+}
+function checkTypedDictTotalFalse(node, ctx) {
+  const children = getChildren(node);
+  for (const child of children) {
+    if (child.name === "ArgList") {
+      const argText = getNodeText(child, ctx.source);
+      if (argText.includes("total=False") || argText.includes("total: False")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function transformTypedDict(className, body, totalFalse, ctx) {
+  const fields = body ? extractDataclassFields(body, ctx) : [];
+  const memberIndent = "  ";
+  const members = fields.map((f) => {
+    const optional = totalFalse ? "?" : "";
+    return `${memberIndent}${f.name}${optional}: ${f.tsType}`;
+  });
+  if (members.length === 0) {
+    return `interface ${className} {}`;
+  }
+  return `interface ${className} {
+${members.join("\n")}
+}`;
+}
+function transformAbstractClass(className, parentClasses, body, ctx, jsdoc) {
+  const filteredParents = parentClasses.filter((p) => p !== "ABC");
+  let classHeader = `abstract class ${className}`;
+  const firstParent = filteredParents[0];
+  if (firstParent) {
+    classHeader += ` extends ${firstParent}`;
+  }
+  ctx.isAbstractClass = true;
+  const bodyCode = body ? transformClassBody(body, ctx, false) : "";
+  ctx.isAbstractClass = false;
+  const classDecl = `${classHeader} {
+${bodyCode}
+}`;
+  return jsdoc ? `${jsdoc}
+${classDecl}` : classDecl;
+}
+function transformProtocol(className, parentClasses, body, ctx) {
+  const memberIndent = "  ";
+  const members = [];
+  const genericParams = extractGenericParams(parentClasses);
+  const genericStr = genericParams.length > 0 ? `<${genericParams.join(", ")}>` : "";
+  const otherParents = parentClasses.filter((p) => p !== "Protocol" && !p.startsWith("Generic["));
+  if (body) {
+    const children = getChildren(body);
+    for (const child of children) {
+      if (child.name === ":") continue;
+      if (child.name === "PassStatement") continue;
+      if (child.name === "FunctionDefinition") {
+        const sig = extractProtocolMethodSignature(child, ctx);
+        if (sig) {
+          members.push(`${memberIndent}${sig}`);
+        }
+      } else if (child.name === "ExpressionStatement" || child.name === "AssignStatement") {
+        const field = parseDataclassFieldFromExpression(child, ctx) || parseDataclassFieldFromAssignment(child, ctx);
+        if (field) {
+          members.push(`${memberIndent}${field.name}: ${field.tsType}`);
+        }
+      }
+    }
+  }
+  let header = `interface ${className}${genericStr}`;
+  if (otherParents.length > 0) {
+    header += ` extends ${otherParents.join(", ")}`;
+  }
+  if (members.length === 0) {
+    return `${header} {}`;
+  }
+  return `${header} {
+${members.join("\n")}
+}`;
+}
+function extractProtocolMethodSignature(node, ctx) {
+  const children = getChildren(node);
+  let methodName = "";
+  let params = [];
+  let returnType = "void";
+  for (const child of children) {
+    if (child.name === "def") continue;
+    if (child.name === "VariableName" && !methodName) {
+      methodName = getNodeText(child, ctx.source);
+    } else if (child.name === "ParamList") {
+      params = extractProtocolParams(child, ctx);
+    } else if (child.name === "TypeDef") {
+      const rt = extractTypeAnnotation(child, ctx);
+      if (rt) returnType = rt === "null" ? "void" : rt;
+    }
+  }
+  if (!methodName || methodName === "__init__") return null;
+  return `${methodName}(${params.join(", ")}): ${returnType}`;
+}
+function extractProtocolParams(node, ctx) {
+  const children = getChildren(node);
+  const params = [];
+  let i = 0;
+  while (i < children.length) {
+    const child = children[i];
+    if (!child || child.name === "(" || child.name === ")" || child.name === ",") {
+      i++;
+      continue;
+    }
+    if (child.name === "VariableName") {
+      const paramName = getNodeText(child, ctx.source);
+      if (paramName === "self" || paramName === "cls") {
+        i++;
+        continue;
+      }
+      let paramType = "unknown";
+      const nextChild = children[i + 1];
+      if (nextChild?.name === "TypeDef") {
+        const t = extractTypeAnnotation(nextChild, ctx);
+        if (t) paramType = t;
+        i++;
+      }
+      params.push(`${paramName}: ${paramType}`);
+    }
+    i++;
+  }
+  return params;
+}
+function extractGenericParams(parentClasses) {
+  for (const parent of parentClasses) {
+    if (parent.startsWith("Generic[") && parent.endsWith("]")) {
+      const inner = parent.slice(8, -1);
+      return inner.split(",").map((p) => p.trim());
+    }
+  }
+  return [];
+}
+function transformGenericClass(className, genericParams, parentClasses, body, ctx, jsdoc) {
+  const genericStr = `<${genericParams.join(", ")}>`;
+  let classHeader = `class ${className}${genericStr}`;
+  const firstParent = parentClasses[0];
+  if (firstParent) {
+    classHeader += ` extends ${firstParent}`;
+  }
+  const bodyCode = body ? transformClassBody(body, ctx, false) : "";
+  const classDecl = `${classHeader} {
+${bodyCode}
+}`;
+  return jsdoc ? `${jsdoc}
+${classDecl}` : classDecl;
+}
+function transformParamList(node, ctx) {
+  const children = getChildren(node);
+  const params = [];
+  let restParam = null;
+  let kwargsParam = null;
+  let i = 0;
+  while (i < children.length) {
+    const child = children[i];
+    if (!child) {
+      i++;
+      continue;
+    }
+    if (child.name === "(" || child.name === ")" || child.name === ",") {
+      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);
+        const typeChild = children[i + 2];
+        if (typeChild && typeChild.name === "TypeDef") {
+          const tsType = extractTypeAnnotation(typeChild, ctx);
+          restParam = tsType ? `...${name}: ${tsType}[]` : `...${name}`;
+          i += 3;
+        } else {
+          restParam = `...${name}`;
+          i += 2;
+        }
+        continue;
+      }
+      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;
+        i += 2;
+        continue;
+      }
+      i++;
+      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;
+        }
+      }
+      params.push(`${nameCode}${typeAnnotation}`);
+      i += offset;
+      continue;
+    }
+    if (child.name === "AssignParam" || child.name === "DefaultParam") {
+      const paramChildren = getChildren(child);
+      const name = paramChildren.find((c) => c.name === "VariableName");
+      const typeDef = paramChildren.find((c) => c.name === "TypeDef");
+      const defaultVal = paramChildren[paramChildren.length - 1];
+      if (name) {
+        const nameCode = getNodeText(name, ctx.source);
+        const tsType = extractTypeAnnotation(typeDef, ctx);
+        const typeAnnotation = tsType ? `: ${tsType}` : "";
+        if (defaultVal && name !== defaultVal && defaultVal.name !== "TypeDef") {
+          const defaultCode = transformNode(defaultVal, ctx);
+          params.push(`${nameCode}${typeAnnotation} = ${defaultCode}`);
+        } else {
+          params.push(`${nameCode}${typeAnnotation}`);
+        }
+      }
+      i++;
+      continue;
+    }
+    i++;
+  }
+  if (kwargsParam && !restParam) {
+    const kwargsType = ": Record<string, unknown>";
+    params.push(`${kwargsParam}${kwargsType} = {}`);
+  }
+  if (restParam) {
+    params.push(restParam);
+  }
+  return params.join(", ");
+}
+function transformComment(node, ctx) {
+  const text = getNodeText(node, ctx.source);
+  return "//" + text.slice(1);
+}
+function transformLambdaExpression(node, ctx) {
+  const children = getChildren(node);
+  let params = "";
+  let body = null;
+  let foundLambda = false;
+  let foundColon = false;
+  const paramNodes = [];
+  for (const child of children) {
+    const text = getNodeText(child, ctx.source);
+    if (child.name === "lambda" || child.name === "Keyword" && text === "lambda") {
+      foundLambda = true;
+      continue;
+    }
+    if (child.name === ":") {
+      foundColon = true;
+      continue;
+    }
+    if (foundLambda && !foundColon) {
+      if (child.name === "ParamList") {
+        params = transformParamList(child, ctx);
+      } else if (child.name === "VariableName") {
+        paramNodes.push(child);
+      } else if (child.name !== ",") {
+        paramNodes.push(child);
+      }
+    } else if (foundColon) {
+      body = child;
+      break;
+    }
+  }
+  if (!params && paramNodes.length > 0) {
+    params = paramNodes.map((p) => getNodeText(p, ctx.source)).join(", ");
+  }
+  const bodyCode = body ? transformNode(body, ctx) : "";
+  if (params) {
+    return `(${params}) => ${bodyCode}`;
+  }
+  return `() => ${bodyCode}`;
+}
+function parseComprehensionClauses(children, ctx) {
+  const items = children.filter(
+    (c) => c.name !== "[" && c.name !== "]" && c.name !== "{" && c.name !== "}"
+  );
+  if (items.length === 0) {
+    return { outputExpr: "", clauses: [] };
+  }
+  const outputNode = items[0];
+  if (!outputNode) {
+    return { outputExpr: "", clauses: [] };
+  }
+  const outputExpr = transformNode(outputNode, ctx);
+  const clauses = [];
+  let i = 1;
+  while (i < items.length) {
+    const item = items[i];
+    if (!item) {
+      i++;
+      continue;
+    }
+    if (item.name === "for" || item.name === "Keyword" && getNodeText(item, ctx.source) === "for") {
+      const varNode = items[i + 1];
+      const iterableNode = items[i + 3];
+      if (varNode && iterableNode) {
+        clauses.push({
+          type: "for",
+          variable: transformNode(varNode, ctx),
+          iterable: transformNode(iterableNode, ctx)
+        });
+        i += 4;
+      } else {
+        i++;
+      }
+    } else if (item.name === "if" || item.name === "Keyword" && getNodeText(item, ctx.source) === "if") {
+      const conditionNode = items[i + 1];
+      if (conditionNode) {
+        clauses.push({
+          type: "if",
+          condition: transformNode(conditionNode, ctx)
+        });
+        i += 2;
+      } else {
+        i++;
+      }
+    } else if (item.name === "in" || item.name === "Keyword" && getNodeText(item, ctx.source) === "in") {
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return { outputExpr, clauses };
+}
+function transformArrayComprehension(node, ctx) {
+  const children = getChildren(node);
+  const { outputExpr, clauses } = parseComprehensionClauses(children, ctx);
+  if (clauses.length === 0) {
+    return `[${outputExpr}]`;
+  }
+  return buildComprehensionChain(outputExpr, clauses, "array");
+}
+function transformDictComprehension(node, ctx) {
+  const children = getChildren(node);
+  const items = children.filter((c) => c.name !== "{" && c.name !== "}");
+  let keyExpr = "";
+  let valueExpr = "";
+  let colonIndex = -1;
+  for (let i2 = 0; i2 < items.length; i2++) {
+    const item = items[i2];
+    if (item?.name === ":") {
+      colonIndex = i2;
+      break;
+    }
+  }
+  const keyNode = items[0];
+  const valueNode = items[colonIndex + 1];
+  if (colonIndex > 0 && keyNode && valueNode) {
+    keyExpr = transformNode(keyNode, ctx);
+    valueExpr = transformNode(valueNode, ctx);
+  }
+  const clauseItems = items.slice(colonIndex + 2);
+  const clauses = [];
+  let i = 0;
+  while (i < clauseItems.length) {
+    const item = clauseItems[i];
+    if (!item) {
+      i++;
+      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) {
+        clauses.push({
+          type: "for",
+          variable: transformNode(varNode, ctx),
+          iterable: transformNode(iterableNode, ctx)
+        });
+        i += 4;
+      } else {
+        i++;
+      }
+    } else if (item.name === "if" || item.name === "Keyword" && getNodeText(item, ctx.source) === "if") {
+      const conditionNode = clauseItems[i + 1];
+      if (conditionNode) {
+        clauses.push({
+          type: "if",
+          condition: transformNode(conditionNode, ctx)
+        });
+        i += 2;
+      } else {
+        i++;
+      }
+    } else {
+      i++;
+    }
+  }
+  ctx.usesRuntime.add("dict");
+  return buildDictComprehensionChain(keyExpr, valueExpr, clauses);
+}
+function transformSetExpression(node, ctx) {
+  const children = getChildren(node);
+  const elements = children.filter((c) => c.name !== "{" && c.name !== "}" && c.name !== ",");
+  ctx.usesRuntime.add("set");
+  const elementCodes = elements.map((el) => transformNode(el, ctx));
+  return `set([${elementCodes.join(", ")}])`;
+}
+function transformSetComprehension(node, ctx) {
+  const children = getChildren(node);
+  const { outputExpr, clauses } = parseComprehensionClauses(children, ctx);
+  if (clauses.length === 0) {
+    ctx.usesRuntime.add("set");
+    return `set([${outputExpr}])`;
+  }
+  ctx.usesRuntime.add("set");
+  const arrayComp = buildComprehensionChain(outputExpr, clauses, "array");
+  return `set(${arrayComp})`;
+}
+function transformGeneratorExpression(node, ctx) {
+  const children = getChildren(node);
+  const items = children.filter((c) => c.name !== "(" && c.name !== ")");
+  const { outputExpr, clauses } = parseComprehensionClauses(items, ctx);
+  if (clauses.length === 0) {
+    return outputExpr;
+  }
+  return buildGeneratorChain(outputExpr, clauses);
+}
+function buildGeneratorChain(outputExpr, clauses) {
+  const forClauses = [];
+  for (const clause of clauses) {
+    if (clause.type === "for" && clause.variable && clause.iterable) {
+      forClauses.push({
+        variable: clause.variable,
+        iterable: clause.iterable,
+        conditions: []
+      });
+    } else if (clause.type === "if" && clause.condition && forClauses.length > 0) {
+      const lastFor = forClauses[forClauses.length - 1];
+      if (lastFor) {
+        lastFor.conditions.push(clause.condition);
+      }
+    }
+  }
+  if (forClauses.length === 0) {
+    return `(function*() { yield ${outputExpr}; })()`;
+  }
+  let body = "";
+  let indent = "";
+  const indentStep = "  ";
+  for (const fc of forClauses) {
+    body += `${indent}for (const ${fc.variable} of ${fc.iterable}) `;
+    if (fc.conditions.length > 0) {
+      const combinedCond = fc.conditions.join(" && ");
+      body += `if (${combinedCond}) `;
+    }
+    indent += indentStep;
+  }
+  body += `yield ${outputExpr};`;
+  return `(function*() { ${body} })()`;
+}
+function wrapIterableIfNeeded(iterable) {
+  if (iterable.startsWith("range(") || iterable.startsWith("enumerate(") || iterable.startsWith("zip(") || iterable.startsWith("reversed(") || iterable.startsWith("filter(") || iterable.startsWith("map(")) {
+    return `[...${iterable}]`;
+  }
+  return iterable;
+}
+function buildComprehensionChain(outputExpr, clauses, type) {
+  if (clauses.length === 0) {
+    return type === "array" ? `[${outputExpr}]` : outputExpr;
+  }
+  const forClauses = [];
+  for (const clause of clauses) {
+    if (clause.type === "for" && clause.variable && clause.iterable) {
+      forClauses.push({
+        variable: clause.variable,
+        iterable: clause.iterable,
+        conditions: []
+      });
+    } else if (clause.type === "if" && clause.condition && forClauses.length > 0) {
+      const lastFor = forClauses[forClauses.length - 1];
+      if (lastFor) {
+        lastFor.conditions.push(clause.condition);
+      }
+    }
+  }
+  if (forClauses.length === 0) {
+    return type === "array" ? `[${outputExpr}]` : outputExpr;
+  }
+  if (forClauses.length === 1) {
+    const fc = forClauses[0];
+    if (!fc) return `[${outputExpr}]`;
+    let chain = wrapIterableIfNeeded(fc.iterable);
+    for (const cond of fc.conditions) {
+      chain = `${chain}.filter((${fc.variable}) => ${cond})`;
+    }
+    chain = `${chain}.map((${fc.variable}) => ${outputExpr})`;
+    return chain;
+  }
+  let result = "";
+  for (let i = 0; i < forClauses.length; i++) {
+    const fc = forClauses[i];
+    if (!fc) continue;
+    const isLast = i === forClauses.length - 1;
+    let inner = wrapIterableIfNeeded(fc.iterable);
+    for (const cond of fc.conditions) {
+      inner = `${inner}.filter((${fc.variable}) => ${cond})`;
+    }
+    if (isLast) {
+      inner = `${inner}.map((${fc.variable}) => ${outputExpr})`;
+    } else {
+      result = inner;
+      continue;
+    }
+    for (let j = forClauses.length - 2; j >= 0; j--) {
+      const outerFc = forClauses[j];
+      if (!outerFc) continue;
+      let outerChain = wrapIterableIfNeeded(outerFc.iterable);
+      for (const cond of outerFc.conditions) {
+        outerChain = `${outerChain}.filter((${outerFc.variable}) => ${cond})`;
+      }
+      inner = `${outerChain}.flatMap((${outerFc.variable}) => ${inner})`;
+    }
+    result = inner;
+    break;
+  }
+  return result;
+}
+function buildDictComprehensionChain(keyExpr, valueExpr, clauses) {
+  if (clauses.length === 0) {
+    return `dict([[${keyExpr}, ${valueExpr}]])`;
+  }
+  const forClauses = [];
+  for (const clause of clauses) {
+    if (clause.type === "for" && clause.variable && clause.iterable) {
+      forClauses.push({
+        variable: clause.variable,
+        iterable: clause.iterable,
+        conditions: []
+      });
+    } else if (clause.type === "if" && clause.condition && forClauses.length > 0) {
+      const lastFor = forClauses[forClauses.length - 1];
+      if (lastFor) {
+        lastFor.conditions.push(clause.condition);
+      }
+    }
+  }
+  if (forClauses.length === 0) {
+    return `dict([[${keyExpr}, ${valueExpr}]])`;
+  }
+  const pairExpr = `[${keyExpr}, ${valueExpr}]`;
+  const arrayComp = buildComprehensionChain(pairExpr, clauses, "array");
+  return `dict(${arrayComp})`;
+}
+function transformScopeStatement(node, ctx) {
+  const children = getChildren(node);
+  const keyword = children.find((c) => c.name === "global" || c.name === "nonlocal");
+  const keywordText = keyword ? getNodeText(keyword, ctx.source) : "scope";
+  const vars = children.filter((c) => c.name === "VariableName").map((c) => getNodeText(c, ctx.source));
+  return `/* ${keywordText} ${vars.join(", ")} */`;
+}
+function transformDeleteStatement(node, ctx) {
+  const children = getChildren(node);
+  const targets = children.filter((c) => c.name !== "del" && c.name !== ",");
+  const deletions = targets.map((target) => {
+    if (target.name === "MemberExpression") {
+      const memberChildren = getChildren(target);
+      const obj = memberChildren[0];
+      const bracket = memberChildren.find((c) => c.name === "[");
+      if (bracket) {
+        const objCode = obj ? transformNode(obj, ctx) : "";
+        const indexNode = memberChildren.find((c) => c.name !== "[" && c.name !== "]" && c !== obj);
+        const indexCode = indexNode ? transformNode(indexNode, ctx) : "0";
+        if (indexNode?.name === "Number") {
+          return `${objCode}.splice(${indexCode}, 1)`;
+        }
+        return `delete ${objCode}[${indexCode}]`;
+      } else {
+        return `delete ${transformNode(target, ctx)}`;
+      }
+    } else if (target.name === "VariableName") {
+      const varName = getNodeText(target, ctx.source);
+      return `${varName} = undefined`;
+    }
+    return `delete ${transformNode(target, ctx)}`;
+  });
+  return deletions.join(";\n");
+}
+function transformAssertStatement(node, ctx) {
+  const children = getChildren(node);
+  const expressions = children.filter((c) => c.name !== "assert" && c.name !== ",");
+  const condition = expressions[0];
+  const message = expressions[1];
+  const conditionCode = condition ? transformNode(condition, ctx) : "true";
+  const messageCode = message ? transformNode(message, ctx) : '"Assertion failed"';
+  return `if (!(${conditionCode})) throw new Error(${messageCode})`;
+}
+function transformYieldStatement(node, ctx) {
+  const children = getChildren(node);
+  const hasFrom = children.some((c) => c.name === "from");
+  const valueNode = children.find((c) => c.name !== "yield" && c.name !== "from");
+  if (hasFrom && valueNode) {
+    return `yield* ${transformNode(valueNode, ctx)}`;
+  } else if (valueNode) {
+    return `yield ${transformNode(valueNode, ctx)}`;
+  }
+  return "yield";
+}
+
+// src/generator/index.ts
+import * as prettier from "prettier";
+var defaultOptions = {
+  includeRuntime: true,
+  runtimeImportPath: "pythonlib"
+};
+var prettierOptions = {
+  parser: "typescript",
+  singleQuote: false,
+  tabWidth: 2,
+  trailingComma: "none",
+  printWidth: 100,
+  semi: false,
+  bracketSpacing: true,
+  arrowParens: "always",
+  endOfLine: "lf"
+};
+var BUILTINS = /* @__PURE__ */ new Set([
+  // Core operations
+  "floorDiv",
+  "pow",
+  "mod",
+  "sprintf",
+  "slice",
+  "at",
+  "contains",
+  "repeatValue",
+  "strFormat",
+  "divMod",
+  // Collection constructors
+  "list",
+  "dict",
+  "set",
+  "tuple",
+  // Iteration
+  "len",
+  "range",
+  "enumerate",
+  "zip",
+  "sorted",
+  "reversed",
+  "iter",
+  "map",
+  "filter",
+  // Aggregation
+  "abs",
+  "min",
+  "max",
+  "sum",
+  "all",
+  "any",
+  "round",
+  // Character/number conversion
+  "ord",
+  "chr",
+  "hex",
+  "oct",
+  "bin",
+  // Type conversion
+  "int",
+  "float",
+  "str",
+  "bool",
+  "repr",
+  "ascii",
+  // Type checking & misc
+  "isinstance",
+  "type",
+  "input",
+  "format"
+]);
+var MODULE_NAMESPACES = /* @__PURE__ */ new Set(["string", "list", "dict", "set"]);
+function generate(input, options = {}) {
+  const opts = { ...defaultOptions, ...options };
+  const result = transform(input);
+  const usedRuntimeFunctions = Array.from(result.usesRuntime).sort();
+  let runtimeImport = null;
+  if (opts.includeRuntime && usedRuntimeFunctions.length > 0) {
+    const basePath = opts.runtimeImportPath ?? "pythonlib";
+    runtimeImport = buildRuntimeImports(usedRuntimeFunctions, basePath);
+  }
+  let code = result.code;
+  if (runtimeImport) {
+    code = runtimeImport + "\n\n" + code;
+  }
+  return {
+    code,
+    runtimeImport,
+    usedRuntimeFunctions
+  };
+}
+function buildRuntimeImports(usedFunctions, basePath) {
+  const mainImports = /* @__PURE__ */ new Set();
+  const moduleImports = /* @__PURE__ */ new Map();
+  for (const func of usedFunctions) {
+    if (func.includes("/")) {
+      const [moduleName, funcName] = func.split("/");
+      if (moduleName && funcName) {
+        let funcs = moduleImports.get(moduleName);
+        if (!funcs) {
+          funcs = /* @__PURE__ */ new Set();
+          moduleImports.set(moduleName, funcs);
+        }
+        funcs.add(funcName);
+      }
+      continue;
+    }
+    if (func.includes(".")) {
+      const [namespace] = func.split(".");
+      if (namespace && MODULE_NAMESPACES.has(namespace)) {
+        mainImports.add(namespace);
+      }
+      continue;
+    }
+    if (MODULE_NAMESPACES.has(func)) {
+      mainImports.add(func);
+      continue;
+    }
+    if (BUILTINS.has(func)) {
+      mainImports.add(func);
+      continue;
+    }
+    mainImports.add(func);
+  }
+  const importStatements = [];
+  if (mainImports.size > 0) {
+    const sorted = Array.from(mainImports).sort();
+    importStatements.push(`import { ${sorted.join(", ")} } from "${basePath}"`);
+  }
+  const sortedModules = Array.from(moduleImports.keys()).sort();
+  for (const moduleName of sortedModules) {
+    const funcSet = moduleImports.get(moduleName);
+    if (funcSet) {
+      const funcs = Array.from(funcSet).sort();
+      importStatements.push(`import { ${funcs.join(", ")} } from "${basePath}/${moduleName}"`);
+    }
+  }
+  return importStatements.join("\n");
+}
+function transpile(python, options = {}) {
+  return generate(python, options).code;
+}
+async function formatCode(code) {
+  try {
+    return await prettier.format(code, prettierOptions);
+  } catch {
+    return code;
+  }
+}
+async function generateAsync(input, options = {}) {
+  const result = generate(input, options);
+  const formattedCode = await formatCode(result.code);
+  return {
+    ...result,
+    code: formattedCode
+  };
+}
+async function transpileAsync(python, options = {}) {
+  const result = await generateAsync(python, options);
+  return result.code;
+}
+
+export {
+  parse,
+  getNodeText,
+  getChildren,
+  getChildByType,
+  getChildrenByType,
+  walkTree,
+  debugTree,
+  transform,
+  generate,
+  transpile,
+  formatCode,
+  generateAsync,
+  transpileAsync
+};
+/* v8 ignore next 3 -- malformed type annotation fallback @preserve */
+/* v8 ignore next 3 -- defensive: empty targets/values can't occur with valid Python @preserve */
+/* v8 ignore next -- @preserve */
+/* v8 ignore next 3 -- defensive: walrus operator always has name and value @preserve */
+/* 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 */
+/* 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