@terminals-tech/py2bend 0.1.0

package/dist/index.js

@@ -0,0 +1,1295 @@
+// src/parser.ts
+function tokenizeLines(source) {
+  return source.split("\n").map((raw, i) => {
+    const text = raw;
+    const trimmed = raw.trimStart();
+    const indent2 = raw.length - trimmed.length;
+    return { text: trimmed, indent: indent2, lineNo: i + 1 };
+  }).filter((l) => l.text.length > 0 && !l.text.startsWith("#"));
+}
+var Cursor = class {
+  constructor(lines, pos = 0) {
+    this.lines = lines;
+    this.pos = pos;
+  }
+  done() {
+    return this.pos >= this.lines.length;
+  }
+  peek() {
+    return this.done() ? null : this.lines[this.pos];
+  }
+  advance() {
+    return this.lines[this.pos++];
+  }
+  /** Collect the body block: all lines with indent > parentIndent */
+  collectBlock(parentIndent) {
+    const block = [];
+    while (!this.done()) {
+      const next = this.peek();
+      if (next.indent <= parentIndent) break;
+      block.push(this.advance());
+    }
+    return block;
+  }
+};
+var UNSUPPORTED_KEYWORDS = [
+  /^async\s+def\b/,
+  /^await\b/,
+  /^yield\b/,
+  /^import\b/,
+  /^from\s+\S+\s+import\b/,
+  /^with\b/,
+  /^assert\b/,
+  /^raise\b/,
+  /^del\b/,
+  /^global\b/,
+  /^nonlocal\b/
+];
+function parsePython(source) {
+  const errors = [];
+  const lines = tokenizeLines(source);
+  try {
+    const cursor = new Cursor(lines);
+    const body = parseBlock(cursor, -1, errors);
+    return { ast: { type: "Module", body }, errors };
+  } catch (e) {
+    errors.push({
+      message: e.message,
+      severity: "error"
+    });
+    return { ast: null, errors };
+  }
+}
+function parseBlock(cursor, parentIndent, errors) {
+  const stmts = [];
+  while (!cursor.done()) {
+    const line = cursor.peek();
+    if (line.indent <= parentIndent) break;
+    cursor.advance();
+    const stmt = parseStatement(line, cursor, errors);
+    if (stmt) stmts.push(stmt);
+  }
+  return stmts;
+}
+function parseStatement(line, cursor, errors) {
+  const text = line.text;
+  for (const pattern of UNSUPPORTED_KEYWORDS) {
+    if (pattern.test(text)) {
+      errors.push({
+        message: `Unsupported syntax: ${text}`,
+        line: line.lineNo,
+        severity: "error"
+      });
+      cursor.collectBlock(line.indent);
+      return null;
+    }
+  }
+  if (text.startsWith("@")) {
+    const decorators = [text.slice(1).trim()];
+    while (!cursor.done() && cursor.peek().text.startsWith("@")) {
+      decorators.push(cursor.advance().text.slice(1).trim());
+    }
+    if (!cursor.done()) {
+      const defLine = cursor.advance();
+      const stmt = parseStatement(defLine, cursor, errors);
+      if (stmt && stmt.type === "FunctionDef") {
+        stmt.decorators = decorators;
+      }
+      return stmt;
+    }
+    return null;
+  }
+  if (text.startsWith("def ")) {
+    return parseFunctionDef(text, line, cursor, errors);
+  }
+  if (text.startsWith("class ")) {
+    return parseClassDef(text, line, cursor, errors);
+  }
+  if (text.startsWith("if ")) {
+    return parseIf(text, line, cursor, errors);
+  }
+  if (text.startsWith("for ")) {
+    return parseFor(text, line, cursor, errors);
+  }
+  if (text.startsWith("while ")) {
+    return parseWhile(text, line, cursor, errors);
+  }
+  if (text.startsWith("try:")) {
+    return parseTry(line, cursor, errors);
+  }
+  if (text === "return" || text.startsWith("return ")) {
+    return parseReturn(text, line, errors);
+  }
+  if (text === "pass") {
+    return null;
+  }
+  if (text.startsWith("elif ") || text === "else:" || text.startsWith("except")) {
+    cursor.collectBlock(line.indent);
+    return null;
+  }
+  const augMatch = text.match(
+    /^([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)\s*(\+\=|\-\=|\*\=|\/\=|\/\/\=|%\=|\*\*\=|&\=|\|\=)\s*(.+)$/
+  );
+  if (augMatch) {
+    return {
+      type: "AugAssign",
+      target: augMatch[1],
+      op: augMatch[2],
+      value: parseExpr(augMatch[3].trim(), line.lineNo, errors)
+    };
+  }
+  const assignMatch = text.match(
+    /^([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*(?:\[[^\]]+\])?)\s*=\s*(.+)$/
+  );
+  if (assignMatch) {
+    const afterTarget = text.slice(assignMatch[1].length).trimStart();
+    if (afterTarget.startsWith("==")) {
+    } else {
+      return {
+        type: "Assign",
+        target: assignMatch[1],
+        value: parseExpr(assignMatch[2].trim(), line.lineNo, errors)
+      };
+    }
+  }
+  const expr = parseExpr(text, line.lineNo, errors);
+  return {
+    type: "Expr",
+    value: expr
+  };
+}
+function parseFunctionDef(text, line, cursor, errors) {
+  const match = text.match(/^def\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)\s*:/);
+  if (!match) {
+    errors.push({
+      message: `Invalid function definition: ${text}`,
+      line: line.lineNo,
+      severity: "error"
+    });
+    cursor.collectBlock(line.indent);
+    return {
+      type: "FunctionDef",
+      name: "unknown",
+      params: [],
+      body: [],
+      decorators: []
+    };
+  }
+  const name = match[1];
+  const paramsStr = match[2].trim();
+  const params = paramsStr ? paramsStr.split(",").map((p) => {
+    const cleaned = p.trim().split("=")[0].trim();
+    return cleaned.split(":")[0].trim();
+  }) : [];
+  const bodyLines = cursor.collectBlock(line.indent);
+  const bodyCursor = new Cursor(bodyLines);
+  const body = parseBlock(bodyCursor, line.indent, errors);
+  return {
+    type: "FunctionDef",
+    name,
+    params,
+    body,
+    decorators: []
+  };
+}
+function parseClassDef(text, line, cursor, errors) {
+  const match = text.match(
+    /^class\s+([A-Za-z_][A-Za-z0-9_]*)(?:\(([^)]*)\))?\s*:/
+  );
+  if (!match) {
+    errors.push({
+      message: `Invalid class definition: ${text}`,
+      line: line.lineNo,
+      severity: "error"
+    });
+    cursor.collectBlock(line.indent);
+    return { type: "ClassDef", name: "unknown", bases: [], body: [] };
+  }
+  const name = match[1];
+  const basesStr = match[2]?.trim() ?? "";
+  const bases = basesStr ? basesStr.split(",").map((b) => b.trim()) : [];
+  const bodyLines = cursor.collectBlock(line.indent);
+  const bodyCursor = new Cursor(bodyLines);
+  const body = parseBlock(bodyCursor, line.indent, errors);
+  return { type: "ClassDef", name, bases, body };
+}
+function parseIf(text, line, cursor, errors) {
+  const condStr = text.replace(/^if\s+/, "").replace(/\s*:\s*$/, "");
+  const test = parseExpr(condStr, line.lineNo, errors);
+  const bodyLines = cursor.collectBlock(line.indent);
+  const bodyCursor = new Cursor(bodyLines);
+  const body = parseBlock(bodyCursor, line.indent, errors);
+  let orelse = [];
+  if (!cursor.done()) {
+    const next = cursor.peek();
+    if (next.indent === line.indent && next.text.startsWith("elif ")) {
+      cursor.advance();
+      const elifText = next.text.replace(/^elif\s+/, "if ");
+      const elifIf = parseIf(elifText, next, cursor, errors);
+      orelse = [elifIf];
+    } else if (next.indent === line.indent && next.text === "else:") {
+      cursor.advance();
+      const elseLines = cursor.collectBlock(line.indent);
+      const elseCursor = new Cursor(elseLines);
+      orelse = parseBlock(elseCursor, line.indent, errors);
+    }
+  }
+  return { type: "If", test, body, orelse };
+}
+function parseFor(text, line, cursor, errors) {
+  const match = text.match(
+    /^for\s+([A-Za-z_][A-Za-z0-9_]*)\s+in\s+(.+)\s*:\s*$/
+  );
+  if (!match) {
+    errors.push({
+      message: `Invalid for loop: ${text}`,
+      line: line.lineNo,
+      severity: "error"
+    });
+    cursor.collectBlock(line.indent);
+    return {
+      type: "For",
+      target: "unknown",
+      iter: { type: "Name", id: "unknown" },
+      body: []
+    };
+  }
+  const target = match[1];
+  const iterExpr = parseExpr(match[2].trim(), line.lineNo, errors);
+  const bodyLines = cursor.collectBlock(line.indent);
+  const bodyCursor = new Cursor(bodyLines);
+  const body = parseBlock(bodyCursor, line.indent, errors);
+  return { type: "For", target, iter: iterExpr, body };
+}
+function parseWhile(text, line, cursor, errors) {
+  const condStr = text.replace(/^while\s+/, "").replace(/\s*:\s*$/, "");
+  const test = parseExpr(condStr, line.lineNo, errors);
+  const bodyLines = cursor.collectBlock(line.indent);
+  const bodyCursor = new Cursor(bodyLines);
+  const body = parseBlock(bodyCursor, line.indent, errors);
+  return { type: "While", test, body };
+}
+function parseTry(line, cursor, errors) {
+  const tryBodyLines = cursor.collectBlock(line.indent);
+  const tryCursor = new Cursor(tryBodyLines);
+  const tryBody = parseBlock(tryCursor, line.indent, errors);
+  let handler = null;
+  if (!cursor.done()) {
+    const next = cursor.peek();
+    if (next.indent === line.indent && next.text.startsWith("except")) {
+      cursor.advance();
+      const exceptMatch = next.text.match(
+        /^except\s*(?:([A-Za-z_][A-Za-z0-9_]*))?(?:\s+as\s+([A-Za-z_][A-Za-z0-9_]*))?\s*:\s*$/
+      );
+      const handlerType = exceptMatch?.[1] ?? null;
+      const handlerName = exceptMatch?.[2] ?? null;
+      const handlerBodyLines = cursor.collectBlock(line.indent);
+      const handlerCursor = new Cursor(handlerBodyLines);
+      const handlerBody = parseBlock(handlerCursor, line.indent, errors);
+      handler = { type: handlerType, name: handlerName, body: handlerBody };
+    }
+  }
+  return { type: "Try", body: tryBody, handler };
+}
+function parseReturn(text, line, errors) {
+  const valueStr = text.replace(/^return\s*/, "").trim();
+  if (!valueStr) {
+    return { type: "Return", value: null };
+  }
+  return { type: "Return", value: parseExpr(valueStr, line.lineNo, errors) };
+}
+function parseExpr(text, lineNo, errors) {
+  text = text.trim();
+  if (!text) {
+    return { type: "Constant", value: null, kind: "none" };
+  }
+  if (text.startsWith("lambda")) {
+    return parseLambda(text, lineNo, errors);
+  }
+  return parseBoolOr(text, lineNo, errors);
+}
+function parseLambda(text, lineNo, errors) {
+  const match = text.match(/^lambda\s*([^:]*)\s*:\s*(.+)$/);
+  if (!match) {
+    return { type: "Lambda", params: [], body: { type: "Constant", value: null, kind: "none" } };
+  }
+  const paramsStr = match[1].trim();
+  const params = paramsStr ? paramsStr.split(",").map((p) => p.trim()) : [];
+  const body = parseExpr(match[2].trim(), lineNo, errors);
+  return { type: "Lambda", params, body };
+}
+function parseBoolOr(text, lineNo, errors) {
+  const parts = splitTopLevel(text, " or ");
+  if (parts.length === 1) return parseBoolAnd(parts[0], lineNo, errors);
+  const values = parts.map((p) => parseBoolAnd(p, lineNo, errors));
+  return { type: "BoolOp", op: "or", values };
+}
+function parseBoolAnd(text, lineNo, errors) {
+  const parts = splitTopLevel(text, " and ");
+  if (parts.length === 1) return parseNot(parts[0], lineNo, errors);
+  const values = parts.map((p) => parseNot(p, lineNo, errors));
+  return { type: "BoolOp", op: "and", values };
+}
+function parseNot(text, lineNo, errors) {
+  text = text.trim();
+  if (text.startsWith("not ")) {
+    const operand = parseNot(text.slice(4).trim(), lineNo, errors);
+    return { type: "UnaryOp", op: "not", operand };
+  }
+  return parseComparison(text, lineNo, errors);
+}
+var COMPARISON_OPS = [" not in ", " in ", "<=", ">=", "!=", "==", "<", ">"];
+function parseComparison(text, lineNo, errors) {
+  let bestIdx = -1;
+  let bestOp = "";
+  for (const op of COMPARISON_OPS) {
+    const idx = findTopLevel(text, op);
+    if (idx !== -1 && (bestIdx === -1 || idx < bestIdx)) {
+      bestIdx = idx;
+      bestOp = op;
+    }
+  }
+  if (bestIdx === -1) {
+    return parseAddSub(text, lineNo, errors);
+  }
+  const left = parseAddSub(text.slice(0, bestIdx).trim(), lineNo, errors);
+  const right = parseComparison(
+    text.slice(bestIdx + bestOp.length).trim(),
+    lineNo,
+    errors
+  );
+  if (right.type === "Compare") {
+    const rightCmp = right;
+    return {
+      type: "Compare",
+      left,
+      ops: [bestOp.trim(), ...rightCmp.ops],
+      comparators: [rightCmp.left, ...rightCmp.comparators]
+    };
+  }
+  return {
+    type: "Compare",
+    left,
+    ops: [bestOp.trim()],
+    comparators: [right]
+  };
+}
+function parseAddSub(text, lineNo, errors) {
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  let inStr = null;
+  let splitIdx = -1;
+  let splitOp = "";
+  for (let i = text.length - 1; i >= 1; i--) {
+    const ch = text[i];
+    if ((ch === '"' || ch === "'") && text[i - 1] !== "\\") {
+      if (inStr === ch) {
+        inStr = null;
+        continue;
+      } else if (!inStr) {
+        inStr = ch;
+        continue;
+      }
+    }
+    if (inStr) continue;
+    if (ch === ")") parenDepth++;
+    else if (ch === "(") parenDepth--;
+    else if (ch === "]") bracketDepth++;
+    else if (ch === "[") bracketDepth--;
+    else if (ch === "}") braceDepth++;
+    else if (ch === "{") braceDepth--;
+    if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+      if ((ch === "+" || ch === "-") && text[i - 1] !== "*" && text[i + 1] !== "=" && text[i - 1] !== "=") {
+        const before = text.slice(0, i).trim();
+        if (before.length > 0 && !before.endsWith("(") && !before.endsWith(",") && !before.endsWith("[")) {
+          splitIdx = i;
+          splitOp = ch;
+          break;
+        }
+      }
+    }
+  }
+  if (splitIdx === -1) {
+    return parseMulDiv(text, lineNo, errors);
+  }
+  const left = parseAddSub(text.slice(0, splitIdx).trim(), lineNo, errors);
+  const right = parseMulDiv(text.slice(splitIdx + 1).trim(), lineNo, errors);
+  return { type: "BinOp", left, op: splitOp, right };
+}
+function parseMulDiv(text, lineNo, errors) {
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  let inStr = null;
+  let splitIdx = -1;
+  let splitOp = "";
+  for (let i = text.length - 1; i >= 0; i--) {
+    const ch = text[i];
+    if ((ch === '"' || ch === "'") && (i === 0 || text[i - 1] !== "\\")) {
+      if (inStr === ch) {
+        inStr = null;
+        continue;
+      } else if (!inStr) {
+        inStr = ch;
+        continue;
+      }
+    }
+    if (inStr) continue;
+    if (ch === ")") parenDepth++;
+    else if (ch === "(") parenDepth--;
+    else if (ch === "]") bracketDepth++;
+    else if (ch === "[") bracketDepth--;
+    else if (ch === "}") braceDepth++;
+    else if (ch === "{") braceDepth--;
+    if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+      if (ch === "*" && i > 0 && text[i - 1] !== "*" && (i + 1 >= text.length || text[i + 1] !== "*")) {
+        splitIdx = i;
+        splitOp = "*";
+        break;
+      }
+      if (ch === "/" && i > 0) {
+        if (text[i - 1] === "/") {
+          splitIdx = i - 1;
+          splitOp = "//";
+          break;
+        }
+        splitIdx = i;
+        splitOp = "/";
+        break;
+      }
+      if (ch === "%") {
+        splitIdx = i;
+        splitOp = "%";
+        break;
+      }
+    }
+  }
+  if (splitIdx === -1) {
+    return parsePower(text, lineNo, errors);
+  }
+  const left = parseMulDiv(text.slice(0, splitIdx).trim(), lineNo, errors);
+  const right = parsePower(
+    text.slice(splitIdx + splitOp.length).trim(),
+    lineNo,
+    errors
+  );
+  return { type: "BinOp", left, op: splitOp, right };
+}
+function parsePower(text, lineNo, errors) {
+  const idx = findTopLevel(text, "**");
+  if (idx === -1) {
+    return parseUnary(text, lineNo, errors);
+  }
+  const left = parseUnary(text.slice(0, idx).trim(), lineNo, errors);
+  const right = parsePower(text.slice(idx + 2).trim(), lineNo, errors);
+  return { type: "BinOp", left, op: "**", right };
+}
+function parseUnary(text, lineNo, errors) {
+  text = text.trim();
+  if (text.startsWith("-") && text.length > 1) {
+    const rest = text.slice(1).trim();
+    if (rest && !/^\d/.test(rest)) {
+      const operand = parseUnary(rest, lineNo, errors);
+      return { type: "UnaryOp", op: "-", operand };
+    }
+  }
+  if (text.startsWith("+") && text.length > 1) {
+    const rest = text.slice(1).trim();
+    if (rest && !/^\d/.test(rest)) {
+      const operand = parseUnary(rest, lineNo, errors);
+      return { type: "UnaryOp", op: "+", operand };
+    }
+  }
+  return parsePostfix(text, lineNo, errors);
+}
+function parsePostfix(text, lineNo, errors) {
+  text = text.trim();
+  const parsed = parsePrimaryWithPostfix(text, lineNo, errors);
+  return parsed;
+}
+function parsePrimaryWithPostfix(text, lineNo, errors) {
+  text = text.trim();
+  let pos = 0;
+  const { node, endPos } = parsePrimaryAt(text, pos, lineNo, errors);
+  pos = endPos;
+  let current = node;
+  while (pos < text.length) {
+    const ch = text[pos];
+    if (ch === ".") {
+      pos++;
+      const attrMatch = text.slice(pos).match(/^[A-Za-z_][A-Za-z0-9_]*/);
+      if (attrMatch) {
+        const attr = attrMatch[0];
+        pos += attr.length;
+        current = { type: "Attribute", value: current, attr };
+      } else {
+        break;
+      }
+    } else if (ch === "[") {
+      const closeIdx = findMatchingClose(text, pos, "[", "]");
+      if (closeIdx === -1) break;
+      const sliceStr = text.slice(pos + 1, closeIdx).trim();
+      const sliceNode = parseExpr(sliceStr, lineNo, errors);
+      current = { type: "Subscript", value: current, slice: sliceNode };
+      pos = closeIdx + 1;
+    } else if (ch === "(") {
+      const closeIdx = findMatchingClose(text, pos, "(", ")");
+      if (closeIdx === -1) break;
+      const argsStr = text.slice(pos + 1, closeIdx).trim();
+      const { args, kwargs } = parseCallArgs(argsStr, lineNo, errors);
+      current = { type: "Call", func: current, args, kwargs };
+      pos = closeIdx + 1;
+    } else if (ch === " " || ch === "	") {
+      pos++;
+    } else {
+      break;
+    }
+  }
+  return current;
+}
+function parsePrimaryAt(text, pos, lineNo, errors) {
+  while (pos < text.length && (text[pos] === " " || text[pos] === "	")) pos++;
+  if (pos >= text.length) {
+    return {
+      node: { type: "Constant", value: null, kind: "none" },
+      endPos: pos
+    };
+  }
+  const remaining = text.slice(pos);
+  if (remaining[0] === "(") {
+    const closeIdx = findMatchingClose(text, pos, "(", ")");
+    if (closeIdx !== -1) {
+      const inner = text.slice(pos + 1, closeIdx).trim();
+      const node = parseExpr(inner, lineNo, errors);
+      return { node, endPos: closeIdx + 1 };
+    }
+  }
+  if (remaining[0] === "[") {
+    const closeIdx = findMatchingClose(text, pos, "[", "]");
+    if (closeIdx !== -1) {
+      const inner = text.slice(pos + 1, closeIdx).trim();
+      const elts = inner ? splitArgs(inner).map((e) => parseExpr(e.trim(), lineNo, errors)) : [];
+      return {
+        node: { type: "List", elts },
+        endPos: closeIdx + 1
+      };
+    }
+  }
+  if (remaining[0] === "{") {
+    const closeIdx = findMatchingClose(text, pos, "{", "}");
+    if (closeIdx !== -1) {
+      const inner = text.slice(pos + 1, closeIdx).trim();
+      const keys = [];
+      const values = [];
+      if (inner) {
+        const entries = splitArgs(inner);
+        for (const entry of entries) {
+          const colonIdx = findTopLevel(entry, ":");
+          if (colonIdx !== -1) {
+            keys.push(
+              parseExpr(entry.slice(0, colonIdx).trim(), lineNo, errors)
+            );
+            values.push(
+              parseExpr(entry.slice(colonIdx + 1).trim(), lineNo, errors)
+            );
+          }
+        }
+      }
+      return {
+        node: { type: "Dict", keys, values },
+        endPos: closeIdx + 1
+      };
+    }
+  }
+  if (remaining[0] === '"' || remaining[0] === "'") {
+    const quote = remaining[0];
+    if (remaining.startsWith(quote + quote + quote)) {
+      const endQuote = remaining.indexOf(quote + quote + quote, 3);
+      if (endQuote !== -1) {
+        const value = remaining.slice(3, endQuote);
+        return {
+          node: { type: "Constant", value, kind: "str" },
+          endPos: pos + endQuote + 3
+        };
+      }
+    }
+    let i = 1;
+    while (i < remaining.length) {
+      if (remaining[i] === "\\" && i + 1 < remaining.length) {
+        i += 2;
+        continue;
+      }
+      if (remaining[i] === quote) {
+        const value = remaining.slice(1, i);
+        return {
+          node: { type: "Constant", value, kind: "str" },
+          endPos: pos + i + 1
+        };
+      }
+      i++;
+    }
+    return {
+      node: {
+        type: "Constant",
+        value: remaining.slice(1),
+        kind: "str"
+      },
+      endPos: pos + remaining.length
+    };
+  }
+  if ((remaining[0] === "f" || remaining[0] === "F") && remaining.length > 1 && (remaining[1] === '"' || remaining[1] === "'")) {
+    const quote = remaining[1];
+    let i = 2;
+    while (i < remaining.length) {
+      if (remaining[i] === "\\" && i + 1 < remaining.length) {
+        i += 2;
+        continue;
+      }
+      if (remaining[i] === quote) {
+        const value = remaining.slice(2, i);
+        return {
+          node: { type: "Constant", value, kind: "str" },
+          endPos: pos + i + 1
+        };
+      }
+      i++;
+    }
+    return {
+      node: {
+        type: "Constant",
+        value: remaining.slice(2),
+        kind: "str"
+      },
+      endPos: pos + remaining.length
+    };
+  }
+  const numMatch = remaining.match(/^-?\d+(\.\d+)?/);
+  if (numMatch) {
+    const numStr = numMatch[0];
+    const isFloat = numStr.includes(".");
+    return {
+      node: {
+        type: "Constant",
+        value: isFloat ? parseFloat(numStr) : parseInt(numStr, 10),
+        kind: isFloat ? "float" : "int"
+      },
+      endPos: pos + numStr.length
+    };
+  }
+  const identMatch = remaining.match(/^[A-Za-z_][A-Za-z0-9_]*/);
+  if (identMatch) {
+    const id = identMatch[0];
+    const endPos = pos + id.length;
+    if (id === "True") {
+      return {
+        node: { type: "Constant", value: true, kind: "bool" },
+        endPos
+      };
+    }
+    if (id === "False") {
+      return {
+        node: { type: "Constant", value: false, kind: "bool" },
+        endPos
+      };
+    }
+    if (id === "None") {
+      return {
+        node: { type: "Constant", value: null, kind: "none" },
+        endPos
+      };
+    }
+    return {
+      node: { type: "Name", id },
+      endPos
+    };
+  }
+  errors.push({
+    message: `Unexpected token: ${remaining.slice(0, 20)}`,
+    line: lineNo,
+    severity: "error"
+  });
+  return {
+    node: { type: "Name", id: remaining.trim() },
+    endPos: pos + remaining.length
+  };
+}
+function splitTopLevel(text, delimiter) {
+  const parts = [];
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  let inStr = null;
+  let start = 0;
+  for (let i = 0; i <= text.length - delimiter.length; i++) {
+    const ch = text[i];
+    if ((ch === '"' || ch === "'") && (i === 0 || text[i - 1] !== "\\")) {
+      if (inStr === ch) {
+        inStr = null;
+        continue;
+      } else if (!inStr) {
+        inStr = ch;
+        continue;
+      }
+    }
+    if (inStr) continue;
+    if (ch === "(") parenDepth++;
+    else if (ch === ")") parenDepth--;
+    else if (ch === "[") bracketDepth++;
+    else if (ch === "]") bracketDepth--;
+    else if (ch === "{") braceDepth++;
+    else if (ch === "}") braceDepth--;
+    if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0 && text.slice(i, i + delimiter.length) === delimiter) {
+      parts.push(text.slice(start, i).trim());
+      start = i + delimiter.length;
+      i = start - 1;
+    }
+  }
+  parts.push(text.slice(start).trim());
+  return parts;
+}
+function findTopLevel(text, needle) {
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  let inStr = null;
+  for (let i = 0; i <= text.length - needle.length; i++) {
+    const ch = text[i];
+    if ((ch === '"' || ch === "'") && (i === 0 || text[i - 1] !== "\\")) {
+      if (inStr === ch) {
+        inStr = null;
+        continue;
+      } else if (!inStr) {
+        inStr = ch;
+        continue;
+      }
+    }
+    if (inStr) continue;
+    if (ch === "(") parenDepth++;
+    else if (ch === ")") parenDepth--;
+    else if (ch === "[") bracketDepth++;
+    else if (ch === "]") bracketDepth--;
+    else if (ch === "{") braceDepth++;
+    else if (ch === "}") braceDepth--;
+    if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0 && text.slice(i, i + needle.length) === needle) {
+      return i;
+    }
+  }
+  return -1;
+}
+function findMatchingClose(text, openIdx, open, close) {
+  let depth = 0;
+  let inStr = null;
+  for (let i = openIdx; i < text.length; i++) {
+    const ch = text[i];
+    if ((ch === '"' || ch === "'") && (i === 0 || text[i - 1] !== "\\")) {
+      if (inStr === ch) {
+        inStr = null;
+        continue;
+      } else if (!inStr) {
+        inStr = ch;
+        continue;
+      }
+    }
+    if (inStr) continue;
+    if (ch === open) depth++;
+    else if (ch === close) {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function splitArgs(text) {
+  return splitTopLevel(text, ",");
+}
+function parseCallArgs(text, lineNo, errors) {
+  if (!text.trim()) return { args: [], kwargs: [] };
+  const parts = splitArgs(text);
+  const args = [];
+  const kwargs = [];
+  for (const part of parts) {
+    const trimmed = part.trim();
+    const kwMatch = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=(?!=)\s*(.+)$/);
+    if (kwMatch) {
+      kwargs.push({
+        key: kwMatch[1],
+        value: parseExpr(kwMatch[2].trim(), lineNo, errors)
+      });
+    } else {
+      args.push(parseExpr(trimmed, lineNo, errors));
+    }
+  }
+  return { args, kwargs };
+}
+
+// src/transforms.ts
+function transformModule(ast) {
+  return {
+    type: "BendModule",
+    source: "Module",
+    body: transformNodes(ast.body)
+  };
+}
+function transformNodes(nodes) {
+  return nodes.map(transformNode);
+}
+function transformNode(node) {
+  switch (node.type) {
+    case "FunctionDef":
+      return transformFunctionDef(node);
+    case "For":
+      return transformFor(node);
+    case "While":
+      return transformWhile(node);
+    case "ClassDef":
+      return transformClass(node);
+    case "Try":
+      return transformTry(node);
+    default:
+      return passthrough(node);
+  }
+}
+function transformFunctionDef(node) {
+  return {
+    type: "BendFunctionDef",
+    source: "FunctionDef",
+    name: node.name,
+    params: node.params,
+    body: transformNodes(node.body),
+    decorators: node.decorators
+  };
+}
+function transformFor(node) {
+  const accumulator = findAccumulator(node.body);
+  return {
+    type: "BendFold",
+    source: "For",
+    target: node.target,
+    iter: node.iter,
+    body: transformNodes(node.body),
+    accumulator
+  };
+}
+function findAccumulator(body) {
+  for (const stmt of body) {
+    if (stmt.type === "AugAssign") {
+      return stmt.target;
+    }
+  }
+  return null;
+}
+function transformWhile(node) {
+  return {
+    type: "BendLoop",
+    source: "While",
+    test: node.test,
+    body: transformNodes(node.body),
+    stateVars: []
+  };
+}
+function transformClass(node) {
+  const fields = extractFields(node.body);
+  const methods = [];
+  for (const member of node.body) {
+    if (member.type === "FunctionDef") {
+      methods.push(transformFunctionDef(member));
+    }
+  }
+  return {
+    type: "BendObject",
+    source: "ClassDef",
+    name: node.name,
+    bases: node.bases,
+    fields,
+    methods
+  };
+}
+function extractFields(body) {
+  const fields = [];
+  const initMethod = body.find(
+    (n) => n.type === "FunctionDef" && n.name === "__init__"
+  );
+  if (!initMethod) return fields;
+  for (const stmt of initMethod.body) {
+    if (stmt.type === "Assign") {
+      const assign = stmt;
+      if (assign.target.startsWith("self.")) {
+        fields.push(assign.target.slice(5));
+      }
+    }
+  }
+  return fields;
+}
+function transformTry(node) {
+  return {
+    type: "BendWith",
+    source: "Try",
+    body: transformNodes(node.body),
+    handler: node.handler ? {
+      name: node.handler.name,
+      type: node.handler.type,
+      body: transformNodes(node.handler.body)
+    } : null
+  };
+}
+function passthrough(node) {
+  return {
+    type: "BendPassthrough",
+    source: node.type,
+    node
+  };
+}
+
+// src/stdlib.ts
+var BUILTIN_MAP = {
+  len: "List/len",
+  print: "IO/print",
+  range: "List/range",
+  int: "Num/to_int",
+  float: "Num/to_float",
+  str: "Str/from",
+  bool: "Bool/from",
+  abs: "Num/abs",
+  min: "Num/min",
+  max: "Num/max",
+  sum: "List/sum",
+  sorted: "List/sort",
+  reversed: "List/reverse",
+  enumerate: "List/enumerate",
+  zip: "List/zip",
+  map: "List/map",
+  filter: "List/filter",
+  any: "List/any",
+  all: "List/all",
+  isinstance: "Type/is",
+  type: "Type/of",
+  input: "IO/input",
+  open: "IO/open",
+  round: "Num/round",
+  list: "List/from",
+  dict: "Map/from",
+  tuple: "Tuple/from",
+  set: "Set/from"
+};
+var OP_MAP = {
+  "+": "+",
+  "-": "-",
+  "*": "*",
+  "/": "/",
+  "//": "/",
+  "%": "%",
+  "**": "**",
+  "&": "&",
+  "|": "|",
+  "==": "==",
+  "!=": "!=",
+  "<": "<",
+  ">": ">",
+  "<=": "<=",
+  ">=": ">=",
+  and: "&",
+  or: "|",
+  not: "!",
+  in: "List/contains",
+  "not in": "List/not_contains"
+};
+var METHOD_MAP = {
+  // list methods
+  "list.append": "List/push",
+  "list.pop": "List/pop",
+  "list.insert": "List/insert",
+  "list.remove": "List/remove",
+  "list.index": "List/index",
+  "list.count": "List/count",
+  "list.sort": "List/sort",
+  "list.reverse": "List/reverse",
+  "list.extend": "List/concat",
+  "list.copy": "List/copy",
+  "list.clear": "List/clear",
+  // dict methods
+  "dict.get": "Map/get",
+  "dict.keys": "Map/keys",
+  "dict.values": "Map/values",
+  "dict.items": "Map/items",
+  "dict.update": "Map/merge",
+  "dict.pop": "Map/remove",
+  "dict.setdefault": "Map/get_or_set",
+  "dict.clear": "Map/clear",
+  "dict.copy": "Map/copy",
+  // str methods
+  "str.split": "Str/split",
+  "str.join": "Str/join",
+  "str.strip": "Str/trim",
+  "str.lower": "Str/lower",
+  "str.upper": "Str/upper",
+  "str.replace": "Str/replace",
+  "str.startswith": "Str/starts_with",
+  "str.endswith": "Str/ends_with",
+  "str.find": "Str/find",
+  "str.format": "Str/format"
+};
+
+// src/codegen.ts
+function generateBend(module) {
+  const lines = [];
+  for (const node of module.body) {
+    lines.push(generateNode(node, 0));
+  }
+  return lines.join("\n\n") + "\n";
+}
+function generateNode(node, depth) {
+  switch (node.type) {
+    case "BendFunctionDef":
+      return generateFunctionDef(node, depth);
+    case "BendFold":
+      return generateFold(node, depth);
+    case "BendLoop":
+      return generateLoop(node, depth);
+    case "BendObject":
+      return generateObject(node, depth);
+    case "BendWith":
+      return generateWith(node, depth);
+    case "BendPassthrough":
+      return generatePassthrough(node, depth);
+    default:
+      return indent(depth) + `# unsupported: ${node.type}`;
+  }
+}
+function generateFunctionDef(node, depth) {
+  const params = node.params.join(", ");
+  const head = `${indent(depth)}def ${node.name}(${params}):`;
+  const bodyLines = node.body.map((n) => generateNode(n, depth + 1));
+  if (bodyLines.length === 0) {
+    return head + "\n" + indent(depth + 1) + "return *";
+  }
+  return head + "\n" + bodyLines.join("\n");
+}
+function generateFold(node, depth) {
+  const iterExpr = generateExpr(node.iter, depth);
+  const head = `${indent(depth)}fold ${iterExpr}:`;
+  const consCase = `${indent(depth + 1)}case List/Cons:`;
+  const bodyLines = node.body.map((n) => generateNode(n, depth + 2));
+  const nilCase = `${indent(depth + 1)}case List/Nil:`;
+  const nilBody = node.accumulator ? `${indent(depth + 2)}${node.accumulator}` : `${indent(depth + 2)}*`;
+  return [head, consCase, ...bodyLines, nilCase, nilBody].join("\n");
+}
+function generateLoop(node, depth) {
+  const testExpr = generateExpr(node.test, depth);
+  const head = `${indent(depth)}bend x = 0:`;
+  const whenLine = `${indent(depth + 1)}when ${testExpr}:`;
+  const bodyLines = node.body.map((n) => generateNode(n, depth + 2));
+  const forkLine = `${indent(depth + 2)}fork(x + 1)`;
+  const elseLine = `${indent(depth + 1)}else:`;
+  const elseBody = `${indent(depth + 2)}x`;
+  return [head, whenLine, ...bodyLines, forkLine, elseLine, elseBody].join(
+    "\n"
+  );
+}
+function generateObject(node, depth) {
+  const fieldsStr = node.fields.length > 0 ? ` { ${node.fields.join(", ")} }` : "";
+  const head = `${indent(depth)}object ${node.name}${fieldsStr}`;
+  if (node.methods.length === 0) {
+    return head;
+  }
+  const nonInitMethods = node.methods.filter((m) => m.name !== "__init__");
+  if (nonInitMethods.length === 0) {
+    return head;
+  }
+  const methodLines = nonInitMethods.map(
+    (m) => generateFunctionDef(m, depth)
+  );
+  return head + "\n\n" + methodLines.join("\n\n");
+}
+function generateWith(node, depth) {
+  const head = `${indent(depth)}with Result:`;
+  const bodyLines = node.body.map((n) => generateNode(n, depth + 1));
+  if (!node.handler) {
+    return [head, ...bodyLines].join("\n");
+  }
+  const handlerLines = node.handler.body.map(
+    (n) => generateNode(n, depth + 1)
+  );
+  const handlerHead = node.handler.name ? `${indent(depth)}catch ${node.handler.name}:` : `${indent(depth)}catch _err:`;
+  return [head, ...bodyLines, handlerHead, ...handlerLines].join("\n");
+}
+function generatePassthrough(node, depth) {
+  return generatePyStatement(node.node, depth);
+}
+function generatePyStatement(node, depth) {
+  switch (node.type) {
+    case "Return":
+      return generateReturn(node, depth);
+    case "Assign":
+      return generateAssign(node, depth);
+    case "AugAssign":
+      return generateAugAssign(node, depth);
+    case "If":
+      return generateIf(node, depth);
+    case "Expr":
+      return indent(depth) + generateExpr(node.value, depth);
+    default:
+      return indent(depth) + generateExpr(node, depth);
+  }
+}
+function generateReturn(node, depth) {
+  if (!node.value) {
+    return `${indent(depth)}return *`;
+  }
+  return `${indent(depth)}return ${generateExpr(node.value, depth)}`;
+}
+function generateAssign(node, depth) {
+  return `${indent(depth)}let ${node.target} = ${generateExpr(node.value, depth)}`;
+}
+function generateAugAssign(node, depth) {
+  const op = node.op.slice(0, -1);
+  const mappedOp = OP_MAP[op] ?? op;
+  return `${indent(depth)}let ${node.target} = (${node.target} ${mappedOp} ${generateExpr(node.value, depth)})`;
+}
+function generateIf(node, depth) {
+  const testExpr = generateExpr(node.test, depth);
+  const head = `${indent(depth)}if ${testExpr}:`;
+  const bodyLines = node.body.map(
+    (n) => generatePyStatement(n, depth + 1)
+  );
+  if (!node.orelse || node.orelse.length === 0) {
+    return [head, ...bodyLines].join("\n");
+  }
+  const elseLine = `${indent(depth)}else:`;
+  const elseLines = node.orelse.map(
+    (n) => generatePyStatement(n, depth + 1)
+  );
+  return [head, ...bodyLines, elseLine, ...elseLines].join("\n");
+}
+function generateExpr(node, _depth) {
+  switch (node.type) {
+    case "Name":
+      return node.id;
+    case "Constant":
+      return generateConstant(node);
+    case "BinOp": {
+      const binop = node;
+      const mappedOp = OP_MAP[binop.op] ?? binop.op;
+      return `(${generateExpr(binop.left, _depth)} ${mappedOp} ${generateExpr(binop.right, _depth)})`;
+    }
+    case "UnaryOp": {
+      const unary = node;
+      const mappedOp = OP_MAP[unary.op] ?? unary.op;
+      if (mappedOp === "!") {
+        return `(!${generateExpr(unary.operand, _depth)})`;
+      }
+      return `(${mappedOp}${generateExpr(unary.operand, _depth)})`;
+    }
+    case "Compare": {
+      const cmp = node;
+      if (cmp.ops.length === 1) {
+        const mappedOp = OP_MAP[cmp.ops[0]] ?? cmp.ops[0];
+        return `(${generateExpr(cmp.left, _depth)} ${mappedOp} ${generateExpr(cmp.comparators[0], _depth)})`;
+      }
+      const parts = [];
+      let prevExpr = generateExpr(cmp.left, _depth);
+      for (let i = 0; i < cmp.ops.length; i++) {
+        const mappedOp = OP_MAP[cmp.ops[i]] ?? cmp.ops[i];
+        const rightExpr = generateExpr(cmp.comparators[i], _depth);
+        parts.push(`(${prevExpr} ${mappedOp} ${rightExpr})`);
+        prevExpr = rightExpr;
+      }
+      return parts.join(" & ");
+    }
+    case "BoolOp": {
+      const boolop = node;
+      const mappedOp = OP_MAP[boolop.op] ?? boolop.op;
+      const exprs = boolop.values.map((v) => generateExpr(v, _depth));
+      return `(${exprs.join(` ${mappedOp} `)})`;
+    }
+    case "Call": {
+      const call = node;
+      const funcName = generateExpr(call.func, _depth);
+      const mappedName = BUILTIN_MAP[funcName] ?? funcName;
+      const args = call.args.map((a) => generateExpr(a, _depth));
+      const kwargs = call.kwargs.map(
+        (kw) => `${kw.key}=${generateExpr(kw.value, _depth)}`
+      );
+      const allArgs = [...args, ...kwargs].join(", ");
+      return `${mappedName}(${allArgs})`;
+    }
+    case "Attribute": {
+      const attr = node;
+      return `${generateExpr(attr.value, _depth)}.${attr.attr}`;
+    }
+    case "Subscript": {
+      const sub = node;
+      return `List/get(${generateExpr(sub.value, _depth)}, ${generateExpr(sub.slice, _depth)})`;
+    }
+    case "List": {
+      const list = node;
+      const elts = list.elts.map((e) => generateExpr(e, _depth));
+      return `[${elts.join(", ")}]`;
+    }
+    case "Dict": {
+      const dict = node;
+      const entries = dict.keys.map(
+        (k, i) => `${generateExpr(k, _depth)}: ${generateExpr(dict.values[i], _depth)}`
+      );
+      return `{${entries.join(", ")}}`;
+    }
+    case "Lambda": {
+      const lam = node;
+      const params = lam.params.join(", ");
+      return `@${params} ${generateExpr(lam.body, _depth)}`;
+    }
+    default:
+      return `/* unsupported: ${node.type} */`;
+  }
+}
+function generateConstant(node) {
+  switch (node.kind) {
+    case "str":
+      return `"${String(node.value).replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    case "int":
+    case "float":
+      return String(node.value);
+    case "bool":
+      return node.value ? "True" : "False";
+    case "none":
+      return "*";
+    default:
+      return String(node.value);
+  }
+}
+function indent(depth) {
+  return "  ".repeat(depth);
+}
+
+// src/index.ts
+function compile(pythonSource) {
+  const warnings = [];
+  const { ast, errors: parseErrors } = parsePython(pythonSource);
+  if (!ast) {
+    return {
+      bend: "",
+      errors: parseErrors,
+      warnings
+    };
+  }
+  const errors = parseErrors.filter((e) => e.severity === "error");
+  const parseWarnings = parseErrors.filter((e) => e.severity === "warning");
+  warnings.push(...parseWarnings.map((w) => w.message));
+  const bendModule = transformModule(ast);
+  const bend = generateBend(bendModule);
+  return {
+    bend,
+    errors,
+    warnings
+  };
+}
+export {
+  BUILTIN_MAP,
+  METHOD_MAP,
+  OP_MAP,
+  compile,
+  generateBend,
+  parsePython,
+  transformModule
+};
+//# sourceMappingURL=index.js.map