@nice2dev/game-engine 1.3.15 → 1.3.17

package/dist/cjs/import/GodotSceneImporter.js

@@ -1,841 +1,807 @@
-'use strict';
-
-var SceneImporter = require('./SceneImporter.js');
-
-/**
- * @file GodotSceneImporter.ts
- * @description Import Godot scenes (.tscn) and resources (.tres)
- * PRO-1.3: Scene Format Interoperability
- *
- * Parses Godot 4.x scene format and converts to Nice2Dev entities.
- * Supports:
- * - Scene files (.tscn)
- * - Resource files (.tres)
- * - Project files (.godot)
- */
-// ============================================================
-// Godot Node Types Mapping
-// ============================================================
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const SceneImporter = require("./SceneImporter.js");
 const GODOT_NODE_MAPPING = {
-    // 2D Nodes
-    Node2D: { niceType: 'Transform2D', category: '2d' },
-    Sprite2D: { niceType: 'Sprite', category: '2d' },
-    AnimatedSprite2D: { niceType: 'AnimatedSprite', category: '2d' },
-    CharacterBody2D: { niceType: 'CharacterController2D', category: '2d' },
-    RigidBody2D: { niceType: 'Rigidbody2D', category: '2d' },
-    StaticBody2D: { niceType: 'StaticBody2D', category: '2d' },
-    Area2D: { niceType: 'Trigger2D', category: '2d' },
-    CollisionShape2D: { niceType: 'Collider2D', category: '2d' },
-    CollisionPolygon2D: { niceType: 'PolygonCollider2D', category: '2d' },
-    TileMap: { niceType: 'Tilemap', category: '2d' },
-    TileMapLayer: { niceType: 'TilemapLayer', category: '2d' },
-    Camera2D: { niceType: 'Camera2D', category: '2d' },
-    Light2D: { niceType: 'Light2D', category: '2d' },
-    PointLight2D: { niceType: 'PointLight2D', category: '2d' },
-    DirectionalLight2D: { niceType: 'DirectionalLight2D', category: '2d' },
-    Line2D: { niceType: 'LineRenderer', category: '2d' },
-    Path2D: { niceType: 'Path2D', category: '2d' },
-    PathFollow2D: { niceType: 'PathFollower2D', category: '2d' },
-    GPUParticles2D: { niceType: 'ParticleSystem2D', category: '2d' },
-    CPUParticles2D: { niceType: 'CPUParticles2D', category: '2d' },
-    // 3D Nodes
-    Node3D: { niceType: 'Transform3D', category: '3d' },
-    MeshInstance3D: { niceType: 'MeshRenderer', category: '3d' },
-    CharacterBody3D: { niceType: 'CharacterController3D', category: '3d' },
-    RigidBody3D: { niceType: 'Rigidbody3D', category: '3d' },
-    StaticBody3D: { niceType: 'StaticBody3D', category: '3d' },
-    Area3D: { niceType: 'Trigger3D', category: '3d' },
-    CollisionShape3D: { niceType: 'Collider3D', category: '3d' },
-    Camera3D: { niceType: 'Camera3D', category: '3d' },
-    DirectionalLight3D: { niceType: 'DirectionalLight', category: '3d' },
-    OmniLight3D: { niceType: 'PointLight', category: '3d' },
-    SpotLight3D: { niceType: 'SpotLight', category: '3d' },
-    GPUParticles3D: { niceType: 'ParticleSystem3D', category: '3d' },
-    // Audio
-    AudioStreamPlayer: { niceType: 'AudioSource', category: 'audio' },
-    AudioStreamPlayer2D: { niceType: 'AudioSource2D', category: 'audio' },
-    AudioStreamPlayer3D: { niceType: 'AudioSource3D', category: 'audio' },
-    // UI
-    Control: { niceType: 'UIElement', category: 'ui' },
-    Label: { niceType: 'Text', category: 'ui' },
-    Button: { niceType: 'Button', category: 'ui' },
-    TextureRect: { niceType: 'Image', category: 'ui' },
-    Panel: { niceType: 'Panel', category: 'ui' },
-    HBoxContainer: { niceType: 'HorizontalLayout', category: 'ui' },
-    VBoxContainer: { niceType: 'VerticalLayout', category: 'ui' },
-    GridContainer: { niceType: 'GridLayout', category: 'ui' },
-    ScrollContainer: { niceType: 'ScrollView', category: 'ui' },
-    LineEdit: { niceType: 'InputField', category: 'ui' },
-    TextEdit: { niceType: 'TextArea', category: 'ui' },
-    CheckBox: { niceType: 'Checkbox', category: 'ui' },
-    ProgressBar: { niceType: 'ProgressBar', category: 'ui' },
-    Slider: { niceType: 'Slider', category: 'ui' },
-    SpinBox: { niceType: 'SpinBox', category: 'ui' },
-    ColorRect: { niceType: 'ColorPanel', category: 'ui' },
-    NinePatchRect: { niceType: 'NineSlice', category: 'ui' },
-    CanvasLayer: { niceType: 'UICanvas', category: 'ui' },
-    // Animation
-    AnimationPlayer: { niceType: 'Animator', category: 'animation' },
-    AnimationTree: { niceType: 'AnimationStateMachine', category: 'animation' },
-    // Navigation
-    NavigationRegion2D: { niceType: 'NavMesh2D', category: 'navigation' },
-    NavigationAgent2D: { niceType: 'NavAgent2D', category: 'navigation' },
-    NavigationRegion3D: { niceType: 'NavMesh3D', category: 'navigation' },
-    NavigationAgent3D: { niceType: 'NavAgent3D', category: 'navigation' },
-    // Other
-    Timer: { niceType: 'Timer', category: 'utility' },
-    HTTPRequest: { niceType: 'HTTPClient', category: 'utility' },
+  // 2D Nodes
+  Node2D: { niceType: "Transform2D", category: "2d" },
+  Sprite2D: { niceType: "Sprite", category: "2d" },
+  AnimatedSprite2D: { niceType: "AnimatedSprite", category: "2d" },
+  CharacterBody2D: { niceType: "CharacterController2D", category: "2d" },
+  RigidBody2D: { niceType: "Rigidbody2D", category: "2d" },
+  StaticBody2D: { niceType: "StaticBody2D", category: "2d" },
+  Area2D: { niceType: "Trigger2D", category: "2d" },
+  CollisionShape2D: { niceType: "Collider2D", category: "2d" },
+  CollisionPolygon2D: { niceType: "PolygonCollider2D", category: "2d" },
+  TileMap: { niceType: "Tilemap", category: "2d" },
+  TileMapLayer: { niceType: "TilemapLayer", category: "2d" },
+  Camera2D: { niceType: "Camera2D", category: "2d" },
+  Light2D: { niceType: "Light2D", category: "2d" },
+  PointLight2D: { niceType: "PointLight2D", category: "2d" },
+  DirectionalLight2D: { niceType: "DirectionalLight2D", category: "2d" },
+  Line2D: { niceType: "LineRenderer", category: "2d" },
+  Path2D: { niceType: "Path2D", category: "2d" },
+  PathFollow2D: { niceType: "PathFollower2D", category: "2d" },
+  GPUParticles2D: { niceType: "ParticleSystem2D", category: "2d" },
+  CPUParticles2D: { niceType: "CPUParticles2D", category: "2d" },
+  // 3D Nodes
+  Node3D: { niceType: "Transform3D", category: "3d" },
+  MeshInstance3D: { niceType: "MeshRenderer", category: "3d" },
+  CharacterBody3D: { niceType: "CharacterController3D", category: "3d" },
+  RigidBody3D: { niceType: "Rigidbody3D", category: "3d" },
+  StaticBody3D: { niceType: "StaticBody3D", category: "3d" },
+  Area3D: { niceType: "Trigger3D", category: "3d" },
+  CollisionShape3D: { niceType: "Collider3D", category: "3d" },
+  Camera3D: { niceType: "Camera3D", category: "3d" },
+  DirectionalLight3D: { niceType: "DirectionalLight", category: "3d" },
+  OmniLight3D: { niceType: "PointLight", category: "3d" },
+  SpotLight3D: { niceType: "SpotLight", category: "3d" },
+  GPUParticles3D: { niceType: "ParticleSystem3D", category: "3d" },
+  // Audio
+  AudioStreamPlayer: { niceType: "AudioSource", category: "audio" },
+  AudioStreamPlayer2D: { niceType: "AudioSource2D", category: "audio" },
+  AudioStreamPlayer3D: { niceType: "AudioSource3D", category: "audio" },
+  // UI
+  Control: { niceType: "UIElement", category: "ui" },
+  Label: { niceType: "Text", category: "ui" },
+  Button: { niceType: "Button", category: "ui" },
+  TextureRect: { niceType: "Image", category: "ui" },
+  Panel: { niceType: "Panel", category: "ui" },
+  HBoxContainer: { niceType: "HorizontalLayout", category: "ui" },
+  VBoxContainer: { niceType: "VerticalLayout", category: "ui" },
+  GridContainer: { niceType: "GridLayout", category: "ui" },
+  ScrollContainer: { niceType: "ScrollView", category: "ui" },
+  LineEdit: { niceType: "InputField", category: "ui" },
+  TextEdit: { niceType: "TextArea", category: "ui" },
+  CheckBox: { niceType: "Checkbox", category: "ui" },
+  ProgressBar: { niceType: "ProgressBar", category: "ui" },
+  Slider: { niceType: "Slider", category: "ui" },
+  SpinBox: { niceType: "SpinBox", category: "ui" },
+  ColorRect: { niceType: "ColorPanel", category: "ui" },
+  NinePatchRect: { niceType: "NineSlice", category: "ui" },
+  CanvasLayer: { niceType: "UICanvas", category: "ui" },
+  // Animation
+  AnimationPlayer: { niceType: "Animator", category: "animation" },
+  AnimationTree: { niceType: "AnimationStateMachine", category: "animation" },
+  // Navigation
+  NavigationRegion2D: { niceType: "NavMesh2D", category: "navigation" },
+  NavigationAgent2D: { niceType: "NavAgent2D", category: "navigation" },
+  NavigationRegion3D: { niceType: "NavMesh3D", category: "navigation" },
+  NavigationAgent3D: { niceType: "NavAgent3D", category: "navigation" },
+  // Other
+  Timer: { niceType: "Timer", category: "utility" },
+  HTTPRequest: { niceType: "HTTPClient", category: "utility" }
 };
-// ============================================================
-// Godot Scene Importer
-// ============================================================
 class GodotSceneImporter extends SceneImporter.SceneImporter {
-    constructor() {
-        super('godot');
-        this.extResources = new Map();
-        this.subResources = new Map();
-        this.nodes = [];
-        this.connections = [];
-        this.header = {};
-    }
-    async import(options) {
-        const startTime = Date.now();
-        this.options = options;
-        this.clearMessages();
-        this.extResources.clear();
-        this.subResources.clear();
-        this.nodes = [];
-        this.connections = [];
-        const errors = await this.validate(options.sourcePath);
-        if (errors.some((e) => e.fatal)) {
-            return {
-                ...this.createEmptyResult(),
-                errors: errors,
-            };
-        }
-        const scenes = [];
-        const assets = [];
-        try {
-            const content = await this.readFile(options.sourcePath);
-            const parsed = this.parseGodotScene(content, options.sourcePath);
-            if (parsed) {
-                const niceScene = this.convertParsedToNiceScene(parsed);
-                scenes.push(niceScene);
-                const extractedAssets = this.extractAssets();
-                assets.push(...extractedAssets);
-            }
-        }
-        catch (error) {
-            this.addError('IMPORT_ERROR', `Failed to import: ${error}`, options.sourcePath, undefined, true);
-        }
-        return this.createResult(scenes, assets, startTime);
-    }
-    async parseFile(content, filePath) {
-        const stringContent = typeof content === 'string' ? content : new TextDecoder().decode(content);
-        return this.parseGodotScene(stringContent, filePath);
-    }
-    async validate(sourcePath) {
-        const errors = [];
-        if (!this.canHandle(sourcePath)) {
-            errors.push({
-                code: 'INVALID_FORMAT',
-                message: `File ${sourcePath} is not a valid Godot file`,
-                file: sourcePath,
-                fatal: true,
-            });
-        }
-        return errors;
-    }
-    // ----------------------------------------
-    // Godot Parsing
-    // ----------------------------------------
-    parseGodotScene(content, filePath) {
-        const lines = content.split('\n');
-        let currentSection = null;
-        let currentItem = {};
-        let bracketDepth = 0;
-        let multilineKey = '';
-        let multilineValue = '';
-        for (const line of lines) {
-            const trimmed = line.trim();
-            // Skip empty lines and comments
-            if (trimmed === '' || trimmed.startsWith(';')) {
-                continue;
-            }
-            // Check for section headers
-            const sectionMatch = trimmed.match(/^\[(\w+)(.*?)\]$/);
-            if (sectionMatch) {
-                // Save previous item
-                this.saveCurrentItem(currentSection, currentItem);
-                currentItem = {};
-                const sectionType = sectionMatch[1];
-                const sectionParams = sectionMatch[2].trim();
-                if (sectionType === 'gd_scene' || sectionType === 'gd_resource') {
-                    currentSection = 'header';
-                    this.header = this.parseInlineParams(sectionParams);
-                }
-                else if (sectionType === 'ext_resource') {
-                    currentSection = 'ext_resource';
-                    currentItem = this.parseInlineParams(sectionParams);
-                }
-                else if (sectionType === 'sub_resource') {
-                    currentSection = 'sub_resource';
-                    currentItem = this.parseInlineParams(sectionParams);
-                }
-                else if (sectionType === 'node') {
-                    currentSection = 'node';
-                    currentItem = this.parseInlineParams(sectionParams);
-                }
-                else if (sectionType === 'connection') {
-                    currentSection = 'connection';
-                    currentItem = this.parseInlineParams(sectionParams);
-                }
-                continue;
-            }
-            // Handle multiline values
-            if (multilineKey) {
-                multilineValue += '\n' + line;
-                bracketDepth += (line.match(/[[{]/g) || []).length;
-                bracketDepth -= (line.match(/[\]}]/g) || []).length;
-                if (bracketDepth === 0) {
-                    currentItem[multilineKey] = this.parseGodotValue(multilineValue);
-                    multilineKey = '';
-                    multilineValue = '';
-                }
-                continue;
-            }
-            // Parse property assignment
-            const propMatch = trimmed.match(/^(\w+)\s*=\s*(.*)$/);
-            if (propMatch) {
-                const key = propMatch[1];
-                const value = propMatch[2];
-                // Check if value starts multiline
-                bracketDepth = (value.match(/[[{]/g) || []).length;
-                bracketDepth -= (value.match(/[\]}]/g) || []).length;
-                if (bracketDepth > 0) {
-                    multilineKey = key;
-                    multilineValue = value;
-                }
-                else {
-                    currentItem[key] = this.parseGodotValue(value);
-                }
-            }
-        }
-        // Save final item
+  constructor() {
+    super("godot");
+    this.extResources = /* @__PURE__ */ new Map();
+    this.subResources = /* @__PURE__ */ new Map();
+    this.nodes = [];
+    this.connections = [];
+    this.header = {};
+  }
+  async import(options) {
+    const startTime = Date.now();
+    this.options = options;
+    this.clearMessages();
+    this.extResources.clear();
+    this.subResources.clear();
+    this.nodes = [];
+    this.connections = [];
+    const errors = await this.validate(options.sourcePath);
+    if (errors.some((e) => e.fatal)) {
+      return {
+        ...this.createEmptyResult(),
+        errors
+      };
+    }
+    const scenes = [];
+    const assets = [];
+    try {
+      const content = await this.readFile(options.sourcePath);
+      const parsed = this.parseGodotScene(content, options.sourcePath);
+      if (parsed) {
+        const niceScene = this.convertParsedToNiceScene(parsed);
+        scenes.push(niceScene);
+        const extractedAssets = this.extractAssets();
+        assets.push(...extractedAssets);
+      }
+    } catch (error) {
+      this.addError(
+        "IMPORT_ERROR",
+        `Failed to import: ${error}`,
+        options.sourcePath,
+        void 0,
+        true
+      );
+    }
+    return this.createResult(scenes, assets, startTime);
+  }
+  async parseFile(content, filePath) {
+    const stringContent = typeof content === "string" ? content : new TextDecoder().decode(content);
+    return this.parseGodotScene(stringContent, filePath);
+  }
+  async validate(sourcePath) {
+    const errors = [];
+    if (!this.canHandle(sourcePath)) {
+      errors.push({
+        code: "INVALID_FORMAT",
+        message: `File ${sourcePath} is not a valid Godot file`,
+        file: sourcePath,
+        fatal: true
+      });
+    }
+    return errors;
+  }
+  // ----------------------------------------
+  // Godot Parsing
+  // ----------------------------------------
+  parseGodotScene(content, filePath) {
+    const lines = content.split("\n");
+    let currentSection = null;
+    let currentItem = {};
+    let bracketDepth = 0;
+    let multilineKey = "";
+    let multilineValue = "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed === "" || trimmed.startsWith(";")) {
+        continue;
+      }
+      const sectionMatch = trimmed.match(/^\[(\w+)(.*?)\]$/);
+      if (sectionMatch) {
         this.saveCurrentItem(currentSection, currentItem);
-        // Build scene structure
-        const sceneName = filePath.substring(filePath.lastIndexOf('/') + 1).replace(/\.\w+$/, '');
-        // Find root node
-        const rootNode = this.nodes.find((n) => !n.parent);
-        return {
-            name: sceneName,
-            width: 1920,
-            height: 1080,
-            backgroundColor: '#1a1a2e',
-            layers: [],
-            entities: rootNode ? [this.convertNodeToEntity(rootNode)] : [],
-            properties: {
-                godotVersion: this.header.gdVersion,
-                format: this.header.format,
-                loadSteps: this.header.loadSteps,
-            },
+        currentItem = {};
+        const sectionType = sectionMatch[1];
+        const sectionParams = sectionMatch[2].trim();
+        if (sectionType === "gd_scene" || sectionType === "gd_resource") {
+          currentSection = "header";
+          this.header = this.parseInlineParams(sectionParams);
+        } else if (sectionType === "ext_resource") {
+          currentSection = "ext_resource";
+          currentItem = this.parseInlineParams(sectionParams);
+        } else if (sectionType === "sub_resource") {
+          currentSection = "sub_resource";
+          currentItem = this.parseInlineParams(sectionParams);
+        } else if (sectionType === "node") {
+          currentSection = "node";
+          currentItem = this.parseInlineParams(sectionParams);
+        } else if (sectionType === "connection") {
+          currentSection = "connection";
+          currentItem = this.parseInlineParams(sectionParams);
+        }
+        continue;
+      }
+      if (multilineKey) {
+        multilineValue += "\n" + line;
+        bracketDepth += (line.match(/[[{]/g) || []).length;
+        bracketDepth -= (line.match(/[\]}]/g) || []).length;
+        if (bracketDepth === 0) {
+          currentItem[multilineKey] = this.parseGodotValue(multilineValue);
+          multilineKey = "";
+          multilineValue = "";
+        }
+        continue;
+      }
+      const propMatch = trimmed.match(/^(\w+)\s*=\s*(.*)$/);
+      if (propMatch) {
+        const key = propMatch[1];
+        const value = propMatch[2];
+        bracketDepth = (value.match(/[[{]/g) || []).length;
+        bracketDepth -= (value.match(/[\]}]/g) || []).length;
+        if (bracketDepth > 0) {
+          multilineKey = key;
+          multilineValue = value;
+        } else {
+          currentItem[key] = this.parseGodotValue(value);
+        }
+      }
+    }
+    this.saveCurrentItem(currentSection, currentItem);
+    const sceneName = filePath.substring(filePath.lastIndexOf("/") + 1).replace(/\.\w+$/, "");
+    const rootNode = this.nodes.find((n) => !n.parent);
+    return {
+      name: sceneName,
+      width: 1920,
+      height: 1080,
+      backgroundColor: "#1a1a2e",
+      layers: [],
+      entities: rootNode ? [this.convertNodeToEntity(rootNode)] : [],
+      properties: {
+        godotVersion: this.header.gdVersion,
+        format: this.header.format,
+        loadSteps: this.header.loadSteps
+      }
+    };
+  }
+  saveCurrentItem(section, item) {
+    if (!section || Object.keys(item).length === 0) {
+      return;
+    }
+    switch (section) {
+      case "ext_resource": {
+        const extRes = {
+          id: String(item.id || ""),
+          type: String(item.type || ""),
+          path: String(item.path || ""),
+          uid: item.uid ? String(item.uid) : void 0
         };
+        this.extResources.set(extRes.id, extRes);
+        break;
+      }
+      case "sub_resource": {
+        const subRes = {
+          id: String(item.id || ""),
+          type: String(item.type || ""),
+          properties: { ...item }
+        };
+        delete subRes.properties.id;
+        delete subRes.properties.type;
+        this.subResources.set(subRes.id, subRes);
+        break;
+      }
+      case "node": {
+        const node = {
+          name: String(item.name || ""),
+          type: item.type ? String(item.type) : void 0,
+          parent: item.parent ? String(item.parent) : void 0,
+          instance: item.instance ? String(item.instance) : void 0,
+          instancePlaceholder: item.instance_placeholder ? String(item.instance_placeholder) : void 0,
+          owner: item.owner ? String(item.owner) : void 0,
+          index: item.index ? Number(item.index) : void 0,
+          groups: item.groups ? item.groups : void 0,
+          properties: {},
+          children: []
+        };
+        for (const [key, value] of Object.entries(item)) {
+          if (![
+            "name",
+            "type",
+            "parent",
+            "instance",
+            "instance_placeholder",
+            "owner",
+            "index",
+            "groups"
+          ].includes(key)) {
+            node.properties[key] = value;
+          }
+        }
+        this.nodes.push(node);
+        break;
+      }
+      case "connection": {
+        const conn = {
+          signal: String(item.signal || ""),
+          from: String(item.from || ""),
+          to: String(item.to || ""),
+          method: String(item.method || ""),
+          flags: item.flags ? Number(item.flags) : void 0,
+          binds: item.binds
+        };
+        this.connections.push(conn);
+        break;
+      }
     }
-    saveCurrentItem(section, item) {
-        if (!section || Object.keys(item).length === 0) {
-            return;
-        }
-        switch (section) {
-            case 'ext_resource': {
-                const extRes = {
-                    id: String(item.id || ''),
-                    type: String(item.type || ''),
-                    path: String(item.path || ''),
-                    uid: item.uid ? String(item.uid) : undefined,
-                };
-                this.extResources.set(extRes.id, extRes);
-                break;
-            }
-            case 'sub_resource': {
-                const subRes = {
-                    id: String(item.id || ''),
-                    type: String(item.type || ''),
-                    properties: { ...item },
-                };
-                delete subRes.properties.id;
-                delete subRes.properties.type;
-                this.subResources.set(subRes.id, subRes);
-                break;
-            }
-            case 'node': {
-                const node = {
-                    name: String(item.name || ''),
-                    type: item.type ? String(item.type) : undefined,
-                    parent: item.parent ? String(item.parent) : undefined,
-                    instance: item.instance ? String(item.instance) : undefined,
-                    instancePlaceholder: item.instance_placeholder
-                        ? String(item.instance_placeholder)
-                        : undefined,
-                    owner: item.owner ? String(item.owner) : undefined,
-                    index: item.index ? Number(item.index) : undefined,
-                    groups: item.groups ? item.groups : undefined,
-                    properties: {},
-                    children: [],
-                };
-                // Copy remaining properties
-                for (const [key, value] of Object.entries(item)) {
-                    if (![
-                        'name',
-                        'type',
-                        'parent',
-                        'instance',
-                        'instance_placeholder',
-                        'owner',
-                        'index',
-                        'groups',
-                    ].includes(key)) {
-                        node.properties[key] = value;
-                    }
-                }
-                this.nodes.push(node);
-                break;
-            }
-            case 'connection': {
-                const conn = {
-                    signal: String(item.signal || ''),
-                    from: String(item.from || ''),
-                    to: String(item.to || ''),
-                    method: String(item.method || ''),
-                    flags: item.flags ? Number(item.flags) : undefined,
-                    binds: item.binds,
-                };
-                this.connections.push(conn);
-                break;
-            }
-        }
+  }
+  parseInlineParams(params) {
+    const result = {};
+    const paramRegex = /(\w+)=("(?:[^"\\]|\\.)*"|[^\s]+)/g;
+    let match;
+    while ((match = paramRegex.exec(params)) !== null) {
+      const key = match[1];
+      let value = match[2];
+      if (value.startsWith('"') && value.endsWith('"')) {
+        value = value.slice(1, -1).replace(/\\"/g, '"');
+      }
+      result[key] = this.parseGodotValue(value);
     }
-    parseInlineParams(params) {
-        const result = {};
-        // Parse space-separated key=value pairs
-        const paramRegex = /(\w+)=("(?:[^"\\]|\\.)*"|[^\s]+)/g;
-        let match;
-        while ((match = paramRegex.exec(params)) !== null) {
-            const key = match[1];
-            let value = match[2];
-            // Remove quotes
-            if (value.startsWith('"') && value.endsWith('"')) {
-                value = value.slice(1, -1).replace(/\\"/g, '"');
-            }
-            result[key] = this.parseGodotValue(value);
-        }
-        return result;
+    return result;
+  }
+  parseGodotValue(value) {
+    value = value.trim();
+    if (value === "null") {
+      return null;
     }
-    parseGodotValue(value) {
-        value = value.trim();
-        // Null
-        if (value === 'null') {
-            return null;
-        }
-        // Boolean
-        if (value === 'true') {
-            return true;
-        }
-        if (value === 'false') {
-            return false;
-        }
-        // Number
-        if (/^-?\d+$/.test(value)) {
-            return parseInt(value, 10);
-        }
-        if (/^-?\d+\.\d+$/.test(value)) {
-            return parseFloat(value);
-        }
-        // String
-        if (value.startsWith('"') && value.endsWith('"')) {
-            return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\n/g, '\n');
-        }
-        // Vector2
-        const vec2Match = value.match(/^Vector2\s*\(\s*([\d.-]+)\s*,\s*([\d.-]+)\s*\)$/);
-        if (vec2Match) {
-            return {
-                _type: 'Vector2',
-                x: parseFloat(vec2Match[1]),
-                y: parseFloat(vec2Match[2]),
-            };
-        }
-        // Vector3
-        const vec3Match = value.match(/^Vector3\s*\(\s*([\d.-]+)\s*,\s*([\d.-]+)\s*,\s*([\d.-]+)\s*\)$/);
-        if (vec3Match) {
-            return {
-                _type: 'Vector3',
-                x: parseFloat(vec3Match[1]),
-                y: parseFloat(vec3Match[2]),
-                z: parseFloat(vec3Match[3]),
-            };
-        }
-        // Rect2
-        const rect2Match = value.match(/^Rect2\s*\(\s*([\d.-]+)\s*,\s*([\d.-]+)\s*,\s*([\d.-]+)\s*,\s*([\d.-]+)\s*\)$/);
-        if (rect2Match) {
-            return {
-                _type: 'Rect2',
-                x: parseFloat(rect2Match[1]),
-                y: parseFloat(rect2Match[2]),
-                width: parseFloat(rect2Match[3]),
-                height: parseFloat(rect2Match[4]),
-            };
-        }
-        // Color
-        const colorMatch = value.match(/^Color\s*\(\s*([\d.-]+)\s*,\s*([\d.-]+)\s*,\s*([\d.-]+)\s*(?:,\s*([\d.-]+))?\s*\)$/);
-        if (colorMatch) {
-            return {
-                _type: 'Color',
-                r: parseFloat(colorMatch[1]),
-                g: parseFloat(colorMatch[2]),
-                b: parseFloat(colorMatch[3]),
-                a: colorMatch[4] ? parseFloat(colorMatch[4]) : 1.0,
-            };
-        }
-        // ExtResource
-        const extResMatch = value.match(/^ExtResource\s*\(\s*"?(\d+)"?\s*\)$/);
-        if (extResMatch) {
-            return { _type: 'ExtResource', id: extResMatch[1] };
-        }
-        // SubResource
-        const subResMatch = value.match(/^SubResource\s*\(\s*"?(\d+)"?\s*\)$/);
-        if (subResMatch) {
-            return { _type: 'SubResource', id: subResMatch[1] };
-        }
-        // Array
-        if (value.startsWith('[') && value.endsWith(']')) {
-            return this.parseGodotArray(value);
-        }
-        // Dictionary
-        if (value.startsWith('{') && value.endsWith('}')) {
-            return this.parseGodotDictionary(value);
-        }
-        // Unquoted string
-        return value;
+    if (value === "true") {
+      return true;
     }
-    parseGodotArray(value) {
-        const content = value.slice(1, -1).trim();
-        if (!content) {
-            return [];
-        }
-        const items = [];
-        let depth = 0;
-        let current = '';
-        for (let i = 0; i < content.length; i++) {
-            const char = content[i];
-            if (char === '[' || char === '{' || char === '(') {
-                depth++;
-            }
-            else if (char === ']' || char === '}' || char === ')') {
-                depth--;
-            }
-            if (char === ',' && depth === 0) {
-                items.push(this.parseGodotValue(current.trim()));
-                current = '';
-            }
-            else {
-                current += char;
-            }
-        }
-        if (current.trim()) {
-            items.push(this.parseGodotValue(current.trim()));
-        }
-        return items;
+    if (value === "false") {
+      return false;
     }
-    parseGodotDictionary(value) {
-        const content = value.slice(1, -1).trim();
-        if (!content) {
-            return {};
-        }
-        const result = {};
-        let depth = 0;
-        let current = '';
-        let key = '';
-        let inKey = true;
-        for (let i = 0; i < content.length; i++) {
-            const char = content[i];
-            if (char === '[' || char === '{' || char === '(') {
-                depth++;
-            }
-            else if (char === ']' || char === '}' || char === ')') {
-                depth--;
-            }
-            if (char === ':' && depth === 0 && inKey) {
-                key = current.trim().replace(/^"|"$/g, '');
-                current = '';
-                inKey = false;
-            }
-            else if (char === ',' && depth === 0) {
-                result[key] = this.parseGodotValue(current.trim());
-                current = '';
-                key = '';
-                inKey = true;
-            }
-            else {
-                current += char;
-            }
-        }
-        if (key && current.trim()) {
-            result[key] = this.parseGodotValue(current.trim());
-        }
-        return result;
+    if (/^-?\d+$/.test(value)) {
+      return parseInt(value, 10);
+    }
+    if (/^-?\d+\.\d+$/.test(value)) {
+      return parseFloat(value);
+    }
+    if (value.startsWith('"') && value.endsWith('"')) {
+      return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\n/g, "\n");
+    }
+    const vec2Match = value.match(/^Vector2\s*\(\s*([\d.-]+)\s*,\s*([\d.-]+)\s*\)$/);
+    if (vec2Match) {
+      return {
+        _type: "Vector2",
+        x: parseFloat(vec2Match[1]),
+        y: parseFloat(vec2Match[2])
+      };
+    }
+    const vec3Match = value.match(
+      /^Vector3\s*\(\s*([\d.-]+)\s*,\s*([\d.-]+)\s*,\s*([\d.-]+)\s*\)$/
+    );
+    if (vec3Match) {
+      return {
+        _type: "Vector3",
+        x: parseFloat(vec3Match[1]),
+        y: parseFloat(vec3Match[2]),
+        z: parseFloat(vec3Match[3])
+      };
+    }
+    const rect2Match = value.match(
+      /^Rect2\s*\(\s*([\d.-]+)\s*,\s*([\d.-]+)\s*,\s*([\d.-]+)\s*,\s*([\d.-]+)\s*\)$/
+    );
+    if (rect2Match) {
+      return {
+        _type: "Rect2",
+        x: parseFloat(rect2Match[1]),
+        y: parseFloat(rect2Match[2]),
+        width: parseFloat(rect2Match[3]),
+        height: parseFloat(rect2Match[4])
+      };
+    }
+    const colorMatch = value.match(
+      /^Color\s*\(\s*([\d.-]+)\s*,\s*([\d.-]+)\s*,\s*([\d.-]+)\s*(?:,\s*([\d.-]+))?\s*\)$/
+    );
+    if (colorMatch) {
+      return {
+        _type: "Color",
+        r: parseFloat(colorMatch[1]),
+        g: parseFloat(colorMatch[2]),
+        b: parseFloat(colorMatch[3]),
+        a: colorMatch[4] ? parseFloat(colorMatch[4]) : 1
+      };
+    }
+    const extResMatch = value.match(/^ExtResource\s*\(\s*"?(\d+)"?\s*\)$/);
+    if (extResMatch) {
+      return { _type: "ExtResource", id: extResMatch[1] };
+    }
+    const subResMatch = value.match(/^SubResource\s*\(\s*"?(\d+)"?\s*\)$/);
+    if (subResMatch) {
+      return { _type: "SubResource", id: subResMatch[1] };
+    }
+    if (value.startsWith("[") && value.endsWith("]")) {
+      return this.parseGodotArray(value);
     }
-    convertNodeToEntity(node) {
-        const mapping = GODOT_NODE_MAPPING[node.type || ''] || {
-            niceType: node.type || 'Node',
-            category: 'unknown',
+    if (value.startsWith("{") && value.endsWith("}")) {
+      return this.parseGodotDictionary(value);
+    }
+    return value;
+  }
+  parseGodotArray(value) {
+    const content = value.slice(1, -1).trim();
+    if (!content) {
+      return [];
+    }
+    const items = [];
+    let depth = 0;
+    let current = "";
+    for (let i = 0; i < content.length; i++) {
+      const char = content[i];
+      if (char === "[" || char === "{" || char === "(") {
+        depth++;
+      } else if (char === "]" || char === "}" || char === ")") {
+        depth--;
+      }
+      if (char === "," && depth === 0) {
+        items.push(this.parseGodotValue(current.trim()));
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    if (current.trim()) {
+      items.push(this.parseGodotValue(current.trim()));
+    }
+    return items;
+  }
+  parseGodotDictionary(value) {
+    const content = value.slice(1, -1).trim();
+    if (!content) {
+      return {};
+    }
+    const result = {};
+    let depth = 0;
+    let current = "";
+    let key = "";
+    let inKey = true;
+    for (let i = 0; i < content.length; i++) {
+      const char = content[i];
+      if (char === "[" || char === "{" || char === "(") {
+        depth++;
+      } else if (char === "]" || char === "}" || char === ")") {
+        depth--;
+      }
+      if (char === ":" && depth === 0 && inKey) {
+        key = current.trim().replace(/^"|"$/g, "");
+        current = "";
+        inKey = false;
+      } else if (char === "," && depth === 0) {
+        result[key] = this.parseGodotValue(current.trim());
+        current = "";
+        key = "";
+        inKey = true;
+      } else {
+        current += char;
+      }
+    }
+    if (key && current.trim()) {
+      result[key] = this.parseGodotValue(current.trim());
+    }
+    return result;
+  }
+  convertNodeToEntity(node) {
+    const mapping = GODOT_NODE_MAPPING[node.type || ""] || {
+      niceType: node.type || "Node",
+      category: "unknown"
+    };
+    const children = this.nodes.filter((n) => {
+      if (!n.parent) {
+        return false;
+      }
+      if (n.parent === ".") {
+        return node.parent === void 0;
+      }
+      return n.parent === node.name || n.parent.endsWith("/" + node.name);
+    });
+    const position = this.extractVector2(node.properties.position) || { x: 0, y: 0 };
+    const rotation = typeof node.properties.rotation === "number" ? node.properties.rotation * (180 / Math.PI) : 0;
+    const scale = this.extractVector2(node.properties.scale) || { x: 1, y: 1 };
+    const components = [];
+    components.push(this.convertGodotNodeToComponent(node));
+    if (node.properties.script) {
+      components.push({
+        type: "Script",
+        data: {
+          script: node.properties.script,
+          scriptType: "gdscript"
+        }
+      });
+    }
+    return {
+      id: this.generateId(),
+      name: node.name,
+      type: mapping.niceType,
+      x: position.x,
+      y: position.y,
+      width: 1,
+      height: 1,
+      rotation,
+      scaleX: scale.x,
+      scaleY: scale.y,
+      visible: node.properties.visible !== false,
+      components,
+      children: children.map((c) => this.convertNodeToEntity(c)),
+      properties: {
+        godotType: node.type,
+        category: mapping.category,
+        groups: node.groups,
+        ...node.properties
+      }
+    };
+  }
+  convertGodotNodeToComponent(node) {
+    const type = node.type || "Node";
+    switch (type) {
+      case "Sprite2D":
+        return {
+          type: "Sprite",
+          data: {
+            texture: node.properties.texture,
+            centered: node.properties.centered !== false,
+            offset: this.extractVector2(node.properties.offset),
+            flipH: node.properties.flip_h || false,
+            flipV: node.properties.flip_v || false,
+            hframes: node.properties.hframes || 1,
+            vframes: node.properties.vframes || 1,
+            frame: node.properties.frame || 0,
+            modulate: node.properties.modulate
+          }
         };
-        // Find children
-        const children = this.nodes.filter((n) => {
-            if (!n.parent) {
-                return false;
-            }
-            // Parent is "." means direct child of root
-            if (n.parent === '.') {
-                return node.parent === undefined;
-            }
-            // Match by path
-            return n.parent === node.name || n.parent.endsWith('/' + node.name);
-        });
-        // Extract position and rotation
-        const position = this.extractVector2(node.properties.position) || { x: 0, y: 0 };
-        const rotation = typeof node.properties.rotation === 'number' ? node.properties.rotation * (180 / Math.PI) : 0;
-        const scale = this.extractVector2(node.properties.scale) || { x: 1, y: 1 };
-        // Build components
-        const components = [];
-        components.push(this.convertGodotNodeToComponent(node));
-        // Add script component if present
-        if (node.properties.script) {
-            components.push({
-                type: 'Script',
-                data: {
-                    script: node.properties.script,
-                    scriptType: 'gdscript',
-                },
-            });
-        }
+      case "AnimatedSprite2D":
+        return {
+          type: "AnimatedSprite",
+          data: {
+            spriteFrames: node.properties.sprite_frames,
+            animation: node.properties.animation,
+            frame: node.properties.frame || 0,
+            playing: node.properties.playing || false,
+            speedScale: node.properties.speed_scale || 1,
+            centered: node.properties.centered !== false,
+            offset: this.extractVector2(node.properties.offset),
+            flipH: node.properties.flip_h || false,
+            flipV: node.properties.flip_v || false
+          }
+        };
+      case "CharacterBody2D":
+        return {
+          type: "CharacterController2D",
+          data: {
+            motionMode: node.properties.motion_mode || 0,
+            upDirection: this.extractVector2(node.properties.up_direction) || { x: 0, y: -1 },
+            floorStopOnSlope: node.properties.floor_stop_on_slope || true,
+            floorMaxAngle: node.properties.floor_max_angle || 0.785398,
+            platformOnLeave: node.properties.platform_on_leave || 0,
+            safeMargin: node.properties.safe_margin || 0.08
+          }
+        };
+      case "RigidBody2D":
+        return {
+          type: "Rigidbody2D",
+          data: {
+            mass: node.properties.mass || 1,
+            physicsMaterialOverride: node.properties.physics_material_override,
+            gravityScale: node.properties.gravity_scale ?? 1,
+            freezeMode: node.properties.freeze_mode || 0,
+            freeze: node.properties.freeze || false,
+            customIntegrator: node.properties.custom_integrator || false,
+            continuousCd: node.properties.continuous_cd || 0,
+            linearVelocity: this.extractVector2(node.properties.linear_velocity),
+            angularVelocity: node.properties.angular_velocity || 0,
+            linearDamp: node.properties.linear_damp || 0,
+            angularDamp: node.properties.angular_damp || 0
+          }
+        };
+      case "CollisionShape2D":
+        return {
+          type: "Collider2D",
+          data: {
+            shape: node.properties.shape,
+            disabled: node.properties.disabled || false,
+            oneWayCollision: node.properties.one_way_collision || false,
+            oneWayCollisionMargin: node.properties.one_way_collision_margin || 1
+          }
+        };
+      case "Area2D":
+        return {
+          type: "Trigger2D",
+          data: {
+            monitorable: node.properties.monitorable ?? true,
+            monitoring: node.properties.monitoring ?? true,
+            priority: node.properties.priority || 0,
+            collisionLayer: node.properties.collision_layer,
+            collisionMask: node.properties.collision_mask,
+            gravitySpaceOverride: node.properties.gravity_space_override,
+            gravityPointCenter: this.extractVector2(node.properties.gravity_point_center),
+            gravity: node.properties.gravity
+          }
+        };
+      case "Camera2D":
+        return {
+          type: "Camera2D",
+          data: {
+            enabled: node.properties.enabled ?? true,
+            zoom: this.extractVector2(node.properties.zoom) || { x: 1, y: 1 },
+            offset: this.extractVector2(node.properties.offset),
+            anchorMode: node.properties.anchor_mode || 1,
+            rotationSmoothingEnabled: node.properties.rotation_smoothing_enabled || false,
+            positionSmoothingEnabled: node.properties.position_smoothing_enabled || false,
+            positionSmoothingSpeed: node.properties.position_smoothing_speed || 5,
+            limitLeft: node.properties.limit_left,
+            limitTop: node.properties.limit_top,
+            limitRight: node.properties.limit_right,
+            limitBottom: node.properties.limit_bottom,
+            limitSmoothed: node.properties.limit_smoothed || false
+          }
+        };
+      case "TileMap":
+      case "TileMapLayer":
+        return {
+          type: "Tilemap",
+          data: {
+            tileSet: node.properties.tile_set,
+            cellSize: this.extractVector2(node.properties.cell_size) || { x: 16, y: 16 },
+            quadrantSize: node.properties.quadrant_size || 16,
+            format: node.properties.format,
+            tileData: node.properties.tile_data || node.properties.layer_0 || node.properties.layer0
+          }
+        };
+      case "AudioStreamPlayer":
+      case "AudioStreamPlayer2D":
+      case "AudioStreamPlayer3D":
+        return {
+          type: "AudioSource",
+          data: {
+            stream: node.properties.stream,
+            volumeDb: node.properties.volume_db || 0,
+            pitchScale: node.properties.pitch_scale || 1,
+            playing: node.properties.playing || false,
+            autoplay: node.properties.autoplay || false,
+            bus: node.properties.bus || "Master",
+            maxDistance: node.properties.max_distance,
+            attenuation: node.properties.attenuation
+          }
+        };
+      case "AnimationPlayer":
+        return {
+          type: "Animator",
+          data: {
+            rootNode: node.properties.root_node,
+            autoplay: node.properties.autoplay,
+            currentAnimation: node.properties.current_animation,
+            playbackSpeed: node.properties.playback_speed || 1,
+            libraries: node.properties.libraries
+          }
+        };
+      case "GPUParticles2D":
+      case "CPUParticles2D":
+        return {
+          type: "ParticleSystem2D",
+          data: {
+            emitting: node.properties.emitting ?? true,
+            amount: node.properties.amount || 8,
+            lifetime: node.properties.lifetime || 1,
+            oneShot: node.properties.one_shot || false,
+            preprocess: node.properties.preprocess || 0,
+            speedScale: node.properties.speed_scale || 1,
+            explosiveness: node.properties.explosiveness || 0,
+            randomness: node.properties.randomness || 0,
+            texture: node.properties.texture,
+            processMaterial: node.properties.process_material
+          }
+        };
+      case "Light2D":
+      case "PointLight2D":
+        return {
+          type: "Light2D",
+          data: {
+            enabled: node.properties.enabled ?? true,
+            color: node.properties.color,
+            energy: node.properties.energy ?? 1,
+            texture: node.properties.texture,
+            textureScale: node.properties.texture_scale || 1,
+            blendMode: node.properties.blend_mode || 0,
+            shadowEnabled: node.properties.shadow_enabled || false,
+            shadowColor: node.properties.shadow_color
+          }
+        };
+      case "Label":
         return {
-            id: this.generateId(),
-            name: node.name,
-            type: mapping.niceType,
-            x: position.x,
-            y: position.y,
-            width: 1,
-            height: 1,
-            rotation,
-            scaleX: scale.x,
-            scaleY: scale.y,
-            visible: node.properties.visible !== false,
-            components,
-            children: children.map((c) => this.convertNodeToEntity(c)),
-            properties: {
-                godotType: node.type,
-                category: mapping.category,
-                groups: node.groups,
-                ...node.properties,
-            },
+          type: "Text",
+          data: {
+            text: node.properties.text || "",
+            horizontalAlignment: node.properties.horizontal_alignment || 0,
+            verticalAlignment: node.properties.vertical_alignment || 0,
+            autowrapMode: node.properties.autowrap_mode || 0,
+            clipText: node.properties.clip_text || false,
+            textOverrunBehavior: node.properties.text_overrun_behavior || 0,
+            theme: node.properties.theme,
+            themeOverride: node.properties.theme_override_colors || node.properties.theme_override_fonts
+          }
+        };
+      case "Button":
+        return {
+          type: "Button",
+          data: {
+            text: node.properties.text || "",
+            disabled: node.properties.disabled || false,
+            flat: node.properties.flat || false,
+            icon: node.properties.icon,
+            toggleMode: node.properties.toggle_mode || false,
+            buttonPressed: node.properties.button_pressed || false
+          }
+        };
+      default:
+        return {
+          type,
+          data: { ...node.properties }
         };
     }
-    convertGodotNodeToComponent(node) {
-        const type = node.type || 'Node';
-        switch (type) {
-            case 'Sprite2D':
-                return {
-                    type: 'Sprite',
-                    data: {
-                        texture: node.properties.texture,
-                        centered: node.properties.centered !== false,
-                        offset: this.extractVector2(node.properties.offset),
-                        flipH: node.properties.flip_h || false,
-                        flipV: node.properties.flip_v || false,
-                        hframes: node.properties.hframes || 1,
-                        vframes: node.properties.vframes || 1,
-                        frame: node.properties.frame || 0,
-                        modulate: node.properties.modulate,
-                    },
-                };
-            case 'AnimatedSprite2D':
-                return {
-                    type: 'AnimatedSprite',
-                    data: {
-                        spriteFrames: node.properties.sprite_frames,
-                        animation: node.properties.animation,
-                        frame: node.properties.frame || 0,
-                        playing: node.properties.playing || false,
-                        speedScale: node.properties.speed_scale || 1.0,
-                        centered: node.properties.centered !== false,
-                        offset: this.extractVector2(node.properties.offset),
-                        flipH: node.properties.flip_h || false,
-                        flipV: node.properties.flip_v || false,
-                    },
-                };
-            case 'CharacterBody2D':
-                return {
-                    type: 'CharacterController2D',
-                    data: {
-                        motionMode: node.properties.motion_mode || 0,
-                        upDirection: this.extractVector2(node.properties.up_direction) || { x: 0, y: -1 },
-                        floorStopOnSlope: node.properties.floor_stop_on_slope || true,
-                        floorMaxAngle: node.properties.floor_max_angle || 0.785398,
-                        platformOnLeave: node.properties.platform_on_leave || 0,
-                        safeMargin: node.properties.safe_margin || 0.08,
-                    },
-                };
-            case 'RigidBody2D':
-                return {
-                    type: 'Rigidbody2D',
-                    data: {
-                        mass: node.properties.mass || 1.0,
-                        physicsMaterialOverride: node.properties.physics_material_override,
-                        gravityScale: node.properties.gravity_scale ?? 1.0,
-                        freezeMode: node.properties.freeze_mode || 0,
-                        freeze: node.properties.freeze || false,
-                        customIntegrator: node.properties.custom_integrator || false,
-                        continuousCd: node.properties.continuous_cd || 0,
-                        linearVelocity: this.extractVector2(node.properties.linear_velocity),
-                        angularVelocity: node.properties.angular_velocity || 0,
-                        linearDamp: node.properties.linear_damp || 0,
-                        angularDamp: node.properties.angular_damp || 0,
-                    },
-                };
-            case 'CollisionShape2D':
-                return {
-                    type: 'Collider2D',
-                    data: {
-                        shape: node.properties.shape,
-                        disabled: node.properties.disabled || false,
-                        oneWayCollision: node.properties.one_way_collision || false,
-                        oneWayCollisionMargin: node.properties.one_way_collision_margin || 1.0,
-                    },
-                };
-            case 'Area2D':
-                return {
-                    type: 'Trigger2D',
-                    data: {
-                        monitorable: node.properties.monitorable ?? true,
-                        monitoring: node.properties.monitoring ?? true,
-                        priority: node.properties.priority || 0,
-                        collisionLayer: node.properties.collision_layer,
-                        collisionMask: node.properties.collision_mask,
-                        gravitySpaceOverride: node.properties.gravity_space_override,
-                        gravityPointCenter: this.extractVector2(node.properties.gravity_point_center),
-                        gravity: node.properties.gravity,
-                    },
-                };
-            case 'Camera2D':
-                return {
-                    type: 'Camera2D',
-                    data: {
-                        enabled: node.properties.enabled ?? true,
-                        zoom: this.extractVector2(node.properties.zoom) || { x: 1, y: 1 },
-                        offset: this.extractVector2(node.properties.offset),
-                        anchorMode: node.properties.anchor_mode || 1,
-                        rotationSmoothingEnabled: node.properties.rotation_smoothing_enabled || false,
-                        positionSmoothingEnabled: node.properties.position_smoothing_enabled || false,
-                        positionSmoothingSpeed: node.properties.position_smoothing_speed || 5,
-                        limitLeft: node.properties.limit_left,
-                        limitTop: node.properties.limit_top,
-                        limitRight: node.properties.limit_right,
-                        limitBottom: node.properties.limit_bottom,
-                        limitSmoothed: node.properties.limit_smoothed || false,
-                    },
-                };
-            case 'TileMap':
-            case 'TileMapLayer':
-                return {
-                    type: 'Tilemap',
-                    data: {
-                        tileSet: node.properties.tile_set,
-                        cellSize: this.extractVector2(node.properties.cell_size) || { x: 16, y: 16 },
-                        quadrantSize: node.properties.quadrant_size || 16,
-                        format: node.properties.format,
-                        tileData: node.properties.tile_data || node.properties.layer_0 || node.properties.layer0,
-                    },
-                };
-            case 'AudioStreamPlayer':
-            case 'AudioStreamPlayer2D':
-            case 'AudioStreamPlayer3D':
-                return {
-                    type: 'AudioSource',
-                    data: {
-                        stream: node.properties.stream,
-                        volumeDb: node.properties.volume_db || 0,
-                        pitchScale: node.properties.pitch_scale || 1.0,
-                        playing: node.properties.playing || false,
-                        autoplay: node.properties.autoplay || false,
-                        bus: node.properties.bus || 'Master',
-                        maxDistance: node.properties.max_distance,
-                        attenuation: node.properties.attenuation,
-                    },
-                };
-            case 'AnimationPlayer':
-                return {
-                    type: 'Animator',
-                    data: {
-                        rootNode: node.properties.root_node,
-                        autoplay: node.properties.autoplay,
-                        currentAnimation: node.properties.current_animation,
-                        playbackSpeed: node.properties.playback_speed || 1.0,
-                        libraries: node.properties.libraries,
-                    },
-                };
-            case 'GPUParticles2D':
-            case 'CPUParticles2D':
-                return {
-                    type: 'ParticleSystem2D',
-                    data: {
-                        emitting: node.properties.emitting ?? true,
-                        amount: node.properties.amount || 8,
-                        lifetime: node.properties.lifetime || 1.0,
-                        oneShot: node.properties.one_shot || false,
-                        preprocess: node.properties.preprocess || 0,
-                        speedScale: node.properties.speed_scale || 1.0,
-                        explosiveness: node.properties.explosiveness || 0,
-                        randomness: node.properties.randomness || 0,
-                        texture: node.properties.texture,
-                        processMaterial: node.properties.process_material,
-                    },
-                };
-            case 'Light2D':
-            case 'PointLight2D':
-                return {
-                    type: 'Light2D',
-                    data: {
-                        enabled: node.properties.enabled ?? true,
-                        color: node.properties.color,
-                        energy: node.properties.energy ?? 1.0,
-                        texture: node.properties.texture,
-                        textureScale: node.properties.texture_scale || 1.0,
-                        blendMode: node.properties.blend_mode || 0,
-                        shadowEnabled: node.properties.shadow_enabled || false,
-                        shadowColor: node.properties.shadow_color,
-                    },
-                };
-            case 'Label':
-                return {
-                    type: 'Text',
-                    data: {
-                        text: node.properties.text || '',
-                        horizontalAlignment: node.properties.horizontal_alignment || 0,
-                        verticalAlignment: node.properties.vertical_alignment || 0,
-                        autowrapMode: node.properties.autowrap_mode || 0,
-                        clipText: node.properties.clip_text || false,
-                        textOverrunBehavior: node.properties.text_overrun_behavior || 0,
-                        theme: node.properties.theme,
-                        themeOverride: node.properties.theme_override_colors || node.properties.theme_override_fonts,
-                    },
-                };
-            case 'Button':
-                return {
-                    type: 'Button',
-                    data: {
-                        text: node.properties.text || '',
-                        disabled: node.properties.disabled || false,
-                        flat: node.properties.flat || false,
-                        icon: node.properties.icon,
-                        toggleMode: node.properties.toggle_mode || false,
-                        buttonPressed: node.properties.button_pressed || false,
-                    },
-                };
-            default:
-                return {
-                    type: type,
-                    data: { ...node.properties },
-                };
-        }
+  }
+  extractVector2(value) {
+    if (!value) {
+      return void 0;
     }
-    extractVector2(value) {
-        if (!value) {
-            return undefined;
-        }
-        if (typeof value === 'object' && value !== null) {
-            if ('_type' in value && value._type === 'Vector2') {
-                return { x: value.x, y: value.y };
-            }
-            if ('x' in value && 'y' in value) {
-                return {
-                    x: Number(value.x),
-                    y: Number(value.y),
-                };
-            }
-        }
-        return undefined;
-    }
-    extractAssets() {
-        const assets = [];
-        for (const [id, extRes] of this.extResources) {
-            let assetType = 'data';
-            // Determine asset type from Godot resource type
-            switch (extRes.type) {
-                case 'Texture2D':
-                case 'CompressedTexture2D':
-                case 'AtlasTexture':
-                case 'ImageTexture':
-                    assetType = 'texture';
-                    break;
-                case 'AudioStream':
-                case 'AudioStreamMP3':
-                case 'AudioStreamOGGVorbis':
-                case 'AudioStreamWAV':
-                    assetType = 'audio';
-                    break;
-                case 'SpriteFrames':
-                case 'Animation':
-                case 'AnimationLibrary':
-                    assetType = 'animation';
-                    break;
-                case 'TileSet':
-                    assetType = 'tileset';
-                    break;
-                case 'Script':
-                case 'GDScript':
-                case 'CSharpScript':
-                    assetType = 'script';
-                    break;
-                case 'Shader':
-                case 'VisualShader':
-                    assetType = 'shader';
-                    break;
-                case 'Font':
-                case 'FontFile':
-                case 'SystemFont':
-                    assetType = 'font';
-                    break;
-            }
-            assets.push({
-                id: this.generateId(),
-                name: extRes.path
-                    .split('/')
-                    .pop()
-                    ?.replace(/\.\w+$/, '') || `resource_${id}`,
-                type: assetType,
-                path: extRes.path,
-                data: {
-                    godotType: extRes.type,
-                    extResourceId: id,
-                    uid: extRes.uid,
-                },
-            });
-        }
-        return assets;
-    }
-    // ----------------------------------------
-    // Helper Methods
-    // ----------------------------------------
-    async readFile(path) {
-        if (typeof globalThis.process !== 'undefined' && globalThis.process.versions?.node) {
-            const fs = await import('fs');
-            return fs.readFileSync(path, 'utf-8');
-        }
-        else if (typeof fetch !== 'undefined') {
-            const response = await fetch(path);
-            return response.text();
-        }
-        throw new Error('Unable to read file in current environment');
+    if (typeof value === "object" && value !== null) {
+      if ("_type" in value && value._type === "Vector2") {
+        return { x: value.x, y: value.y };
+      }
+      if ("x" in value && "y" in value) {
+        return {
+          x: Number(value.x),
+          y: Number(value.y)
+        };
+      }
+    }
+    return void 0;
+  }
+  extractAssets() {
+    const assets = [];
+    for (const [id, extRes] of this.extResources) {
+      let assetType = "data";
+      switch (extRes.type) {
+        case "Texture2D":
+        case "CompressedTexture2D":
+        case "AtlasTexture":
+        case "ImageTexture":
+          assetType = "texture";
+          break;
+        case "AudioStream":
+        case "AudioStreamMP3":
+        case "AudioStreamOGGVorbis":
+        case "AudioStreamWAV":
+          assetType = "audio";
+          break;
+        case "SpriteFrames":
+        case "Animation":
+        case "AnimationLibrary":
+          assetType = "animation";
+          break;
+        case "TileSet":
+          assetType = "tileset";
+          break;
+        case "Script":
+        case "GDScript":
+        case "CSharpScript":
+          assetType = "script";
+          break;
+        case "Shader":
+        case "VisualShader":
+          assetType = "shader";
+          break;
+        case "Font":
+        case "FontFile":
+        case "SystemFont":
+          assetType = "font";
+          break;
+      }
+      assets.push({
+        id: this.generateId(),
+        name: extRes.path.split("/").pop()?.replace(/\.\w+$/, "") || `resource_${id}`,
+        type: assetType,
+        path: extRes.path,
+        data: {
+          godotType: extRes.type,
+          extResourceId: id,
+          uid: extRes.uid
+        }
+      });
+    }
+    return assets;
+  }
+  // ----------------------------------------
+  // Helper Methods
+  // ----------------------------------------
+  async readFile(path) {
+    if (typeof globalThis.process !== "undefined" && globalThis.process.versions?.node) {
+      const fs = await import("fs");
+      return fs.readFileSync(path, "utf-8");
+    } else if (typeof fetch !== "undefined") {
+      const response = await fetch(path);
+      return response.text();
     }
+    throw new Error("Unable to read file in current environment");
+  }
 }
-
 exports.GodotSceneImporter = GodotSceneImporter;