diff --git a/src/core/abstractions/AnimatedSprite/Atlas.ts b/src/core/abstractions/AnimatedSprite/Atlas.ts
index d88007cf..08d07968 100644
--- a/src/core/abstractions/AnimatedSprite/Atlas.ts
+++ b/src/core/abstractions/AnimatedSprite/Atlas.ts
@@ -1,118 +1,120 @@
-import type { Texture } from "three";
-import { TextureLoader } from "three";
-import { useLoader, useLogger } from "@tresjs/core";
-import { getNumbersFromEnd, stripUnderscoresNumbersFromEnd } from "./StringOps";
-import { expand } from "./AtlasAnimationDefinitionParser";
+import type { Texture } from 'three'
+import { TextureLoader } from 'three'
+import { useLoader, useLogger } from '@tresjs/core'
+import { getNumbersFromEnd, stripUnderscoresNumbersFromEnd } from './StringOps'
+import { expand } from './AtlasAnimationDefinitionParser'
 
 export interface AtlasFrame {
-  name: string;
-  width: number;
-  height: number;
-  offsetX: number;
-  offsetY: number;
-  repeatX: number;
-  repeatY: number;
+  name: string
+  width: number
+  height: number
+  offsetX: number
+  offsetY: number
+  repeatX: number
+  repeatY: number
 }
 
 export interface AtlasPage {
-  frames: AtlasFrame[];
-  namedFrames: Record<string, AtlasFrame[]>;
-  texture: Texture;
+  frames: AtlasFrame[]
+  namedFrames: Record<string, AtlasFrame[]>
+  texture: Texture
 }
 
 export async function getAtlasPageAsync(
   atlas:
-    | string
-    | number
-    | [number, number]
-    | string[]
-    | TexturePackerFrameDataArray
-    | TexturePackerFrameDataObject,
+  | string
+  | number
+  | [number, number]
+  | string[]
+  | TexturePackerFrameDataArray
+  | TexturePackerFrameDataObject,
   image: string,
-  definitions?: Record<string, string>
+  definitions?: Record<string, string>,
 ): Promise<AtlasPage> {
-  const texturePromise = useLoader(TextureLoader, image);
-  const atlasPromise =
-    typeof atlas === "string"
+  const texturePromise = useLoader(TextureLoader, image)
+  const atlasPromise
+    = typeof atlas === 'string'
       ? fetch(atlas)
-          .then((response) => response.json())
-          .catch((e) => useLogger().logError(`Cientos Atlas - ${e}`))
-      : new Promise((resolve) => resolve(atlas));
+        .then(response => response.json())
+        .catch(e => useLogger().logError(`Cientos Atlas - ${e}`))
+      : new Promise(resolve => resolve(atlas))
 
   const pagePromise = Promise.all([atlasPromise, texturePromise]).then(
     (response) => {
-      const texture: Texture = response[1];
+      const texture: Texture = response[1]
       const processingFn = (() => {
-        if (typeof atlas === "string" || atlas.hasOwnProperty("frames")) {
-          return framesFromTexturePackerData;
-        } else if (
-          typeof atlas === "number" ||
-          (Array.isArray(atlas) &&
-            atlas.length === 2 &&
-            typeof atlas[0] === "number")
+        if (typeof atlas === 'string' || atlas.hasOwnProperty('frames')) {
+          return framesFromTexturePackerData
+        }
+        else if (
+          typeof atlas === 'number'
+          || (Array.isArray(atlas)
+            && atlas.length === 2
+            && typeof atlas[0] === 'number')
         ) {
-          return framesFromNumColsNumRowsWidthHeight;
-        } else {
-          return framesFromAnimationNamesWidthHeight;
+          return framesFromNumColsNumRowsWidthHeight
         }
-      })();
+        else {
+          return framesFromAnimationNamesWidthHeight
+        }
+      })()
       const frames = processingFn(
         response[0],
         texture.image.width,
-        texture.image.height
-      );
-      const namedFrames = groupFramesByKey(frames);
-      texture.matrixAutoUpdate = false;
-      const page: AtlasPage = { frames, namedFrames, texture };
+        texture.image.height,
+      )
+      const namedFrames = groupFramesByKey(frames)
+      texture.matrixAutoUpdate = false
+      const page: AtlasPage = { frames, namedFrames, texture }
       if (definitions) {
-        setDefinitions(page, definitions);
+        setDefinitions(page, definitions)
       }
-      return page;
-    }
-  );
+      return page
+    },
+  )
 
-  return pagePromise;
+  return pagePromise
 }
 
 export interface TexturePackerFrameData {
-  filename: string;
-  frame: { x: number; y: number; w: number; h: number };
+  filename: string
+  frame: { x: number; y: number; w: number; h: number }
 }
 
 export interface TexturePackerFrameDataArray {
-  frames: TexturePackerFrameData[];
+  frames: TexturePackerFrameData[]
 }
 
 export interface TexturePackerFrameDataObject {
-  frames: Record<string, TexturePackerFrameData>;
+  frames: Record<string, TexturePackerFrameData>
 }
 
 function framesFromTexturePackerData(
   data: TexturePackerFrameDataArray | TexturePackerFrameDataObject,
   width: number,
-  height: number
+  height: number,
 ) {
   return Array.isArray(data.frames)
     ? framesFromTexturePackerDataArray(
-        data as TexturePackerFrameDataArray,
-        width,
-        height
-      )
+      data as TexturePackerFrameDataArray,
+      width,
+      height,
+    )
     : framesFromTexturePackerDataObject(
-        data as TexturePackerFrameDataObject,
-        width,
-        height
-      );
+      data as TexturePackerFrameDataObject,
+      width,
+      height,
+    )
 }
 
 function framesFromTexturePackerDataArray(
   data: TexturePackerFrameDataArray,
   width: number,
-  height: number
+  height: number,
 ): AtlasFrame[] {
-  const invWidth = 1 / width;
-  const invHeight = 1 / height;
-  return data.frames.map((d) => ({
+  const invWidth = 1 / width
+  const invHeight = 1 / height
+  return data.frames.map(d => ({
     name: d.filename,
     offsetX: d.frame.x * invWidth,
     offsetY: 1 - (d.frame.y + d.frame.h) * invHeight,
@@ -120,16 +122,16 @@ function framesFromTexturePackerDataArray(
     repeatY: d.frame.h * invHeight,
     width: d.frame.w,
     height: d.frame.h,
-  }));
+  }))
 }
 
 function framesFromTexturePackerDataObject(
   data: TexturePackerFrameDataObject,
   width: number,
-  height: number
+  height: number,
 ): AtlasFrame[] {
-  const invWidth = 1 / width;
-  const invHeight = 1 / height;
+  const invWidth = 1 / width
+  const invHeight = 1 / height
   return Object.entries(data.frames).map(([k, v]) => ({
     name: k,
     offsetX: v.frame.x * invWidth,
@@ -138,91 +140,90 @@ function framesFromTexturePackerDataObject(
     repeatY: v.frame.h * invHeight,
     width: v.frame.w,
     height: v.frame.h,
-  }));
+  }))
 }
 
 function framesFromNumColsNumRowsWidthHeight(
   numColsOrNumColsNumRows: number | [number, number],
   width: number,
   height: number,
-  name = "default"
+  name = 'default',
 ): AtlasFrame[] {
   const [numCols, numRows] = Array.isArray(numColsOrNumColsNumRows)
     ? numColsOrNumColsNumRows
-    : [numColsOrNumColsNumRows, 1];
-  const frameWidth = width / numCols;
-  const frameHeight = height / numRows;
-  const padAmount = (numCols * numRows).toString().length;
-  const repeatX = 1 / numCols;
-  const repeatY = 1 / numRows;
-  const result: AtlasFrame[] = [];
+    : [numColsOrNumColsNumRows, 1]
+  const frameWidth = width / numCols
+  const frameHeight = height / numRows
+  const padAmount = (numCols * numRows).toString().length
+  const repeatX = 1 / numCols
+  const repeatY = 1 / numRows
+  const result: AtlasFrame[] = []
 
   let i = 0
-  for (let row = numRows-1; row >= 0; row--) {
+  for (let row = numRows - 1; row >= 0; row--) {
     for (let col = 0; col < numCols; col++) {
       i++
       result.push({
-        name: name + String(i).padStart(padAmount, "0"),
+        name: name + String(i).padStart(padAmount, '0'),
         offsetX: col * repeatX,
         offsetY: row * repeatY,
         repeatX,
         repeatY,
         width: frameWidth,
         height: frameHeight,
-      });
+      })
     }
   }
-  console.log(result)
-  return result;
+  return result
 }
 
 function framesFromAnimationNamesWidthHeight(
   animationNames: string[],
   width: number,
-  height: number
+  height: number,
 ): AtlasFrame[] {
-  const numCols = animationNames.length;
-  const frames = framesFromNumColsNumRowsWidthHeight(numCols, width, height);
-  const padAmount = numCols.toString().length;
+  const numCols = animationNames.length
+  const frames = framesFromNumColsNumRowsWidthHeight(numCols, width, height)
+  const padAmount = numCols.toString().length
   animationNames.forEach((name, i) => {
-    frames[i].name = `${name}_${String(i).padStart(padAmount, "0")}`;
-  });
-  return frames;
+    frames[i].name = `${name}_${String(i).padStart(padAmount, '0')}`
+  })
+  return frames
 }
 
 function setDefinitions(page: AtlasPage, definitions: Record<string, string>) {
   for (const [animationName, definitionStr] of Object.entries(definitions)) {
-    const frames: AtlasFrame[] = getFrames(page, animationName);
-    const expanded = expand(definitionStr);
+    const frames: AtlasFrame[] = getFrames(page, animationName)
+    const expanded = expand(definitionStr)
     for (const i of expanded) {
       if (i < 0 || frames.length <= i) {
         useLogger().logError(
-          `Cientos Atlas: Attempting to access frame index ${i} in animation ${animationName}, but it does not exist.`
-        );
+          `Cientos Atlas: Attempting to access frame index ${i} in animation ${animationName}, but it does not exist.`,
+        )
       }
     }
-    page.namedFrames[animationName] = expanded.map((i) => frames[i]);
+    page.namedFrames[animationName] = expanded.map(i => frames[i])
   }
 }
 
 export function getFrames(
   page: AtlasPage,
-  animationNameOrFrameNumber: string | number | [number, number]
+  animationNameOrFrameNumber: string | number | [number, number],
 ): AtlasFrame[] {
-  if (typeof animationNameOrFrameNumber === "string")
-    return getFramesByName(page, animationNameOrFrameNumber);
-  else if (typeof animationNameOrFrameNumber === "number")
+  if (typeof animationNameOrFrameNumber === 'string')
+    return getFramesByName(page, animationNameOrFrameNumber)
+  else if (typeof animationNameOrFrameNumber === 'number')
     return getFramesByIndices(
       page,
       animationNameOrFrameNumber,
-      animationNameOrFrameNumber
-    );
+      animationNameOrFrameNumber,
+    )
   else {
     return getFramesByIndices(
       page,
       animationNameOrFrameNumber[0],
-      animationNameOrFrameNumber[1]
-    );
+      animationNameOrFrameNumber[1],
+    )
   }
 }
 
@@ -230,35 +231,35 @@ function getFramesByName(page: AtlasPage, name: string): AtlasFrame[] {
   if (!(name in page.namedFrames)) {
     useLogger().logError(
       `Cientos Atlas: getFramesByName – name ${name} does not exist in page. Available names: ${Object.keys(
-        page
-      )}`
-    );
+        page,
+      )}`,
+    )
   }
-  return page.namedFrames[name];
+  return page.namedFrames[name]
 }
 
 function getFramesByIndices(
   page: AtlasPage,
   startI: number,
-  endI: number
+  endI: number,
 ): AtlasFrame[] {
   if (
-    startI < 0 ||
-    page.frames.length <= startI ||
-    endI < 0 ||
-    page.frames.length <= endI
+    startI < 0
+    || page.frames.length <= startI
+    || endI < 0
+    || page.frames.length <= endI
   ) {
     useLogger().logError(
-      `Cientos Atlas: getFramesByIndex – [${startI}, ${endI}] is out of bounds.`
-    );
+      `Cientos Atlas: getFramesByIndex – [${startI}, ${endI}] is out of bounds.`,
+    )
   }
-  const result = [];
-  const sign = Math.sign(endI - startI);
-  if (sign === 0) return [page.frames[startI]];
+  const result = []
+  const sign = Math.sign(endI - startI)
+  if (sign === 0) return [page.frames[startI]]
   for (let i = startI; i !== endI + sign; i += sign) {
-    result.push(page.frames[i]);
+    result.push(page.frames[i])
   }
-  return result;
+  return result
 }
 
 /**
@@ -276,22 +277,23 @@ function getFramesByIndices(
  * ```
  */
 function groupFramesByKey(frames: AtlasFrame[]): Record<string, AtlasFrame[]> {
-  const result: Record<string, AtlasFrame[]> = {};
+  const result: Record<string, AtlasFrame[]> = {}
 
   for (const frame of frames) {
     if (getNumbersFromEnd(frame.name) !== null) {
-      const key = stripUnderscoresNumbersFromEnd(frame.name);
+      const key = stripUnderscoresNumbersFromEnd(frame.name)
       if (result.hasOwnProperty(key)) {
-        result[key].push(frame);
-      } else {
-        result[key] = [frame];
+        result[key].push(frame)
+      }
+      else {
+        result[key] = [frame]
       }
     }
   }
 
   for (const entry of Object.values(result)) {
-    entry.sort((a, b) => a.name.localeCompare(b.name));
+    entry.sort((a, b) => a.name.localeCompare(b.name))
   }
 
-  return result;
+  return result
 }