@nice2dev/game-engine 1.3.14 → 1.3.16

package/dist/cjs/import/DragonBonesImporter.js

@@ -1,494 +1,470 @@
-'use strict';
-
-var SceneImporter = require('./SceneImporter.js');
-
-/**
- * @file DragonBonesImporter.ts
- * @description DragonBones Skeletal Animation Importer
- * PRO-1.3: Scene Format Interoperability
- *
- * DragonBones is a free, open-source 2D skeletal animation tool.
- *
- * File Types:
- * - *_ske.json - Skeleton data
- * - *_tex.json - Texture atlas data
- * - *_tex.png - Texture image
- */
-// ============================================================
-// DragonBones 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 DragonBonesImporter extends SceneImporter.SceneImporter {
-    constructor() {
-        super('dragonbones');
-        this.textureAtlas = null;
-    }
-    canHandle(filePath) {
-        const name = filePath.toLowerCase();
-        return name.endsWith('_ske.json') || name.endsWith('_tex.json') || name.endsWith('.dbbin');
-    }
-    async import(options) {
-        const startTime = Date.now();
-        this.options = options;
-        this.clearMessages();
-        const scenes = [];
-        const assets = [];
-        try {
-            const fileName = options.sourcePath.toLowerCase();
-            const content = await this.readFile(options.sourcePath);
-            if (fileName.endsWith('_tex.json')) {
-                // Parse texture atlas
-                this.textureAtlas = JSON.parse(content);
-                // Create texture asset
-                assets.push({
+  constructor() {
+    super("dragonbones");
+    this.textureAtlas = null;
+  }
+  canHandle(filePath) {
+    const name = filePath.toLowerCase();
+    return name.endsWith("_ske.json") || name.endsWith("_tex.json") || name.endsWith(".dbbin");
+  }
+  async import(options) {
+    const startTime = Date.now();
+    this.options = options;
+    this.clearMessages();
+    const scenes = [];
+    const assets = [];
+    try {
+      const fileName = options.sourcePath.toLowerCase();
+      const content = await this.readFile(options.sourcePath);
+      if (fileName.endsWith("_tex.json")) {
+        this.textureAtlas = JSON.parse(content);
+        assets.push({
+          id: this.generateId(),
+          name: this.textureAtlas.name,
+          type: "texture",
+          path: this.textureAtlas.imagePath,
+          data: {
+            width: this.textureAtlas.width,
+            height: this.textureAtlas.height
+          }
+        });
+        for (const subTex of this.textureAtlas.SubTexture) {
+          assets.push({
+            id: this.generateId(),
+            name: subTex.name,
+            type: "texture",
+            path: this.textureAtlas.imagePath,
+            data: {
+              frame: { x: subTex.x, y: subTex.y, width: subTex.width, height: subTex.height },
+              sourceSize: subTex.frameWidth && subTex.frameHeight ? { width: subTex.frameWidth, height: subTex.frameHeight } : void 0,
+              offset: subTex.frameX !== void 0 ? { x: subTex.frameX, y: subTex.frameY || 0 } : void 0
+            }
+          });
+        }
+      } else if (fileName.endsWith("_ske.json")) {
+        const skeleton = JSON.parse(content);
+        if (options.resolveDependencies) {
+          const texPath = options.sourcePath.replace("_ske.json", "_tex.json");
+          try {
+            const texContent = await this.readFile(texPath);
+            this.textureAtlas = JSON.parse(texContent);
+          } catch {
+            this.addWarning("TEX_NOT_FOUND", "Texture atlas not found", texPath);
+          }
+        }
+        for (const armature of skeleton.armature) {
+          const scene = this.convertArmatureToScene(armature, skeleton);
+          scenes.push(scene);
+          for (const skin of armature.skin) {
+            for (const slot of skin.slot) {
+              for (const display of slot.display) {
+                if (display.type === "image" || !display.type) {
+                  const imageDisplay = display;
+                  assets.push({
                     id: this.generateId(),
-                    name: this.textureAtlas.name,
-                    type: 'texture',
-                    path: this.textureAtlas.imagePath,
+                    name: imageDisplay.path || imageDisplay.name,
+                    type: "texture",
+                    path: imageDisplay.path || imageDisplay.name,
                     data: {
-                        width: this.textureAtlas.width,
-                        height: this.textureAtlas.height,
-                    },
-                });
-                // Create subtexture assets
-                for (const subTex of this.textureAtlas.SubTexture) {
-                    assets.push({
-                        id: this.generateId(),
-                        name: subTex.name,
-                        type: 'texture',
-                        path: this.textureAtlas.imagePath,
-                        data: {
-                            frame: { x: subTex.x, y: subTex.y, width: subTex.width, height: subTex.height },
-                            sourceSize: subTex.frameWidth && subTex.frameHeight
-                                ? { width: subTex.frameWidth, height: subTex.frameHeight }
-                                : undefined,
-                            offset: subTex.frameX !== undefined
-                                ? { x: subTex.frameX, y: subTex.frameY || 0 }
-                                : undefined,
-                        },
-                    });
-                }
-            }
-            else if (fileName.endsWith('_ske.json')) {
-                // Parse skeleton data
-                const skeleton = JSON.parse(content);
-                // Try to load texture atlas
-                if (options.resolveDependencies) {
-                    const texPath = options.sourcePath.replace('_ske.json', '_tex.json');
-                    try {
-                        const texContent = await this.readFile(texPath);
-                        this.textureAtlas = JSON.parse(texContent);
-                    }
-                    catch {
-                        this.addWarning('TEX_NOT_FOUND', 'Texture atlas not found', texPath);
-                    }
-                }
-                // Convert each armature to a scene
-                for (const armature of skeleton.armature) {
-                    const scene = this.convertArmatureToScene(armature, skeleton);
-                    scenes.push(scene);
-                    // Extract display assets
-                    for (const skin of armature.skin) {
-                        for (const slot of skin.slot) {
-                            for (const display of slot.display) {
-                                if (display.type === 'image' || !display.type) {
-                                    const imageDisplay = display;
-                                    assets.push({
-                                        id: this.generateId(),
-                                        name: imageDisplay.path || imageDisplay.name,
-                                        type: 'texture',
-                                        path: imageDisplay.path || imageDisplay.name,
-                                        data: {
-                                            pivot: imageDisplay.pivot,
-                                        },
-                                    });
-                                }
-                            }
-                        }
+                      pivot: imageDisplay.pivot
                     }
+                  });
                 }
+              }
             }
+          }
         }
-        catch (error) {
-            this.addError('IMPORT_ERROR', `Failed to import: ${error}`, options.sourcePath, undefined, true);
-        }
-        return this.createResult(scenes, assets, startTime);
+      }
+    } catch (error) {
+      this.addError(
+        "IMPORT_ERROR",
+        `Failed to import: ${error}`,
+        options.sourcePath,
+        void 0,
+        true
+      );
     }
-    async parseFile(content, filePath) {
-        const stringContent = typeof content === 'string' ? content : new TextDecoder().decode(content);
-        try {
-            if (filePath.toLowerCase().endsWith('_tex.json')) {
-                return null; // Texture files don't produce scenes
-            }
-            const skeleton = JSON.parse(stringContent);
-            if (skeleton.armature && skeleton.armature.length > 0) {
-                return this.convertArmatureToParsed(skeleton.armature[0], skeleton);
-            }
-        }
-        catch {
-            return null;
-        }
+    return this.createResult(scenes, assets, startTime);
+  }
+  async parseFile(content, filePath) {
+    const stringContent = typeof content === "string" ? content : new TextDecoder().decode(content);
+    try {
+      if (filePath.toLowerCase().endsWith("_tex.json")) {
         return null;
+      }
+      const skeleton = JSON.parse(stringContent);
+      if (skeleton.armature && skeleton.armature.length > 0) {
+        return this.convertArmatureToParsed(skeleton.armature[0], 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 DragonBones file`,
-                file: sourcePath,
-                fatal: true,
-            });
-        }
-        return errors;
+    return null;
+  }
+  async validate(sourcePath) {
+    const errors = [];
+    if (!this.canHandle(sourcePath)) {
+      errors.push({
+        code: "INVALID_FORMAT",
+        message: `File ${sourcePath} is not a valid DragonBones file`,
+        file: sourcePath,
+        fatal: true
+      });
     }
-    // ----------------------------------------
-    // Armature Conversion
-    // ----------------------------------------
-    convertArmatureToScene(armature, skeleton) {
-        const entities = [];
-        // Create root entity
-        const rootEntity = {
-            id: this.generateId(),
-            name: armature.name,
-            components: [
-                {
-                    type: 'Transform',
-                    data: {
-                        position: { x: 0, y: 0 },
-                        rotation: 0,
-                        scale: { x: 1, y: 1 },
-                    },
-                },
-                {
-                    type: 'DragonBonesArmature',
-                    data: {
-                        version: skeleton.version,
-                        frameRate: armature.frameRate || skeleton.frameRate,
-                        aabb: armature.aabb,
-                        skins: armature.skin.map((s) => s.name),
-                        animations: armature.animation.map((a) => a.name),
-                    },
-                },
-            ],
-            children: [],
-            tags: ['dragonbones', 'armature'],
-            active: true,
-        };
-        // Create bone hierarchy
-        rootEntity.children = this.createBoneHierarchy(armature.bone);
-        // Add slots
-        for (const slot of armature.slot) {
-            this.addSlotToEntity(rootEntity, slot, armature);
+    return errors;
+  }
+  // ----------------------------------------
+  // Armature Conversion
+  // ----------------------------------------
+  convertArmatureToScene(armature, skeleton) {
+    const entities = [];
+    const rootEntity = {
+      id: this.generateId(),
+      name: armature.name,
+      components: [
+        {
+          type: "Transform",
+          data: {
+            position: { x: 0, y: 0 },
+            rotation: 0,
+            scale: { x: 1, y: 1 }
+          }
+        },
+        {
+          type: "DragonBonesArmature",
+          data: {
+            version: skeleton.version,
+            frameRate: armature.frameRate || skeleton.frameRate,
+            aabb: armature.aabb,
+            skins: armature.skin.map((s) => s.name),
+            animations: armature.animation.map((a) => a.name)
+          }
         }
-        // Add IK constraints
-        if (armature.ik) {
-            for (const ik of armature.ik) {
-                rootEntity.components.push({
-                    type: 'IKConstraint',
-                    data: {
-                        name: ik.name,
-                        bone: ik.bone,
-                        target: ik.target,
-                        chain: ik.chain ?? 0,
-                        bendPositive: ik.bendPositive ?? true,
-                        weight: ik.weight ?? 1,
-                    },
-                });
-            }
-        }
-        // Add animations
-        for (const anim of armature.animation) {
-            rootEntity.components.push({
-                type: 'Animation',
-                data: this.convertAnimation(anim, armature.frameRate || skeleton.frameRate),
-            });
-        }
-        entities.push(rootEntity);
-        return {
-            id: this.generateId(),
-            name: armature.name,
-            entities,
-            settings: {
-                width: armature.aabb.width,
-                height: armature.aabb.height,
-                backgroundColor: '#1a1a2e',
-                frameRate: armature.frameRate || skeleton.frameRate,
-            },
-        };
+      ],
+      children: [],
+      tags: ["dragonbones", "armature"],
+      active: true
+    };
+    rootEntity.children = this.createBoneHierarchy(armature.bone);
+    for (const slot of armature.slot) {
+      this.addSlotToEntity(rootEntity, slot, armature);
+    }
+    if (armature.ik) {
+      for (const ik of armature.ik) {
+        rootEntity.components.push({
+          type: "IKConstraint",
+          data: {
+            name: ik.name,
+            bone: ik.bone,
+            target: ik.target,
+            chain: ik.chain ?? 0,
+            bendPositive: ik.bendPositive ?? true,
+            weight: ik.weight ?? 1
+          }
+        });
+      }
     }
-    convertArmatureToParsed(armature, skeleton) {
-        const entities = [];
-        // Create bone entities
-        for (const bone of armature.bone) {
-            entities.push({
-                id: bone.name,
-                name: bone.name,
-                type: 'Bone',
-                x: bone.transform?.x || 0,
-                y: bone.transform?.y || 0,
-                width: bone.length || 0,
-                height: 4,
-                rotation: bone.transform?.skX || 0,
-                scaleX: bone.transform?.scX ?? 1,
-                scaleY: bone.transform?.scY ?? 1,
-                visible: true,
-                components: [],
-                children: [],
-                properties: {
-                    parent: bone.parent,
-                    length: bone.length,
-                    skewY: bone.transform?.skY,
-                },
-            });
+    for (const anim of armature.animation) {
+      rootEntity.components.push({
+        type: "Animation",
+        data: this.convertAnimation(anim, armature.frameRate || skeleton.frameRate)
+      });
+    }
+    entities.push(rootEntity);
+    return {
+      id: this.generateId(),
+      name: armature.name,
+      entities,
+      settings: {
+        width: armature.aabb.width,
+        height: armature.aabb.height,
+        backgroundColor: "#1a1a2e",
+        frameRate: armature.frameRate || skeleton.frameRate
+      }
+    };
+  }
+  convertArmatureToParsed(armature, skeleton) {
+    const entities = [];
+    for (const bone of armature.bone) {
+      entities.push({
+        id: bone.name,
+        name: bone.name,
+        type: "Bone",
+        x: bone.transform?.x || 0,
+        y: bone.transform?.y || 0,
+        width: bone.length || 0,
+        height: 4,
+        rotation: bone.transform?.skX || 0,
+        scaleX: bone.transform?.scX ?? 1,
+        scaleY: bone.transform?.scY ?? 1,
+        visible: true,
+        components: [],
+        children: [],
+        properties: {
+          parent: bone.parent,
+          length: bone.length,
+          skewY: bone.transform?.skY
         }
-        // Create slot entities
-        for (const slot of armature.slot) {
-            entities.push({
-                id: slot.name,
-                name: slot.name,
-                type: 'Slot',
-                x: 0,
-                y: 0,
-                width: 32,
-                height: 32,
-                rotation: 0,
-                scaleX: 1,
-                scaleY: 1,
-                visible: true,
-                components: [],
-                children: [],
-                properties: {
-                    bone: slot.parent,
-                    displayIndex: slot.displayIndex,
-                    blendMode: slot.blendMode,
-                    color: slot.color,
-                },
-            });
+      });
+    }
+    for (const slot of armature.slot) {
+      entities.push({
+        id: slot.name,
+        name: slot.name,
+        type: "Slot",
+        x: 0,
+        y: 0,
+        width: 32,
+        height: 32,
+        rotation: 0,
+        scaleX: 1,
+        scaleY: 1,
+        visible: true,
+        components: [],
+        children: [],
+        properties: {
+          bone: slot.parent,
+          displayIndex: slot.displayIndex,
+          blendMode: slot.blendMode,
+          color: slot.color
         }
-        return {
-            name: armature.name,
-            width: armature.aabb.width,
-            height: armature.aabb.height,
-            backgroundColor: '#1a1a2e',
-            layers: [
-                {
-                    name: 'Armature',
-                    type: 'object',
-                    visible: true,
-                    opacity: 1,
-                    offsetX: 0,
-                    offsetY: 0,
-                    zIndex: 0,
-                    properties: {},
-                },
-            ],
-            entities,
-            properties: {
-                version: skeleton.version,
-                frameRate: armature.frameRate || skeleton.frameRate,
-                animations: armature.animation.map((a) => a.name),
-                skins: armature.skin.map((s) => s.name),
-            },
-        };
+      });
     }
-    // ----------------------------------------
-    // Bone Hierarchy
-    // ----------------------------------------
-    createBoneHierarchy(bones) {
-        const boneMap = new Map();
-        const rootBones = [];
-        // Create all bone entities first
-        for (const bone of bones) {
-            const transform = bone.transform || {};
-            const entity = {
-                id: bone.name,
-                name: bone.name,
-                components: [
-                    {
-                        type: 'Transform',
-                        data: {
-                            position: { x: transform.x || 0, y: transform.y || 0 },
-                            rotation: transform.skX || 0,
-                            scale: { x: transform.scX ?? 1, y: transform.scY ?? 1 },
-                        },
-                    },
-                    {
-                        type: 'Bone',
-                        data: {
-                            length: bone.length || 0,
-                            skewY: transform.skY || 0,
-                            inheritTranslation: bone.inheritTranslation ?? true,
-                            inheritRotation: bone.inheritRotation ?? true,
-                            inheritScale: bone.inheritScale ?? true,
-                        },
-                    },
-                ],
-                children: [],
-                tags: ['bone'],
-                active: true,
-            };
-            boneMap.set(bone.name, entity);
+    return {
+      name: armature.name,
+      width: armature.aabb.width,
+      height: armature.aabb.height,
+      backgroundColor: "#1a1a2e",
+      layers: [
+        {
+          name: "Armature",
+          type: "object",
+          visible: true,
+          opacity: 1,
+          offsetX: 0,
+          offsetY: 0,
+          zIndex: 0,
+          properties: {}
         }
-        // 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);
-                }
+      ],
+      entities,
+      properties: {
+        version: skeleton.version,
+        frameRate: armature.frameRate || skeleton.frameRate,
+        animations: armature.animation.map((a) => a.name),
+        skins: armature.skin.map((s) => s.name)
+      }
+    };
+  }
+  // ----------------------------------------
+  // Bone Hierarchy
+  // ----------------------------------------
+  createBoneHierarchy(bones) {
+    const boneMap = /* @__PURE__ */ new Map();
+    const rootBones = [];
+    for (const bone of bones) {
+      const transform = bone.transform || {};
+      const entity = {
+        id: bone.name,
+        name: bone.name,
+        components: [
+          {
+            type: "Transform",
+            data: {
+              position: { x: transform.x || 0, y: transform.y || 0 },
+              rotation: transform.skX || 0,
+              scale: { x: transform.scX ?? 1, y: transform.scY ?? 1 }
             }
-            else {
-                rootBones.push(entity);
+          },
+          {
+            type: "Bone",
+            data: {
+              length: bone.length || 0,
+              skewY: transform.skY || 0,
+              inheritTranslation: bone.inheritTranslation ?? true,
+              inheritRotation: bone.inheritRotation ?? true,
+              inheritScale: bone.inheritScale ?? true
             }
-        }
-        return rootBones;
+          }
+        ],
+        children: [],
+        tags: ["bone"],
+        active: true
+      };
+      boneMap.set(bone.name, entity);
     }
-    addSlotToEntity(rootEntity, slot, armature) {
-        // Find the bone entity
-        const boneEntity = this.findBoneEntity(rootEntity, slot.parent);
-        if (!boneEntity) {
-            return;
-        }
-        // Get display from default skin
-        const defaultSkin = armature.skin.find((s) => s.name === 'default') || armature.skin[0];
-        const skinSlot = defaultSkin?.slot.find((s) => s.name === slot.name);
-        const defaultDisplay = skinSlot?.display[slot.displayIndex ?? 0];
-        const slotData = {
-            name: slot.name,
-            bone: slot.parent,
-            displayIndex: slot.displayIndex ?? 0,
-            blendMode: slot.blendMode || 'normal',
-        };
-        if (slot.color) {
-            slotData.color = this.convertColor(slot.color);
+    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);
+      }
+    }
+    return rootBones;
+  }
+  addSlotToEntity(rootEntity, slot, armature) {
+    const boneEntity = this.findBoneEntity(rootEntity, slot.parent);
+    if (!boneEntity) {
+      return;
+    }
+    const defaultSkin = armature.skin.find((s) => s.name === "default") || armature.skin[0];
+    const skinSlot = defaultSkin?.slot.find((s) => s.name === slot.name);
+    const defaultDisplay = skinSlot?.display[slot.displayIndex ?? 0];
+    const slotData = {
+      name: slot.name,
+      bone: slot.parent,
+      displayIndex: slot.displayIndex ?? 0,
+      blendMode: slot.blendMode || "normal"
+    };
+    if (slot.color) {
+      slotData.color = this.convertColor(slot.color);
+    }
+    boneEntity.components.push({
+      type: "Slot",
+      data: slotData
+    });
+    if (defaultDisplay) {
+      if (defaultDisplay.type === "mesh") {
+        const meshDisplay = defaultDisplay;
         boneEntity.components.push({
-            type: 'Slot',
-            data: slotData,
+          type: "Mesh",
+          data: {
+            name: meshDisplay.name,
+            path: meshDisplay.path,
+            vertices: meshDisplay.vertices,
+            uvs: meshDisplay.uvs,
+            triangles: meshDisplay.triangles,
+            weights: meshDisplay.weights,
+            transform: meshDisplay.transform
+          }
         });
-        // Add display component
-        if (defaultDisplay) {
-            if (defaultDisplay.type === 'mesh') {
-                const meshDisplay = defaultDisplay;
-                boneEntity.components.push({
-                    type: 'Mesh',
-                    data: {
-                        name: meshDisplay.name,
-                        path: meshDisplay.path,
-                        vertices: meshDisplay.vertices,
-                        uvs: meshDisplay.uvs,
-                        triangles: meshDisplay.triangles,
-                        weights: meshDisplay.weights,
-                        transform: meshDisplay.transform,
-                    },
-                });
-            }
-            else if (defaultDisplay.type === 'boundingBox') {
-                const bbDisplay = defaultDisplay;
-                boneEntity.components.push({
-                    type: 'BoundingBox',
-                    data: {
-                        name: bbDisplay.name,
-                        subType: bbDisplay.subType || 'rectangle',
-                        width: bbDisplay.width,
-                        height: bbDisplay.height,
-                        vertices: bbDisplay.vertices,
-                    },
-                });
-            }
-            else {
-                const imageDisplay = defaultDisplay;
-                boneEntity.components.push({
-                    type: 'Sprite',
-                    data: {
-                        name: imageDisplay.name,
-                        path: imageDisplay.path || imageDisplay.name,
-                        pivot: imageDisplay.pivot,
-                        transform: imageDisplay.transform,
-                    },
-                });
-            }
-        }
+      } else if (defaultDisplay.type === "boundingBox") {
+        const bbDisplay = defaultDisplay;
+        boneEntity.components.push({
+          type: "BoundingBox",
+          data: {
+            name: bbDisplay.name,
+            subType: bbDisplay.subType || "rectangle",
+            width: bbDisplay.width,
+            height: bbDisplay.height,
+            vertices: bbDisplay.vertices
+          }
+        });
+      } else {
+        const imageDisplay = defaultDisplay;
+        boneEntity.components.push({
+          type: "Sprite",
+          data: {
+            name: imageDisplay.name,
+            path: imageDisplay.path || imageDisplay.name,
+            pivot: imageDisplay.pivot,
+            transform: imageDisplay.transform
+          }
+        });
+      }
     }
-    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;
+  }
+  findBoneEntity(entity, boneName) {
+    if (entity.name === boneName) {
+      return entity;
     }
-    // ----------------------------------------
-    // Animation Conversion
-    // ----------------------------------------
-    convertAnimation(anim, frameRate) {
-        return {
-            name: anim.name,
-            duration: anim.duration / frameRate,
-            frameRate,
-            playTimes: anim.playTimes ?? 0,
-            fadeInTime: anim.fadeInTime ?? 0,
-            bones: anim.bone?.map((timeline) => ({
-                name: timeline.name,
-                translate: timeline.translateFrame,
-                rotate: timeline.rotateFrame,
-                scale: timeline.scaleFrame,
-                legacy: timeline.frame,
-            })),
-            slots: anim.slot?.map((timeline) => ({
-                name: timeline.name,
-                display: timeline.displayFrame,
-                color: timeline.colorFrame,
-                legacy: timeline.frame,
-            })),
-            ffd: anim.ffd,
-            ik: anim.ik,
-            zOrder: anim.zOrder,
-            events: anim.frame,
-        };
+    for (const child of entity.children ?? []) {
+      const found = this.findBoneEntity(child, boneName);
+      if (found) {
+        return found;
+      }
     }
-    // ----------------------------------------
-    // Utilities
-    // ----------------------------------------
-    convertColor(color) {
-        const r = Math.round(255 * (color.rM ?? 1) + (color.rO ?? 0));
-        const g = Math.round(255 * (color.gM ?? 1) + (color.gO ?? 0));
-        const b = Math.round(255 * (color.bM ?? 1) + (color.bO ?? 0));
-        const a = color.aM ?? 1;
-        if (a < 1) {
-            return `rgba(${r}, ${g}, ${b}, ${a})`;
-        }
-        return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`;
+    return null;
+  }
+  // ----------------------------------------
+  // Animation Conversion
+  // ----------------------------------------
+  convertAnimation(anim, frameRate) {
+    return {
+      name: anim.name,
+      duration: anim.duration / frameRate,
+      frameRate,
+      playTimes: anim.playTimes ?? 0,
+      fadeInTime: anim.fadeInTime ?? 0,
+      bones: anim.bone?.map((timeline) => ({
+        name: timeline.name,
+        translate: timeline.translateFrame,
+        rotate: timeline.rotateFrame,
+        scale: timeline.scaleFrame,
+        legacy: timeline.frame
+      })),
+      slots: anim.slot?.map((timeline) => ({
+        name: timeline.name,
+        display: timeline.displayFrame,
+        color: timeline.colorFrame,
+        legacy: timeline.frame
+      })),
+      ffd: anim.ffd,
+      ik: anim.ik,
+      zOrder: anim.zOrder,
+      events: anim.frame
+    };
+  }
+  // ----------------------------------------
+  // Utilities
+  // ----------------------------------------
+  convertColor(color) {
+    const r = Math.round(255 * (color.rM ?? 1) + (color.rO ?? 0));
+    const g = Math.round(255 * (color.gM ?? 1) + (color.gO ?? 0));
+    const b = Math.round(255 * (color.bM ?? 1) + (color.bO ?? 0));
+    const a = color.aM ?? 1;
+    if (a < 1) {
+      return `rgba(${r}, ${g}, ${b}, ${a})`;
     }
-    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');
+    return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+  }
+  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");
+  }
 }
-// ============================================================
-// Factory Function
-// ============================================================
 function createDragonBonesImporter() {
-    return new DragonBonesImporter();
+  return new DragonBonesImporter();
 }
-
 exports.DragonBonesImporter = DragonBonesImporter;
 exports.createDragonBonesImporter = createDragonBonesImporter;