@nice2dev/game-engine 1.3.15 → 1.3.17

package/dist/cjs/import/SpineImporter.js

@@ -1,582 +1,547 @@
-'use strict';
-
-var SceneImporter = require('./SceneImporter.js');
-
-/**
- * @file SpineImporter.ts
- * @description Spine 2D Skeletal Animation Importer
- * PRO-1.3: Scene Format Interoperability
- *
- * Spine is a professional 2D skeletal animation tool.
- * Supports both JSON and binary formats.
- *
- * File Types:
- * - .json - Spine skeleton data (JSON)
- * - .skel - Spine skeleton data (binary)
- * - .atlas - Texture atlas
- */
-// ============================================================
-// Spine Importer
-// ============================================================
+"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");
 class SpineImporter extends SceneImporter.SceneImporter {
-    constructor() {
-        super('spine');
-        this.atlas = null;
-    }
-    canHandle(filePath) {
-        const ext = filePath.substring(filePath.lastIndexOf('.')).toLowerCase();
-        return ext === '.json' || ext === '.skel' || ext === '.atlas';
-    }
-    async import(options) {
-        const startTime = Date.now();
-        this.options = options;
-        this.clearMessages();
-        const scenes = [];
-        const assets = [];
-        try {
-            const ext = options.sourcePath.substring(options.sourcePath.lastIndexOf('.')).toLowerCase();
-            if (ext === '.atlas') {
-                // Parse atlas file
-                const atlasContent = await this.readFile(options.sourcePath);
-                this.atlas = this.parseAtlas(atlasContent);
-                // Create assets from atlas
-                for (const page of this.atlas.pages) {
-                    assets.push({
-                        id: this.generateId(),
-                        name: page.name,
-                        type: 'texture',
-                        path: page.name,
-                        data: {
-                            width: page.size.width,
-                            height: page.size.height,
-                            format: page.format,
-                            filter: page.filter,
-                            pma: page.pma,
-                        },
-                    });
-                    // Add individual regions as sprite assets
-                    for (const region of page.regions) {
-                        assets.push({
-                            id: this.generateId(),
-                            name: region.name,
-                            type: 'texture',
-                            path: page.name,
-                            data: {
-                                frame: region.bounds,
-                                rotate: region.rotate,
-                                index: region.index,
-                            },
-                        });
-                    }
-                }
-            }
-            else {
-                // Parse skeleton file
-                const content = await this.readFile(options.sourcePath);
-                const skeleton = JSON.parse(content);
-                // Try to load atlas if resolveDependencies is enabled
-                if (options.resolveDependencies) {
-                    const atlasPath = options.sourcePath.replace(/\.(json|skel)$/i, '.atlas');
-                    try {
-                        const atlasContent = await this.readFile(atlasPath);
-                        this.atlas = this.parseAtlas(atlasContent);
-                    }
-                    catch {
-                        this.addWarning('ATLAS_NOT_FOUND', 'Atlas file not found', atlasPath);
-                    }
-                }
-                // Convert skeleton to scene
-                const scene = this.convertSkeletonToScene(skeleton, options.sourcePath);
-                scenes.push(scene);
-                // Extract assets from skins
-                for (const skin of skeleton.skins) {
-                    for (const [slotName, attachments] of Object.entries(skin.attachments)) {
-                        for (const [attachmentName, attachment] of Object.entries(attachments)) {
-                            if ('width' in attachment && 'height' in attachment) {
-                                const regionAttachment = attachment;
-                                assets.push({
-                                    id: this.generateId(),
-                                    name: regionAttachment.path || attachmentName,
-                                    type: 'texture',
-                                    path: regionAttachment.path || attachmentName,
-                                    data: {
-                                        width: regionAttachment.width,
-                                        height: regionAttachment.height,
-                                        slot: slotName,
-                                        skin: skin.name,
-                                    },
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        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);
-        try {
-            if (filePath.endsWith('.atlas')) {
-                return null; // Atlas files don't produce scenes
+  constructor() {
+    super("spine");
+    this.atlas = null;
+  }
+  canHandle(filePath) {
+    const ext = filePath.substring(filePath.lastIndexOf(".")).toLowerCase();
+    return ext === ".json" || ext === ".skel" || ext === ".atlas";
+  }
+  async import(options) {
+    const startTime = Date.now();
+    this.options = options;
+    this.clearMessages();
+    const scenes = [];
+    const assets = [];
+    try {
+      const ext = options.sourcePath.substring(options.sourcePath.lastIndexOf(".")).toLowerCase();
+      if (ext === ".atlas") {
+        const atlasContent = await this.readFile(options.sourcePath);
+        this.atlas = this.parseAtlas(atlasContent);
+        for (const page of this.atlas.pages) {
+          assets.push({
+            id: this.generateId(),
+            name: page.name,
+            type: "texture",
+            path: page.name,
+            data: {
+              width: page.size.width,
+              height: page.size.height,
+              format: page.format,
+              filter: page.filter,
+              pma: page.pma
             }
-            const skeleton = JSON.parse(stringContent);
-            return this.convertSkeletonToParsed(skeleton);
-        }
-        catch {
-            return null;
-        }
-    }
-    async validate(sourcePath) {
-        const errors = [];
-        if (!this.canHandle(sourcePath)) {
-            errors.push({
-                code: 'INVALID_FORMAT',
-                message: `File ${sourcePath} is not a valid Spine file`,
-                file: sourcePath,
-                fatal: true,
+          });
+          for (const region of page.regions) {
+            assets.push({
+              id: this.generateId(),
+              name: region.name,
+              type: "texture",
+              path: page.name,
+              data: {
+                frame: region.bounds,
+                rotate: region.rotate,
+                index: region.index
+              }
             });
+          }
         }
-        return errors;
-    }
-    // ----------------------------------------
-    // Skeleton Conversion
-    // ----------------------------------------
-    convertSkeletonToScene(skeleton, sourcePath) {
-        const name = this.extractFileName(sourcePath);
-        const entities = [];
-        // Create root entity
-        const rootEntity = {
-            id: this.generateId(),
-            name: name,
-            components: [
-                {
-                    type: 'Transform',
-                    data: {
-                        position: { x: skeleton.skeleton.x || 0, y: skeleton.skeleton.y || 0 },
-                        rotation: 0,
-                        scale: { x: 1, y: 1 },
-                    },
-                },
-                {
-                    type: 'SpineSkeleton',
-                    data: {
-                        version: skeleton.skeleton.spine,
-                        width: skeleton.skeleton.width,
-                        height: skeleton.skeleton.height,
-                        fps: skeleton.skeleton.fps || 30,
-                        skins: skeleton.skins.map((s) => s.name),
-                        animations: Object.keys(skeleton.animations),
-                    },
-                },
-            ],
-            children: [],
-            tags: ['spine', 'skeleton'],
-            active: true,
-        };
-        // Create bone hierarchy
-        const boneEntities = this.createBoneHierarchy(skeleton.bones);
-        rootEntity.children = boneEntities;
-        // Add slots and attachments
-        for (const slot of skeleton.slots) {
-            this.addSlotToEntity(rootEntity, slot, skeleton.skins);
+      } else {
+        const content = await this.readFile(options.sourcePath);
+        const skeleton = JSON.parse(content);
+        if (options.resolveDependencies) {
+          const atlasPath = options.sourcePath.replace(/\.(json|skel)$/i, ".atlas");
+          try {
+            const atlasContent = await this.readFile(atlasPath);
+            this.atlas = this.parseAtlas(atlasContent);
+          } catch {
+            this.addWarning("ATLAS_NOT_FOUND", "Atlas file not found", atlasPath);
+          }
         }
-        // Add IK constraints
-        if (skeleton.ik) {
-            for (const ik of skeleton.ik) {
-                rootEntity.components.push({
-                    type: 'IKConstraint',
-                    data: {
-                        name: ik.name,
-                        bones: ik.bones,
-                        target: ik.target,
-                        mix: ik.mix ?? 1,
-                        softness: ik.softness ?? 0,
-                        bendPositive: ik.bendPositive ?? true,
-                    },
+        const scene = this.convertSkeletonToScene(skeleton, options.sourcePath);
+        scenes.push(scene);
+        for (const skin of skeleton.skins) {
+          for (const [slotName, attachments] of Object.entries(skin.attachments)) {
+            for (const [attachmentName, attachment] of Object.entries(attachments)) {
+              if ("width" in attachment && "height" in attachment) {
+                const regionAttachment = attachment;
+                assets.push({
+                  id: this.generateId(),
+                  name: regionAttachment.path || attachmentName,
+                  type: "texture",
+                  path: regionAttachment.path || attachmentName,
+                  data: {
+                    width: regionAttachment.width,
+                    height: regionAttachment.height,
+                    slot: slotName,
+                    skin: skin.name
+                  }
                 });
+              }
             }
+          }
         }
-        // Add animations
-        for (const [animName, anim] of Object.entries(skeleton.animations)) {
-            const animationData = this.convertAnimation(animName, anim, skeleton);
-            rootEntity.components.push({
-                type: 'Animation',
-                data: animationData,
-            });
-        }
-        entities.push(rootEntity);
-        return {
-            id: this.generateId(),
-            name,
-            entities,
-            settings: {
-                width: skeleton.skeleton.width || 800,
-                height: skeleton.skeleton.height || 600,
-                backgroundColor: '#1a1a2e',
-                fps: skeleton.skeleton.fps || 30,
-            },
-        };
+      }
+    } catch (error) {
+      this.addError(
+        "IMPORT_ERROR",
+        `Failed to import: ${error}`,
+        options.sourcePath,
+        void 0,
+        true
+      );
     }
-    convertSkeletonToParsed(skeleton) {
-        const entities = [];
-        // Create bone entities
-        for (const bone of skeleton.bones) {
-            entities.push({
-                id: bone.name,
-                name: bone.name,
-                type: 'Bone',
-                x: bone.x || 0,
-                y: bone.y || 0,
-                width: bone.length || 0,
-                height: 4,
-                rotation: bone.rotation || 0,
-                scaleX: bone.scaleX ?? 1,
-                scaleY: bone.scaleY ?? 1,
-                visible: true,
-                components: [],
-                children: [],
-                properties: {
-                    parent: bone.parent,
-                    length: bone.length,
-                    transform: bone.transform,
-                    shearX: bone.shearX,
-                    shearY: bone.shearY,
-                    color: bone.color,
-                },
-            });
-        }
-        return {
-            name: 'Spine Skeleton',
-            width: skeleton.skeleton.width || 800,
-            height: skeleton.skeleton.height || 600,
-            backgroundColor: '#1a1a2e',
-            layers: [
-                {
-                    name: 'Skeleton',
-                    type: 'object',
-                    visible: true,
-                    opacity: 1,
-                    offsetX: 0,
-                    offsetY: 0,
-                    zIndex: 0,
-                    properties: {},
-                },
-            ],
-            entities,
-            properties: {
-                version: skeleton.skeleton.spine,
-                fps: skeleton.skeleton.fps,
-                skins: skeleton.skins.map((s) => s.name),
-                animations: Object.keys(skeleton.animations),
-            },
-        };
+    return this.createResult(scenes, assets, startTime);
+  }
+  async parseFile(content, filePath) {
+    const stringContent = typeof content === "string" ? content : new TextDecoder().decode(content);
+    try {
+      if (filePath.endsWith(".atlas")) {
+        return null;
+      }
+      const skeleton = JSON.parse(stringContent);
+      return this.convertSkeletonToParsed(skeleton);
+    } catch {
+      return null;
     }
-    // ----------------------------------------
-    // Bone Hierarchy
-    // ----------------------------------------
-    createBoneHierarchy(bones) {
-        const boneMap = new Map();
-        const rootBones = [];
-        // Create all bone entities
-        for (const bone of bones) {
-            const entity = {
-                id: bone.name,
-                name: bone.name,
-                components: [
-                    {
-                        type: 'Transform',
-                        data: {
-                            position: { x: bone.x || 0, y: bone.y || 0 },
-                            rotation: bone.rotation || 0,
-                            scale: { x: bone.scaleX ?? 1, y: bone.scaleY ?? 1 },
-                        },
-                    },
-                    {
-                        type: 'Bone',
-                        data: {
-                            length: bone.length || 0,
-                            shearX: bone.shearX || 0,
-                            shearY: bone.shearY || 0,
-                            transform: bone.transform || 'normal',
-                            color: bone.color,
-                        },
-                    },
-                ],
-                children: [],
-                tags: ['bone'],
-                active: true,
-            };
-            boneMap.set(bone.name, entity);
+  }
+  async validate(sourcePath) {
+    const errors = [];
+    if (!this.canHandle(sourcePath)) {
+      errors.push({
+        code: "INVALID_FORMAT",
+        message: `File ${sourcePath} is not a valid Spine file`,
+        file: sourcePath,
+        fatal: true
+      });
+    }
+    return errors;
+  }
+  // ----------------------------------------
+  // Skeleton Conversion
+  // ----------------------------------------
+  convertSkeletonToScene(skeleton, sourcePath) {
+    const name = this.extractFileName(sourcePath);
+    const entities = [];
+    const rootEntity = {
+      id: this.generateId(),
+      name,
+      components: [
+        {
+          type: "Transform",
+          data: {
+            position: { x: skeleton.skeleton.x || 0, y: skeleton.skeleton.y || 0 },
+            rotation: 0,
+            scale: { x: 1, y: 1 }
+          }
+        },
+        {
+          type: "SpineSkeleton",
+          data: {
+            version: skeleton.skeleton.spine,
+            width: skeleton.skeleton.width,
+            height: skeleton.skeleton.height,
+            fps: skeleton.skeleton.fps || 30,
+            skins: skeleton.skins.map((s) => s.name),
+            animations: Object.keys(skeleton.animations)
+          }
         }
-        // Build hierarchy
-        for (const bone of bones) {
-            const entity = boneMap.get(bone.name);
-            if (bone.parent) {
-                const parent = boneMap.get(bone.parent);
-                if (parent) {
-                    if (!parent.children) {
-                        parent.children = [];
-                    }
-                    parent.children.push(entity);
-                }
-                else {
-                    rootBones.push(entity);
-                }
-            }
-            else {
-                rootBones.push(entity);
-            }
+      ],
+      children: [],
+      tags: ["spine", "skeleton"],
+      active: true
+    };
+    const boneEntities = this.createBoneHierarchy(skeleton.bones);
+    rootEntity.children = boneEntities;
+    for (const slot of skeleton.slots) {
+      this.addSlotToEntity(rootEntity, slot, skeleton.skins);
+    }
+    if (skeleton.ik) {
+      for (const ik of skeleton.ik) {
+        rootEntity.components.push({
+          type: "IKConstraint",
+          data: {
+            name: ik.name,
+            bones: ik.bones,
+            target: ik.target,
+            mix: ik.mix ?? 1,
+            softness: ik.softness ?? 0,
+            bendPositive: ik.bendPositive ?? true
+          }
+        });
+      }
+    }
+    for (const [animName, anim] of Object.entries(skeleton.animations)) {
+      const animationData = this.convertAnimation(animName, anim, skeleton);
+      rootEntity.components.push({
+        type: "Animation",
+        data: animationData
+      });
+    }
+    entities.push(rootEntity);
+    return {
+      id: this.generateId(),
+      name,
+      entities,
+      settings: {
+        width: skeleton.skeleton.width || 800,
+        height: skeleton.skeleton.height || 600,
+        backgroundColor: "#1a1a2e",
+        fps: skeleton.skeleton.fps || 30
+      }
+    };
+  }
+  convertSkeletonToParsed(skeleton) {
+    const entities = [];
+    for (const bone of skeleton.bones) {
+      entities.push({
+        id: bone.name,
+        name: bone.name,
+        type: "Bone",
+        x: bone.x || 0,
+        y: bone.y || 0,
+        width: bone.length || 0,
+        height: 4,
+        rotation: bone.rotation || 0,
+        scaleX: bone.scaleX ?? 1,
+        scaleY: bone.scaleY ?? 1,
+        visible: true,
+        components: [],
+        children: [],
+        properties: {
+          parent: bone.parent,
+          length: bone.length,
+          transform: bone.transform,
+          shearX: bone.shearX,
+          shearY: bone.shearY,
+          color: bone.color
         }
-        return rootBones;
+      });
     }
-    addSlotToEntity(entity, slot, skins) {
-        // Find bone to attach to
-        const bone = this.findBoneEntity(entity, slot.bone);
-        if (!bone) {
-            return;
+    return {
+      name: "Spine Skeleton",
+      width: skeleton.skeleton.width || 800,
+      height: skeleton.skeleton.height || 600,
+      backgroundColor: "#1a1a2e",
+      layers: [
+        {
+          name: "Skeleton",
+          type: "object",
+          visible: true,
+          opacity: 1,
+          offsetX: 0,
+          offsetY: 0,
+          zIndex: 0,
+          properties: {}
         }
-        const slotComponent = {
-            type: 'Slot',
+      ],
+      entities,
+      properties: {
+        version: skeleton.skeleton.spine,
+        fps: skeleton.skeleton.fps,
+        skins: skeleton.skins.map((s) => s.name),
+        animations: Object.keys(skeleton.animations)
+      }
+    };
+  }
+  // ----------------------------------------
+  // Bone Hierarchy
+  // ----------------------------------------
+  createBoneHierarchy(bones) {
+    const boneMap = /* @__PURE__ */ new Map();
+    const rootBones = [];
+    for (const bone of bones) {
+      const entity = {
+        id: bone.name,
+        name: bone.name,
+        components: [
+          {
+            type: "Transform",
             data: {
-                name: slot.name,
-                bone: slot.bone,
-                attachment: slot.attachment,
-                color: slot.color,
-                dark: slot.dark,
-                blend: slot.blend || 'normal',
-            },
-        };
-        bone.components.push(slotComponent);
-        // Add default attachment from default skin
-        const defaultSkin = skins.find((s) => s.name === 'default');
-        if (defaultSkin && slot.attachment) {
-            const attachments = defaultSkin.attachments[slot.name];
-            if (attachments && attachments[slot.attachment]) {
-                const attachment = attachments[slot.attachment];
-                bone.components.push({
-                    type: 'Attachment',
-                    data: {
-                        name: slot.attachment,
-                        ...attachment,
-                    },
-                });
+              position: { x: bone.x || 0, y: bone.y || 0 },
+              rotation: bone.rotation || 0,
+              scale: { x: bone.scaleX ?? 1, y: bone.scaleY ?? 1 }
             }
-        }
+          },
+          {
+            type: "Bone",
+            data: {
+              length: bone.length || 0,
+              shearX: bone.shearX || 0,
+              shearY: bone.shearY || 0,
+              transform: bone.transform || "normal",
+              color: bone.color
+            }
+          }
+        ],
+        children: [],
+        tags: ["bone"],
+        active: true
+      };
+      boneMap.set(bone.name, entity);
     }
-    findBoneEntity(entity, boneName) {
-        if (entity.name === boneName) {
-            return entity;
+    for (const bone of bones) {
+      const entity = boneMap.get(bone.name);
+      if (bone.parent) {
+        const parent = boneMap.get(bone.parent);
+        if (parent) {
+          if (!parent.children) {
+            parent.children = [];
+          }
+          parent.children.push(entity);
+        } else {
+          rootBones.push(entity);
         }
-        for (const child of entity.children ?? []) {
-            const found = this.findBoneEntity(child, boneName);
-            if (found) {
-                return found;
-            }
+      } else {
+        rootBones.push(entity);
+      }
+    }
+    return rootBones;
+  }
+  addSlotToEntity(entity, slot, skins) {
+    const bone = this.findBoneEntity(entity, slot.bone);
+    if (!bone) {
+      return;
+    }
+    const slotComponent = {
+      type: "Slot",
+      data: {
+        name: slot.name,
+        bone: slot.bone,
+        attachment: slot.attachment,
+        color: slot.color,
+        dark: slot.dark,
+        blend: slot.blend || "normal"
+      }
+    };
+    bone.components.push(slotComponent);
+    const defaultSkin = skins.find((s) => s.name === "default");
+    if (defaultSkin && slot.attachment) {
+      const attachments = defaultSkin.attachments[slot.name];
+      if (attachments && attachments[slot.attachment]) {
+        const attachment = attachments[slot.attachment];
+        bone.components.push({
+          type: "Attachment",
+          data: {
+            name: slot.attachment,
+            ...attachment
+          }
+        });
+      }
+    }
+  }
+  findBoneEntity(entity, boneName) {
+    if (entity.name === boneName) {
+      return entity;
+    }
+    for (const child of entity.children ?? []) {
+      const found = this.findBoneEntity(child, boneName);
+      if (found) {
+        return found;
+      }
+    }
+    return null;
+  }
+  // ----------------------------------------
+  // Animation Conversion
+  // ----------------------------------------
+  convertAnimation(name, anim, skeleton) {
+    const duration = this.calculateAnimationDuration(anim);
+    return {
+      name,
+      duration,
+      fps: skeleton.skeleton.fps || 30,
+      bones: anim.bones,
+      slots: anim.slots,
+      ik: anim.ik,
+      transform: anim.transform,
+      path: anim.path,
+      deform: anim.deform,
+      drawOrder: anim.drawOrder,
+      events: anim.events
+    };
+  }
+  calculateAnimationDuration(anim) {
+    let maxTime = 0;
+    const checkKeyframes = (keyframes) => {
+      if (keyframes) {
+        for (const kf of keyframes) {
+          if (kf.time > maxTime) {
+            maxTime = kf.time;
+          }
         }
-        return null;
+      }
+    };
+    if (anim.bones) {
+      for (const timeline of Object.values(anim.bones)) {
+        checkKeyframes(timeline.rotate);
+        checkKeyframes(timeline.translate);
+        checkKeyframes(timeline.scale);
+        checkKeyframes(timeline.shear);
+      }
     }
-    // ----------------------------------------
-    // Animation Conversion
-    // ----------------------------------------
-    convertAnimation(name, anim, skeleton) {
-        const duration = this.calculateAnimationDuration(anim);
-        return {
-            name,
-            duration,
-            fps: skeleton.skeleton.fps || 30,
-            bones: anim.bones,
-            slots: anim.slots,
-            ik: anim.ik,
-            transform: anim.transform,
-            path: anim.path,
-            deform: anim.deform,
-            drawOrder: anim.drawOrder,
-            events: anim.events,
-        };
+    if (anim.slots) {
+      for (const timeline of Object.values(anim.slots)) {
+        checkKeyframes(timeline.color);
+        checkKeyframes(timeline.twoColor);
+      }
     }
-    calculateAnimationDuration(anim) {
-        let maxTime = 0;
-        const checkKeyframes = (keyframes) => {
-            if (keyframes) {
-                for (const kf of keyframes) {
-                    if (kf.time > maxTime) {
-                        maxTime = kf.time;
-                    }
-                }
-            }
+    checkKeyframes(anim.events);
+    checkKeyframes(anim.drawOrder);
+    return maxTime;
+  }
+  // ----------------------------------------
+  // Atlas Parsing
+  // ----------------------------------------
+  parseAtlas(content) {
+    const atlas = { pages: [] };
+    const lines = content.split(/\r?\n/);
+    let currentPage = null;
+    let i = 0;
+    while (i < lines.length) {
+      const line = lines[i].trim();
+      if (line === "") {
+        i++;
+        continue;
+      }
+      if (!line.includes(":") && lines[i].charAt(0) !== " " && lines[i].charAt(0) !== "	") {
+        currentPage = {
+          name: line,
+          size: { width: 0, height: 0 },
+          format: "RGBA8888",
+          filter: { min: "Linear", mag: "Linear" },
+          repeat: "none",
+          regions: []
         };
-        // Check bones
-        if (anim.bones) {
-            for (const timeline of Object.values(anim.bones)) {
-                checkKeyframes(timeline.rotate);
-                checkKeyframes(timeline.translate);
-                checkKeyframes(timeline.scale);
-                checkKeyframes(timeline.shear);
+        atlas.pages.push(currentPage);
+        i++;
+        while (i < lines.length && lines[i].includes(":")) {
+          const propLine = lines[i].trim();
+          const colonIndex = propLine.indexOf(":");
+          const key = propLine.substring(0, colonIndex).trim();
+          const value = propLine.substring(colonIndex + 1).trim();
+          switch (key) {
+            case "size": {
+              const [w, h] = value.split(",").map((s) => parseInt(s.trim()));
+              currentPage.size = { width: w, height: h };
+              break;
             }
-        }
-        // Check slots
-        if (anim.slots) {
-            for (const timeline of Object.values(anim.slots)) {
-                checkKeyframes(timeline.color);
-                checkKeyframes(timeline.twoColor);
+            case "format":
+              currentPage.format = value;
+              break;
+            case "filter": {
+              const [min, mag] = value.split(",").map((s) => s.trim());
+              currentPage.filter = { min, mag };
+              break;
             }
+            case "repeat":
+              currentPage.repeat = value;
+              break;
+            case "pma":
+              currentPage.pma = value === "true";
+              break;
+          }
+          i++;
         }
-        // Check events
-        checkKeyframes(anim.events);
-        // Check draw order
-        checkKeyframes(anim.drawOrder);
-        return maxTime;
-    }
-    // ----------------------------------------
-    // Atlas Parsing
-    // ----------------------------------------
-    parseAtlas(content) {
-        const atlas = { pages: [] };
-        const lines = content.split(/\r?\n/);
-        let currentPage = null;
-        let i = 0;
-        while (i < lines.length) {
-            const line = lines[i].trim();
-            if (line === '') {
-                i++;
-                continue;
-            }
-            // Check if this is a page header (no colon, no indentation)
-            if (!line.includes(':') && lines[i].charAt(0) !== ' ' && lines[i].charAt(0) !== '\t') {
-                currentPage = {
-                    name: line,
-                    size: { width: 0, height: 0 },
-                    format: 'RGBA8888',
-                    filter: { min: 'Linear', mag: 'Linear' },
-                    repeat: 'none',
-                    regions: [],
-                };
-                atlas.pages.push(currentPage);
-                i++;
-                // Parse page properties
-                while (i < lines.length && lines[i].includes(':')) {
-                    const propLine = lines[i].trim();
-                    const colonIndex = propLine.indexOf(':');
-                    const key = propLine.substring(0, colonIndex).trim();
-                    const value = propLine.substring(colonIndex + 1).trim();
-                    switch (key) {
-                        case 'size': {
-                            const [w, h] = value.split(',').map((s) => parseInt(s.trim()));
-                            currentPage.size = { width: w, height: h };
-                            break;
-                        }
-                        case 'format':
-                            currentPage.format = value;
-                            break;
-                        case 'filter': {
-                            const [min, mag] = value.split(',').map((s) => s.trim());
-                            currentPage.filter = { min, mag };
-                            break;
-                        }
-                        case 'repeat':
-                            currentPage.repeat = value;
-                            break;
-                        case 'pma':
-                            currentPage.pma = value === 'true';
-                            break;
-                    }
-                    i++;
-                }
+      } else if (currentPage && !line.includes(":")) {
+        const region = {
+          name: line,
+          bounds: { x: 0, y: 0, width: 0, height: 0 }
+        };
+        currentPage.regions.push(region);
+        i++;
+        while (i < lines.length && lines[i].includes(":")) {
+          const propLine = lines[i].trim();
+          const colonIndex = propLine.indexOf(":");
+          const key = propLine.substring(0, colonIndex).trim();
+          const value = propLine.substring(colonIndex + 1).trim();
+          switch (key) {
+            case "bounds":
+            case "xy": {
+              const parts = value.split(",").map((s) => parseInt(s.trim()));
+              if (key === "bounds" && parts.length === 4) {
+                region.bounds = { x: parts[0], y: parts[1], width: parts[2], height: parts[3] };
+              } else if (parts.length >= 2) {
+                region.bounds.x = parts[0];
+                region.bounds.y = parts[1];
+              }
+              break;
             }
-            else if (currentPage && !line.includes(':')) {
-                // This is a region name
-                const region = {
-                    name: line,
-                    bounds: { x: 0, y: 0, width: 0, height: 0 },
-                };
-                currentPage.regions.push(region);
-                i++;
-                // Parse region properties
-                while (i < lines.length && lines[i].includes(':')) {
-                    const propLine = lines[i].trim();
-                    const colonIndex = propLine.indexOf(':');
-                    const key = propLine.substring(0, colonIndex).trim();
-                    const value = propLine.substring(colonIndex + 1).trim();
-                    switch (key) {
-                        case 'bounds':
-                        case 'xy': {
-                            const parts = value.split(',').map((s) => parseInt(s.trim()));
-                            if (key === 'bounds' && parts.length === 4) {
-                                region.bounds = { x: parts[0], y: parts[1], width: parts[2], height: parts[3] };
-                            }
-                            else if (parts.length >= 2) {
-                                region.bounds.x = parts[0];
-                                region.bounds.y = parts[1];
-                            }
-                            break;
-                        }
-                        case 'size': {
-                            const [w, h] = value.split(',').map((s) => parseInt(s.trim()));
-                            region.bounds.width = w;
-                            region.bounds.height = h;
-                            break;
-                        }
-                        case 'orig':
-                        case 'offsets': {
-                            const parts = value.split(',').map((s) => parseInt(s.trim()));
-                            if (parts.length >= 4) {
-                                region.offsets = { x: parts[0], y: parts[1], width: parts[2], height: parts[3] };
-                            }
-                            break;
-                        }
-                        case 'rotate':
-                            region.rotate =
-                                value === 'true' || value === '90'
-                                    ? true
-                                    : value === '270'
-                                        ? 270
-                                        : value === '180'
-                                            ? 180
-                                            : false;
-                            break;
-                        case 'index':
-                            region.index = parseInt(value);
-                            break;
-                    }
-                    i++;
-                }
+            case "size": {
+              const [w, h] = value.split(",").map((s) => parseInt(s.trim()));
+              region.bounds.width = w;
+              region.bounds.height = h;
+              break;
             }
-            else {
-                i++;
+            case "orig":
+            case "offsets": {
+              const parts = value.split(",").map((s) => parseInt(s.trim()));
+              if (parts.length >= 4) {
+                region.offsets = { x: parts[0], y: parts[1], width: parts[2], height: parts[3] };
+              }
+              break;
             }
+            case "rotate":
+              region.rotate = value === "true" || value === "90" ? true : value === "270" ? 270 : value === "180" ? 180 : false;
+              break;
+            case "index":
+              region.index = parseInt(value);
+              break;
+          }
+          i++;
         }
-        return atlas;
-    }
-    // ----------------------------------------
-    // Utilities
-    // ----------------------------------------
-    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');
+      } else {
+        i++;
+      }
     }
-    extractFileName(path) {
-        const name = path.substring(path.lastIndexOf('/') + 1);
-        const dotIndex = name.lastIndexOf('.');
-        return dotIndex > 0 ? name.substring(0, dotIndex) : name;
+    return atlas;
+  }
+  // ----------------------------------------
+  // Utilities
+  // ----------------------------------------
+  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");
+  }
+  extractFileName(path) {
+    const name = path.substring(path.lastIndexOf("/") + 1);
+    const dotIndex = name.lastIndexOf(".");
+    return dotIndex > 0 ? name.substring(0, dotIndex) : name;
+  }
 }
-// ============================================================
-// Factory Function
-// ============================================================
 function createSpineImporter() {
-    return new SpineImporter();
+  return new SpineImporter();
 }
-
 exports.SpineImporter = SpineImporter;
 exports.createSpineImporter = createSpineImporter;