@nice2dev/game-engine 1.3.14 → 1.3.16

package/dist/cjs/godot-integration/GodotImport.js

@@ -1,1068 +1,970 @@
-'use strict';
-
-/**
- * @file GodotImport.ts
- * @description Godot Engine Project Import for Nice2Dev Game Engine
- * PRO-1.9.1: Godot Project Import
- *
- * Features:
- * - .tscn (text scene) parsing
- * - .scn (binary scene) detection
- * - .tres resource parsing
- * - GDScript parser and AST extraction
- * - Node tree reconstruction
- * - Signal/connection mapping
- */
-// ============================================================
-// TSCN Parser
-// ============================================================
-/**
- * Parses Godot's text scene format (.tscn)
- */
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 function parseGodotScene(content) {
-    const lines = content.split('\n');
-    const scene = {
-        header: { loadSteps: 0, format: 3 },
-        extResources: [],
-        subResources: [],
-        rootNode: null,
-        connections: [],
-        editable: [],
-    };
-    let currentSection = 'header';
-    let currentNode = null;
-    const nodeMap = new Map();
-    let currentSubResource = null;
-    let multiLineValue = '';
-    let multiLineKey = '';
-    let inMultiLine = false;
-    for (let i = 0; i < lines.length; i++) {
-        let line = lines[i];
-        // Handle multi-line values (strings, arrays, etc.)
-        if (inMultiLine) {
-            multiLineValue += '\n' + line;
-            if (line.includes(']') || (line.includes('"') && line.trim().endsWith('"'))) {
-                if (currentNode) {
-                    currentNode.properties[multiLineKey] = parseGodotValue(multiLineValue);
-                }
-                else if (currentSubResource) {
-                    currentSubResource.properties[multiLineKey] = parseGodotValue(multiLineValue);
-                }
-                inMultiLine = false;
-                multiLineValue = '';
-                multiLineKey = '';
-            }
-            continue;
-        }
-        line = line.trim();
-        if (!line || line.startsWith(';')) {
-            continue;
-        }
-        // Section headers
-        if (line.startsWith('[')) {
-            const sectionMatch = line.match(/^\[(\w+)(?:\s+(.+))?\]$/);
-            if (sectionMatch) {
-                const sectionType = sectionMatch[1];
-                const sectionParams = sectionMatch[2] || '';
-                switch (sectionType) {
-                    case 'gd_scene':
-                        currentSection = 'header';
-                        scene.header = parseGodotSceneHeader(sectionParams);
-                        break;
-                    case 'ext_resource':
-                        currentSection = 'ext_resource';
-                        scene.extResources.push(parseExtResource(sectionParams));
-                        break;
-                    case 'sub_resource':
-                        currentSection = 'sub_resource';
-                        currentSubResource = parseSubResourceHeader(sectionParams);
-                        scene.subResources.push(currentSubResource);
-                        break;
-                    case 'node':
-                        currentSection = 'node';
-                        currentNode = parseNodeHeader(sectionParams);
-                        if (!currentNode.parent) {
-                            // Root node
-                            scene.rootNode = currentNode;
-                            nodeMap.set('.', currentNode);
-                        }
-                        else {
-                            // Find parent and add as child
-                            const parentPath = currentNode.parent;
-                            const parentNode = nodeMap.get(parentPath);
-                            if (parentNode) {
-                                parentNode.children.push(currentNode);
-                            }
-                            // Calculate this node's path
-                            const nodePath = parentPath === '.' ? currentNode.name : `${parentPath}/${currentNode.name}`;
-                            nodeMap.set(nodePath, currentNode);
-                        }
-                        break;
-                    case 'connection':
-                        currentSection = 'connection';
-                        scene.connections.push(parseConnectionHeader(sectionParams));
-                        break;
-                    case 'editable': {
-                        currentSection = 'editable';
-                        const pathMatch = sectionParams.match(/path="([^"]+)"/);
-                        if (pathMatch) {
-                            scene.editable.push(pathMatch[1]);
-                        }
-                        break;
-                    }
-                }
-                continue;
-            }
-        }
-        // Property assignment
-        if (line.includes('=')) {
-            const eqIndex = line.indexOf('=');
-            const key = line.substring(0, eqIndex).trim();
-            const valueStr = line.substring(eqIndex + 1).trim();
-            // Check for multi-line value start
-            if ((valueStr.startsWith('[') && !valueStr.includes(']')) ||
-                (valueStr.startsWith('"') && !valueStr.endsWith('"') && valueStr.length > 1)) {
-                inMultiLine = true;
-                multiLineKey = key;
-                multiLineValue = valueStr;
-                continue;
-            }
-            const value = parseGodotValue(valueStr);
-            if (currentSection === 'node' && currentNode) {
-                currentNode.properties[key] = value;
+  const lines = content.split("\n");
+  const scene = {
+    header: { loadSteps: 0, format: 3 },
+    extResources: [],
+    subResources: [],
+    rootNode: null,
+    connections: [],
+    editable: []
+  };
+  let currentSection = "header";
+  let currentNode = null;
+  const nodeMap = /* @__PURE__ */ new Map();
+  let currentSubResource = null;
+  let multiLineValue = "";
+  let multiLineKey = "";
+  let inMultiLine = false;
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    if (inMultiLine) {
+      multiLineValue += "\n" + line;
+      if (line.includes("]") || line.includes('"') && line.trim().endsWith('"')) {
+        if (currentNode) {
+          currentNode.properties[multiLineKey] = parseGodotValue(multiLineValue);
+        } else if (currentSubResource) {
+          currentSubResource.properties[multiLineKey] = parseGodotValue(multiLineValue);
+        }
+        inMultiLine = false;
+        multiLineValue = "";
+        multiLineKey = "";
+      }
+      continue;
+    }
+    line = line.trim();
+    if (!line || line.startsWith(";")) {
+      continue;
+    }
+    if (line.startsWith("[")) {
+      const sectionMatch = line.match(/^\[(\w+)(?:\s+(.+))?\]$/);
+      if (sectionMatch) {
+        const sectionType = sectionMatch[1];
+        const sectionParams = sectionMatch[2] || "";
+        switch (sectionType) {
+          case "gd_scene":
+            currentSection = "header";
+            scene.header = parseGodotSceneHeader(sectionParams);
+            break;
+          case "ext_resource":
+            currentSection = "ext_resource";
+            scene.extResources.push(parseExtResource(sectionParams));
+            break;
+          case "sub_resource":
+            currentSection = "sub_resource";
+            currentSubResource = parseSubResourceHeader(sectionParams);
+            scene.subResources.push(currentSubResource);
+            break;
+          case "node":
+            currentSection = "node";
+            currentNode = parseNodeHeader(sectionParams);
+            if (!currentNode.parent) {
+              scene.rootNode = currentNode;
+              nodeMap.set(".", currentNode);
+            } else {
+              const parentPath = currentNode.parent;
+              const parentNode = nodeMap.get(parentPath);
+              if (parentNode) {
+                parentNode.children.push(currentNode);
+              }
+              const nodePath = parentPath === "." ? currentNode.name : `${parentPath}/${currentNode.name}`;
+              nodeMap.set(nodePath, currentNode);
             }
-            else if (currentSection === 'sub_resource' && currentSubResource) {
-                currentSubResource.properties[key] = value;
+            break;
+          case "connection":
+            currentSection = "connection";
+            scene.connections.push(parseConnectionHeader(sectionParams));
+            break;
+          case "editable": {
+            currentSection = "editable";
+            const pathMatch = sectionParams.match(/path="([^"]+)"/);
+            if (pathMatch) {
+              scene.editable.push(pathMatch[1]);
             }
-        }
-    }
-    return scene;
+            break;
+          }
+        }
+        continue;
+      }
+    }
+    if (line.includes("=")) {
+      const eqIndex = line.indexOf("=");
+      const key = line.substring(0, eqIndex).trim();
+      const valueStr = line.substring(eqIndex + 1).trim();
+      if (valueStr.startsWith("[") && !valueStr.includes("]") || valueStr.startsWith('"') && !valueStr.endsWith('"') && valueStr.length > 1) {
+        inMultiLine = true;
+        multiLineKey = key;
+        multiLineValue = valueStr;
+        continue;
+      }
+      const value = parseGodotValue(valueStr);
+      if (currentSection === "node" && currentNode) {
+        currentNode.properties[key] = value;
+      } else if (currentSection === "sub_resource" && currentSubResource) {
+        currentSubResource.properties[key] = value;
+      }
+    }
+  }
+  return scene;
 }
 function parseGodotSceneHeader(params) {
-    const header = { loadSteps: 0, format: 3 };
-    const loadStepsMatch = params.match(/load_steps=(\d+)/);
-    if (loadStepsMatch) {
-        header.loadSteps = parseInt(loadStepsMatch[1], 10);
-    }
-    const formatMatch = params.match(/format=(\d+)/);
-    if (formatMatch) {
-        header.format = parseInt(formatMatch[1], 10);
-    }
-    const uidMatch = params.match(/uid="([^"]+)"/);
-    if (uidMatch) {
-        header.uid = uidMatch[1];
-    }
-    const typeMatch = params.match(/type="([^"]+)"/);
-    if (typeMatch) {
-        header.type = typeMatch[1];
-    }
-    return header;
+  const header = { loadSteps: 0, format: 3 };
+  const loadStepsMatch = params.match(/load_steps=(\d+)/);
+  if (loadStepsMatch) {
+    header.loadSteps = parseInt(loadStepsMatch[1], 10);
+  }
+  const formatMatch = params.match(/format=(\d+)/);
+  if (formatMatch) {
+    header.format = parseInt(formatMatch[1], 10);
+  }
+  const uidMatch = params.match(/uid="([^"]+)"/);
+  if (uidMatch) {
+    header.uid = uidMatch[1];
+  }
+  const typeMatch = params.match(/type="([^"]+)"/);
+  if (typeMatch) {
+    header.type = typeMatch[1];
+  }
+  return header;
 }
 function parseExtResource(params) {
-    const resource = { id: '', type: '', path: '' };
-    const typeMatch = params.match(/type="([^"]+)"/);
-    if (typeMatch) {
-        resource.type = typeMatch[1];
-    }
-    const pathMatch = params.match(/path="([^"]+)"/);
-    if (pathMatch) {
-        resource.path = pathMatch[1];
-    }
-    const idMatch = params.match(/id="?([^"\s]+)"?/);
-    if (idMatch) {
-        resource.id = idMatch[1];
-    }
-    const uidMatch = params.match(/uid="([^"]+)"/);
-    if (uidMatch) {
-        resource.uid = uidMatch[1];
-    }
-    return resource;
+  const resource = { id: "", type: "", path: "" };
+  const typeMatch = params.match(/type="([^"]+)"/);
+  if (typeMatch) {
+    resource.type = typeMatch[1];
+  }
+  const pathMatch = params.match(/path="([^"]+)"/);
+  if (pathMatch) {
+    resource.path = pathMatch[1];
+  }
+  const idMatch = params.match(/id="?([^"\s]+)"?/);
+  if (idMatch) {
+    resource.id = idMatch[1];
+  }
+  const uidMatch = params.match(/uid="([^"]+)"/);
+  if (uidMatch) {
+    resource.uid = uidMatch[1];
+  }
+  return resource;
 }
 function parseSubResourceHeader(params) {
-    const resource = { id: '', type: '', properties: {} };
-    const typeMatch = params.match(/type="([^"]+)"/);
-    if (typeMatch) {
-        resource.type = typeMatch[1];
-    }
-    const idMatch = params.match(/id="?([^"\s]+)"?/);
-    if (idMatch) {
-        resource.id = idMatch[1];
-    }
-    return resource;
+  const resource = { id: "", type: "", properties: {} };
+  const typeMatch = params.match(/type="([^"]+)"/);
+  if (typeMatch) {
+    resource.type = typeMatch[1];
+  }
+  const idMatch = params.match(/id="?([^"\s]+)"?/);
+  if (idMatch) {
+    resource.id = idMatch[1];
+  }
+  return resource;
 }
 function parseNodeHeader(params) {
-    const node = {
-        name: '',
-        type: 'Node',
-        properties: {},
-        children: [],
-    };
-    const nameMatch = params.match(/name="([^"]+)"/);
-    if (nameMatch) {
-        node.name = nameMatch[1];
-    }
-    const typeMatch = params.match(/type="([^"]+)"/);
-    if (typeMatch) {
-        node.type = typeMatch[1];
-    }
-    const parentMatch = params.match(/parent="([^"]+)"/);
-    if (parentMatch) {
-        node.parent = parentMatch[1];
-    }
-    const instanceMatch = params.match(/instance=ExtResource\(\s*"?([^")]+)"?\s*\)/);
-    if (instanceMatch) {
-        node.instance = instanceMatch[1];
-    }
-    const groupsMatch = params.match(/groups=\[([^\]]+)\]/);
-    if (groupsMatch) {
-        node.groups = groupsMatch[1].split(',').map((g) => g.trim().replace(/"/g, ''));
-    }
-    const indexMatch = params.match(/index="?(\d+)"?/);
-    if (indexMatch) {
-        node.index = parseInt(indexMatch[1], 10);
-    }
-    return node;
+  const node = {
+    name: "",
+    type: "Node",
+    properties: {},
+    children: []
+  };
+  const nameMatch = params.match(/name="([^"]+)"/);
+  if (nameMatch) {
+    node.name = nameMatch[1];
+  }
+  const typeMatch = params.match(/type="([^"]+)"/);
+  if (typeMatch) {
+    node.type = typeMatch[1];
+  }
+  const parentMatch = params.match(/parent="([^"]+)"/);
+  if (parentMatch) {
+    node.parent = parentMatch[1];
+  }
+  const instanceMatch = params.match(/instance=ExtResource\(\s*"?([^")]+)"?\s*\)/);
+  if (instanceMatch) {
+    node.instance = instanceMatch[1];
+  }
+  const groupsMatch = params.match(/groups=\[([^\]]+)\]/);
+  if (groupsMatch) {
+    node.groups = groupsMatch[1].split(",").map((g) => g.trim().replace(/"/g, ""));
+  }
+  const indexMatch = params.match(/index="?(\d+)"?/);
+  if (indexMatch) {
+    node.index = parseInt(indexMatch[1], 10);
+  }
+  return node;
 }
 function parseConnectionHeader(params) {
-    const connection = {
-        signal: '',
-        from: '',
-        to: '',
-        method: '',
-    };
-    const signalMatch = params.match(/signal="([^"]+)"/);
-    if (signalMatch) {
-        connection.signal = signalMatch[1];
-    }
-    const fromMatch = params.match(/from="([^"]+)"/);
-    if (fromMatch) {
-        connection.from = fromMatch[1];
-    }
-    const toMatch = params.match(/to="([^"]+)"/);
-    if (toMatch) {
-        connection.to = toMatch[1];
-    }
-    const methodMatch = params.match(/method="([^"]+)"/);
-    if (methodMatch) {
-        connection.method = methodMatch[1];
-    }
-    const flagsMatch = params.match(/flags=(\d+)/);
-    if (flagsMatch) {
-        connection.flags = parseInt(flagsMatch[1], 10);
-    }
-    return connection;
+  const connection = {
+    signal: "",
+    from: "",
+    to: "",
+    method: ""
+  };
+  const signalMatch = params.match(/signal="([^"]+)"/);
+  if (signalMatch) {
+    connection.signal = signalMatch[1];
+  }
+  const fromMatch = params.match(/from="([^"]+)"/);
+  if (fromMatch) {
+    connection.from = fromMatch[1];
+  }
+  const toMatch = params.match(/to="([^"]+)"/);
+  if (toMatch) {
+    connection.to = toMatch[1];
+  }
+  const methodMatch = params.match(/method="([^"]+)"/);
+  if (methodMatch) {
+    connection.method = methodMatch[1];
+  }
+  const flagsMatch = params.match(/flags=(\d+)/);
+  if (flagsMatch) {
+    connection.flags = parseInt(flagsMatch[1], 10);
+  }
+  return connection;
 }
 function parseGodotValue(valueStr) {
-    valueStr = valueStr.trim();
-    // null
-    if (valueStr === 'null') {
-        return null;
-    }
-    // Boolean
-    if (valueStr === 'true') {
-        return true;
-    }
-    if (valueStr === 'false') {
-        return false;
-    }
-    // Integer
-    if (/^-?\d+$/.test(valueStr)) {
-        return parseInt(valueStr, 10);
-    }
-    // Float
-    if (/^-?\d+\.\d+$/.test(valueStr)) {
-        return parseFloat(valueStr);
-    }
-    // String
-    if (valueStr.startsWith('"') && valueStr.endsWith('"')) {
-        return valueStr.slice(1, -1);
-    }
-    // Vector2
-    const vec2Match = valueStr.match(/^Vector2\(\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*\)$/);
-    if (vec2Match) {
-        return { x: parseFloat(vec2Match[1]), y: parseFloat(vec2Match[2]) };
-    }
-    // Vector2i
-    const vec2iMatch = valueStr.match(/^Vector2i\(\s*(-?\d+)\s*,\s*(-?\d+)\s*\)$/);
-    if (vec2iMatch) {
-        return { x: parseInt(vec2iMatch[1], 10), y: parseInt(vec2iMatch[2], 10) };
-    }
-    // Vector3
-    const vec3Match = valueStr.match(/^Vector3\(\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*\)$/);
-    if (vec3Match) {
-        return {
-            x: parseFloat(vec3Match[1]),
-            y: parseFloat(vec3Match[2]),
-            z: parseFloat(vec3Match[3]),
-        };
-    }
-    // Vector3i
-    const vec3iMatch = valueStr.match(/^Vector3i\(\s*(-?\d+)\s*,\s*(-?\d+)\s*,\s*(-?\d+)\s*\)$/);
-    if (vec3iMatch) {
-        return {
-            x: parseInt(vec3iMatch[1], 10),
-            y: parseInt(vec3iMatch[2], 10),
-            z: parseInt(vec3iMatch[3], 10),
-        };
-    }
-    // Color
-    const colorMatch = valueStr.match(/^Color\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*([\d.]+))?\s*\)$/);
-    if (colorMatch) {
-        return {
-            r: parseFloat(colorMatch[1]),
-            g: parseFloat(colorMatch[2]),
-            b: parseFloat(colorMatch[3]),
-            a: colorMatch[4] ? parseFloat(colorMatch[4]) : 1,
-        };
-    }
-    // Rect2
-    const rect2Match = valueStr.match(/^Rect2\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*\)$/);
-    if (rect2Match) {
-        return {
-            x: parseFloat(rect2Match[1]),
-            y: parseFloat(rect2Match[2]),
-            width: parseFloat(rect2Match[3]),
-            height: parseFloat(rect2Match[4]),
-        };
-    }
-    // Transform2D
-    const transform2dMatch = valueStr.match(/^Transform2D\(\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*\)$/);
-    if (transform2dMatch) {
-        return {
-            type: 'Transform2D',
-            x: { x: parseFloat(transform2dMatch[1]), y: parseFloat(transform2dMatch[2]) },
-            y: { x: parseFloat(transform2dMatch[3]), y: parseFloat(transform2dMatch[4]) },
-            origin: { x: parseFloat(transform2dMatch[5]), y: parseFloat(transform2dMatch[6]) },
-        };
-    }
-    // Transform3D
-    const transform3dMatch = valueStr.match(/^Transform3D\(([^)]+)\)$/);
-    if (transform3dMatch) {
-        const values = transform3dMatch[1].split(',').map((v) => parseFloat(v.trim()));
-        if (values.length === 12) {
-            return {
-                type: 'Transform3D',
-                basis: {
-                    x: { x: values[0], y: values[1], z: values[2] },
-                    y: { x: values[3], y: values[4], z: values[5] },
-                    z: { x: values[6], y: values[7], z: values[8] },
-                },
-                origin: { x: values[9], y: values[10], z: values[11] },
-            };
-        }
-    }
-    // NodePath
-    const nodePathMatch = valueStr.match(/^NodePath\("([^"]*)"\)$/);
-    if (nodePathMatch) {
-        return { type: 'NodePath', path: nodePathMatch[1] };
-    }
-    // ExtResource reference
-    const extResMatch = valueStr.match(/^ExtResource\(\s*"?([^")]+)"?\s*\)$/);
-    if (extResMatch) {
-        return { type: 'ExtResource', id: extResMatch[1] };
-    }
-    // SubResource reference
-    const subResMatch = valueStr.match(/^SubResource\(\s*"?([^")]+)"?\s*\)$/);
-    if (subResMatch) {
-        return { type: 'SubResource', id: subResMatch[1] };
-    }
-    // Array
-    if (valueStr.startsWith('[') && valueStr.endsWith(']')) {
-        const inner = valueStr.slice(1, -1).trim();
-        if (!inner) {
-            return [];
-        }
-        // Simple split for basic arrays (doesn't handle nested structures well)
-        return inner.split(/,(?![^(]*\))/).map((v) => parseGodotValue(v.trim()));
-    }
-    // Dictionary
-    if (valueStr.startsWith('{') && valueStr.endsWith('}')) {
-        // Simple dict parsing
-        const inner = valueStr.slice(1, -1).trim();
-        if (!inner) {
-            return {};
-        }
-        const dict = {};
-        // Match key: value pairs
-        const pairRegex = /"([^"]+)":\s*([^,}]+)/g;
-        let match;
-        while ((match = pairRegex.exec(inner)) !== null) {
-            dict[match[1]] = parseGodotValue(match[2].trim());
-        }
-        return dict;
-    }
-    // PackedStringArray
-    const packedStrMatch = valueStr.match(/^PackedStringArray\(\s*([^)]*)\s*\)$/);
-    if (packedStrMatch) {
-        const inner = packedStrMatch[1].trim();
-        if (!inner) {
-            return [];
-        }
-        return inner.split(',').map((s) => s.trim().replace(/^"|"$/g, ''));
-    }
-    // PackedVector2Array
-    const packedVec2Match = valueStr.match(/^PackedVector2Array\(\s*([^)]*)\s*\)$/);
-    if (packedVec2Match) {
-        const inner = packedVec2Match[1].trim();
-        if (!inner) {
-            return [];
-        }
-        const nums = inner.split(',').map((n) => parseFloat(n.trim()));
-        const vectors = [];
-        for (let i = 0; i < nums.length; i += 2) {
-            vectors.push({ x: nums[i], y: nums[i + 1] });
-        }
-        return vectors;
-    }
-    // Return as-is for unknown types
-    return valueStr;
+  valueStr = valueStr.trim();
+  if (valueStr === "null") {
+    return null;
+  }
+  if (valueStr === "true") {
+    return true;
+  }
+  if (valueStr === "false") {
+    return false;
+  }
+  if (/^-?\d+$/.test(valueStr)) {
+    return parseInt(valueStr, 10);
+  }
+  if (/^-?\d+\.\d+$/.test(valueStr)) {
+    return parseFloat(valueStr);
+  }
+  if (valueStr.startsWith('"') && valueStr.endsWith('"')) {
+    return valueStr.slice(1, -1);
+  }
+  const vec2Match = valueStr.match(/^Vector2\(\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*\)$/);
+  if (vec2Match) {
+    return { x: parseFloat(vec2Match[1]), y: parseFloat(vec2Match[2]) };
+  }
+  const vec2iMatch = valueStr.match(/^Vector2i\(\s*(-?\d+)\s*,\s*(-?\d+)\s*\)$/);
+  if (vec2iMatch) {
+    return { x: parseInt(vec2iMatch[1], 10), y: parseInt(vec2iMatch[2], 10) };
+  }
+  const vec3Match = valueStr.match(
+    /^Vector3\(\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*\)$/
+  );
+  if (vec3Match) {
+    return {
+      x: parseFloat(vec3Match[1]),
+      y: parseFloat(vec3Match[2]),
+      z: parseFloat(vec3Match[3])
+    };
+  }
+  const vec3iMatch = valueStr.match(/^Vector3i\(\s*(-?\d+)\s*,\s*(-?\d+)\s*,\s*(-?\d+)\s*\)$/);
+  if (vec3iMatch) {
+    return {
+      x: parseInt(vec3iMatch[1], 10),
+      y: parseInt(vec3iMatch[2], 10),
+      z: parseInt(vec3iMatch[3], 10)
+    };
+  }
+  const colorMatch = valueStr.match(
+    /^Color\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*([\d.]+))?\s*\)$/
+  );
+  if (colorMatch) {
+    return {
+      r: parseFloat(colorMatch[1]),
+      g: parseFloat(colorMatch[2]),
+      b: parseFloat(colorMatch[3]),
+      a: colorMatch[4] ? parseFloat(colorMatch[4]) : 1
+    };
+  }
+  const rect2Match = valueStr.match(
+    /^Rect2\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*\)$/
+  );
+  if (rect2Match) {
+    return {
+      x: parseFloat(rect2Match[1]),
+      y: parseFloat(rect2Match[2]),
+      width: parseFloat(rect2Match[3]),
+      height: parseFloat(rect2Match[4])
+    };
+  }
+  const transform2dMatch = valueStr.match(
+    /^Transform2D\(\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*\)$/
+  );
+  if (transform2dMatch) {
+    return {
+      type: "Transform2D",
+      x: { x: parseFloat(transform2dMatch[1]), y: parseFloat(transform2dMatch[2]) },
+      y: { x: parseFloat(transform2dMatch[3]), y: parseFloat(transform2dMatch[4]) },
+      origin: { x: parseFloat(transform2dMatch[5]), y: parseFloat(transform2dMatch[6]) }
+    };
+  }
+  const transform3dMatch = valueStr.match(/^Transform3D\(([^)]+)\)$/);
+  if (transform3dMatch) {
+    const values = transform3dMatch[1].split(",").map((v) => parseFloat(v.trim()));
+    if (values.length === 12) {
+      return {
+        type: "Transform3D",
+        basis: {
+          x: { x: values[0], y: values[1], z: values[2] },
+          y: { x: values[3], y: values[4], z: values[5] },
+          z: { x: values[6], y: values[7], z: values[8] }
+        },
+        origin: { x: values[9], y: values[10], z: values[11] }
+      };
+    }
+  }
+  const nodePathMatch = valueStr.match(/^NodePath\("([^"]*)"\)$/);
+  if (nodePathMatch) {
+    return { type: "NodePath", path: nodePathMatch[1] };
+  }
+  const extResMatch = valueStr.match(/^ExtResource\(\s*"?([^")]+)"?\s*\)$/);
+  if (extResMatch) {
+    return { type: "ExtResource", id: extResMatch[1] };
+  }
+  const subResMatch = valueStr.match(/^SubResource\(\s*"?([^")]+)"?\s*\)$/);
+  if (subResMatch) {
+    return { type: "SubResource", id: subResMatch[1] };
+  }
+  if (valueStr.startsWith("[") && valueStr.endsWith("]")) {
+    const inner = valueStr.slice(1, -1).trim();
+    if (!inner) {
+      return [];
+    }
+    return inner.split(/,(?![^(]*\))/).map((v) => parseGodotValue(v.trim()));
+  }
+  if (valueStr.startsWith("{") && valueStr.endsWith("}")) {
+    const inner = valueStr.slice(1, -1).trim();
+    if (!inner) {
+      return {};
+    }
+    const dict = {};
+    const pairRegex = /"([^"]+)":\s*([^,}]+)/g;
+    let match;
+    while ((match = pairRegex.exec(inner)) !== null) {
+      dict[match[1]] = parseGodotValue(match[2].trim());
+    }
+    return dict;
+  }
+  const packedStrMatch = valueStr.match(/^PackedStringArray\(\s*([^)]*)\s*\)$/);
+  if (packedStrMatch) {
+    const inner = packedStrMatch[1].trim();
+    if (!inner) {
+      return [];
+    }
+    return inner.split(",").map((s) => s.trim().replace(/^"|"$/g, ""));
+  }
+  const packedVec2Match = valueStr.match(/^PackedVector2Array\(\s*([^)]*)\s*\)$/);
+  if (packedVec2Match) {
+    const inner = packedVec2Match[1].trim();
+    if (!inner) {
+      return [];
+    }
+    const nums = inner.split(",").map((n) => parseFloat(n.trim()));
+    const vectors = [];
+    for (let i = 0; i < nums.length; i += 2) {
+      vectors.push({ x: nums[i], y: nums[i + 1] });
+    }
+    return vectors;
+  }
+  return valueStr;
 }
-// ============================================================
-// TRES Resource Parser
-// ============================================================
-/**
- * Parses Godot's text resource format (.tres)
- */
 function parseGodotResource(content) {
-    const lines = content.split('\n');
-    const resource = {
-        header: { type: '', format: 3 },
-        extResources: [],
-        subResources: [],
-        resource: { type: '', properties: {} },
-    };
-    let currentSection = 'header';
-    let currentSubResource = null;
-    for (let line of lines) {
-        line = line.trim();
-        if (!line || line.startsWith(';')) {
-            continue;
-        }
-        // Section headers
-        if (line.startsWith('[')) {
-            const sectionMatch = line.match(/^\[(\w+)(?:\s+(.+))?\]$/);
-            if (sectionMatch) {
-                const sectionType = sectionMatch[1];
-                const sectionParams = sectionMatch[2] || '';
-                switch (sectionType) {
-                    case 'gd_resource':
-                        currentSection = 'header';
-                        resource.header = parseResourceHeader(sectionParams);
-                        break;
-                    case 'ext_resource':
-                        currentSection = 'ext_resource';
-                        resource.extResources.push(parseExtResource(sectionParams));
-                        break;
-                    case 'sub_resource':
-                        currentSection = 'sub_resource';
-                        currentSubResource = parseSubResourceHeader(sectionParams);
-                        resource.subResources.push(currentSubResource);
-                        break;
-                    case 'resource':
-                        currentSection = 'resource';
-                        break;
-                }
-                continue;
-            }
-        }
-        // Property assignment
-        if (line.includes('=')) {
-            const eqIndex = line.indexOf('=');
-            const key = line.substring(0, eqIndex).trim();
-            const valueStr = line.substring(eqIndex + 1).trim();
-            const value = parseGodotValue(valueStr);
-            if (currentSection === 'resource') {
-                resource.resource.properties[key] = value;
-            }
-            else if (currentSection === 'sub_resource' && currentSubResource) {
-                currentSubResource.properties[key] = value;
-            }
-        }
-    }
-    resource.resource.type = resource.header.type;
-    return resource;
+  const lines = content.split("\n");
+  const resource = {
+    header: { type: "", format: 3 },
+    extResources: [],
+    subResources: [],
+    resource: { type: "", properties: {} }
+  };
+  let currentSection = "header";
+  let currentSubResource = null;
+  for (let line of lines) {
+    line = line.trim();
+    if (!line || line.startsWith(";")) {
+      continue;
+    }
+    if (line.startsWith("[")) {
+      const sectionMatch = line.match(/^\[(\w+)(?:\s+(.+))?\]$/);
+      if (sectionMatch) {
+        const sectionType = sectionMatch[1];
+        const sectionParams = sectionMatch[2] || "";
+        switch (sectionType) {
+          case "gd_resource":
+            currentSection = "header";
+            resource.header = parseResourceHeader(sectionParams);
+            break;
+          case "ext_resource":
+            currentSection = "ext_resource";
+            resource.extResources.push(parseExtResource(sectionParams));
+            break;
+          case "sub_resource":
+            currentSection = "sub_resource";
+            currentSubResource = parseSubResourceHeader(sectionParams);
+            resource.subResources.push(currentSubResource);
+            break;
+          case "resource":
+            currentSection = "resource";
+            break;
+        }
+        continue;
+      }
+    }
+    if (line.includes("=")) {
+      const eqIndex = line.indexOf("=");
+      const key = line.substring(0, eqIndex).trim();
+      const valueStr = line.substring(eqIndex + 1).trim();
+      const value = parseGodotValue(valueStr);
+      if (currentSection === "resource") {
+        resource.resource.properties[key] = value;
+      } else if (currentSection === "sub_resource" && currentSubResource) {
+        currentSubResource.properties[key] = value;
+      }
+    }
+  }
+  resource.resource.type = resource.header.type;
+  return resource;
 }
 function parseResourceHeader(params) {
-    const header = { type: '', format: 3 };
-    const typeMatch = params.match(/type="([^"]+)"/);
-    if (typeMatch) {
-        header.type = typeMatch[1];
-    }
-    const loadStepsMatch = params.match(/load_steps=(\d+)/);
-    if (loadStepsMatch) {
-        header.loadSteps = parseInt(loadStepsMatch[1], 10);
-    }
-    const formatMatch = params.match(/format=(\d+)/);
-    if (formatMatch) {
-        header.format = parseInt(formatMatch[1], 10);
-    }
-    const uidMatch = params.match(/uid="([^"]+)"/);
-    if (uidMatch) {
-        header.uid = uidMatch[1];
-    }
-    return header;
+  const header = { type: "", format: 3 };
+  const typeMatch = params.match(/type="([^"]+)"/);
+  if (typeMatch) {
+    header.type = typeMatch[1];
+  }
+  const loadStepsMatch = params.match(/load_steps=(\d+)/);
+  if (loadStepsMatch) {
+    header.loadSteps = parseInt(loadStepsMatch[1], 10);
+  }
+  const formatMatch = params.match(/format=(\d+)/);
+  if (formatMatch) {
+    header.format = parseInt(formatMatch[1], 10);
+  }
+  const uidMatch = params.match(/uid="([^"]+)"/);
+  if (uidMatch) {
+    header.uid = uidMatch[1];
+  }
+  return header;
 }
-// ============================================================
-// GDScript Parser
-// ============================================================
-/**
- * Parses GDScript files and extracts structure
- */
-function parseGDScript(content, filePath = '') {
-    const script = {
-        path: filePath,
-        extends: 'Node',
-        isToolScript: false,
+function parseGDScript(content, filePath = "") {
+  const script = {
+    path: filePath,
+    extends: "Node",
+    isToolScript: false,
+    signals: [],
+    enums: [],
+    constants: [],
+    exportVars: [],
+    onreadyVars: [],
+    variables: [],
+    functions: [],
+    innerClasses: [],
+    staticFunctions: [],
+    annotations: []
+  };
+  const lines = content.split("\n");
+  let currentFunction = null;
+  let functionIndent = 0;
+  let currentEnum = null;
+  let enumIndent = 0;
+  let pendingDocComment;
+  let pendingAnnotations = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    const indent = line.length - line.trimStart().length;
+    if (!trimmed) {
+      continue;
+    }
+    if (trimmed.startsWith("##")) {
+      pendingDocComment = (pendingDocComment || "") + trimmed.substring(2).trim() + "\n";
+      continue;
+    }
+    if (trimmed.startsWith("#")) {
+      continue;
+    }
+    if (currentFunction && indent > functionIndent) {
+      currentFunction.body += line + "\n";
+      continue;
+    } else if (currentFunction && indent <= functionIndent) {
+      currentFunction = null;
+    }
+    if (currentEnum && indent > enumIndent) {
+      const enumValMatch = trimmed.match(/^(\w+)(?:\s*=\s*(-?\d+))?,?$/);
+      if (enumValMatch) {
+        const name = enumValMatch[1];
+        const value = enumValMatch[2] ? parseInt(enumValMatch[2], 10) : Object.keys(currentEnum.values).length;
+        currentEnum.values[name] = value;
+      }
+      continue;
+    } else if (currentEnum && indent <= enumIndent) {
+      currentEnum = null;
+    }
+    if (trimmed === "@tool") {
+      script.isToolScript = true;
+      continue;
+    }
+    if (trimmed.startsWith("@")) {
+      const annotationMatch = trimmed.match(/^@(\w+)(?:\(([^)]*)\))?/);
+      if (annotationMatch) {
+        const annotation = { name: annotationMatch[1] };
+        if (annotationMatch[2]) {
+          annotation.arguments = annotationMatch[2].split(",").map((a) => a.trim());
+        }
+        pendingAnnotations.push(annotation);
+        if (annotation.name === "icon" && annotation.arguments?.[0]) {
+          script.iconPath = annotation.arguments[0].replace(/"/g, "");
+        }
+      }
+      continue;
+    }
+    const classNameMatch = trimmed.match(/^class_name\s+(\w+)/);
+    if (classNameMatch) {
+      script.className = classNameMatch[1];
+      script.classNameToken = classNameMatch[1];
+      continue;
+    }
+    const extendsMatch = trimmed.match(/^extends\s+(.+)$/);
+    if (extendsMatch) {
+      script.extends = extendsMatch[1].trim();
+      continue;
+    }
+    const signalMatch = trimmed.match(/^signal\s+(\w+)(?:\(([^)]*)\))?/);
+    if (signalMatch) {
+      const sig = {
+        name: signalMatch[1],
+        parameters: [],
+        documentation: pendingDocComment?.trim()
+      };
+      if (signalMatch[2]) {
+        sig.parameters = parseGDScriptParameters(signalMatch[2]);
+      }
+      script.signals.push(sig);
+      pendingDocComment = void 0;
+      continue;
+    }
+    const enumMatch = trimmed.match(/^enum\s+(\w+)\s*{?/);
+    if (enumMatch) {
+      currentEnum = {
+        name: enumMatch[1],
+        values: {},
+        documentation: pendingDocComment?.trim()
+      };
+      enumIndent = indent;
+      const inlineMatch = trimmed.match(/^enum\s+\w+\s*{([^}]+)}/);
+      if (inlineMatch) {
+        const entries = inlineMatch[1].split(",");
+        let nextVal = 0;
+        for (const entry of entries) {
+          const valMatch = entry.trim().match(/^(\w+)(?:\s*=\s*(-?\d+))?$/);
+          if (valMatch) {
+            const val = valMatch[2] ? parseInt(valMatch[2], 10) : nextVal;
+            currentEnum.values[valMatch[1]] = val;
+            nextVal = val + 1;
+          }
+        }
+        script.enums.push(currentEnum);
+        currentEnum = null;
+      } else {
+        script.enums.push(currentEnum);
+      }
+      pendingDocComment = void 0;
+      continue;
+    }
+    const constMatch = trimmed.match(/^const\s+(\w+)(?:\s*:\s*(\w+))?\s*=\s*(.+)$/);
+    if (constMatch) {
+      script.constants.push({
+        name: constMatch[1],
+        type: constMatch[2],
+        value: constMatch[3],
+        documentation: pendingDocComment?.trim()
+      });
+      pendingDocComment = void 0;
+      continue;
+    }
+    if (trimmed.startsWith("@export")) {
+      const exportAnnotations = [trimmed];
+      let j = i + 1;
+      while (j < lines.length && lines[j].trim().startsWith("@export")) {
+        exportAnnotations.push(lines[j].trim());
+        j++;
+      }
+      if (j < lines.length) {
+        const varLine = lines[j].trim();
+        const varMatch2 = varLine.match(/^var\s+(\w+)(?:\s*:\s*(\w+))?(?:\s*=\s*(.+))?$/);
+        if (varMatch2) {
+          script.exportVars.push({
+            name: varMatch2[1],
+            type: varMatch2[2],
+            default: varMatch2[3],
+            exportAnnotations,
+            documentation: pendingDocComment?.trim()
+          });
+          i = j;
+          pendingDocComment = void 0;
+          pendingAnnotations = [];
+        }
+      }
+      continue;
+    }
+    const onreadyMatch = trimmed.match(/^@onready\s+var\s+(\w+)(?:\s*:\s*(\w+))?(?:\s*=\s*(.+))?$/);
+    if (onreadyMatch) {
+      script.onreadyVars.push({
+        name: onreadyMatch[1],
+        type: onreadyMatch[2],
+        default: onreadyMatch[3],
+        documentation: pendingDocComment?.trim()
+      });
+      pendingDocComment = void 0;
+      continue;
+    }
+    const varMatch = trimmed.match(
+      /^var\s+(\w+)(?:\s*:\s*(\w+))?(?:\s*=\s*(.+))?(?:\s*:\s*(?:get\s*=\s*(\w+))?(?:\s*,?\s*set\s*=\s*(\w+))?)?$/
+    );
+    if (varMatch) {
+      const variable = {
+        name: varMatch[1],
+        type: varMatch[2],
+        default: varMatch[3],
+        documentation: pendingDocComment?.trim()
+      };
+      if (varMatch[4] || varMatch[5]) {
+        variable.setget = {
+          getter: varMatch[4],
+          setter: varMatch[5]
+        };
+      }
+      script.variables.push(variable);
+      pendingDocComment = void 0;
+      continue;
+    }
+    const funcMatch = trimmed.match(
+      /^(?:(static)\s+)?func\s+(\w+)\(([^)]*)\)(?:\s*->\s*(\w+))?(?:\s*:\s*)?$/
+    );
+    if (funcMatch) {
+      currentFunction = {
+        name: funcMatch[2],
+        parameters: parseGDScriptParameters(funcMatch[3]),
+        returnType: funcMatch[4],
+        isVirtual: funcMatch[2].startsWith("_"),
+        isStatic: !!funcMatch[1],
+        isCoroutine: false,
+        body: "",
+        documentation: pendingDocComment?.trim()
+      };
+      functionIndent = indent;
+      if (currentFunction.isStatic) {
+        script.staticFunctions.push(currentFunction);
+      } else {
+        script.functions.push(currentFunction);
+      }
+      pendingDocComment = void 0;
+      continue;
+    }
+    const classMatch = trimmed.match(/^class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s*:\s*)?$/);
+    if (classMatch) {
+      script.innerClasses.push({
+        name: classMatch[1],
+        extends: classMatch[2],
         signals: [],
-        enums: [],
-        constants: [],
-        exportVars: [],
-        onreadyVars: [],
         variables: [],
-        functions: [],
-        innerClasses: [],
-        staticFunctions: [],
-        annotations: [],
+        functions: []
+      });
+      pendingDocComment = void 0;
+      continue;
+    }
+    pendingDocComment = void 0;
+    pendingAnnotations = [];
+  }
+  return script;
+}
+function parseGDScriptParameters(paramString) {
+  if (!paramString.trim()) {
+    return [];
+  }
+  const params = [];
+  const parts = paramString.split(",");
+  for (const part of parts) {
+    const trimmed = part.trim();
+    const paramMatch = trimmed.match(/^(\w+)(?:\s*:\s*(\w+))?(?:\s*=\s*(.+))?$/);
+    if (paramMatch) {
+      params.push({
+        name: paramMatch[1],
+        type: paramMatch[2],
+        default: paramMatch[3]
+      });
+    }
+  }
+  return params;
+}
+class GodotProjectImporter {
+  constructor(callbacks) {
+    this.projectPath = "";
+    this.config = null;
+    this.scenes = /* @__PURE__ */ new Map();
+    this.resources = /* @__PURE__ */ new Map();
+    this.scripts = /* @__PURE__ */ new Map();
+    this.callbacks = {};
+    if (callbacks) {
+      this.callbacks = callbacks;
+    }
+  }
+  /**
+   * Parses project.godot configuration file
+   */
+  parseProjectConfig(content) {
+    const config = {
+      configVersion: 5,
+      name: "Untitled",
+      features: [],
+      autoloads: {},
+      inputMap: {},
+      layers: { layer2d: {}, layer3d: {} }
     };
-    const lines = content.split('\n');
-    let currentFunction = null;
-    let functionIndent = 0;
-    let currentEnum = null;
-    let enumIndent = 0;
-    let pendingDocComment;
-    let pendingAnnotations = [];
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const trimmed = line.trim();
-        const indent = line.length - line.trimStart().length;
-        // Skip empty lines and comments (but capture doc comments)
-        if (!trimmed) {
-            continue;
-        }
-        if (trimmed.startsWith('##')) {
-            pendingDocComment = (pendingDocComment || '') + trimmed.substring(2).trim() + '\n';
-            continue;
-        }
-        if (trimmed.startsWith('#')) {
-            continue;
-        }
-        // Handle being inside function body
-        if (currentFunction && indent > functionIndent) {
-            currentFunction.body += line + '\n';
-            continue;
-        }
-        else if (currentFunction && indent <= functionIndent) {
-            currentFunction = null;
-        }
-        // Handle being inside enum
-        if (currentEnum && indent > enumIndent) {
-            // Parse enum value
-            const enumValMatch = trimmed.match(/^(\w+)(?:\s*=\s*(-?\d+))?,?$/);
-            if (enumValMatch) {
-                const name = enumValMatch[1];
-                const value = enumValMatch[2]
-                    ? parseInt(enumValMatch[2], 10)
-                    : Object.keys(currentEnum.values).length;
-                currentEnum.values[name] = value;
+    let currentSection = "";
+    const lines = content.split("\n");
+    for (let line of lines) {
+      line = line.trim();
+      if (!line || line.startsWith(";")) {
+        continue;
+      }
+      if (line.startsWith("[")) {
+        const match = line.match(/^\[(.+)\]$/);
+        if (match) {
+          currentSection = match[1];
+        }
+        continue;
+      }
+      if (line.includes("=")) {
+        const eqIndex = line.indexOf("=");
+        const key = line.substring(0, eqIndex).trim();
+        const valueStr = line.substring(eqIndex + 1).trim();
+        const value = parseGodotValue(valueStr);
+        switch (currentSection) {
+          case "":
+            if (key === "config_version") {
+              config.configVersion = value;
             }
-            continue;
-        }
-        else if (currentEnum && indent <= enumIndent) {
-            currentEnum = null;
-        }
-        // @tool annotation
-        if (trimmed === '@tool') {
-            script.isToolScript = true;
-            continue;
-        }
-        // Annotations
-        if (trimmed.startsWith('@')) {
-            const annotationMatch = trimmed.match(/^@(\w+)(?:\(([^)]*)\))?/);
-            if (annotationMatch) {
-                const annotation = { name: annotationMatch[1] };
-                if (annotationMatch[2]) {
-                    annotation.arguments = annotationMatch[2].split(',').map((a) => a.trim());
-                }
-                pendingAnnotations.push(annotation);
-                // Handle @icon specifically
-                if (annotation.name === 'icon' && annotation.arguments?.[0]) {
-                    script.iconPath = annotation.arguments[0].replace(/"/g, '');
-                }
+            break;
+          case "application":
+            if (key === "config/name") {
+              config.name = value;
             }
-            continue;
-        }
-        // class_name
-        const classNameMatch = trimmed.match(/^class_name\s+(\w+)/);
-        if (classNameMatch) {
-            script.className = classNameMatch[1];
-            script.classNameToken = classNameMatch[1];
-            continue;
-        }
-        // extends
-        const extendsMatch = trimmed.match(/^extends\s+(.+)$/);
-        if (extendsMatch) {
-            script.extends = extendsMatch[1].trim();
-            continue;
-        }
-        // signal
-        const signalMatch = trimmed.match(/^signal\s+(\w+)(?:\(([^)]*)\))?/);
-        if (signalMatch) {
-            const sig = {
-                name: signalMatch[1],
-                parameters: [],
-                documentation: pendingDocComment?.trim(),
-            };
-            if (signalMatch[2]) {
-                sig.parameters = parseGDScriptParameters(signalMatch[2]);
+            if (key === "config/features") {
+              config.features = value;
             }
-            script.signals.push(sig);
-            pendingDocComment = undefined;
-            continue;
-        }
-        // enum
-        const enumMatch = trimmed.match(/^enum\s+(\w+)\s*{?/);
-        if (enumMatch) {
-            currentEnum = {
-                name: enumMatch[1],
-                values: {},
-                documentation: pendingDocComment?.trim(),
-            };
-            enumIndent = indent;
-            // Check for single-line enum
-            const inlineMatch = trimmed.match(/^enum\s+\w+\s*{([^}]+)}/);
-            if (inlineMatch) {
-                const entries = inlineMatch[1].split(',');
-                let nextVal = 0;
-                for (const entry of entries) {
-                    const valMatch = entry.trim().match(/^(\w+)(?:\s*=\s*(-?\d+))?$/);
-                    if (valMatch) {
-                        const val = valMatch[2] ? parseInt(valMatch[2], 10) : nextVal;
-                        currentEnum.values[valMatch[1]] = val;
-                        nextVal = val + 1;
-                    }
-                }
-                script.enums.push(currentEnum);
-                currentEnum = null;
+            if (key === "config/icon") {
+              config.icon = value;
             }
-            else {
-                script.enums.push(currentEnum);
+            if (key === "run/main_scene") {
+              config.mainScene = value;
             }
-            pendingDocComment = undefined;
-            continue;
-        }
-        // const
-        const constMatch = trimmed.match(/^const\s+(\w+)(?:\s*:\s*(\w+))?\s*=\s*(.+)$/);
-        if (constMatch) {
-            script.constants.push({
-                name: constMatch[1],
-                type: constMatch[2],
-                value: constMatch[3],
-                documentation: pendingDocComment?.trim(),
-            });
-            pendingDocComment = undefined;
-            continue;
-        }
-        // @export var
-        if (trimmed.startsWith('@export')) {
-            // This is an export annotation, the var should follow
-            const exportAnnotations = [trimmed];
-            // Look for subsequent export annotations or the var line
-            let j = i + 1;
-            while (j < lines.length && lines[j].trim().startsWith('@export')) {
-                exportAnnotations.push(lines[j].trim());
-                j++;
+            break;
+          case "autoload": {
+            const autoloadMatch = key.match(/^(.+)$/);
+            if (autoloadMatch) {
+              const autoloadPath = value.replace(/^\*/, "");
+              config.autoloads[autoloadMatch[1]] = autoloadPath;
             }
-            if (j < lines.length) {
-                const varLine = lines[j].trim();
-                const varMatch = varLine.match(/^var\s+(\w+)(?:\s*:\s*(\w+))?(?:\s*=\s*(.+))?$/);
-                if (varMatch) {
-                    script.exportVars.push({
-                        name: varMatch[1],
-                        type: varMatch[2],
-                        default: varMatch[3],
-                        exportAnnotations: exportAnnotations,
-                        documentation: pendingDocComment?.trim(),
-                    });
-                    i = j; // Skip to after the var line
-                    pendingDocComment = undefined;
-                    pendingAnnotations = [];
-                }
+            break;
+          }
+          case "input": {
+            const inputMatch = key.match(/^(.+)$/);
+            if (inputMatch) {
+              const inputValue = value;
+              config.inputMap[inputMatch[1]] = {
+                deadzone: inputValue.deadzone ?? 0.5,
+                events: inputValue.events ?? []
+              };
             }
-            continue;
-        }
-        // @onready var
-        const onreadyMatch = trimmed.match(/^@onready\s+var\s+(\w+)(?:\s*:\s*(\w+))?(?:\s*=\s*(.+))?$/);
-        if (onreadyMatch) {
-            script.onreadyVars.push({
-                name: onreadyMatch[1],
-                type: onreadyMatch[2],
-                default: onreadyMatch[3],
-                documentation: pendingDocComment?.trim(),
-            });
-            pendingDocComment = undefined;
-            continue;
-        }
-        // Regular var
-        const varMatch = trimmed.match(/^var\s+(\w+)(?:\s*:\s*(\w+))?(?:\s*=\s*(.+))?(?:\s*:\s*(?:get\s*=\s*(\w+))?(?:\s*,?\s*set\s*=\s*(\w+))?)?$/);
-        if (varMatch) {
-            const variable = {
-                name: varMatch[1],
-                type: varMatch[2],
-                default: varMatch[3],
-                documentation: pendingDocComment?.trim(),
-            };
-            if (varMatch[4] || varMatch[5]) {
-                variable.setget = {
-                    getter: varMatch[4],
-                    setter: varMatch[5],
-                };
+            break;
+          }
+          case "layer_names":
+            if (key.startsWith("2d_physics/layer_")) {
+              const layerNum = parseInt(key.split("_").pop(), 10);
+              config.layers.layer2d[value] = layerNum;
             }
-            script.variables.push(variable);
-            pendingDocComment = undefined;
-            continue;
-        }
-        // Function
-        const funcMatch = trimmed.match(/^(?:(static)\s+)?func\s+(\w+)\(([^)]*)\)(?:\s*->\s*(\w+))?(?:\s*:\s*)?$/);
-        if (funcMatch) {
-            currentFunction = {
-                name: funcMatch[2],
-                parameters: parseGDScriptParameters(funcMatch[3]),
-                returnType: funcMatch[4],
-                isVirtual: funcMatch[2].startsWith('_'),
-                isStatic: !!funcMatch[1],
-                isCoroutine: false,
-                body: '',
-                documentation: pendingDocComment?.trim(),
-            };
-            functionIndent = indent;
-            if (currentFunction.isStatic) {
-                script.staticFunctions.push(currentFunction);
+            if (key.startsWith("3d_physics/layer_")) {
+              const layerNum = parseInt(key.split("_").pop(), 10);
+              config.layers.layer3d[value] = layerNum;
             }
-            else {
-                script.functions.push(currentFunction);
-            }
-            pendingDocComment = undefined;
-            continue;
-        }
-        // Inner class
-        const classMatch = trimmed.match(/^class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s*:\s*)?$/);
-        if (classMatch) {
-            script.innerClasses.push({
-                name: classMatch[1],
-                extends: classMatch[2],
-                signals: [],
-                variables: [],
-                functions: [],
-            });
-            pendingDocComment = undefined;
-            continue;
-        }
-        pendingDocComment = undefined;
-        pendingAnnotations = [];
-    }
+            break;
+        }
+      }
+    }
+    this.config = config;
+    return config;
+  }
+  /**
+   * Imports a scene file and all its dependencies
+   */
+  async importScene(content, filePath) {
+    const scene = parseGodotScene(content);
+    this.scenes.set(filePath, scene);
+    this.callbacks.onSceneParsed?.(scene);
+    return this.convertSceneToImported(scene, filePath);
+  }
+  /**
+   * Imports a resource file
+   */
+  async importResource(content, filePath) {
+    const resource = parseGodotResource(content);
+    this.resources.set(filePath, resource);
+    this.callbacks.onResourceParsed?.(resource);
+    return resource;
+  }
+  /**
+   * Imports a GDScript file
+   */
+  async importScript(content, filePath) {
+    const script = parseGDScript(content, filePath);
+    this.scripts.set(filePath, script);
+    this.callbacks.onScriptParsed?.(script);
     return script;
+  }
+  convertSceneToImported(scene, filePath) {
+    const imported = {
+      name: filePath.split("/").pop()?.replace(".tscn", "") ?? "Scene",
+      path: filePath,
+      nodes: [],
+      rootNode: null,
+      connections: scene.connections,
+      resources: /* @__PURE__ */ new Map()
+    };
+    for (const extRes of scene.extResources) {
+      imported.resources.set(String(extRes.id), extRes);
+    }
+    if (scene.rootNode) {
+      imported.rootNode = this.convertNode(scene.rootNode, imported.resources);
+      imported.nodes = this.flattenNodes(imported.rootNode);
+    }
+    return imported;
+  }
+  convertNode(node, resources, parentId) {
+    const id = parentId ? `${parentId}/${node.name}` : node.name;
+    const imported = {
+      id,
+      name: node.name,
+      type: node.type,
+      parentId,
+      properties: { ...node.properties },
+      children: [],
+      groups: node.groups ?? []
+    };
+    if (node.properties.position) {
+      imported.position = node.properties.position;
+    }
+    if (node.properties.global_position) {
+      imported.position = node.properties.global_position;
+    }
+    if (node.properties.rotation) {
+      imported.rotation = node.properties.rotation;
+    }
+    if (node.properties.scale) {
+      imported.scale = node.properties.scale;
+    }
+    if (node.properties.transform) {
+      const t = node.properties.transform;
+      imported.position = t.origin;
+    }
+    if (node.script) {
+      const scriptRes = resources.get(String(node.script));
+      if (scriptRes) {
+        const cachedScript = this.scripts.get(scriptRes.path);
+        if (cachedScript) {
+          imported.script = cachedScript;
+        }
+      }
+    }
+    for (const child of node.children) {
+      imported.children.push(this.convertNode(child, resources, id));
+    }
+    return imported;
+  }
+  flattenNodes(node) {
+    const nodes = [node];
+    for (const child of node.children) {
+      nodes.push(...this.flattenNodes(child));
+    }
+    return nodes;
+  }
+  /**
+   * Gets all imported data
+   */
+  getImportedData() {
+    return {
+      config: this.config,
+      scenes: this.scenes,
+      resources: this.resources,
+      scripts: this.scripts
+    };
+  }
+  setCallbacks(callbacks) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+  }
 }
-function parseGDScriptParameters(paramString) {
-    if (!paramString.trim()) {
-        return [];
-    }
-    const params = [];
-    const parts = paramString.split(',');
-    for (const part of parts) {
-        const trimmed = part.trim();
-        const paramMatch = trimmed.match(/^(\w+)(?:\s*:\s*(\w+))?(?:\s*=\s*(.+))?$/);
-        if (paramMatch) {
-            params.push({
-                name: paramMatch[1],
-                type: paramMatch[2],
-                default: paramMatch[3],
-            });
-        }
-    }
-    return params;
-}
-class GodotProjectImporter {
-    constructor(callbacks) {
-        this.projectPath = '';
-        this.config = null;
-        this.scenes = new Map();
-        this.resources = new Map();
-        this.scripts = new Map();
-        this.callbacks = {};
-        if (callbacks) {
-            this.callbacks = callbacks;
-        }
-    }
-    /**
-     * Parses project.godot configuration file
-     */
-    parseProjectConfig(content) {
-        const config = {
-            configVersion: 5,
-            name: 'Untitled',
-            features: [],
-            autoloads: {},
-            inputMap: {},
-            layers: { layer2d: {}, layer3d: {} },
-        };
-        let currentSection = '';
-        const lines = content.split('\n');
-        for (let line of lines) {
-            line = line.trim();
-            if (!line || line.startsWith(';')) {
-                continue;
-            }
-            // Section header
-            if (line.startsWith('[')) {
-                const match = line.match(/^\[(.+)\]$/);
-                if (match) {
-                    currentSection = match[1];
-                }
-                continue;
-            }
-            // Key-value pair
-            if (line.includes('=')) {
-                const eqIndex = line.indexOf('=');
-                const key = line.substring(0, eqIndex).trim();
-                const valueStr = line.substring(eqIndex + 1).trim();
-                const value = parseGodotValue(valueStr);
-                switch (currentSection) {
-                    case '':
-                        if (key === 'config_version') {
-                            config.configVersion = value;
-                        }
-                        break;
-                    case 'application':
-                        if (key === 'config/name') {
-                            config.name = value;
-                        }
-                        if (key === 'config/features') {
-                            config.features = value;
-                        }
-                        if (key === 'config/icon') {
-                            config.icon = value;
-                        }
-                        if (key === 'run/main_scene') {
-                            config.mainScene = value;
-                        }
-                        break;
-                    case 'autoload': {
-                        const autoloadMatch = key.match(/^(.+)$/);
-                        if (autoloadMatch) {
-                            const autoloadPath = value.replace(/^\*/, '');
-                            config.autoloads[autoloadMatch[1]] = autoloadPath;
-                        }
-                        break;
-                    }
-                    case 'input': {
-                        const inputMatch = key.match(/^(.+)$/);
-                        if (inputMatch) {
-                            const inputValue = value;
-                            config.inputMap[inputMatch[1]] = {
-                                deadzone: inputValue.deadzone ?? 0.5,
-                                events: inputValue.events ?? [],
-                            };
-                        }
-                        break;
-                    }
-                    case 'layer_names':
-                        if (key.startsWith('2d_physics/layer_')) {
-                            const layerNum = parseInt(key.split('_').pop(), 10);
-                            config.layers.layer2d[value] = layerNum;
-                        }
-                        if (key.startsWith('3d_physics/layer_')) {
-                            const layerNum = parseInt(key.split('_').pop(), 10);
-                            config.layers.layer3d[value] = layerNum;
-                        }
-                        break;
-                }
-            }
-        }
-        this.config = config;
-        return config;
-    }
-    /**
-     * Imports a scene file and all its dependencies
-     */
-    async importScene(content, filePath) {
-        const scene = parseGodotScene(content);
-        this.scenes.set(filePath, scene);
-        this.callbacks.onSceneParsed?.(scene);
-        return this.convertSceneToImported(scene, filePath);
-    }
-    /**
-     * Imports a resource file
-     */
-    async importResource(content, filePath) {
-        const resource = parseGodotResource(content);
-        this.resources.set(filePath, resource);
-        this.callbacks.onResourceParsed?.(resource);
-        return resource;
-    }
-    /**
-     * Imports a GDScript file
-     */
-    async importScript(content, filePath) {
-        const script = parseGDScript(content, filePath);
-        this.scripts.set(filePath, script);
-        this.callbacks.onScriptParsed?.(script);
-        return script;
-    }
-    convertSceneToImported(scene, filePath) {
-        const imported = {
-            name: filePath.split('/').pop()?.replace('.tscn', '') ?? 'Scene',
-            path: filePath,
-            nodes: [],
-            rootNode: null,
-            connections: scene.connections,
-            resources: new Map(),
-        };
-        // Build resource map
-        for (const extRes of scene.extResources) {
-            imported.resources.set(String(extRes.id), extRes);
-        }
-        // Convert nodes
-        if (scene.rootNode) {
-            imported.rootNode = this.convertNode(scene.rootNode, imported.resources);
-            imported.nodes = this.flattenNodes(imported.rootNode);
-        }
-        return imported;
-    }
-    convertNode(node, resources, parentId) {
-        const id = parentId ? `${parentId}/${node.name}` : node.name;
-        const imported = {
-            id,
-            name: node.name,
-            type: node.type,
-            parentId,
-            properties: { ...node.properties },
-            children: [],
-            groups: node.groups ?? [],
-        };
-        // Extract position/rotation/scale from properties
-        if (node.properties.position) {
-            imported.position = node.properties.position;
-        }
-        if (node.properties.global_position) {
-            imported.position = node.properties.global_position;
-        }
-        if (node.properties.rotation) {
-            imported.rotation = node.properties.rotation;
-        }
-        if (node.properties.scale) {
-            imported.scale = node.properties.scale;
-        }
-        // 3D transforms
-        if (node.properties.transform) {
-            const t = node.properties.transform;
-            imported.position = t.origin;
-        }
-        // Resolve script reference
-        if (node.script) {
-            const scriptRes = resources.get(String(node.script));
-            if (scriptRes) {
-                const cachedScript = this.scripts.get(scriptRes.path);
-                if (cachedScript) {
-                    imported.script = cachedScript;
-                }
-            }
-        }
-        // Convert children
-        for (const child of node.children) {
-            imported.children.push(this.convertNode(child, resources, id));
-        }
-        return imported;
-    }
-    flattenNodes(node) {
-        const nodes = [node];
-        for (const child of node.children) {
-            nodes.push(...this.flattenNodes(child));
-        }
-        return nodes;
-    }
-    /**
-     * Gets all imported data
-     */
-    getImportedData() {
-        return {
-            config: this.config,
-            scenes: this.scenes,
-            resources: this.resources,
-            scripts: this.scripts,
-        };
-    }
-    setCallbacks(callbacks) {
-        this.callbacks = { ...this.callbacks, ...callbacks };
-    }
-}
-// ============================================================
-// Node Type Mapping
-// ============================================================
 const GODOT_NODE_MAPPING = {
-    // 2D Nodes
-    Node2D: 'Entity2D',
-    Sprite2D: 'Sprite',
-    AnimatedSprite2D: 'AnimatedSprite',
-    Camera2D: 'Camera2D',
-    CharacterBody2D: 'KinematicBody2D',
-    RigidBody2D: 'RigidBody2D',
-    StaticBody2D: 'StaticBody2D',
-    Area2D: 'Area2D',
-    CollisionShape2D: 'CollisionShape2D',
-    TileMap: 'TileMap',
-    TileMapLayer: 'TileMapLayer',
-    GPUParticles2D: 'ParticleEmitter2D',
-    CPUParticles2D: 'ParticleEmitter2D',
-    NavigationAgent2D: 'NavigationAgent2D',
-    AudioStreamPlayer2D: 'AudioSource2D',
-    // 3D Nodes
-    Node3D: 'Entity3D',
-    MeshInstance3D: 'MeshRenderer',
-    Camera3D: 'Camera3D',
-    CharacterBody3D: 'KinematicBody3D',
-    RigidBody3D: 'RigidBody3D',
-    StaticBody3D: 'StaticBody3D',
-    Area3D: 'Area3D',
-    CollisionShape3D: 'CollisionShape3D',
-    DirectionalLight3D: 'DirectionalLight',
-    OmniLight3D: 'PointLight',
-    SpotLight3D: 'SpotLight',
-    GPUParticles3D: 'ParticleEmitter3D',
-    CPUParticles3D: 'ParticleEmitter3D',
-    NavigationAgent3D: 'NavigationAgent3D',
-    AudioStreamPlayer3D: 'AudioSource3D',
-    WorldEnvironment: 'Environment',
-    // Audio
-    AudioStreamPlayer: 'AudioSource',
-    // Animation
-    AnimationPlayer: 'AnimationPlayer',
-    AnimationTree: 'AnimationTree',
-    // UI
-    Control: 'UIElement',
-    Button: 'UIButton',
-    Label: 'UILabel',
-    TextureRect: 'UIImage',
-    Panel: 'UIPanel',
-    VBoxContainer: 'UIVBox',
-    HBoxContainer: 'UIHBox',
-    GridContainer: 'UIGrid',
-    LineEdit: 'UIInput',
-    TextEdit: 'UITextArea',
-    ProgressBar: 'UIProgressBar',
-    Slider: 'UISlider',
-    TabContainer: 'UITabs',
-    CanvasLayer: 'UILayer',
-    // Other
-    Timer: 'Timer',
-    Node: 'Entity',
+  // 2D Nodes
+  Node2D: "Entity2D",
+  Sprite2D: "Sprite",
+  AnimatedSprite2D: "AnimatedSprite",
+  Camera2D: "Camera2D",
+  CharacterBody2D: "KinematicBody2D",
+  RigidBody2D: "RigidBody2D",
+  StaticBody2D: "StaticBody2D",
+  Area2D: "Area2D",
+  CollisionShape2D: "CollisionShape2D",
+  TileMap: "TileMap",
+  TileMapLayer: "TileMapLayer",
+  GPUParticles2D: "ParticleEmitter2D",
+  CPUParticles2D: "ParticleEmitter2D",
+  NavigationAgent2D: "NavigationAgent2D",
+  AudioStreamPlayer2D: "AudioSource2D",
+  // 3D Nodes
+  Node3D: "Entity3D",
+  MeshInstance3D: "MeshRenderer",
+  Camera3D: "Camera3D",
+  CharacterBody3D: "KinematicBody3D",
+  RigidBody3D: "RigidBody3D",
+  StaticBody3D: "StaticBody3D",
+  Area3D: "Area3D",
+  CollisionShape3D: "CollisionShape3D",
+  DirectionalLight3D: "DirectionalLight",
+  OmniLight3D: "PointLight",
+  SpotLight3D: "SpotLight",
+  GPUParticles3D: "ParticleEmitter3D",
+  CPUParticles3D: "ParticleEmitter3D",
+  NavigationAgent3D: "NavigationAgent3D",
+  AudioStreamPlayer3D: "AudioSource3D",
+  WorldEnvironment: "Environment",
+  // Audio
+  AudioStreamPlayer: "AudioSource",
+  // Animation
+  AnimationPlayer: "AnimationPlayer",
+  AnimationTree: "AnimationTree",
+  // UI
+  Control: "UIElement",
+  Button: "UIButton",
+  Label: "UILabel",
+  TextureRect: "UIImage",
+  Panel: "UIPanel",
+  VBoxContainer: "UIVBox",
+  HBoxContainer: "UIHBox",
+  GridContainer: "UIGrid",
+  LineEdit: "UIInput",
+  TextEdit: "UITextArea",
+  ProgressBar: "UIProgressBar",
+  Slider: "UISlider",
+  TabContainer: "UITabs",
+  CanvasLayer: "UILayer",
+  // Other
+  Timer: "Timer",
+  Node: "Entity"
 };
-// ============================================================
-// Factory Functions
-// ============================================================
 function createGodotProjectImporter(callbacks) {
-    return new GodotProjectImporter(callbacks);
+  return new GodotProjectImporter(callbacks);
 }
-
 exports.GODOT_NODE_MAPPING = GODOT_NODE_MAPPING;
 exports.GodotProjectImporter = GodotProjectImporter;
 exports.createGodotProjectImporter = createGodotProjectImporter;