@alepot55/chessboardjs 2.3.7 → 2.3.8

package/dist/chessboard.iife.js

@@ -127,7 +127,6 @@ var Chessboard = (function (exports) {
         invalid_fadeTime: 'Invalid fadeTime: ',
         invalid_fadeAnimation: 'Invalid fadeAnimation: ',
         invalid_ratio: 'Invalid ratio: ',
-        invalid_animationStyle: 'Invalid animationStyle: ',
         animation_failed: 'Animation failed: ',
         
         // Event handlers
@@ -349,7 +348,7 @@ var Chessboard = (function (exports) {
     }
 
     /**
-     * Service for input validation and data sanitization
+     * ValidationService - Handles input validation and data sanitization
      * @module services/ValidationService
      * @since 2.0.0
      */
@@ -379,7 +378,6 @@ var Chessboard = (function (exports) {
         movableColors: ['w', 'b', 'white', 'black', 'both', 'none'],
         dropOffBoard: ['snapback', 'trash'],
         easingTypes: ['linear', 'ease', 'ease-in', 'ease-out', 'ease-in-out'],
-        animationStyles: ['sequential', 'simultaneous'],
         modes: ['normal', 'creative', 'analysis'],
         promotionPieces: ['q', 'r', 'b', 'n', 'Q', 'R', 'B', 'N']
     });
@@ -399,45 +397,39 @@ var Chessboard = (function (exports) {
     /**
      * Service responsible for validating inputs and data
      * Implements caching for performance optimization
-     * @class
+     * @class ValidationService
      */
     class ValidationService {
         /**
-         * Creates a new ValidationService instance
+         * Create a new ValidationService instance
          */
         constructor() {
-            // Cache for validation results to improve performance
             this._validationCache = new Map();
             this._cacheMaxSize = 1000;
-            
-            // Compile patterns for reuse
             this._patterns = VALIDATION_PATTERNS;
             this._validValues = VALID_VALUES;
             this._constraints = SIZE_CONSTRAINTS;
         }
 
         /**
-         * Validates a square identifier with caching
+         * Validate a square identifier with caching
          * @param {string} square - Square to validate (e.g., 'e4')
          * @returns {boolean} True if valid
          */
         isValidSquare(square) {
             const cacheKey = `square:${square}`;
-            
             if (this._validationCache.has(cacheKey)) {
                 return this._validationCache.get(cacheKey);
             }
-            
-            const isValid = typeof square === 'string' && 
-                            square.length === 2 && 
-                            this._patterns.square.test(square);
-            
+            const isValid = typeof square === 'string' &&
+                square.length === 2 &&
+                this._patterns.square.test(square);
             this._cacheValidationResult(cacheKey, isValid);
             return isValid;
         }
 
         /**
-         * Validates a piece identifier with enhanced format support
+         * Validate a piece identifier with enhanced format support
          * @param {string} piece - Piece to validate (e.g., 'wK', 'bp')
          * @returns {boolean} True if valid
          */
@@ -445,28 +437,22 @@ var Chessboard = (function (exports) {
             if (typeof piece !== 'string' || piece.length !== 2) {
                 return false;
             }
-            
             const cacheKey = `piece:${piece}`;
-            
             if (this._validationCache.has(cacheKey)) {
                 return this._validationCache.get(cacheKey);
             }
-            
             const [first, second] = piece.split('');
-            
-            // Check both formats: [type][color] and [color][type]
-            const format1 = PIECE_TYPES.includes(first.toLowerCase()) && 
-                           PIECE_COLORS.includes(second);
-            const format2 = PIECE_COLORS.includes(first) && 
-                           PIECE_TYPES.includes(second.toLowerCase());
-            
+            const format1 = PIECE_TYPES.includes(first.toLowerCase()) &&
+                PIECE_COLORS.includes(second);
+            const format2 = PIECE_COLORS.includes(first) &&
+                PIECE_TYPES.includes(second.toLowerCase());
             const isValid = format1 || format2;
             this._cacheValidationResult(cacheKey, isValid);
             return isValid;
         }
 
         /**
-         * Validates a FEN string with comprehensive checks
+         * Validate a FEN string with comprehensive checks
          * @param {string} fen - FEN string to validate
          * @returns {boolean} True if valid
          */
@@ -474,86 +460,64 @@ var Chessboard = (function (exports) {
             if (typeof fen !== 'string') {
                 return false;
             }
-            
             const cacheKey = `fen:${fen}`;
-            
             if (this._validationCache.has(cacheKey)) {
                 return this._validationCache.get(cacheKey);
             }
-            
-            // Basic pattern check
             if (!this._patterns.fen.test(fen)) {
                 this._cacheValidationResult(cacheKey, false);
                 return false;
             }
-            
-            // Additional FEN validation
             const isValid = this._validateFenStructure(fen);
             this._cacheValidationResult(cacheKey, isValid);
             return isValid;
         }
 
         /**
-         * Validates FEN structure in detail
+         * Validate FEN structure in detail
          * @private
          * @param {string} fen - FEN string to validate
          * @returns {boolean} True if valid
          */
         _validateFenStructure(fen) {
             const parts = fen.split(' ');
-            
             if (parts.length !== 6) {
                 return false;
             }
-            
-            // Validate piece placement
             const ranks = parts[0].split('/');
             if (ranks.length !== 8) {
                 return false;
             }
-            
-            // Validate each rank
             for (const rank of ranks) {
                 if (!this._validateRank(rank)) {
                     return false;
                 }
             }
-            
-            // Validate active color
             if (!['w', 'b'].includes(parts[1])) {
                 return false;
             }
-            
-            // Validate castling rights
             if (!/^[KQkq-]*$/.test(parts[2])) {
                 return false;
             }
-            
-            // Validate en passant target
             if (parts[3] !== '-' && !this.isValidSquare(parts[3])) {
                 return false;
             }
-            
-            // Validate halfmove clock and fullmove number
             const halfmove = parseInt(parts[4], 10);
             const fullmove = parseInt(parts[5], 10);
-            
-            return !isNaN(halfmove) && !isNaN(fullmove) && 
-                   halfmove >= 0 && fullmove >= 1;
+            return !isNaN(halfmove) && !isNaN(fullmove) &&
+                halfmove >= 0 && fullmove >= 1;
         }
 
         /**
-         * Validates a single rank in FEN notation
+         * Validate a single rank in FEN notation
          * @private
          * @param {string} rank - Rank to validate
          * @returns {boolean} True if valid
          */
         _validateRank(rank) {
             let squares = 0;
-            
             for (let i = 0; i < rank.length; i++) {
                 const char = rank[i];
-                
                 if (/[1-8]/.test(char)) {
                     squares += parseInt(char, 10);
                 } else if (/[prnbqkPRNBQK]/.test(char)) {
@@ -562,12 +526,11 @@ var Chessboard = (function (exports) {
                     return false;
                 }
             }
-            
             return squares === 8;
         }
 
         /**
-         * Validates a move string with comprehensive format support
+         * Validate a move string with comprehensive format support
          * @param {string} move - Move string to validate (e.g., 'e2e4', 'e7e8q')
          * @returns {boolean} True if valid
          */
@@ -575,20 +538,17 @@ var Chessboard = (function (exports) {
             if (typeof move !== 'string') {
                 return false;
             }
-            
             const cacheKey = `move:${move}`;
-            
             if (this._validationCache.has(cacheKey)) {
                 return this._validationCache.get(cacheKey);
             }
-            
             const isValid = this._validateMoveFormat(move);
             this._cacheValidationResult(cacheKey, isValid);
             return isValid;
         }
 
         /**
-         * Validates move format in detail
+         * Validate move format in detail
          * @private
          * @param {string} move - Move string to validate
          * @returns {boolean} True if valid
@@ -597,21 +557,15 @@ var Chessboard = (function (exports) {
             if (move.length < 4 || move.length > 5) {
                 return false;
             }
-            
-            const from = move.slice(0, 2);
-            const to = move.slice(2, 4);
-            const promotion = move.slice(4, 5);
-            
+            const from = move.substring(0, 2);
+            const to = move.substring(2, 4);
             if (!this.isValidSquare(from) || !this.isValidSquare(to)) {
                 return false;
             }
-            
-            if (promotion && !this._validValues.promotionPieces.includes(promotion)) {
+            if (move.length === 5 && !/[qrnb]/i.test(move[4])) {
                 return false;
             }
-            
-            // Additional move validation (e.g., source and target different)
-            return from !== to;
+            return true;
         }
 
         /**
@@ -641,11 +595,9 @@ var Chessboard = (function (exports) {
             if (size === 'auto') {
                 return true;
             }
-            
             if (typeof size === 'number') {
                 return size >= this._constraints.min && size <= this._constraints.max;
             }
-            
             return false;
         }
 
@@ -655,9 +607,9 @@ var Chessboard = (function (exports) {
          * @returns {boolean} True if valid
          */
         isValidTime(time) {
-            return typeof time === 'number' && 
-                   time >= 0 && 
-                   time <= this._constraints.maxTime;
+            return typeof time === 'number' &&
+                time >= 0 &&
+                time <= this._constraints.maxTime;
         }
 
         /**
@@ -675,10 +627,10 @@ var Chessboard = (function (exports) {
          * @returns {boolean} True if valid
          */
         isValidElementId(id) {
-            return typeof id === 'string' && 
-                   id.length > 0 && 
-                   id.length <= 100 && // Reasonable length limit
-                   /^[a-zA-Z][\w:-]*$/.test(id); // Valid HTML ID format
+            return typeof id === 'string' &&
+                id.length > 0 &&
+                id.length <= 100 && // Reasonable length limit
+                /^[a-zA-Z][\w:-]*$/.test(id); // Valid HTML ID format
         }
 
         /**
@@ -708,14 +660,6 @@ var Chessboard = (function (exports) {
             return this._validValues.easingTypes.includes(easing);
         }
 
-        /**
-         * Validates animation style
-         * @param {string} style - Animation style to validate
-         * @returns {boolean} True if valid
-         */
-        isValidAnimationStyle(style) {
-            return this._validValues.animationStyles.includes(style);
-        }
 
         /**
          * Validates CSS color format
@@ -726,24 +670,20 @@ var Chessboard = (function (exports) {
             if (typeof color !== 'string') {
                 return false;
             }
-            
             // Check for hex colors
             if (this._patterns.color.test(color)) {
                 return true;
             }
-            
             // Check for named colors (basic set)
             const namedColors = ['white', 'black', 'red', 'green', 'blue', 'yellow', 'cyan', 'magenta'];
             if (namedColors.includes(color.toLowerCase())) {
                 return true;
             }
-            
             // Check for rgb/rgba format
             if (/^rgb\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*\)$/.test(color) ||
                 /^rgba\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*,\s*[0-1](\.\d+)?\s*\)$/.test(color)) {
                 return true;
             }
-            
             return false;
         }
 
@@ -756,8 +696,8 @@ var Chessboard = (function (exports) {
         validateSquare(square) {
             if (!this.isValidSquare(square)) {
                 throw new ValidationError(
-                    ERROR_MESSAGES.invalid_square + square, 
-                    'square', 
+                    ERROR_MESSAGES.invalid_square + square,
+                    'square',
                     square
                 );
             }
@@ -773,8 +713,8 @@ var Chessboard = (function (exports) {
         validatePiece(piece) {
             if (!this.isValidPiece(piece)) {
                 throw new ValidationError(
-                    ERROR_MESSAGES.invalid_piece + piece, 
-                    'piece', 
+                    ERROR_MESSAGES.invalid_piece + piece,
+                    'piece',
                     piece
                 );
             }
@@ -790,8 +730,8 @@ var Chessboard = (function (exports) {
         validateFen(fen) {
             if (!this.isValidFen(fen)) {
                 throw new ValidationError(
-                    ERROR_MESSAGES.invalid_fen + fen, 
-                    'fen', 
+                    ERROR_MESSAGES.invalid_fen + fen,
+                    'fen',
                     fen
                 );
             }
@@ -807,8 +747,8 @@ var Chessboard = (function (exports) {
         validateMove(move) {
             if (!this.isValidMove(move)) {
                 throw new ValidationError(
-                    ERROR_MESSAGES.invalid_move + move, 
-                    'move', 
+                    ERROR_MESSAGES.invalid_move + move,
+                    'move',
                     move
                 );
             }
@@ -824,16 +764,15 @@ var Chessboard = (function (exports) {
         validateOrientation(orientation) {
             if (!this.isValidOrientation(orientation)) {
                 throw new ValidationError(
-                    ERROR_MESSAGES.invalid_orientation + orientation, 
-                    'orientation', 
+                    ERROR_MESSAGES.invalid_orientation + orientation,
+                    'orientation',
                     orientation
                 );
             }
-            
             // Normalize to 'w' or 'b'
-            return orientation === 'white' ? 'w' : 
-                   orientation === 'black' ? 'b' : 
-                   orientation;
+            return orientation === 'white' ? 'w' :
+                orientation === 'black' ? 'b' :
+                    orientation;
         }
 
         /**
@@ -845,16 +784,15 @@ var Chessboard = (function (exports) {
         validateColor(color) {
             if (!this.isValidColor(color)) {
                 throw new ValidationError(
-                    ERROR_MESSAGES.invalid_color + color, 
-                    'color', 
+                    ERROR_MESSAGES.invalid_color + color,
+                    'color',
                     color
                 );
             }
-            
             // Normalize to 'w' or 'b'
-            return color === 'white' ? 'w' : 
-                   color === 'black' ? 'b' : 
-                   color;
+            return color === 'white' ? 'w' :
+                color === 'black' ? 'b' :
+                    color;
         }
 
         /**
@@ -866,8 +804,8 @@ var Chessboard = (function (exports) {
         validateSize(size) {
             if (!this.isValidSize(size)) {
                 throw new ValidationError(
-                    ERROR_MESSAGES.invalid_size + size, 
-                    'size', 
+                    ERROR_MESSAGES.invalid_size + size,
+                    'size',
                     size
                 );
             }
@@ -883,40 +821,29 @@ var Chessboard = (function (exports) {
         validateConfig(config) {
             if (!config || typeof config !== 'object') {
                 throw new ValidationError(
-                    'Configuration must be an object', 
-                    'config', 
+                    'Configuration must be an object',
+                    'config',
                     config
                 );
             }
-            
             const errors = [];
-            
             // Validate required fields
             if (!config.id && !config.id_div) {
                 errors.push('Configuration must include id or id_div');
             }
-            
             // Validate optional fields
             if (config.orientation && !this.isValidOrientation(config.orientation)) {
                 errors.push(ERROR_MESSAGES.invalid_orientation + config.orientation);
             }
-            
             if (config.size && !this.isValidSize(config.size)) {
                 errors.push(ERROR_MESSAGES.invalid_size + config.size);
             }
-            
             if (config.movableColors && !this.isValidMovableColors(config.movableColors)) {
                 errors.push(ERROR_MESSAGES.invalid_color + config.movableColors);
             }
-            
             if (config.dropOffBoard && !this.isValidDropOffBoard(config.dropOffBoard)) {
                 errors.push(ERROR_MESSAGES.invalid_dropOffBoard + config.dropOffBoard);
             }
-            
-            if (config.animationStyle && !this.isValidAnimationStyle(config.animationStyle)) {
-                errors.push(ERROR_MESSAGES.invalid_animationStyle + config.animationStyle);
-            }
-            
             // Validate callbacks
             const callbacks = ['onMove', 'onMoveEnd', 'onChange', 'onDragStart', 'onDragMove', 'onDrop', 'onSnapbackEnd'];
             for (const callback of callbacks) {
@@ -924,7 +851,6 @@ var Chessboard = (function (exports) {
                     errors.push(`Invalid ${callback} callback`);
                 }
             }
-            
             // Validate colors
             const colorFields = ['whiteSquare', 'blackSquare', 'highlight', 'hintColor'];
             for (const field of colorFields) {
@@ -932,15 +858,13 @@ var Chessboard = (function (exports) {
                     errors.push(`Invalid ${field} color: ${config[field]}`);
                 }
             }
-            
             if (errors.length > 0) {
                 throw new ValidationError(
-                    `Configuration validation failed: ${errors.join(', ')}`, 
-                    'config', 
+                    `Configuration validation failed: ${errors.join(', ')}`,
+                    'config',
                     config
                 );
             }
-            
             return config;
         }
 
@@ -956,7 +880,6 @@ var Chessboard = (function (exports) {
                 const firstKey = this._validationCache.keys().next().value;
                 this._validationCache.delete(firstKey);
             }
-            
             this._validationCache.set(key, result);
         }
 
@@ -988,7 +911,6 @@ var Chessboard = (function (exports) {
             return validations.map(validation => {
                 try {
                     const { type, value } = validation;
-                    
                     switch (type) {
                         case 'square':
                             return { valid: this.isValidSquare(value), value };
@@ -1094,8 +1016,7 @@ var Chessboard = (function (exports) {
         fadeAnimation: 'ease',
         ratio: 0.9,
         piecesPath: '../assets/themes/default',
-        animationStyle: 'simultaneous',
-        simultaneousAnimationDelay: 0,
+        simultaneousAnimationDelay: 100,
         onMove: () => true,
         onMoveEnd: () => true,
         onChange: () => true,
@@ -1129,19 +1050,19 @@ var Chessboard = (function (exports) {
         constructor(settings = {}) {
             // Initialize validation service
             this._validationService = new ValidationService();
-            
+
             // Validate input
             this._validateInput(settings);
-            
+
             // Merge with defaults
             const config = this._mergeWithDefaults(settings);
-            
+
             // Process and validate configuration
             this._processConfiguration(config);
-            
+
             // Set CSS properties
             this._setCSSProperties(config);
-            
+
             // Configure mode-specific settings
             this._configureModeSettings();
         }
@@ -1156,7 +1077,7 @@ var Chessboard = (function (exports) {
             if (settings !== null && typeof settings !== 'object') {
                 throw new ConfigurationError('Settings must be an object', 'settings', settings);
             }
-            
+
             // Validate using validation service
             try {
                 this._validationService.validateConfig(settings);
@@ -1190,7 +1111,7 @@ var Chessboard = (function (exports) {
             this.size = config.size;
             this.movableColors = config.movableColors;
             this.piecesPath = config.piecesPath;
-            
+
             // Event handlers
             this.onMove = this._validateCallback(config.onMove);
             this.onMoveEnd = this._validateCallback(config.onMoveEnd);
@@ -1218,9 +1139,8 @@ var Chessboard = (function (exports) {
             this.snapbackTime = this._setTime(config.snapbackTime);
             this.dropCenterTime = this._setTime(config.dropCenterTime);
             this.fadeTime = this._setTime(config.fadeTime);
-            
+
             // Animation style properties
-            this.animationStyle = this._validateAnimationStyle(config.animationStyle);
             this.simultaneousAnimationDelay = this._validateDelay(config.simultaneousAnimationDelay);
         }
 
@@ -1281,19 +1201,6 @@ var Chessboard = (function (exports) {
             return callback;
         }
 
-        /**
-         * Validates animation style
-         * @private
-         * @param {string} style - Animation style
-         * @returns {string} Validated style
-         * @throws {ConfigurationError} If style is invalid
-         */
-        _validateAnimationStyle(style) {
-            if (!this._validationService.isValidAnimationStyle(style)) {
-                throw new ConfigurationError('Invalid animation style', 'animationStyle', style);
-            }
-            return style;
-        }
 
         /**
          * Validates animation delay
@@ -1351,11 +1258,11 @@ var Chessboard = (function (exports) {
                 }
                 return value;
             }
-            
+
             if (typeof value === 'string' && value in ANIMATION_TIMES) {
                 return ANIMATION_TIMES[value];
             }
-            
+
             throw new ConfigurationError('Invalid time value', 'time', value);
         }
 
@@ -1370,11 +1277,11 @@ var Chessboard = (function (exports) {
             if (typeof value === 'boolean') {
                 return value;
             }
-            
+
             if (value in BOOLEAN_VALUES) {
                 return BOOLEAN_VALUES[value];
             }
-            
+
             throw new ConfigurationError('Invalid boolean value', 'boolean', value);
         }
 
@@ -1390,17 +1297,17 @@ var Chessboard = (function (exports) {
             if (typeof value === 'boolean') {
                 return value ? TRANSITION_FUNCTIONS.ease : null;
             }
-            
+
             // Handle string values
             if (typeof value === 'string' && value in TRANSITION_FUNCTIONS) {
                 return TRANSITION_FUNCTIONS[value];
             }
-            
+
             // Handle null/undefined
             if (value === null || value === undefined) {
                 return null;
             }
-            
+
             throw new ConfigurationError('Invalid transition function', 'transitionFunction', value);
         }
 
@@ -1431,7 +1338,6 @@ var Chessboard = (function (exports) {
                 fadeTime: this.fadeTime,
                 fadeAnimation: this.fadeAnimation,
                 piecesPath: this.piecesPath,
-                animationStyle: this.animationStyle,
                 simultaneousAnimationDelay: this.simultaneousAnimationDelay,
                 onlyLegalMoves: this.onlyLegalMoves
             };
@@ -1453,7 +1359,7 @@ var Chessboard = (function (exports) {
 
             // Apply updates
             const newConfig = Object.assign({}, this.toObject(), updates);
-            
+
             // Re-process configuration
             this._processConfiguration(newConfig);
             this._setCSSProperties(newConfig);
@@ -1676,22 +1582,10 @@ var Chessboard = (function (exports) {
 
         setDrag(f) {
             if (!this.element) { console.debug(`[Piece] setDrag: ${this.id} - element is null`); return; }
-            // Remove previous handlers
-            this.element.onmousedown = null;
-            this.element.ontouchstart = null;
-            this.element.ondragstart = null;
-            if (window.PointerEvent) {
-                this.element.onpointerdown = null;
-            }
-            // Set new handlers
             this.element.ondragstart = (e) => { e.preventDefault(); };
             this.element.onmousedown = f;
             this.element.ontouchstart = f; // Drag touch
-            if (window.PointerEvent) {
-                this.element.onpointerdown = f;
-                console.debug(`[Piece] setDrag: pointerdown set for ${this.id}`);
-            }
-            console.debug(`[Piece] setDrag: mousedown/ontouchstart set for ${this.id}`);
+            console.debug(`[Piece] setDrag: ${this.id}`);
         }
 
         destroy() {
@@ -2031,180 +1925,155 @@ var Chessboard = (function (exports) {
     };
 
     /**
-     * Service for managing animations and transitions
+     * AnimationService - Gestione centralizzata delle animazioni e transizioni per la scacchiera
      * @module services/AnimationService
      * @since 2.0.0
      */
 
     /**
-     * Service responsible for coordinating animations and transitions
-     * @class
+     * Service responsabile del coordinamento delle animazioni e delle transizioni
+     * @class AnimationService
      */
     class AnimationService {
         /**
-         * Creates a new AnimationService instance
-         * @param {ChessboardConfig} config - Board configuration
+         * Crea una nuova istanza di AnimationService
+         * @param {Object} config - Configurazione della scacchiera
          */
         constructor(config) {
+            /** @type {Object} */
             this.config = config;
+            /** @type {Map<number, {element: HTMLElement, animate: Function, callback?: Function}>} */
             this.activeAnimations = new Map();
+            /** @type {number} */
             this.animationId = 0;
         }
 
         /**
-         * Creates a timing function for animations
-         * @param {string} [type='ease'] - Animation type
-         * @returns {Function} Timing function
+         * Crea una funzione di timing per le animazioni
+         * @param {string} [type='ease'] - Tipo di easing
+         * @returns {Function} Funzione di timing
          */
         createTimingFunction(type = 'ease') {
             return (elapsed, duration) => {
-                const x = elapsed / duration;
-
+                const x = duration > 0 ? Math.max(0, Math.min(1, elapsed / duration)) : 1;
                 switch (type) {
-                    case 'linear':
-                        return x;
-                    case 'ease':
-                        return (x ** 2) * (3 - 2 * x);
-                    case 'ease-in':
-                        return x ** 2;
-                    case 'ease-out':
-                        return -1 * (x - 1) ** 2 + 1;
-                    case 'ease-in-out':
-                        return (x < 0.5) ? 2 * x ** 2 : 4 * x - 2 * x ** 2 - 1;
-                    default:
-                        return x;
+                    case 'linear': return x;
+                    case 'ease': return (x ** 2) * (3 - 2 * x);
+                    case 'ease-in': return x ** 2;
+                    case 'ease-out': return -1 * (x - 1) ** 2 + 1;
+                    case 'ease-in-out': return (x < 0.5) ? 2 * x ** 2 : 4 * x - 2 * x ** 2 - 1;
+                    default: return x;
                 }
             };
         }
 
         /**
-         * Animates an element with given properties
-         * @param {HTMLElement} element - Element to animate
-         * @param {Object} properties - Properties to animate
-         * @param {number} duration - Animation duration in milliseconds
-         * @param {string} [easing='ease'] - Easing function
-         * @param {Function} [callback] - Callback when animation completes
-         * @returns {number} Animation ID
+         * Anima un elemento HTML con le proprietà specificate
+         * @param {HTMLElement} element - Elemento da animare
+         * @param {Object} properties - Proprietà da animare (es: {left: 100, top: 50, opacity: 1})
+         * @param {number} duration - Durata in ms
+         * @param {string} [easing='ease'] - Tipo di easing
+         * @param {Function} [callback] - Callback al termine
+         * @returns {number} ID dell'animazione
          */
         animate(element, properties, duration, easing = 'ease', callback) {
+            if (!element || typeof properties !== 'object' || typeof duration !== 'number') {
+                throw new Error('AnimationService.animate: parametri non validi');
+            }
             const animationId = ++this.animationId;
             const timingFunction = this.createTimingFunction(easing);
             const startTime = performance.now();
             const startValues = {};
-
-            // Store initial values
             Object.keys(properties).forEach(prop => {
                 startValues[prop] = this._getInitialValue(element, prop);
             });
-
             const animate = (currentTime) => {
                 const elapsed = currentTime - startTime;
                 const progress = Math.min(elapsed / duration, 1);
                 const easedProgress = timingFunction(elapsed, duration);
-
-                // Apply animated values
                 Object.keys(properties).forEach(prop => {
                     const startValue = startValues[prop];
                     const endValue = properties[prop];
                     const currentValue = this._interpolateValue(startValue, endValue, easedProgress);
                     this._applyValue(element, prop, currentValue);
                 });
-
                 if (progress < 1 && this.activeAnimations.has(animationId)) {
                     requestAnimationFrame(animate);
                 } else {
                     this.activeAnimations.delete(animationId);
-                    if (callback) callback();
+                    if (typeof callback === 'function') callback();
                 }
             };
-
             this.activeAnimations.set(animationId, { element, animate, callback });
             requestAnimationFrame(animate);
-
             return animationId;
         }
 
         /**
-         * Cancels an animation
-         * @param {number} animationId - Animation ID to cancel
+         * Annulla una animazione attiva
+         * @param {number} animationId - ID dell'animazione
          */
         cancel(animationId) {
-            if (this.activeAnimations.has(animationId)) {
-                this.activeAnimations.delete(animationId);
-            }
+            this.activeAnimations.delete(animationId);
         }
 
         /**
-         * Cancels all animations
+         * Annulla tutte le animazioni attive
          */
         cancelAll() {
             this.activeAnimations.clear();
         }
 
         /**
-         * Gets initial value for a property
+         * Ottiene il valore iniziale di una proprietà
          * @private
-         * @param {HTMLElement} element - Element
-         * @param {string} property - Property name
-         * @returns {number} Initial value
+         * @param {HTMLElement} element
+         * @param {string} property
+         * @returns {number}
          */
         _getInitialValue(element, property) {
             if (!element || !element.style) return 0;
             switch (property) {
-                case 'opacity':
-                    return parseFloat(getComputedStyle(element).opacity) || 1;
-                case 'left':
-                    return parseFloat(element.style.left) || 0;
-                case 'top':
-                    return parseFloat(element.style.top) || 0;
-                case 'scale':
-                    return 1;
-                default:
-                    return 0;
+                case 'opacity': return parseFloat(getComputedStyle(element).opacity) || 1;
+                case 'left': return parseFloat(element.style.left) || 0;
+                case 'top': return parseFloat(element.style.top) || 0;
+                case 'scale': return 1;
+                default: return 0;
             }
         }
 
         /**
-         * Interpolates between two values
+         * Interpola tra due valori
          * @private
-         * @param {number} start - Start value
-         * @param {number} end - End value
-         * @param {number} progress - Progress (0-1)
-         * @returns {number} Interpolated value
+         * @param {number} start
+         * @param {number} end
+         * @param {number} progress
+         * @returns {number}
          */
         _interpolateValue(start, end, progress) {
             return start + (end - start) * progress;
         }
 
         /**
-         * Applies animated value to element
+         * Applica il valore animato all'elemento
          * @private
-         * @param {HTMLElement} element - Element
-         * @param {string} property - Property name
-         * @param {number} value - Value to apply
+         * @param {HTMLElement} element
+         * @param {string} property
+         * @param {number} value
          */
         _applyValue(element, property, value) {
             if (!element || !element.style) return;
             switch (property) {
-                case 'opacity':
-                    element.style.opacity = value;
-                    break;
-                case 'left':
-                    element.style.left = value + 'px';
-                    break;
-                case 'top':
-                    element.style.top = value + 'px';
-                    break;
-                case 'scale':
-                    element.style.transform = `scale(${value})`;
-                    break;
-                default:
-                    element.style[property] = value;
+                case 'opacity': element.style.opacity = value; break;
+                case 'left': element.style.left = value + 'px'; break;
+                case 'top': element.style.top = value + 'px'; break;
+                case 'scale': element.style.transform = `scale(${value})`; break;
+                default: element.style[property] = value;
             }
         }
 
         /**
-         * Cleans up resources
+         * Cleanup risorse e animazioni
          */
         destroy() {
             this.cancelAll();
@@ -2212,7 +2081,7 @@ var Chessboard = (function (exports) {
     }
 
     /**
-     * Service for managing board setup and DOM operations
+     * BoardService - Handles board DOM setup, manipulation, and resource management
      * @module services/BoardService
      * @since 2.0.0
      */
@@ -2220,45 +2089,45 @@ var Chessboard = (function (exports) {
 
     /**
      * Service responsible for board DOM manipulation and setup
-     * @class
+     * @class BoardService
      */
     class BoardService {
         /**
-         * Creates a new BoardService instance
-         * @param {ChessboardConfig} config - Board configuration
+         * Create a new BoardService instance
+         * @param {Object} config - Board configuration
          */
         constructor(config) {
+            /** @type {Object} */
             this.config = config;
+            /** @type {HTMLElement|null} */
             this.element = null;
+            /** @type {Object.<string, Square>} */
             this.squares = {};
         }
 
         /**
-         * Builds the board DOM element and attaches it to the configured container
-         * @throws {DOMError} When the container element cannot be found
+         * Build the board DOM element and attach it to the configured container
+         * @throws {DOMError} If the container element cannot be found
          */
         buildBoard() {
-            console.log('BoardService.buildBoard: Looking for element with ID:', this.config.id_div);
-
             this.element = document.getElementById(this.config.id_div);
             if (!this.element) {
                 throw new DOMError(ERROR_MESSAGES.invalid_id_div + this.config.id_div, this.config.id_div);
             }
-
             this.resize(this.config.size);
-            this.element.className = "board";
+            this.element.className = 'board';
         }
 
         /**
-         * Creates all 64 squares and adds them to the board
+         * Create all 64 squares and add them to the board
          * @param {Function} coordConverter - Function to convert row/col to real coordinates
          */
         buildSquares(coordConverter) {
+            if (!this.element) throw new DOMError('Board element not initialized', this.config.id_div);
             for (let row = 0; row < BOARD_SIZE.ROWS; row++) {
                 for (let col = 0; col < BOARD_SIZE.COLS; col++) {
                     const [squareRow, squareCol] = coordConverter(row, col);
                     const square = new Square(squareRow, squareCol);
-
                     this.squares[square.getId()] = square;
                     this.element.appendChild(square.element);
                 }
@@ -2266,20 +2135,17 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Removes all squares from the board and cleans up their resources
-         * Best practice: always destroy JS objects and DOM nodes, and clear references.
+         * Remove all squares from the board and clean up their resources
          */
         removeSquares() {
             for (const square of Object.values(this.squares)) {
-                // Always call destroy to remove DOM and clear piece reference
                 square.destroy();
             }
             this.squares = {};
         }
 
         /**
-         * Removes all content from the board element
-         * Best practice: clear DOM and force element to be re-fetched on next build.
+         * Remove all content from the board element
          */
         removeBoard() {
             if (this.element) {
@@ -2289,9 +2155,9 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Resizes the board to the specified size
+         * Resize the board to the specified size
          * @param {number|string} value - Size in pixels or 'auto'
-         * @throws {ValidationError} When size value is invalid
+         * @throws {ValidationError} If size value is invalid
          */
         resize(value) {
             if (value === 'auto') {
@@ -2305,15 +2171,13 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Calculates the optimal size when 'auto' is specified
+         * Calculate the optimal size when 'auto' is specified
          * @private
          * @returns {number} Calculated size in pixels
          */
         _calculateAutoSize() {
-            if (!this.element) return 400; // Default fallback
-
+            if (!this.element) return 400;
             const { offsetWidth, offsetHeight } = this.element;
-
             if (offsetWidth === 0) {
                 return offsetHeight || 400;
             } else if (offsetHeight === 0) {
@@ -2324,8 +2188,8 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Gets a square by its ID
-         * @param {string} squareId - Square identifier (API pubblica)
+         * Get a square by its ID
+         * @param {string} squareId - Square identifier
          * @returns {Square|null} The square or null if not found
          */
         getSquare(squareId) {
@@ -2333,26 +2197,37 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Highlight a square (solo oggetto)
+         * Highlight a square
          * @param {Square} square
          * @param {Object} [opts]
          */
         highlightSquare(square, opts = {}) {
-            if (!square) throw new Error('highlightSquare richiede oggetto Square');
-            // ... logica esistente ...
+            if (!square) throw new Error('highlightSquare requires a Square object');
+            // Implement highlight logic or call square.highlight() if available
+            if (typeof square.highlight === 'function') {
+                square.highlight(opts);
+            } else {
+                square.element.classList.add('highlighted');
+            }
         }
+
         /**
-         * Dehighlight a square (solo oggetto)
+         * Remove highlight from a square
          * @param {Square} square
          * @param {Object} [opts]
          */
         dehighlightSquare(square, opts = {}) {
-            if (!square) throw new Error('dehighlightSquare richiede oggetto Square');
-            // ... logica esistente ...
+            if (!square) throw new Error('dehighlightSquare requires a Square object');
+            // Implement dehighlight logic or call square.dehighlight() if available
+            if (typeof square.dehighlight === 'function') {
+                square.dehighlight(opts);
+            } else {
+                square.element.classList.remove('highlighted');
+            }
         }
 
         /**
-         * Gets all squares
+         * Get all squares
          * @returns {Object.<string, Square>} All squares indexed by ID
          */
         getAllSquares() {
@@ -2360,7 +2235,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Applies a method to all squares
+         * Apply a method to all squares
          * @param {string} methodName - Name of the method to call on each square
          * @param {...*} args - Arguments to pass to the method
          */
@@ -2373,7 +2248,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Cleans up all resources
+         * Clean up all resources
          */
         destroy() {
             this.removeSquares();
@@ -2384,7 +2259,7 @@ var Chessboard = (function (exports) {
     }
 
     /**
-     * Service for managing coordinate conversions and board orientation
+     * CoordinateService - Handles coordinate conversions and board orientation logic
      * @module services/CoordinateService
      * @since 2.0.0
      */
@@ -2392,19 +2267,20 @@ var Chessboard = (function (exports) {
 
     /**
      * Service responsible for coordinate conversions and board orientation
-     * @class
+     * @class CoordinateService
      */
     class CoordinateService {
         /**
-         * Creates a new CoordinateService instance
-         * @param {ChessboardConfig} config - Board configuration
+         * Create a new CoordinateService instance
+         * @param {Object} config - Board configuration
          */
         constructor(config) {
+            /** @type {Object} */
             this.config = config;
         }
 
         /**
-         * Converts logical coordinates to real coordinates based on board orientation
+         * Convert logical coordinates to real coordinates based on board orientation
          * @param {number} row - Row index (0-7)
          * @param {number} col - Column index (0-7)
          * @returns {Array<number>} Real coordinates [row, col] (1-8)
@@ -2412,18 +2288,16 @@ var Chessboard = (function (exports) {
         realCoord(row, col) {
             let realRow = row;
             let realCol = col;
-            
             if (this.isWhiteOriented()) {
                 realRow = 7 - row;
             } else {
                 realCol = 7 - col;
             }
-            
             return [realRow + 1, realCol + 1];
         }
 
         /**
-         * Converts board coordinates to square ID
+         * Convert board coordinates to square ID
          * @param {number} row - Row index (0-7)
          * @param {number} col - Column index (0-7)
          * @returns {string} Square ID (e.g., 'e4')
@@ -2431,7 +2305,6 @@ var Chessboard = (function (exports) {
         getSquareID(row, col) {
             row = parseInt(row);
             col = parseInt(col);
-            
             if (this.isWhiteOriented()) {
                 row = 8 - row;
                 col = col + 1;
@@ -2439,7 +2312,6 @@ var Chessboard = (function (exports) {
                 row = row + 1;
                 col = 8 - col;
             }
-            
             if (col < 1 || col > 8 || row < 1 || row > 8) {
                 throw new ValidationError(
                     `Invalid board coordinates: row=${row}, col=${col}`,
@@ -2447,13 +2319,12 @@ var Chessboard = (function (exports) {
                     { row, col }
                 );
             }
-            
             const letter = BOARD_LETTERS[col - 1];
             return letter + row;
         }
 
         /**
-         * Converts square ID to board coordinates
+         * Convert square ID to board coordinates
          * @param {string} squareId - Square ID (e.g., 'e4')
          * @returns {Array<number>} Board coordinates [row, col] (0-7)
          */
@@ -2465,10 +2336,8 @@ var Chessboard = (function (exports) {
                     squareId
                 );
             }
-            
             const letter = squareId[0];
             const number = parseInt(squareId[1]);
-            
             const col = BOARD_LETTERS.indexOf(letter);
             if (col === -1) {
                 throw new ValidationError(
@@ -2477,7 +2346,6 @@ var Chessboard = (function (exports) {
                     squareId
                 );
             }
-            
             if (number < 1 || number > 8) {
                 throw new ValidationError(
                     ERROR_MESSAGES.invalid_square + squareId,
@@ -2485,9 +2353,7 @@ var Chessboard = (function (exports) {
                     squareId
                 );
             }
-            
             let row, boardCol;
-            
             if (this.isWhiteOriented()) {
                 row = 8 - number;
                 boardCol = col;
@@ -2495,12 +2361,11 @@ var Chessboard = (function (exports) {
                 row = number - 1;
                 boardCol = 7 - col;
             }
-            
             return [row, boardCol];
         }
 
         /**
-         * Converts pixel coordinates to square ID
+         * Convert pixel coordinates to square ID
          * @param {number} x - X coordinate in pixels
          * @param {number} y - Y coordinate in pixels
          * @param {HTMLElement} boardElement - Board DOM element
@@ -2508,21 +2373,15 @@ var Chessboard = (function (exports) {
          */
         pixelToSquareID(x, y, boardElement) {
             if (!boardElement) return null;
-            
             const rect = boardElement.getBoundingClientRect();
             const { width, height } = rect;
-            
-            // Check if coordinates are within board bounds
             if (x < 0 || x >= width || y < 0 || y >= height) {
                 return null;
             }
-            
             const squareWidth = width / 8;
             const squareHeight = height / 8;
-            
             const col = Math.floor(x / squareWidth);
             const row = Math.floor(y / squareHeight);
-            
             try {
                 return this.getSquareID(row, col);
             } catch (error) {
@@ -2531,25 +2390,21 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Converts square ID to pixel coordinates
+         * Convert square ID to pixel coordinates
          * @param {string} squareId - Square ID (e.g., 'e4')
          * @param {HTMLElement} boardElement - Board DOM element
          * @returns {Object|null} Pixel coordinates {x, y} or null if invalid
          */
         squareIDToPixel(squareId, boardElement) {
             if (!boardElement) return null;
-            
             try {
                 const [row, col] = this.getCoordinatesFromSquareID(squareId);
                 const rect = boardElement.getBoundingClientRect();
                 const { width, height } = rect;
-                
                 const squareWidth = width / 8;
                 const squareHeight = height / 8;
-                
                 const x = col * squareWidth;
                 const y = row * squareHeight;
-                
                 return { x, y };
             } catch (error) {
                 return null;
@@ -2557,7 +2412,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Gets the center pixel coordinates of a square
+         * Get the center pixel coordinates of a square
          * @param {string} squareId - Square ID (e.g., 'e4')
          * @param {HTMLElement} boardElement - Board DOM element
          * @returns {Object|null} Center coordinates {x, y} or null if invalid
@@ -2565,11 +2420,9 @@ var Chessboard = (function (exports) {
         getSquareCenter(squareId, boardElement) {
             const coords = this.squareIDToPixel(squareId, boardElement);
             if (!coords) return null;
-            
             const rect = boardElement.getBoundingClientRect();
             const squareWidth = rect.width / 8;
             const squareHeight = rect.height / 8;
-            
             return {
                 x: coords.x + squareWidth / 2,
                 y: coords.y + squareHeight / 2
@@ -2577,7 +2430,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Calculates the distance between two squares
+         * Calculate the distance between two squares
          * @param {string} fromSquare - Source square ID
          * @param {string} toSquare - Target square ID
          * @returns {number} Distance between squares
@@ -2586,10 +2439,8 @@ var Chessboard = (function (exports) {
             try {
                 const [fromRow, fromCol] = this.getCoordinatesFromSquareID(fromSquare);
                 const [toRow, toCol] = this.getCoordinatesFromSquareID(toSquare);
-                
                 const rowDiff = Math.abs(toRow - fromRow);
                 const colDiff = Math.abs(toCol - fromCol);
-                
                 return Math.sqrt(rowDiff * rowDiff + colDiff * colDiff);
             } catch (error) {
                 return 0;
@@ -2597,7 +2448,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Checks if the board is oriented from white's perspective
+         * Check if the board is oriented from white's perspective
          * @returns {boolean} True if white-oriented
          */
         isWhiteOriented() {
@@ -2605,7 +2456,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Checks if the board is oriented from black's perspective
+         * Check if the board is oriented from black's perspective
          * @returns {boolean} True if black-oriented
          */
         isBlackOriented() {
@@ -2613,31 +2464,31 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Flips the board orientation
+         * Flip the board orientation
          */
         flipOrientation() {
             this.config.orientation = this.isWhiteOriented() ? 'b' : 'w';
         }
 
         /**
-         * Sets the board orientation
-         * @param {string} orientation - 'w' for white, 'b' for black
-         * @throws {ValidationError} When orientation is invalid
+         * Set the board orientation
+         * @param {string} orientation - 'w', 'b', 'white', or 'black'
+         * @throws {ValidationError} If orientation is invalid
          */
         setOrientation(orientation) {
-            if (orientation !== 'w' && orientation !== 'b') {
+            const normalized = orientation === 'white' ? 'w' : orientation === 'black' ? 'b' : orientation;
+            if (normalized !== 'w' && normalized !== 'b') {
                 throw new ValidationError(
                     ERROR_MESSAGES.invalid_orientation + orientation,
                     'orientation',
                     orientation
                 );
             }
-            
-            this.config.orientation = orientation;
+            this.config.orientation = normalized;
         }
 
         /**
-         * Gets the current orientation
+         * Get the current orientation
          * @returns {string} Current orientation ('w' or 'b')
          */
         getOrientation() {
@@ -2645,50 +2496,21 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Sets the orientation
-         * @param {string} orientation - New orientation ('w', 'b', 'white', 'black')
-         */
-        setOrientation(orientation) {
-            // Normalize orientation
-            const normalizedOrientation = orientation === 'white' ? 'w' : 
-                                         orientation === 'black' ? 'b' : orientation;
-            
-            if (normalizedOrientation !== 'w' && normalizedOrientation !== 'b') {
-                throw new ValidationError(
-                    ERROR_MESSAGES.invalid_orientation + orientation,
-                    'orientation',
-                    orientation
-                );
-            }
-            
-            this.config.orientation = normalizedOrientation;
-        }
-
-        /**
-         * Flips the board orientation
-         */
-        flipOrientation() {
-            this.config.orientation = this.isWhiteOriented() ? 'b' : 'w';
-        }
-
-        /**
-         * Gets all square IDs in order
+         * Get all square IDs in order
          * @returns {Array<string>} Array of all square IDs
          */
         getAllSquareIDs() {
             const squares = [];
-            
             for (let row = 0; row < 8; row++) {
                 for (let col = 0; col < 8; col++) {
                     squares.push(this.getSquareID(row, col));
                 }
             }
-            
             return squares;
         }
 
         /**
-         * Gets squares in a specific rank (row)
+         * Get all squares in a specific rank (row)
          * @param {number} rank - Rank number (1-8)
          * @returns {Array<string>} Array of square IDs in the rank
          */
@@ -2700,19 +2522,16 @@ var Chessboard = (function (exports) {
                     rank
                 );
             }
-            
             const squares = [];
-            
             for (let col = 0; col < 8; col++) {
                 const row = this.isWhiteOriented() ? 8 - rank : rank - 1;
                 squares.push(this.getSquareID(row, col));
             }
-            
             return squares;
         }
 
         /**
-         * Gets squares in a specific file (column)
+         * Get all squares in a specific file (column)
          * @param {string} file - File letter (a-h)
          * @returns {Array<string>} Array of square IDs in the file
          */
@@ -2725,13 +2544,10 @@ var Chessboard = (function (exports) {
                     file
                 );
             }
-            
             const squares = [];
-            
             for (let row = 0; row < 8; row++) {
                 squares.push(this.getSquareID(row, col));
             }
-            
             return squares;
         }
     }
@@ -3111,6 +2927,67 @@ var Chessboard = (function (exports) {
         }
     };
 
+    /**
+     * ListenerManager - Utility per la gestione centralizzata dei listener DOM
+     * Permette di aggiungere, rimuovere e pulire tutti i listener in modo sicuro e senza duplicazioni.
+     * @module utils/listenerManager
+     * @since 2.0.0
+     */
+
+    class ListenerManager {
+        constructor() {
+            /**
+             * Lista di tutti i listener registrati
+             * @type {Array<{element: EventTarget, type: string, handler: Function, options?: any}>}
+             */
+            this.listeners = [];
+        }
+
+        /**
+         * Aggiunge un listener e lo traccia per la rimozione automatica
+         * @param {EventTarget} element - Elemento su cui aggiungere il listener
+         * @param {string} type - Tipo di evento
+         * @param {Function} handler - Funzione handler
+         * @param {Object|boolean} [options] - Opzioni per addEventListener
+         */
+        add(element, type, handler, options) {
+            if (!element || !type || !handler) return;
+            element.addEventListener(type, handler, options);
+            this.listeners.push({ element, type, handler, options });
+        }
+
+        /**
+         * Rimuove un listener specifico
+         * @param {EventTarget} element
+         * @param {string} type
+         * @param {Function} handler
+         */
+        remove(element, type, handler) {
+            if (!element || !type || !handler) return;
+            element.removeEventListener(type, handler);
+            this.listeners = this.listeners.filter(
+                l => !(l.element === element && l.type === type && l.handler === handler)
+            );
+        }
+
+        /**
+         * Rimuove tutti i listener registrati
+         */
+        removeAll() {
+            for (const { element, type, handler, options } of this.listeners) {
+                element.removeEventListener(type, handler, options);
+            }
+            this.listeners = [];
+        }
+
+        /**
+         * Pulizia risorse
+         */
+        destroy() {
+            this.removeAll();
+        }
+    }
+
     /**
      * Service for managing events and user interactions
      * @module services/EventService
@@ -3143,8 +3020,8 @@ var Chessboard = (function (exports) {
             this.promoting = false;
             this.isAnimating = false;
 
-            // Event listeners storage for cleanup
-            this.eventListeners = new Map();
+            // Listener manager per gestione centralizzata
+            this.listenerManager = new ListenerManager();
         }
 
         /**
@@ -3154,8 +3031,8 @@ var Chessboard = (function (exports) {
          * @param {Function} onPieceLeave - Callback for piece leave
          */
         addListeners(onSquareClick, onPieceHover, onPieceLeave) {
-            // Remove existing listeners to avoid duplicates
-            this.removeListeners();
+            // Rimuovi tutti i listener esistenti
+            this.listenerManager.removeAll();
 
             const squares = this.boardService.getAllSquares();
 
@@ -3173,8 +3050,6 @@ var Chessboard = (function (exports) {
          * @param {Function} onPieceLeave - Leave callback
          */
         _addSquareListeners(square, onSquareClick, onPieceHover, onPieceLeave) {
-            const listeners = [];
-
             // Throttled hover handlers for performance
             const throttledHover = rafThrottle((e) => {
                 if (!this.clicked && this.config.hints) {
@@ -3244,26 +3119,13 @@ var Chessboard = (function (exports) {
                 }
             };
 
-            // Add listeners
-            square.element.addEventListener('mouseover', throttledHover);
-            square.element.addEventListener('mouseout', throttledLeave);
-            square.element.addEventListener('click', handleClick);
-            // Touch: separa tap e drag
-            square.element.addEventListener('touchstart', handleTouchStart);
-            square.element.addEventListener('touchmove', handleTouchMove);
-            square.element.addEventListener('touchend', handleTouchEnd);
-
-            // Store listeners for cleanup
-            listeners.push(
-                { element: square.element, type: 'mouseover', handler: throttledHover },
-                { element: square.element, type: 'mouseout', handler: throttledLeave },
-                { element: square.element, type: 'click', handler: handleClick },
-                { element: square.element, type: 'touchstart', handler: handleTouchStart },
-                { element: square.element, type: 'touchmove', handler: handleTouchMove },
-                { element: square.element, type: 'touchend', handler: handleTouchEnd }
-            );
-
-            this.eventListeners.set(square.id, listeners);
+            // Usa ListenerManager per aggiungere tutti i listener
+            this.listenerManager.add(square.element, 'mouseover', throttledHover);
+            this.listenerManager.add(square.element, 'mouseout', throttledLeave);
+            this.listenerManager.add(square.element, 'click', handleClick);
+            this.listenerManager.add(square.element, 'touchstart', handleTouchStart);
+            this.listenerManager.add(square.element, 'touchmove', handleTouchMove);
+            this.listenerManager.add(square.element, 'touchend', handleTouchEnd);
         }
 
         /**
@@ -3280,18 +3142,14 @@ var Chessboard = (function (exports) {
          */
         createDragFunction(square, piece, onDragStart, onDragMove, onDrop, onSnapback, onMove, onRemove) {
             return (event) => {
-                event.preventDefault();
-
                 if (!this.config.draggable || !piece || this.isAnimating) {
                     return;
                 }
 
                 const originalFrom = square;
-                let isDragging = false;
                 let from = originalFrom;
                 let to = square;
                 let previousHighlight = null;
-
                 const img = piece.element;
 
                 if (!this.moveService.canMove(from)) {
@@ -3302,6 +3160,15 @@ var Chessboard = (function (exports) {
                 const isTouch = event.type && event.type.startsWith('touch');
                 const startX = event.clientX || (event.touches && event.touches[0]?.clientX) || 0;
                 const startY = event.clientY || (event.touches && event.touches[0]?.clientY) || 0;
+                let dragStarted = false;
+
+                // --- Calculate offset between cursor/finger and piece top-left at drag start ---
+                const pieceRect = img.getBoundingClientRect();
+                const boardElement = this.boardService.element;
+                const boardRect = boardElement.getBoundingClientRect();
+                // Offset from cursor/finger to top-left of piece
+                const offsetX = startX - pieceRect.left;
+                const offsetY = startY - pieceRect.top;
 
                 // --- Touch scroll lock helper ---
                 const addScrollLock = () => {
@@ -3313,10 +3180,6 @@ var Chessboard = (function (exports) {
 
                 // --- MOVE HANDLER (mouse + touch unified) ---
                 const moveAt = (event) => {
-                    const boardElement = this.boardService.element;
-                    const squareSize = boardElement.offsetWidth / 8;
-
-                    // Get mouse/touch coordinates
                     let clientX, clientY;
                     if (event.touches && event.touches[0]) {
                         clientX = event.touches[0].clientX;
@@ -3325,77 +3188,54 @@ var Chessboard = (function (exports) {
                         clientX = event.clientX;
                         clientY = event.clientY;
                     }
-
-                    // Calculate position relative to board
-                    const boardRect = boardElement.getBoundingClientRect();
-                    const x = clientX - boardRect.left - (squareSize / 2);
-                    const y = clientY - boardRect.top - (squareSize / 2);
-
+                    // Position the piece so the cursor/finger stays at the same relative point
+                    const x = clientX - boardRect.left - offsetX;
+                    const y = clientY - boardRect.top - offsetY;
                     img.style.left = x + 'px';
                     img.style.top = y + 'px';
-
                     return true;
                 };
 
                 // --- DRAG MOVE (mouse + touch) ---
+                const moveThreshold = 5; // px
                 const onPointerMove = (event) => {
-                    // For touch, only handle the first finger
                     if (event.touches && event.touches.length > 1) return;
                     if (event.touches && !event.touches[0]) return;
-                    if (event.type && event.type.startsWith('touch')) event.preventDefault();
-
                     const currentX = event.clientX || (event.touches && event.touches[0]?.clientX) || 0;
                     const currentY = event.clientY || (event.touches && event.touches[0]?.clientY) || 0;
                     const deltaX = Math.abs(currentX - startX);
                     const deltaY = Math.abs(currentY - startY);
-
-                    // Start dragging if mouse/touch moved enough
-                    if (!isDragging && (deltaX > 3 || deltaY > 3)) {
-                        isDragging = true;
-                        // Inizio drag: blocca update board
+                    if (!dragStarted && (deltaX > moveThreshold || deltaY > moveThreshold)) {
+                        dragStarted = true;
+                        if (isTouch) addScrollLock();
                         if (this.chessboard) this.chessboard._isDragging = true;
-
-                        // Mostra hint all'inizio del drag se attivi
                         if (this.config.hints && typeof this.chessboard._boundOnPieceHover === 'function') {
                             this.chessboard._boundOnPieceHover(from);
                         }
-
-                        // Set up drag state
                         if (!this.config.clickable) {
                             this.clicked = null;
                             this.clicked = from;
                         } else if (!this.clicked) {
                             this.clicked = from;
                         }
-
-                        // Visual feedback
                         if (this.config.clickable) {
                             from.select();
                         }
-
-                        // Prepare piece for dragging
                         img.style.position = 'absolute';
                         img.style.zIndex = '100';
                         img.classList.add('dragging');
-
                         DragOptimizations.enableForDrag(img);
-
-                        // Lock scroll for touch
-                        if (isTouch) addScrollLock();
-
-                        // Call drag start callback
                         if (!onDragStart(square, piece)) {
                             return;
                         }
                     }
-
-                    if (!isDragging) return;
-
+                    // Only block scroll and call preventDefault after drag has started
+                    if (dragStarted && isTouch && event.cancelable) {
+                        event.preventDefault();
+                    }
+                    if (!dragStarted) return;
                     if (!moveAt(event)) ;
-
                     // Update target square
-                    const boardElement = this.boardService.element;
-                    const boardRect = boardElement.getBoundingClientRect();
                     let clientX, clientY;
                     if (event.touches && event.touches[0]) {
                         clientX = event.touches[0].clientX;
@@ -3406,22 +3246,16 @@ var Chessboard = (function (exports) {
                     }
                     const x = clientX - boardRect.left;
                     const y = clientY - boardRect.top;
-
                     let newTo = null;
                     if (x >= 0 && x <= boardRect.width && y >= 0 && y <= boardRect.height) {
                         const squareId = this.coordinateService.pixelToSquareID(x, y, boardElement);
                         newTo = squareId ? this.boardService.getSquare(squareId) : null;
                     }
-
                     to = newTo;
                     onDragMove(from, to, piece);
-
-                    // Update visual feedback
-                    if (to !== previousHighlight) {
-                        to?.highlight();
-                        previousHighlight?.dehighlight();
-                        previousHighlight = to;
-                    }
+                    if (to) to.highlight();
+                    if (previousHighlight && previousHighlight !== to) previousHighlight.dehighlight();
+                    previousHighlight = to;
                 };
 
                 // --- DRAG END (mouse + touch) ---
@@ -3432,26 +3266,19 @@ var Chessboard = (function (exports) {
                     document.removeEventListener('touchmove', onPointerMove);
                     window.removeEventListener('touchend', onPointerUp);
                     if (isTouch) removeScrollLock();
-                    // Fine drag: sblocca update board
                     if (this.chessboard) this.chessboard._isDragging = false;
-
-                    // Rimuovi hint alla fine del drag se attivi
                     if (this.config.hints && typeof this.chessboard._boundOnPieceLeave === 'function') {
                         this.chessboard._boundOnPieceLeave(from);
                     }
-
-                    if (!isDragging) {
+                    if (!dragStarted) {
                         return;
                     }
-
                     img.style.zIndex = '20';
                     img.classList.remove('dragging');
                     img.style.willChange = 'auto';
-
                     // Handle drop
                     const dropResult = onDrop(originalFrom, to, piece);
                     const isTrashDrop = !to && (this.config.dropOffBoard === 'trash' || dropResult === 'trash');
-
                     if (isTrashDrop) {
                         this._handleTrashDrop(originalFrom, onRemove);
                     } else if (!to) {
@@ -3465,16 +3292,12 @@ var Chessboard = (function (exports) {
                     }
                 };
 
-                // --- Attach listeners (mouse + touch) ---
+                // Attach listeners (mouse + touch)
                 window.addEventListener('mouseup', onPointerUp, { once: true });
                 document.addEventListener('mousemove', onPointerMove);
                 img.addEventListener('mouseup', onPointerUp, { once: true });
-                // Touch events
                 window.addEventListener('touchend', onPointerUp, { once: true });
                 document.addEventListener('touchmove', onPointerMove, { passive: false });
-
-                // Per robustezza: se il drag parte da touch, blocca subito lo scroll
-                if (isTouch) addScrollLock();
             };
         }
 
@@ -3967,33 +3790,21 @@ var Chessboard = (function (exports) {
          * Removes all existing event listeners
          */
         removeListeners() {
-            this.eventListeners.forEach((listeners, squareId) => {
-                listeners.forEach(({ element, type, handler }) => {
-                    element.removeEventListener(type, handler);
-                });
-            });
-
-            this.eventListeners.clear();
+            this.listenerManager.removeAll();
         }
 
         /**
          * Removes all event listeners
          */
         removeAllListeners() {
-            this.eventListeners.forEach((listeners, squareId) => {
-                listeners.forEach(({ element, type, handler }) => {
-                    element.removeEventListener(type, handler);
-                });
-            });
-
-            this.eventListeners.clear();
+            this.listenerManager.removeAll();
         }
 
         /**
          * Cleans up resources
          */
         destroy() {
-            this.removeAllListeners();
+            this.listenerManager.destroy();
             this.clicked = null;
             this.promoting = false;
             this.isAnimating = false;
@@ -4001,7 +3812,7 @@ var Chessboard = (function (exports) {
     }
 
     /**
-     * Service for managing chess moves and move validation
+     * MoveService - Handles chess move management and validation
      * @module services/MoveService
      * @since 2.0.0
      */
@@ -4009,13 +3820,13 @@ var Chessboard = (function (exports) {
 
     /**
      * Service responsible for move management and validation
-     * @class
+     * @class MoveService
      */
     class MoveService {
         /**
-         * Creates a new MoveService instance
-         * @param {ChessboardConfig} config - Board configuration
-         * @param {PositionService} positionService - Position service instance
+         * Create a new MoveService instance
+         * @param {Object} config - Board configuration
+         * @param {Object} positionService - Position service instance
          */
         constructor(config, positionService) {
             this.config = config;
@@ -4025,43 +3836,32 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Checks if a piece on a square can move
+         * Check if a piece on a square can move
          * @param {Square} square - Square to check
          * @returns {boolean} True if piece can move
          */
         canMove(square) {
             if (!square.piece) return false;
-
             const { movableColors, onlyLegalMoves } = this.config;
-
             if (movableColors === 'none') return false;
             if (movableColors === 'w' && square.piece.color === 'b') return false;
             if (movableColors === 'b' && square.piece.color === 'w') return false;
-
             if (!onlyLegalMoves) return true;
-
-            // Check if position service and game are available
-            if (!this.positionService || !this.positionService.getGame()) {
-                return false;
-            }
-
+            if (!this.positionService || !this.positionService.getGame()) return false;
             const game = this.positionService.getGame();
             return square.piece.color === game.turn();
         }
 
         /**
-         * Converts various move formats to a Move instance
+         * Convert various move formats to a Move instance
          * @param {string|Move|Object} move - Move in various formats
          * @param {Object} squares - All board squares
          * @returns {Move} Move instance
          * @throws {MoveError} When move format is invalid
          */
         convertMove(move, squares) {
-            if (move instanceof Move$1) {
-                return move;
-            }
+            if (move instanceof Move$1) return move;
             if (typeof move === 'object' && move.from && move.to) {
-                // Se sono id, converto in oggetti; se sono già oggetti, li uso direttamente
                 const fromSquare = typeof move.from === 'string' ? squares[move.from] : move.from;
                 const toSquare = typeof move.to === 'string' ? squares[move.to] : move.to;
                 if (!fromSquare || !toSquare) throw new MoveError(ERROR_MESSAGES.invalid_move_format, move.from, move.to);
@@ -4080,13 +3880,12 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Checks if a move is legal
+         * Check if a move is legal
          * @param {Move} move - Move to check
          * @returns {boolean} True if move is legal
          */
         isLegalMove(move) {
             const legalMoves = this.getLegalMoves(move.from.id);
-
             return legalMoves.some(legalMove =>
                 legalMove.to === move.to.id &&
                 move.promotion === legalMove.promotion
@@ -4094,180 +3893,100 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Gets all legal moves for a square or the entire position
+         * Get all legal moves for a square or the entire position
          * @param {string} [from] - Square to get moves from (optional)
          * @param {boolean} [verbose=true] - Whether to return verbose move objects
          * @returns {Array} Array of legal moves
          */
         getLegalMoves(from = null, verbose = true) {
-            // Check if position service and game are available
-            if (!this.positionService || !this.positionService.getGame()) {
-                return [];
-            }
-
+            if (!this.positionService || !this.positionService.getGame()) return [];
             const game = this.positionService.getGame();
-
             if (!game) return [];
-
             const options = { verbose };
-            if (from) {
-                options.square = from;
-            }
-
+            if (from) options.square = from;
             return game.moves(options);
         }
 
         /**
-         * Gets legal moves with caching for performance
+         * Get legal moves with caching for performance
          * @param {Square} square - Square to get moves from
          * @returns {Array} Array of legal moves
          */
         getCachedLegalMoves(square) {
-            // Check if position service and game are available
-            if (!this.positionService || !this.positionService.getGame()) {
-                return [];
-            }
-
+            if (!this.positionService || !this.positionService.getGame()) return [];
             const game = this.positionService.getGame();
             if (!game) return [];
-
             const cacheKey = `${square.id}-${game.fen()}`;
             let moves = this._movesCache.get(cacheKey);
-
             if (!moves) {
                 moves = game.moves({ square: square.id, verbose: true });
                 this._movesCache.set(cacheKey, moves);
-
-                // Clear cache after a short delay to prevent memory buildup
-                if (this._cacheTimeout) {
-                    clearTimeout(this._cacheTimeout);
-                }
-
+                if (this._cacheTimeout) clearTimeout(this._cacheTimeout);
                 this._cacheTimeout = setTimeout(() => {
                     this._movesCache.clear();
                 }, 1000);
             }
-
             return moves;
         }
 
         /**
-         * Executes a move on the game
-         * @param {Move} move - Move to execute (deve essere oggetto Move)
+         * Execute a move on the game
+         * @param {Move} move - Move to execute (must be a Move object)
          * @returns {Object|null} Move result from chess.js or null if invalid
          */
         executeMove(move) {
-            if (!(move instanceof Move$1)) throw new Error('executeMove richiede un oggetto Move');
-            if (!this.positionService || !this.positionService.getGame()) {
-                return null;
-            }
+            if (!(move instanceof Move$1)) throw new Error('executeMove requires a Move object');
+            if (!this.positionService || !this.positionService.getGame()) return null;
             const game = this.positionService.getGame();
             if (!game) return null;
-            const moveOptions = {
-                from: move.from.id,
-                to: move.to.id
-            };
-            if (move.hasPromotion()) {
-                moveOptions.promotion = move.promotion;
-            }
+            const moveOptions = { from: move.from.id, to: move.to.id };
+            if (move.hasPromotion()) moveOptions.promotion = move.promotion;
             const result = game.move(moveOptions);
             return result;
         }
 
         /**
-         * Determina se una mossa richiede promozione
-         * @param {Move} move - Deve essere oggetto Move
+         * Determine if a move requires promotion
+         * @param {Move} move - Must be a Move object
          * @returns {boolean}
          */
         requiresPromotion(move) {
-            if (!(move instanceof Move$1)) throw new Error('requiresPromotion richiede un oggetto Move');
-            console.log('Checking if move requires promotion:', move.from.id, '->', move.to.id);
-
-            if (!this.config.onlyLegalMoves) {
-                console.log('Not in legal moves mode, no promotion required');
-                return false;
-            }
-
+            if (!(move instanceof Move$1)) throw new Error('requiresPromotion requires a Move object');
+            if (!this.config.onlyLegalMoves) return false;
             const game = this.positionService.getGame();
-            if (!game) {
-                console.log('No game instance available');
-                return false;
-            }
-
+            if (!game) return false;
             const piece = game.get(move.from.id);
-            if (!piece || piece.type !== 'p') {
-                console.log('Not a pawn move, no promotion required');
-                return false;
-            }
-
+            if (!piece || piece.type !== 'p') return false;
             const targetRank = move.to.row;
-            if (targetRank !== 1 && targetRank !== 8) {
-                console.log('Not reaching promotion rank, no promotion required');
-                return false;
-            }
-
-            console.log('Pawn reaching promotion rank, validating move...');
-
-            // Additional validation: check if the pawn can actually reach this square
-            if (!this._isPawnMoveValid(move.from, move.to, piece.color)) {
-                console.log('Pawn move not valid, no promotion required');
-                return false;
-            }
-
-            // First check if the move is legal without promotion
-            const simpleMoveObj = {
-                from: move.from.id,
-                to: move.to.id
-            };
-
+            if (targetRank !== 1 && targetRank !== 8) return false;
+            if (!this._isPawnMoveValid(move.from, move.to, piece.color)) return false;
+            // Try move without promotion
+            const simpleMoveObj = { from: move.from.id, to: move.to.id };
             try {
-                console.log('Testing move without promotion:', simpleMoveObj);
-                // Test if the move is legal without promotion first
                 const testMove = game.move(simpleMoveObj);
                 if (testMove) {
-                    // Move was successful, but check if it was a promotion
                     const wasPromotion = testMove.promotion;
-
-                    // Undo the test move
                     game.undo();
-
-                    console.log('Move successful without promotion, was promotion:', wasPromotion !== undefined);
-
-                    // If it was a promotion, return true
                     return wasPromotion !== undefined;
                 }
             } catch (error) {
-                console.log('Move failed without promotion, trying with promotion:', error.message);
-
-                // If simple move fails, try with promotion
-                const promotionMoveObj = {
-                    from: move.from.id,
-                    to: move.to.id,
-                    promotion: 'q' // test with queen
-                };
-
+                // Try with promotion
+                const promotionMoveObj = { from: move.from.id, to: move.to.id, promotion: 'q' };
                 try {
-                    console.log('Testing move with promotion:', promotionMoveObj);
                     const testMove = game.move(promotionMoveObj);
                     if (testMove) {
-                        // Undo the test move
                         game.undo();
-                        console.log('Move successful with promotion, promotion required');
                         return true;
                     }
                 } catch (promotionError) {
-                    console.log('Move failed even with promotion:', promotionError.message);
-                    // Move is not legal even with promotion
                     return false;
                 }
             }
-
-            console.log('Move validation complete, no promotion required');
             return false;
         }
 
         /**
-         * Validates if a pawn move is theoretically possible
+         * Validate if a pawn move is theoretically possible
          * @private
          * @param {Square} from - Source square
          * @param {Square} to - Target square
@@ -4279,48 +3998,21 @@ var Chessboard = (function (exports) {
             const toRank = to.row;
             const fromFile = from.col;
             const toFile = to.col;
-
-            console.log(`Validating pawn move: ${from.id} -> ${to.id} (${color})`);
-            console.log(`Ranks: ${fromRank} -> ${toRank}, Files: ${fromFile} -> ${toFile}`);
-
-            // Direction of pawn movement
             const direction = color === 'w' ? 1 : -1;
             const rankDiff = toRank - fromRank;
             const fileDiff = Math.abs(toFile - fromFile);
-
-            // Pawn can only move forward
-            if (rankDiff * direction <= 0) {
-                console.log('Invalid: Pawn cannot move backward or stay in place');
-                return false;
-            }
-
-            // Pawn can only move 1 rank at a time (except for double move from starting position)
-            if (Math.abs(rankDiff) > 2) {
-                console.log('Invalid: Pawn cannot move more than 2 ranks');
-                return false;
-            }
-
-            // If moving 2 ranks, must be from starting position
+            if (rankDiff * direction <= 0) return false;
+            if (Math.abs(rankDiff) > 2) return false;
             if (Math.abs(rankDiff) === 2) {
                 const startingRank = color === 'w' ? 2 : 7;
-                if (fromRank !== startingRank) {
-                    console.log(`Invalid: Pawn cannot move 2 ranks from rank ${fromRank}`);
-                    return false;
-                }
-            }
-
-            // Pawn can only move to adjacent files (diagonal capture) or same file (forward move)
-            if (fileDiff > 1) {
-                console.log('Invalid: Pawn cannot move more than 1 file');
-                return false;
+                if (fromRank !== startingRank) return false;
             }
-
-            console.log('Pawn move validation passed');
+            if (fileDiff > 1) return false;
             return true;
         }
 
         /**
-         * Handles promotion UI setup
+         * Handle promotion UI setup
          * @param {Move} move - Move requiring promotion
          * @param {Object} squares - All board squares
          * @param {Function} onPromotionSelect - Callback when promotion piece is selected
@@ -4329,55 +4021,33 @@ var Chessboard = (function (exports) {
          */
         setupPromotion(move, squares, onPromotionSelect, onPromotionCancel) {
             if (!this.requiresPromotion(move)) return false;
-
-            // Check if position service and game are available
-            if (!this.positionService || !this.positionService.getGame()) {
-                return false;
-            }
-
+            if (!this.positionService || !this.positionService.getGame()) return false;
             const game = this.positionService.getGame();
             const piece = game.get(move.from.id);
             const targetSquare = move.to;
-
-            // Clear any existing promotion UI
             Object.values(squares).forEach(square => {
                 square.removePromotion();
                 square.removeCover();
             });
-
-            // Always show promotion choices in a column
             this._showPromotionInColumn(targetSquare, piece, squares, onPromotionSelect, onPromotionCancel);
-
             return true;
         }
 
         /**
-         * Shows promotion choices in a column
+         * Show promotion choices in a column
          * @private
          */
         _showPromotionInColumn(targetSquare, piece, squares, onPromotionSelect, onPromotionCancel) {
-            console.log('Setting up promotion for', targetSquare.id, 'piece color:', piece.color);
-
-            // Set up promotion choices starting from border row
             PROMOTION_PIECES.forEach((pieceType, index) => {
                 const choiceSquare = this._findPromotionSquare(targetSquare, index, squares);
-
                 if (choiceSquare) {
                     const pieceId = pieceType + piece.color;
                     const piecePath = this._getPiecePathForPromotion(pieceId);
-
-                    console.log('Setting up promotion choice:', pieceType, 'on square:', choiceSquare.id);
-
                     choiceSquare.putPromotion(piecePath, () => {
-                        console.log('Promotion choice selected:', pieceType);
                         onPromotionSelect(pieceType);
                     });
-                } else {
-                    console.log('Could not find square for promotion choice:', pieceType, 'index:', index);
                 }
             });
-
-            // Set up cover squares (for cancellation)
             Object.values(squares).forEach(square => {
                 if (!square.hasPromotion()) {
                     square.putCover(() => {
@@ -4385,181 +4055,119 @@ var Chessboard = (function (exports) {
                     });
                 }
             });
-
             return true;
         }
 
         /**
-         * Finds the appropriate square for a promotion piece
+         * Find the appropriate square for a promotion piece
          * @private
          * @param {Square} targetSquare - Target square of the promotion move
-         * @param {number} distance - Distance from target square
+         * @param {number} index - Distance from target square
          * @param {Object} squares - All board squares
          * @returns {Square|null} Square for promotion piece or null
          */
         _findPromotionSquare(targetSquare, index, squares) {
             const col = targetSquare.col;
             const baseRow = targetSquare.row;
-
-            console.log('Looking for promotion square - target:', targetSquare.id, 'index:', index, 'col:', col, 'baseRow:', baseRow);
-
-            // Calculate row based on index and promotion direction
-            // Start from the border row (1 or 8) and go inward
             let row;
             if (baseRow === 8) {
-                // White promotion: start from row 8 and go down
                 row = 8 - index;
             } else if (baseRow === 1) {
-                // Black promotion: start from row 1 and go up
                 row = 1 + index;
             } else {
-                console.log('Invalid promotion row:', baseRow);
                 return null;
             }
-
-            console.log('Calculated row:', row);
-
-            // Ensure row is within bounds
-            if (row < 1 || row > 8) {
-                console.log('Row out of bounds:', row);
-                return null;
-            }
-
-            // Find square by row/col
+            if (row < 1 || row > 8) return null;
             for (const square of Object.values(squares)) {
                 if (square.col === col && square.row === row) {
-                    console.log('Found promotion square:', square.id);
                     return square;
                 }
             }
-
-            console.log('No square found for col:', col, 'row:', row);
             return null;
         }
 
         /**
-         * Gets piece path for promotion UI
+         * Get piece path for promotion UI
          * @private
          * @param {string} pieceId - Piece identifier
          * @returns {string} Path to piece asset
          */
         _getPiecePathForPromotion(pieceId) {
-            // This would typically use the PieceService
-            // For now, we'll use a simple implementation
             const { piecesPath } = this.config;
-
             if (typeof piecesPath === 'string') {
                 return `${piecesPath}/${pieceId}.svg`;
             }
-
-            // Fallback for other path types
             return `assets/pieces/${pieceId}.svg`;
         }
 
         /**
-         * Parses a move string into a move object
+         * Parse a move string into a move object
          * @param {string} moveString - Move string (e.g., 'e2e4', 'e7e8q')
          * @returns {Object|null} Move object or null if invalid
          */
         parseMove(moveString) {
-            if (typeof moveString !== 'string' || moveString.length < 4 || moveString.length > 5) {
-                return null;
-            }
-
+            if (typeof moveString !== 'string' || moveString.length < 4 || moveString.length > 5) return null;
             const from = moveString.slice(0, 2);
             const to = moveString.slice(2, 4);
             const promotion = moveString.slice(4, 5);
-
-            // Basic validation
-            if (!/^[a-h][1-8]$/.test(from) || !/^[a-h][1-8]$/.test(to)) {
-                return null;
-            }
-
-            if (promotion && !['q', 'r', 'b', 'n'].includes(promotion.toLowerCase())) {
-                return null;
-            }
-
-            return {
-                from: from,
-                to: to,
-                promotion: promotion || null
-            };
+            if (!/^[a-h][1-8]$/.test(from) || !/^[a-h][1-8]$/.test(to)) return null;
+            if (promotion && !['q', 'r', 'b', 'n'].includes(promotion.toLowerCase())) return null;
+            return { from, to, promotion: promotion || null };
         }
 
         /**
-         * Checks if a move is a castle move
+         * Check if a move is a castle move
          * @param {Object} gameMove - Game move object from chess.js
          * @returns {boolean} True if move is castle
          */
         isCastle(gameMove) {
-            return gameMove && (gameMove.isKingsideCastle() || gameMove.isQueensideCastle());
+            return gameMove && (gameMove.isKingsideCastle && gameMove.isKingsideCastle() || gameMove.isQueensideCastle && gameMove.isQueensideCastle());
         }
 
         /**
-         * Gets the rook move for a castle move
+         * Get the rook move for a castle move
          * @param {Object} gameMove - Game move object from chess.js
          * @returns {Object|null} Rook move object or null if not castle
          */
         getCastleRookMove(gameMove) {
-            if (!this.isCastle(gameMove)) {
-                return null;
-            }
-
+            if (!this.isCastle(gameMove)) return null;
             const isKingSide = gameMove.isKingsideCastle();
             const isWhite = gameMove.color === 'w';
-
             if (isKingSide) {
-                // King side castle
-                if (isWhite) {
-                    return { from: 'h1', to: 'f1' };
-                } else {
-                    return { from: 'h8', to: 'f8' };
-                }
+                return isWhite ? { from: 'h1', to: 'f1' } : { from: 'h8', to: 'f8' };
             } else {
-                // Queen side castle
-                if (isWhite) {
-                    return { from: 'a1', to: 'd1' };
-                } else {
-                    return { from: 'a8', to: 'd8' };
-                }
+                return isWhite ? { from: 'a1', to: 'd1' } : { from: 'a8', to: 'd8' };
             }
         }
 
         /**
-         * Checks if a move is en passant
+         * Check if a move is en passant
          * @param {Object} gameMove - Game move object from chess.js
          * @returns {boolean} True if move is en passant
          */
         isEnPassant(gameMove) {
-            return gameMove && gameMove.isEnPassant();
+            return gameMove && gameMove.isEnPassant && gameMove.isEnPassant();
         }
 
         /**
-         * Gets the captured pawn square for en passant
+         * Get the captured pawn square for en passant
          * @param {Object} gameMove - Game move object from chess.js
          * @returns {string|null} Square of captured pawn or null if not en passant
          */
         getEnPassantCapturedSquare(gameMove) {
-            if (!this.isEnPassant(gameMove)) {
-                return null;
-            }
-
+            if (!this.isEnPassant(gameMove)) return null;
             const toSquare = gameMove.to;
             const rank = parseInt(toSquare[1]);
             const file = toSquare[0];
-
-            // The captured pawn is on the same file but different rank
             if (gameMove.color === 'w') {
-                // White captures black pawn one rank below
                 return file + (rank - 1);
             } else {
-                // Black captures white pawn one rank above
                 return file + (rank + 1);
             }
         }
 
         /**
-         * Clears the moves cache
+         * Clear the moves cache
          */
         clearCache() {
             this._movesCache.clear();
@@ -4570,7 +4178,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Cleans up resources
+         * Clean up resources
          */
         destroy() {
             this.clearCache();
@@ -4579,7 +4187,7 @@ var Chessboard = (function (exports) {
     }
 
     /**
-     * Service for managing chess pieces and their operations
+     * PieceService - Handles chess piece management and operations
      * @module services/PieceService
      * @since 2.0.0
      */
@@ -4587,11 +4195,11 @@ var Chessboard = (function (exports) {
 
     /**
      * Service responsible for piece management and operations
-     * @class
+     * @class PieceService
      */
     class PieceService {
         /**
-         * Creates a new PieceService instance
+         * Create a new PieceService instance
          * @param {ChessboardConfig} config - Board configuration
          */
         constructor(config) {
@@ -4599,14 +4207,13 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Gets the path to a piece asset
+         * Get the path to a piece asset
          * @param {string} piece - Piece identifier (e.g., 'wK', 'bP')
          * @returns {string} Path to piece asset
          * @throws {ValidationError} When piecesPath configuration is invalid
          */
         getPiecePath(piece) {
             const { piecesPath } = this.config;
-
             if (typeof piecesPath === 'string') {
                 return `${piecesPath}/${piece}.svg`;
             } else if (typeof piecesPath === 'object' && piecesPath !== null) {
@@ -4619,7 +4226,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Converts various piece formats to a Piece instance
+         * Convert various piece formats to a Piece instance
          * @param {string|Piece} piece - Piece in various formats
          * @returns {Piece} Piece instance
          * @throws {PieceError} When piece format is invalid
@@ -4628,54 +4235,41 @@ var Chessboard = (function (exports) {
             if (piece instanceof Piece) {
                 return piece;
             }
-
             if (typeof piece === 'string' && piece.length === 2) {
                 const [first, second] = piece.split('');
                 let type, color;
-
-                // Check format: [type][color] (e.g., 'pw')
                 if (PIECE_TYPES.includes(first.toLowerCase()) && PIECE_COLORS.includes(second)) {
                     type = first.toLowerCase();
                     color = second;
-                }
-                // Check format: [color][type] (e.g., 'wP')
-                else if (PIECE_COLORS.includes(first) && PIECE_TYPES.includes(second.toLowerCase())) {
+                } else if (PIECE_COLORS.includes(first) && PIECE_TYPES.includes(second.toLowerCase())) {
                     color = first;
                     type = second.toLowerCase();
                 } else {
                     throw new PieceError(ERROR_MESSAGES.invalid_piece + piece, piece);
                 }
-
                 const piecePath = this.getPiecePath(type + color);
                 return new Piece(color, type, piecePath);
             }
-
             throw new PieceError(ERROR_MESSAGES.invalid_piece + piece, piece);
         }
 
         /**
-         * Adds a piece to a square with optional fade-in animation
-         * @param {Square} square - Target square (oggetto)
-         * @param {Piece} piece - Piece to add (oggetto)
+         * Add a piece to a square with optional fade-in animation
+         * @param {Square} square - Target square
+         * @param {Piece} piece - Piece to add
          * @param {boolean} [fade=true] - Whether to fade in the piece
          * @param {Function} dragFunction - Function to handle drag events
          * @param {Function} [callback] - Callback when animation completes
          */
         addPieceOnSquare(square, piece, fade = true, dragFunction, callback) {
-            if (!square || !piece) throw new Error('addPieceOnSquare richiede oggetti Square e Piece');
-            console.debug(`[PieceService] addPieceOnSquare: ${piece.id} to ${square.id}`);
+            if (!square || !piece) throw new Error('addPieceOnSquare requires Square and Piece objects');
             square.putPiece(piece);
-
-            // Imposta sempre il drag (touch e mouse)
             if (dragFunction) {
                 piece.setDrag(dragFunction(square, piece));
             }
-            // Forza il drag touch se manca (debug/robustezza)
             if (!piece.element.ontouchstart) {
                 piece.element.ontouchstart = dragFunction ? dragFunction(square, piece) : () => { };
-                console.debug(`[PieceService] Forzato ontouchstart su ${piece.id}`);
             }
-
             if (fade && this.config.fadeTime > 0) {
                 piece.fadeIn(
                     this.config.fadeTime,
@@ -4686,28 +4280,24 @@ var Chessboard = (function (exports) {
             } else {
                 if (callback) callback();
             }
-
             piece.visible();
         }
 
         /**
-         * Rimuove un pezzo da una casella
-         * @param {Square} square - Oggetto Square
+         * Remove a piece from a square
+         * @param {Square} square - Square object
          * @param {boolean} [fade=true]
          * @param {Function} [callback]
-         * @returns {Piece} Il pezzo rimosso
+         * @returns {Piece} The removed piece
          */
         removePieceFromSquare(square, fade = true, callback) {
-            if (!square) throw new Error('removePieceFromSquare richiede oggetto Square');
-            console.debug(`[PieceService] removePieceFromSquare: ${square.id}`);
+            if (!square) throw new Error('removePieceFromSquare requires a Square object');
             square.check();
-
             const piece = square.piece;
             if (!piece) {
                 if (callback) callback();
                 throw new PieceError(ERROR_MESSAGES.square_no_piece, null, square.getId());
             }
-
             if (fade && this.config.fadeTime > 0) {
                 piece.fadeOut(
                     this.config.fadeTime,
@@ -4718,26 +4308,22 @@ var Chessboard = (function (exports) {
             } else {
                 if (callback) callback();
             }
-
             square.removePiece();
             return piece;
         }
 
         /**
-         * Moves a piece to a new position with animation
+         * Move a piece to a new position with animation
          * @param {Piece} piece - Piece to move
          * @param {Square} targetSquare - Target square
          * @param {number} duration - Animation duration
          * @param {Function} [callback] - Callback function when animation completes
          */
         movePiece(piece, targetSquare, duration, callback) {
-            console.debug(`[PieceService] movePiece: ${piece.id} to ${targetSquare.id}`);
             if (!piece || !piece.element) {
-                console.warn(`[PieceService] movePiece: piece or element is null, skipping animation`);
                 if (callback) callback();
                 return;
             }
-
             piece.translate(
                 targetSquare,
                 duration,
@@ -4748,7 +4334,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Handles piece translation with optional capture
+         * Handle piece translation with optional capture
          * @param {Move} move - Move object containing from/to squares and piece
          * @param {boolean} removeTarget - Whether to remove piece from target square
          * @param {boolean} animate - Whether to animate the move
@@ -4756,54 +4342,37 @@ var Chessboard = (function (exports) {
          * @param {Function} [callback] - Callback function when complete
          */
         translatePiece(move, removeTarget, animate, dragFunction = null, callback = null) {
-            console.debug(`[PieceService] translatePiece: ${move.piece.id} from ${move.from.id} to ${move.to.id}`);
             if (!move.piece) {
-                console.warn('PieceService.translatePiece: move.piece is null, skipping translation');
                 if (callback) callback();
                 return;
             }
-
             if (removeTarget) {
-                // Deselect the captured piece before removing it
                 move.to.deselect();
                 this.removePieceFromSquare(move.to, false);
             }
-
             const changeSquareCallback = () => {
-                // Check if piece still exists and is on the source square
                 if (move.from.piece === move.piece) {
-                    move.from.removePiece(true); // Preserve the piece when moving
+                    move.from.removePiece(true);
                 }
-
-                // Only put piece if destination square doesn't already have it
                 if (move.to.piece !== move.piece) {
                     move.to.putPiece(move.piece);
-
-                    // Re-attach drag handler if provided
                     if (dragFunction && this.config.draggable && move.piece.element) {
                         move.piece.setDrag(dragFunction(move.to, move.piece));
                     }
                 }
-
                 if (callback) callback();
             };
-
-            // Check if piece is currently being dragged
             const isDragging = move.piece.element && move.piece.element.classList.contains('dragging');
-
             if (isDragging) {
-                // If piece is being dragged, don't animate - just move it immediately
-                // The piece is already visually in the correct position from the drag
                 changeSquareCallback();
             } else {
-                // Normal animation
                 const duration = animate ? this.config.moveTime : 0;
                 this.movePiece(move.piece, move.to, duration, changeSquareCallback);
             }
         }
 
         /**
-         * Snaps a piece back to its original position
+         * Snap a piece back to its original position
          * @param {Square} square - Square containing the piece
          * @param {boolean} [animate=true] - Whether to animate the snapback
          */
@@ -4813,7 +4382,6 @@ var Chessboard = (function (exports) {
             }
             const piece = square.piece;
             const duration = animate ? this.config.snapbackTime : 0;
-            console.debug(`[PieceService] snapbackPiece: ${piece.id} on ${square.id}`);
             piece.translate(
                 square,
                 duration,
@@ -4823,7 +4391,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Centers a piece in its square with animation (after successful drop)
+         * Center a piece in its square with animation (after successful drop)
          * @param {Square} square - Square containing the piece to center
          * @param {boolean} animate - Whether to animate the centering
          */
@@ -4833,14 +4401,12 @@ var Chessboard = (function (exports) {
             }
             const piece = square.piece;
             const duration = animate ? this.config.dropCenterTime : 0;
-            console.debug(`[PieceService] centerPiece: ${piece.id} on ${square.id}`);
             piece.translate(
                 square,
                 duration,
                 this._getTransitionTimingFunction(),
                 this.config.dropCenterAnimation,
                 () => {
-                    // After animation, reset all drag-related styles
                     if (!piece.element) return;
                     piece.element.style.position = '';
                     piece.element.style.left = '';
@@ -4852,14 +4418,13 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Gets the transition timing function for animations
+         * Get the transition timing function for animations
          * @private
          * @returns {Function} Timing function
          */
         _getTransitionTimingFunction() {
             return (elapsed, duration, type = 'ease') => {
                 const x = elapsed / duration;
-
                 switch (type) {
                     case 'linear':
                         return x;
@@ -4878,7 +4443,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Cleans up resources
+         * Clean up resources
          */
         destroy() {
             // Cleanup any cached pieces or references
@@ -6869,7 +6434,7 @@ var Chessboard = (function (exports) {
     }
 
     /**
-     * Service for managing chess positions and FEN conversion
+     * PositionService - Handles chess position management and FEN conversion
      * @module services/PositionService
      * @since 2.0.0
      */
@@ -6877,11 +6442,11 @@ var Chessboard = (function (exports) {
 
     /**
      * Service responsible for position management and FEN operations
-     * @class
+     * @class PositionService
      */
     class PositionService {
         /**
-         * Creates a new PositionService instance
+         * Create a new PositionService instance
          * @param {ChessboardConfig} config - Board configuration
          */
         constructor(config) {
@@ -6890,7 +6455,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Converts various position formats to FEN string
+         * Convert various position formats to FEN string
          * @param {string|Object} position - Position in various formats
          * @returns {string} FEN string representation
          * @throws {ValidationError} When position format is invalid
@@ -6906,7 +6471,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Converts string position to FEN
+         * Convert string position to FEN
          * @private
          * @param {string} position - String position
          * @returns {string} FEN string
@@ -6915,35 +6480,29 @@ var Chessboard = (function (exports) {
             if (position === 'start') {
                 return DEFAULT_STARTING_POSITION;
             }
-            
             if (this.validateFen(position)) {
                 return position;
             }
-            
             if (STANDARD_POSITIONS[position]) {
                 return STANDARD_POSITIONS[position];
             }
-            
             throw new ValidationError(ERROR_MESSAGES.invalid_position + position, 'position', position);
         }
 
         /**
-         * Converts object position to FEN
+         * Convert object position to FEN
          * @private
          * @param {Object} position - Object with square->piece mapping
          * @returns {string} FEN string
          */
         _convertObjectPosition(position) {
             const parts = [];
-            
             for (let row = 0; row < 8; row++) {
                 const rowParts = [];
                 let empty = 0;
-                
                 for (let col = 0; col < 8; col++) {
                     const square = this._getSquareID(row, col);
                     const piece = position[square];
-                    
                     if (piece) {
                         if (empty > 0) {
                             rowParts.push(empty);
@@ -6956,25 +6515,21 @@ var Chessboard = (function (exports) {
                         empty++;
                     }
                 }
-                
                 if (empty > 0) {
                     rowParts.push(empty);
                 }
-                
                 parts.push(rowParts.join(''));
             }
-            
             return parts.join('/') + ' w KQkq - 0 1';
         }
 
         /**
-         * Sets up the game with the given position
+         * Set up the game with the given position
          * @param {string|Object} position - Position to set
          * @param {Object} [options] - Additional options for game setup
          */
         setGame(position, options = {}) {
             const fen = this.convertFen(position);
-            
             if (this.game) {
                 this.game.load(fen, options);
             } else {
@@ -6983,7 +6538,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Gets the current game instance
+         * Get the current game instance
          * @returns {Chess} Current chess.js game instance
          */
         getGame() {
@@ -6991,7 +6546,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Validates a FEN string
+         * Validate a FEN string
          * @param {string} fen - FEN string to validate
          * @returns {boolean} True if valid, false otherwise
          */
@@ -7000,7 +6555,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Gets piece information for a specific square
+         * Get piece information for a specific square
          * @param {string} squareId - Square identifier
          * @returns {string|null} Piece ID or null if no piece
          */
@@ -7011,7 +6566,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Checks if a specific piece is on a specific square
+         * Check if a specific piece is on a specific square
          * @param {string} piece - Piece ID to check
          * @param {string} square - Square to check
          * @returns {boolean} True if piece is on square
@@ -7021,7 +6576,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Converts board coordinates to square ID
+         * Convert board coordinates to square ID
          * @private
          * @param {number} row - Row index (0-7)
          * @param {number} col - Column index (0-7)
@@ -7030,7 +6585,6 @@ var Chessboard = (function (exports) {
         _getSquareID(row, col) {
             row = parseInt(row);
             col = parseInt(col);
-            
             if (this.config.orientation === 'w') {
                 row = 8 - row;
                 col = col + 1;
@@ -7038,13 +6592,12 @@ var Chessboard = (function (exports) {
                 row = row + 1;
                 col = 8 - col;
             }
-            
             const letter = BOARD_LETTERS[col - 1];
             return letter + row;
         }
 
         /**
-         * Changes the turn in a FEN string
+         * Change the turn in a FEN string
          * @param {string} fen - Original FEN string
          * @param {string} color - New turn color ('w' or 'b')
          * @returns {string} Modified FEN string
@@ -7056,35 +6609,33 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Gets the current position as an object
+         * Get the current position as an object
          * @returns {Object} Position object with piece placements
          */
         getPosition() {
             const position = {};
             const game = this.getGame();
-            
-            // Convert chess.js board to position object
-            const squares = ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h1',
-                            'a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2', 'h2',
-                            'a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', 'h3',
-                            'a4', 'b4', 'c4', 'd4', 'e4', 'f4', 'g4', 'h4',
-                            'a5', 'b5', 'c5', 'd5', 'e5', 'f5', 'g5', 'h5',
-                            'a6', 'b6', 'c6', 'd6', 'e6', 'f6', 'g6', 'h6',
-                            'a7', 'b7', 'c7', 'd7', 'e7', 'f7', 'g7', 'h7',
-                            'a8', 'b8', 'c8', 'd8', 'e8', 'f8', 'g8', 'h8'];
-            
+            const squares = [
+                'a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h1',
+                'a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2', 'h2',
+                'a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', 'h3',
+                'a4', 'b4', 'c4', 'd4', 'e4', 'f4', 'g4', 'h4',
+                'a5', 'b5', 'c5', 'd5', 'e5', 'f5', 'g5', 'h5',
+                'a6', 'b6', 'c6', 'd6', 'e6', 'f6', 'g6', 'h6',
+                'a7', 'b7', 'c7', 'd7', 'e7', 'f7', 'g7', 'h7',
+                'a8', 'b8', 'c8', 'd8', 'e8', 'f8', 'g8', 'h8'
+            ];
             for (const square of squares) {
                 const piece = game.get(square);
                 if (piece) {
                     position[square] = piece.type + piece.color;
                 }
             }
-            
             return position;
         }
 
         /**
-         * Toggles the turn in a FEN string
+         * Toggle the turn in a FEN string
          * @param {string} fen - Original FEN string
          * @returns {string} Modified FEN string
          */
@@ -7095,7 +6646,7 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Cleans up resources
+         * Clean up resources
          */
         destroy() {
             this.game = null;
@@ -7103,7 +6654,8 @@ var Chessboard = (function (exports) {
     }
 
     /**
-     * Main Chessboard class - Orchestrates all services and components
+     * Chessboard - Main class orchestrating all services and components
+     * Implements the Facade pattern for the chessboard API
      * @module core/Chessboard
      * @since 2.0.0
      */
@@ -7111,12 +6663,11 @@ var Chessboard = (function (exports) {
 
     /**
      * Main Chessboard class responsible for coordinating all services
-     * Implements the Facade pattern to provide a unified interface
-     * @class
+     * @class Chessboard
      */
-    class Chessboard {
+    let Chessboard$1 = class Chessboard {
         /**
-         * Creates a new Chessboard instance
+         * Create a new Chessboard instance
          * @param {Object} config - Configuration object
          * @throws {ConfigurationError} If configuration is invalid
          */
@@ -7139,6 +6690,8 @@ var Chessboard = (function (exports) {
             } catch (error) {
                 this._handleConstructorError(error);
             }
+            this._undoneMoves = [];
+            this._updateBoardPieces(true, true); // Forza popolamento DOM subito
         }
 
         /**
@@ -7182,6 +6735,31 @@ var Chessboard = (function (exports) {
             }
         }
 
+        /**
+         * Cleans up any partially initialized resources (safe to call multiple times)
+         * @private
+         */
+        _cleanup() {
+            // Remove event listeners if present
+            if (this.eventService && typeof this.eventService.removeListeners === 'function') {
+                this.eventService.removeListeners();
+            }
+            // Clear timeouts
+            if (this._updateTimeout) {
+                clearTimeout(this._updateTimeout);
+                this._updateTimeout = null;
+            }
+            // Null all services
+            this.validationService = null;
+            this.coordinateService = null;
+            this.positionService = null;
+            this.boardService = null;
+            this.pieceService = null;
+            this.animationService = null;
+            this.moveService = null;
+            this.eventService = null;
+        }
+
         /**
          * Initializes all services
          * @private
@@ -7250,8 +6828,23 @@ var Chessboard = (function (exports) {
         /**
          * Builds the board DOM structure
          * @private
+         * Best practice: always remove squares (destroy JS/DOM) before clearing the board container.
          */
         _buildBoard() {
+            console.log('CHIAMATO: _buildBoard');
+            if (this._isUndoRedo) {
+                console.log('SKIP _buildBoard per undo/redo');
+                return;
+            }
+            // Forza la pulizia completa del contenitore board (DOM)
+            const boardContainer = document.getElementById(this.config.id_div);
+            if (boardContainer) boardContainer.innerHTML = '';
+            // Force remove all pieces from all squares (no animation, best practice)
+            if (this.boardService && this.boardService.squares) {
+                Object.values(this.boardService.squares).forEach(sq => sq && sq.forceRemoveAllPieces && sq.forceRemoveAllPieces());
+            }
+            if (this.boardService && this.boardService.removeSquares) this.boardService.removeSquares();
+            if (this.boardService && this.boardService.removeBoard) this.boardService.removeBoard();
             this.boardService.buildBoard();
         }
 
@@ -7260,6 +6853,14 @@ var Chessboard = (function (exports) {
          * @private
          */
         _buildSquares() {
+            console.log('CHIAMATO: _buildSquares');
+            if (this._isUndoRedo) {
+                console.log('SKIP _buildSquares per undo/redo');
+                return;
+            }
+            if (this.boardService && this.boardService.removeSquares) {
+                this.boardService.removeSquares();
+            }
             this.boardService.buildSquares((row, col) => {
                 return this.coordinateService.realCoord(row, col);
             });
@@ -7464,7 +7065,7 @@ var Chessboard = (function (exports) {
                     const capturedPiece = move.to.piece;
 
                     // For castle moves in simultaneous mode, we need to coordinate both animations
-                    if (isCastleMove && this.config.animationStyle === 'simultaneous') {
+                    if (isCastleMove) {
                         // Start king animation
                         this.pieceService.translatePiece(
                             move,
@@ -7629,6 +7230,7 @@ var Chessboard = (function (exports) {
          * @param {boolean} [isPositionLoad=false] - Whether this is a position load
          */
         _updateBoardPieces(animation = false, isPositionLoad = false) {
+            console.log('CHIAMATO: _updateBoardPieces', { animation, isPositionLoad, isUndoRedo: this._isUndoRedo });
             // Check if services are available
             if (!this.positionService || !this.moveService || !this.eventService) {
                 console.log('Cannot update board pieces - services not available');
@@ -7688,112 +7290,125 @@ var Chessboard = (function (exports) {
         }
 
         /**
-         * Performs the actual board update
+         * Aggiorna i pezzi sulla scacchiera con animazione e delay configurabile (greedy matching)
          * @private
-         * @param {boolean} [animation=false] - Whether to animate
-         * @param {boolean} [isPositionLoad=false] - Whether this is a position load (affects delay)
+         * @param {boolean} [animation=false] - Se animare
+         * @param {boolean} [isPositionLoad=false] - Se è un caricamento posizione (delay 0)
          */
         _doUpdateBoardPieces(animation = false, isPositionLoad = false) {
-            // Skip update if we're in the middle of a promotion
-            if (this._isPromoting) {
-                console.log('Skipping board update during promotion');
-                return;
-            }
-
-            // Check if services are available
-            if (!this.positionService || !this.positionService.getGame()) {
-                console.log('Cannot update board pieces - position service not available');
-                return;
-            }
-
+            if (this._isDragging) return;
+            if (this._isPromoting) return;
+            if (!this.positionService || !this.positionService.getGame()) return;
             const squares = this.boardService.getAllSquares();
             const gameStateBefore = this.positionService.getGame().fen();
-
-            console.log('_doUpdateBoardPieces - current FEN:', gameStateBefore);
-            console.log('_doUpdateBoardPieces - animation:', animation, 'style:', this.config.animationStyle, 'isPositionLoad:', isPositionLoad);
-
-            // Determine which animation style to use
-            const useSimultaneous = this.config.animationStyle === 'simultaneous';
-            console.log('_doUpdateBoardPieces - useSimultaneous:', useSimultaneous);
-
-            if (useSimultaneous) {
-                console.log('Using simultaneous animation');
-                this._doSimultaneousUpdate(squares, gameStateBefore, isPositionLoad);
-            } else {
-                console.log('Using sequential animation');
-                this._doSequentialUpdate(squares, gameStateBefore, animation);
+            if (/^8\/8\/8\/8\/8\/8\/8\/8/.test(gameStateBefore)) {
+                const boardContainer = document.getElementById(this.config.id_div);
+                if (boardContainer) {
+                    const pieceElements = boardContainer.querySelectorAll('.piece');
+                    pieceElements.forEach(element => element.remove());
+                }
+                Object.values(squares).forEach(sq => { if (sq && sq.piece) sq.piece = null; });
+                this._clearVisualState();
+                this._addListeners();
+                if (this.config.onChange) this.config.onChange(gameStateBefore);
+                return;
             }
-        }
 
-        /**
-         * Performs sequential piece updates (original behavior)
-         * @private
-         * @param {Object} squares - All squares
-         * @param {string} gameStateBefore - Game state before update
-         * @param {boolean} animation - Whether to animate
-         */
-        _doSequentialUpdate(squares, gameStateBefore, animation) {
-            // Update each square sequentially
+            // --- Matching greedy tra attuale e atteso ---
+            const currentMap = {};
+            const expectedMap = {};
             Object.values(squares).forEach(square => {
-                const expectedPieceId = this.positionService.getGamePieceId(square.id);
                 const currentPiece = square.piece;
-                const currentPieceId = currentPiece ? currentPiece.getId() : null;
-
-                // Log only for squares that are changing
-                if (currentPieceId !== expectedPieceId) {
-                    console.log(`_doSequentialUpdate - ${square.id}: ${currentPieceId} -> ${expectedPieceId}`);
-
-                    // Check if we already have the correct piece (from promotion)
-                    if (currentPiece && currentPiece.getId() === expectedPieceId) {
-                        console.log(`Piece ${expectedPieceId} already correctly placed on ${square.id}`);
-                    } else {
-                        // Remove current piece if exists
-                        if (currentPiece) {
-                            this.pieceService.removePieceFromSquare(square, animation);
-                        }
+                const expectedPieceId = this.positionService.getGamePieceId(square.id);
+                if (currentPiece) {
+                    const key = (currentPiece.color + currentPiece.type).toLowerCase();
+                    if (!currentMap[key]) currentMap[key] = [];
+                    currentMap[key].push({ square, id: square.id, piece: currentPiece });
+                }
+                if (expectedPieceId) {
+                    const key = expectedPieceId.toLowerCase();
+                    if (!expectedMap[key]) expectedMap[key] = [];
+                    expectedMap[key].push({ square, id: square.id });
+                }
+            });
+            const animationDelay = isPositionLoad ? 0 : this.config.simultaneousAnimationDelay || 0;
+            let totalAnimations = 0;
+            let animationsCompleted = 0;
 
-                        // Add new piece if needed
-                        if (expectedPieceId) {
-                            const newPiece = this.pieceService.convertPiece(expectedPieceId);
-                            this.pieceService.addPieceOnSquare(
-                                square,
-                                newPiece,
-                                animation,
-                                this._createDragFunction.bind(this)
-                            );
+            // 1. Matching greedy: trova i movimenti
+            const moves = [];
+            const fromMatched = {};
+            const toMatched = {};
+            const unchanged = [];
+            Object.keys(expectedMap).forEach(key => {
+                const fromList = (currentMap[key] || []).slice();
+                const toList = expectedMap[key].slice();
+                const localFromMatched = new Array(fromList.length).fill(false);
+                const localToMatched = new Array(toList.length).fill(false);
+                // Matrice delle distanze
+                const distances = [];
+                for (let i = 0; i < fromList.length; i++) {
+                    distances[i] = [];
+                    for (let j = 0; j < toList.length; j++) {
+                        distances[i][j] = Math.abs(fromList[i].square.row - toList[j].square.row) +
+                            Math.abs(fromList[i].square.col - toList[j].square.col);
+                    }
+                }
+                while (true) {
+                    let minDist = Infinity, minI = -1, minJ = -1;
+                    for (let i = 0; i < fromList.length; i++) {
+                        if (localFromMatched[i]) continue;
+                        for (let j = 0; j < toList.length; j++) {
+                            if (localToMatched[j]) continue;
+                            if (distances[i][j] < minDist) {
+                                minDist = distances[i][j];
+                                minI = i;
+                                minJ = j;
+                            }
                         }
                     }
+                    if (minI === -1 || minJ === -1) break;
+                    // Se la posizione è la stessa E il Piece è lo stesso oggetto, non fare nulla (pezzo unchanged)
+                    if (fromList[minI].square === toList[minJ].square && squares[toList[minJ].square.id].piece === fromList[minI].piece) {
+                        unchanged.push({ square: fromList[minI].square, piece: fromList[minI].piece });
+                        localFromMatched[minI] = true;
+                        localToMatched[minJ] = true;
+                        fromMatched[fromList[minI].square.id] = true;
+                        toMatched[toList[minJ].square.id] = true;
+                        continue;
+                    }
+                    // Altrimenti, sposta il pezzo
+                    moves.push({ from: fromList[minI].square, to: toList[minJ].square, piece: fromList[minI].piece });
+                    localFromMatched[minI] = true;
+                    localToMatched[minJ] = true;
+                    fromMatched[fromList[minI].square.id] = true;
+                    toMatched[toList[minJ].square.id] = true;
                 }
             });
 
-            // Re-add listeners after updating pieces to ensure hover events work correctly
-            this._addListeners();
-
-            // Trigger change event if position changed
-            const gameStateAfter = this.positionService.getGame().fen();
-            if (gameStateBefore !== gameStateAfter) {
-                this.config.onChange(gameStateAfter);
-            }
-        }
+            // 2. Rimozione: pezzi presenti solo in attuale (non matched)
+            const removes = [];
+            Object.keys(currentMap).forEach(key => {
+                currentMap[key].forEach(({ square, piece }) => {
+                    if (!fromMatched[square.id]) {
+                        removes.push({ square, piece });
+                    }
+                });
+            });
 
-        /**
-         * Performs simultaneous piece updates
-         * @private
-         * @param {Object} squares - All squares
-         * @param {string} gameStateBefore - Game state before update
-         * @param {boolean} [isPositionLoad=false] - Whether this is a position load
-         */
-        _doSimultaneousUpdate(squares, gameStateBefore, isPositionLoad = false) {
-            console.log('_doSimultaneousUpdate - Starting simultaneous update');
-
-            // Analyze what changes need to be made
-            const changeAnalysis = this._analyzePositionChanges(squares);
+            // 3. Aggiunta: pezzi presenti solo in atteso (non matched)
+            const adds = [];
+            Object.keys(expectedMap).forEach(key => {
+                expectedMap[key].forEach(({ square, id }) => {
+                    if (!toMatched[square.id]) {
+                        adds.push({ square, pieceId: key });
+                    }
+                });
+            });
 
-            if (changeAnalysis.totalChanges === 0) {
-                console.log('_doSimultaneousUpdate - No changes needed, returning');
+            totalAnimations = moves.length + removes.length + adds.length;
+            if (totalAnimations === 0) {
                 this._addListeners();
-
-                // Trigger change event if position changed
                 const gameStateAfter = this.positionService.getGame().fen();
                 if (gameStateBefore !== gameStateAfter) {
                     this.config.onChange(gameStateAfter);
@@ -7801,10 +7416,64 @@ var Chessboard = (function (exports) {
                 return;
             }
 
-            console.log('_doSimultaneousUpdate - Change analysis:', changeAnalysis);
+            // Debug: logga i pezzi unchanged
+            if (unchanged.length > 0) {
+                console.debug('[Chessboard] Unchanged pieces:', unchanged.map(u => u.piece.id + '@' + u.square.id));
+            }
 
-            // Execute all changes simultaneously
-            this._executeSimultaneousChanges(changeAnalysis, gameStateBefore, isPositionLoad);
+            const onAnimationComplete = () => {
+                animationsCompleted++;
+                if (animationsCompleted === totalAnimations) {
+                    // Pulizia finale robusta: rimuovi tutti i pezzi orfani dal DOM e dal riferimento JS
+                    Object.values(this.boardService.getAllSquares()).forEach(square => {
+                        const expectedPieceId = this.positionService.getGamePieceId(square.id);
+                        if (!expectedPieceId && typeof square.forceRemoveAllPieces === 'function') {
+                            square.forceRemoveAllPieces();
+                        }
+                    });
+                    this._addListeners();
+                    const gameStateAfter = this.positionService.getGame().fen();
+                    if (gameStateBefore !== gameStateAfter) {
+                        this.config.onChange(gameStateAfter);
+                    }
+                }
+            };
+
+            // 4. Esegui tutte le animazioni con delay
+            let idx = 0;
+            moves.forEach(move => {
+                setTimeout(() => {
+                    this.pieceService.translatePiece(
+                        move,
+                        false,
+                        animation,
+                        this._createDragFunction.bind(this),
+                        onAnimationComplete
+                    );
+                }, idx++ * animationDelay);
+            });
+            removes.forEach(op => {
+                setTimeout(() => {
+                    if (typeof op.square.forceRemoveAllPieces === 'function') {
+                        op.square.forceRemoveAllPieces();
+                        onAnimationComplete();
+                    } else {
+                        this.pieceService.removePieceFromSquare(op.square, animation, onAnimationComplete);
+                    }
+                }, idx++ * animationDelay);
+            });
+            adds.forEach(op => {
+                setTimeout(() => {
+                    const newPiece = this.pieceService.convertPiece(op.pieceId);
+                    this.pieceService.addPieceOnSquare(
+                        op.square,
+                        newPiece,
+                        animation,
+                        this._createDragFunction.bind(this),
+                        onAnimationComplete
+                    );
+                }, idx++ * animationDelay);
+            });
         }
 
         /**
@@ -8130,99 +7799,418 @@ var Chessboard = (function (exports) {
         }
 
         // -------------------
-        // Public API Methods
+        // Public API Methods (Refactored)
         // -------------------
 
+        // --- POSITION & STATE ---
         /**
-         * Gets the current position as FEN
-         * @returns {string} FEN string
+         * Get the current position as FEN
+         * @returns {string}
          */
-        fen() {
-            return this.positionService.getGame().fen();
+        getPosition() { return this.fen(); }
+        /**
+         * Set the board position (FEN or object)
+         * @param {string|Object} position
+         * @param {Object} [opts]
+         * @param {boolean} [opts.animate=true]
+         * @returns {boolean}
+         */
+        setPosition(position, opts = {}) {
+            const animate = opts.animate !== undefined ? opts.animate : true;
+            // Remove highlights and selections
+            if (this.boardService && this.boardService.applyToAllSquares) {
+                this.boardService.applyToAllSquares('removeHint');
+                this.boardService.applyToAllSquares('deselect');
+                this.boardService.applyToAllSquares('unmoved');
+            }
+            if (this.positionService && this.positionService.setGame) {
+                this.positionService.setGame(position);
+            }
+            if (this._updateBoardPieces) {
+                this._updateBoardPieces(animate, true);
+            }
+            // Forza la sincronizzazione dopo setPosition
+            this._updateBoardPieces(true, false);
+            return true;
+        }
+        /**
+         * Reset the board to the starting position
+         * @param {Object} [opts]
+         * @param {boolean} [opts.animate=true]
+         * @returns {boolean}
+         */
+        reset(opts = {}) {
+            const animate = opts.animate !== undefined ? opts.animate : true;
+            // Use the default starting position from config or fallback
+            const startPosition = this.config && this.config.position ? this.config.position : 'start';
+            this._updateBoardPieces(animate);
+            const result = this.setPosition(startPosition, { animate });
+            // Forza la sincronizzazione dopo reset
+            this._updateBoardPieces(true, false);
+            return result;
+        }
+        /**
+         * Clear the board
+         * @param {Object} [opts]
+         * @param {boolean} [opts.animate=true]
+         * @returns {boolean}
+         */
+        clear(opts = {}) {
+            const animate = opts.animate !== undefined ? opts.animate : true;
+            if (!this.positionService || !this.positionService.getGame()) {
+                return false;
+            }
+            if (this._clearVisualState) this._clearVisualState();
+            this.positionService.getGame().clear();
+            // Forza la rimozione di tutti i pezzi dal DOM
+            if (this.boardService && this.boardService.squares) {
+                Object.values(this.boardService.squares).forEach(sq => {
+                    if (sq && sq.piece) sq.piece = null;
+                });
+            }
+            if (this._updateBoardPieces) {
+                this._updateBoardPieces(animate, true);
+            }
+            // Forza la sincronizzazione dopo clear
+            this._updateBoardPieces(true, false);
+            return true;
         }
 
+        // --- MOVE MANAGEMENT ---
         /**
-         * Gets current turn
-         * @returns {string} 'w' or 'b'
+         * Undo last move
+         * @param {Object} [opts]
+         * @param {boolean} [opts.animate=true]
+         * @returns {boolean}
          */
-        turn() {
-            return this.positionService.getGame().turn();
+        undoMove(opts = {}) {
+            const undone = this.positionService.getGame().undo();
+            if (undone) {
+                this._undoneMoves.push(undone);
+                // Forza refresh completo di tutti i pezzi dopo undo
+                this._updateBoardPieces(true, true);
+                return undone;
+            }
+            return null;
         }
+        /**
+         * Redo last undone move
+         * @param {Object} [opts]
+         * @param {boolean} [opts.animate=true]
+         * @returns {boolean}
+         */
+        redoMove(opts = {}) {
+            if (this._undoneMoves && this._undoneMoves.length > 0) {
+                const move = this._undoneMoves.pop();
+                const moveObj = { from: move.from, to: move.to };
+                if (move.promotion) moveObj.promotion = move.promotion;
+                const result = this.positionService.getGame().move(moveObj);
+                // Forza refresh completo di tutti i pezzi dopo redo
+                this._updateBoardPieces(true, true);
+                return result;
+            }
+            return false;
+        }
+        /**
+         * Get legal moves for a square
+         * @param {string} square
+         * @returns {Array}
+         */
+        getLegalMoves(square) { return this.legalMoves(square); }
 
+        // --- PIECE MANAGEMENT ---
         /**
-         * Loads a new position
-         * @param {string|Object} position - Position to load
-         * @param {Object} [options={}] - Loading options
-         * @param {boolean} [animation=true] - Whether to animate
+         * Get the piece at a square
+         * @param {string} square
+         * @returns {string|null}
          */
-        load(position, options = {}, animation = true) {
-            this.boardService.applyToAllSquares('removeHint');
-            this.boardService.applyToAllSquares('deselect');
-            this.boardService.applyToAllSquares('unmoved');
+        getPiece(square) {
+            // Sempre leggi lo stato aggiornato dal boardService
+            const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+            if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[getPiece] Parameter square is invalid');
+            // Forza sync prima di leggere
+            this._updateBoardPieces(false, false);
+            const piece = squareObj.piece;
+            if (!piece) return null;
+            return (piece.color + piece.type).toLowerCase();
+        }
+        /**
+         * Put a piece on a square
+         * @param {string|Piece} piece
+         * @param {string|Square} square
+         * @param {Object} [opts]
+         * @param {boolean} [opts.animate=true]
+         * @returns {boolean}
+         */
+        putPiece(piece, square, opts = {}) {
+            const animate = opts.animate !== undefined ? opts.animate : true;
+            let pieceStr = piece;
+            if (typeof piece === 'object' && piece.type && piece.color) {
+                pieceStr = (piece.color + piece.type).toLowerCase();
+            } else if (typeof piece === 'string' && piece.length === 2) {
+                const a = piece[0].toLowerCase();
+                const b = piece[1].toLowerCase();
+                const types = 'kqrbnp';
+                const colors = 'wb';
+                if (types.includes(a) && colors.includes(b)) {
+                    pieceStr = b + a;
+                } else if (colors.includes(a) && types.includes(b)) {
+                    pieceStr = a + b;
+                } else {
+                    throw new Error(`[putPiece] Invalid piece: ${piece}`);
+                }
+            }
+            const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+            if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[putPiece] Parameter square is invalid');
+            const pieceObj = this.pieceService.convertPiece(pieceStr);
+            if (!pieceObj || typeof pieceObj !== 'object' || !('type' in pieceObj)) throw new Error('[putPiece] Parameter piece is invalid');
+            // Aggiorna solo il motore chess.js
+            const chessJsPiece = { type: pieceObj.type, color: pieceObj.color };
+            const game = this.positionService.getGame();
+            const result = game.put(chessJsPiece, squareObj.id);
+            if (!result) throw new Error(`[putPiece] Game.put failed for ${pieceStr} on ${squareObj.id}`);
+            // Non aggiornare direttamente square.piece!
+            // Riallinea la board JS allo stato del motore
+            this._updateBoardPieces(animate);
+            return true;
+        }
+        /**
+         * Remove a piece from a square
+         * @param {string|Square} square
+         * @param {Object} [opts]
+         * @param {boolean} [opts.animate=true]
+         * @returns {string|null}
+         */
+        removePiece(square, opts = {}) {
+            const animate = opts.animate !== undefined ? opts.animate : true;
+            const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+            if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[removePiece] Parameter square is invalid');
+            // Aggiorna solo il motore chess.js
+            const game = this.positionService.getGame();
+            game.remove(squareObj.id);
+            // Non aggiornare direttamente square.piece!
+            // Riallinea la board JS allo stato del motore
+            this._updateBoardPieces(animate);
+            return true;
+        }
 
-            this.positionService.setGame(position, options);
-            this._updateBoardPieces(animation, true); // Position load
+        // --- BOARD CONTROL ---
+        /**
+         * Flip the board orientation
+         * @param {Object} [opts]
+         * @param {boolean} [opts.animate=true]
+         */
+        flipBoard(opts = {}) {
+            if (this.coordinateService && this.coordinateService.flipOrientation) {
+                this.coordinateService.flipOrientation();
+            }
+            if (this._buildBoard) this._buildBoard();
+            if (this._buildSquares) this._buildSquares();
+            if (this._addListeners) this._addListeners();
+            if (this._updateBoardPieces) this._updateBoardPieces(opts.animate !== false);
+            console.log('FEN dopo flip:', this.fen(), 'Orientamento:', this.coordinateService.getOrientation());
+        }
+        /**
+         * Set the board orientation
+         * @param {'w'|'b'} color
+         * @param {Object} [opts]
+         * @param {boolean} [opts.animate=true]
+         */
+        setOrientation(color, opts = {}) {
+            if (this.validationService.isValidOrientation(color)) {
+                this.coordinateService.setOrientation(color);
+                if (this._buildBoard) this._buildBoard();
+                if (this._buildSquares) this._buildSquares();
+                if (this._addListeners) this._addListeners();
+                if (this._updateBoardPieces) this._updateBoardPieces(opts.animate !== false);
+            }
+            return this.coordinateService.getOrientation();
+        }
+        /**
+         * Get the current orientation
+         * @returns {'w'|'b'}
+         */
+        getOrientation() { return this.orientation(); }
+        /**
+         * Resize the board
+         * @param {number|string} size
+         */
+        resizeBoard(size) {
+            if (size === 'auto') {
+                this.config.size = 'auto';
+                document.documentElement.style.setProperty('--dimBoard', 'auto');
+                this._updateBoardPieces(false);
+                return true;
+            }
+            if (typeof size !== 'number' || size < 50 || size > 3000) {
+                throw new Error(`[resizeBoard] Invalid size: ${size}`);
+            }
+            this.config.size = size;
+            document.documentElement.style.setProperty('--dimBoard', `${size}px`);
+            this._updateBoardPieces(false);
+            return true;
         }
 
+        // --- HIGHLIGHTING & UI ---
         /**
-         * Destroys the board and cleans up resources
+         * Highlight a square
+         * @param {string|Square} square
+         * @param {Object} [opts]
          */
-        destroy() {
-            this.eventService.destroy();
-            this.boardService.destroy();
-            this.positionService.destroy();
-            this.pieceService.destroy();
-            this.moveService.destroy();
-            this.animationService.destroy();
-            this.validationService.destroy();
+        highlight(square, opts = {}) {
+            // API: accetta id, converte subito in oggetto
+            const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+            if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[highlight] Parameter square is invalid');
+            if (this.boardService && this.boardService.highlightSquare) {
+                this.boardService.highlightSquare(squareObj, opts);
+            } else if (this.eventService && this.eventService.highlightSquare) {
+                this.eventService.highlightSquare(squareObj, opts);
+            }
+        }
+        /**
+         * Remove highlight from a square
+         * @param {string|Square} square
+         * @param {Object} [opts]
+         */
+        dehighlight(square, opts = {}) {
+            // API: accetta id, converte subito in oggetto
+            const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+            if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[dehighlight] Parameter square is invalid');
+            if (this.boardService && this.boardService.dehighlightSquare) {
+                this.boardService.dehighlightSquare(squareObj, opts);
+            } else if (this.eventService && this.eventService.dehighlightSquare) {
+                this.eventService.dehighlightSquare(squareObj, opts);
+            }
+        }
+
+        // --- GAME INFO ---
+        /**
+         * Get FEN string
+         * @returns {string}
+         */
+        fen() {
+            // Avoid recursion: call the underlying game object's fen()
+            const game = this.positionService.getGame();
+            if (!game || typeof game.fen !== 'function') return '';
+            return game.fen();
+        }
+        /**
+         * Get current turn
+         * @returns {'w'|'b'}
+         */
+        turn() { return this.positionService.getGame().turn(); }
+        /**
+         * Is the game over?
+         * @returns {boolean}
+         */
+        isGameOver() {
+            // Forza sync prima di interrogare il motore
+            this._updateBoardPieces(false, false);
+            const game = this.positionService.getGame();
+            if (!game) return false;
+            if (game.isGameOver) return game.isGameOver();
+            // Fallback: checkmate or draw
+            if (game.isCheckmate && game.isCheckmate()) return true;
+            if (game.isDraw && game.isDraw()) return true;
+            return false;
+        }
+        /**
+         * Is it checkmate?
+         * @returns {boolean}
+         */
+        isCheckmate() {
+            const game = this.positionService.getGame();
+            if (!game) return false;
+            return game.isCheckmate ? game.isCheckmate() : false;
+        }
+        /**
+         * Is it draw?
+         * @returns {boolean}
+         */
+        isDraw() {
+            const game = this.positionService.getGame();
+            if (!game) return false;
+            return game.isDraw ? game.isDraw() : false;
+        }
+        /**
+         * Get move history
+         * @returns {Array}
+         */
+        getHistory() {
+            const game = this.positionService.getGame();
+            if (!game) return [];
+            return game.history ? game.history() : [];
+        }
 
+        // --- LIFECYCLE ---
+        /**
+         * Destroy the board and cleanup all resources
+         */
+        destroy() {
+            // Remove event listeners
+            if (this.eventService && typeof this.eventService.removeListeners === 'function') {
+                this.eventService.removeListeners();
+            }
+            // Clear timeouts
             if (this._updateTimeout) {
                 clearTimeout(this._updateTimeout);
                 this._updateTimeout = null;
             }
+            // Destroy all services
+            [
+                'validationService',
+                'coordinateService',
+                'positionService',
+                'boardService',
+                'pieceService',
+                'animationService',
+                'moveService',
+                'eventService',
+            ].forEach(service => {
+                if (this[service] && typeof this[service].destroy === 'function') {
+                    this[service].destroy();
+                }
+                this[service] = null;
+            });
+            // Nullify DOM references
+            this._performanceMonitor = null;
+            this._boundUpdateBoardPieces = null;
+            this._boundOnSquareClick = null;
+            this._boundOnPieceHover = null;
+            this._boundOnPieceLeave = null;
+            this._undoneMoves = null;
+            // Remove board DOM if possible
+            const boardContainer = document.getElementById(this.config?.id_div);
+            if (boardContainer) {
+                boardContainer.innerHTML = '';
+            }
         }
-
         /**
-         * Resizes the board
-         * @param {number|string} size - New size
+         * Rebuild the board
          */
-        resize(size) {
-            this.boardService.resize(size);
-            this._updateBoardPieces();
-        }
+        rebuild() { this._initialize(); }
 
+        // --- CONFIGURATION ---
         /**
-         * Flips the board orientation
+         * Get current config
+         * @returns {Object}
          */
-        flip() {
-            this.coordinateService.flipOrientation();
-
-            // Save current position before destroying
-            let currentPosition = null;
-            try {
-                // Check if there are any pieces on the board
-                const position = this.positionService.getPosition();
-                const hasPieces = Object.keys(position).length > 0;
-
-                if (hasPieces) {
-                    currentPosition = this.positionService.getGame().fen();
-                }
-            } catch (error) {
-                console.log('No valid position to save during flip');
-            }
+        getConfig() { return this.config; }
+        /**
+         * Set new config
+         * @param {Object} newConfig
+         */
+        setConfig(newConfig) { this.setConfig(newConfig); }
 
-            this.destroy();
-            this._initializeServices(); // Recreate all services
-            this._initParams();
+        // --- ALIASES/DEPRECATED ---
+        // Note: These methods are now implemented as aliases at the end of the class
 
-            // Restore position after rebuilding if we had one
-            if (currentPosition) {
-                this._setGame(currentPosition);
-            }
-            this._buildBoard();
-            this._buildSquares();
-            this._addListeners();
-            this._updateBoardPieces(true, true);
+        /**
+         * Alias for flipBoard (for backward compatibility)
+         */
+        flip(opts = {}) {
+            this._updateBoardPieces(opts.animate !== false);
+            return this.flipBoard(opts);
         }
 
         /**
@@ -8245,51 +8233,19 @@ var Chessboard = (function (exports) {
             this.load(position, {}, animate); // load() already handles isPositionLoad=true
         }
 
-        /**
-         * Makes a move on the board
-         * @param {string|Object} move - Move to make
-         * @param {boolean} [animate=true] - Whether to animate
-         * @returns {boolean} True if move was successful
-         */
-        move(move, animate = true) {
-            if (typeof move === 'string') {
-                // Parse move string (e.g., 'e2e4')
-                const moveObj = this.moveService.parseMove(move);
-                if (!moveObj) return false;
-
-                const fromSquare = this.boardService.getSquare(moveObj.from);
-                const toSquare = this.boardService.getSquare(moveObj.to);
-
-                if (!fromSquare || !toSquare) return false;
-
-                return this._onMove(fromSquare, toSquare, moveObj.promotion, animate);
-            } else if (move && move.from && move.to) {
-                // Handle move object
-                const fromSquare = this.boardService.getSquare(move.from);
-                const toSquare = this.boardService.getSquare(move.to);
-
-                if (!fromSquare || !toSquare) return false;
-
-                return this._onMove(fromSquare, toSquare, move.promotion, animate);
-            }
-
-            return false;
-        }
-
         /**
          * Undoes the last move
          * @param {boolean} [animate=true] - Whether to animate
          * @returns {boolean} True if undo was successful
          */
         undo(animate = true) {
-            if (this.positionService.getGame().undo) {
-                const undoResult = this.positionService.getGame().undo();
-                if (undoResult) {
-                    this._updateBoardPieces(animate, true); // Position change
-                    return true;
-                }
+            const undone = this.positionService.getGame().undo();
+            if (undone) {
+                this._undoneMoves.push(undone);
+                this._updateBoardPieces(animate);
+                return undone;
             }
-            return false;
+            return null;
         }
 
         /**
@@ -8298,12 +8254,13 @@ var Chessboard = (function (exports) {
          * @returns {boolean} True if redo was successful
          */
         redo(animate = true) {
-            if (this.positionService.getGame().redo) {
-                const redoResult = this.positionService.getGame().redo();
-                if (redoResult) {
-                    this._updateBoardPieces(animate, true); // Position change
-                    return true;
-                }
+            if (this._undoneMoves && this._undoneMoves.length > 0) {
+                const move = this._undoneMoves.pop();
+                const moveObj = { from: move.from, to: move.to };
+                if (move.promotion) moveObj.promotion = move.promotion;
+                const result = this.positionService.getGame().move(moveObj);
+                this._updateBoardPieces(animate);
+                return result;
             }
             return false;
         }
@@ -8465,112 +8422,6 @@ var Chessboard = (function (exports) {
             }
         }
 
-        /**
-         * Clears the board
-         * @param {boolean} [animate=true] - Whether to animate
-         */
-        clear(animate = true) {
-            // Check if services are available
-            if (!this.positionService || !this.positionService.getGame()) {
-                console.log('Cannot clear - position service not available');
-                return;
-            }
-
-            // Clear visual state first
-            this._clearVisualState();
-
-            // Clear game state
-            this.positionService.getGame().clear();
-
-            // Update board visually
-            this._updateBoardPieces(animate, true); // Position change
-        }
-
-        /**
-         * Resets the board to starting position
-         * @param {boolean} [animate=true] - Whether to animate
-         */
-        reset(animate = true) {
-            // Check if services are available
-            if (!this.positionService || !this.positionService.getGame()) {
-                console.log('Cannot reset - position service not available');
-                return;
-            }
-
-            this.positionService.getGame().reset();
-            this._updateBoardPieces(animate, true); // Position change
-        }
-
-        /**
-         * Puts a piece on a square
-         * @param {string} square - Square to put piece on
-         * @param {string} piece - Piece to put
-         * @param {boolean} [animate=true] - Whether to animate
-         * @returns {boolean} True if successful
-         */
-        put(square, piece, animate = true) {
-            console.log(`put() called with square: ${square}, piece: ${piece}`);
-
-            if (!this.validationService.isValidSquare(square) || !this.validationService.isValidPiece(piece)) {
-                console.log('Validation failed');
-                return false;
-            }
-
-            // Check if services are available
-            if (!this.positionService || !this.positionService.getGame()) {
-                console.log('Cannot put piece - position service not available');
-                return false;
-            }
-
-            const pieceObj = this.pieceService.convertPiece(piece);
-            console.log(`Converted piece:`, pieceObj);
-            console.log(`Piece type: ${pieceObj.type}, color: ${pieceObj.color}`);
-
-            const squareObj = this.boardService.getSquare(square);
-
-            if (!squareObj) {
-                console.log('Square not found');
-                return false;
-            }
-
-            // Update game state - note: chess.js expects (piece, square) order
-            const chessJsPiece = { type: pieceObj.type.toLowerCase(), color: pieceObj.color.toLowerCase() };
-            console.log(`Chess.js piece:`, chessJsPiece);
-
-            const result = this.positionService.getGame().put(chessJsPiece, square);
-            console.log(`Chess.js put result:`, result);
-
-            if (result) {
-                // Update visual representation
-                this._updateBoardPieces(animate, true); // Position change
-            }
-
-            return result;
-        }
-
-        /**
-         * Removes a piece from a square
-         * @param {string} square - Square to remove piece from
-         * @param {boolean} [animate=true] - Whether to animate
-         * @returns {boolean} True if successful
-         */
-        remove(square, animate = true) {
-            if (!this.validationService.isValidSquare(square)) {
-                return false;
-            }
-
-            const squareObj = this.boardService.getSquare(square);
-            if (!squareObj) return false;
-
-            // Update game state
-            this.positionService.getGame().remove(square);
-
-            // Update visual representation
-            this._updateBoardPieces(animate, true); // Position change
-
-            return true;
-        }
-
         /**
          * Gets configuration options
          * @returns {Object} Configuration object
@@ -8596,23 +8447,6 @@ var Chessboard = (function (exports) {
             }
         }
 
-        /**
-         * Gets or sets the animation style
-         * @param {string} [style] - New animation style ('sequential' or 'simultaneous')
-         * @returns {string} Current animation style
-         */
-        animationStyle(style) {
-            if (style === undefined) {
-                return this.config.animationStyle;
-            }
-
-            if (this.validationService.isValidAnimationStyle(style)) {
-                this.config.animationStyle = style;
-            }
-
-            return this.config.animationStyle;
-        }
-
         /**
          * Gets or sets the simultaneous animation delay
          * @param {number} [delay] - New delay in milliseconds
@@ -8632,7 +8466,97 @@ var Chessboard = (function (exports) {
 
         // Additional API methods would be added here following the same pattern
         // This is a good starting point for the refactored architecture
-    }
+
+        // Additional API methods and aliases for backward compatibility
+        insert(square, piece) { return this.putPiece(piece, square); }
+        build() { return this._initialize(); }
+        ascii() { return this.positionService.getGame().ascii(); }
+        board() { return this.positionService.getGame().board(); }
+        getCastlingRights(color) { return this.positionService.getGame().getCastlingRights(color); }
+        getComment() { return this.positionService.getGame().getComment(); }
+        getComments() { return this.positionService.getGame().getComments(); }
+        lastMove() { return this.positionService.getGame().lastMove(); }
+        moveNumber() { return this.positionService.getGame().moveNumber(); }
+        moves(options = {}) { return this.positionService.getGame().moves(options); }
+        squareColor(squareId) { return this.boardService.getSquare(squareId).isWhite() ? 'light' : 'dark'; }
+        isDrawByFiftyMoves() { return this.positionService.getGame().isDrawByFiftyMoves(); }
+        isInsufficientMaterial() { return this.positionService.getGame().isInsufficientMaterial(); }
+        removeComment() { return this.positionService.getGame().removeComment(); }
+        removeComments() { return this.positionService.getGame().removeComments(); }
+        removeHeader(field) { return this.positionService.getGame().removeHeader(field); }
+        setCastlingRights(color, rights) { return this.positionService.getGame().setCastlingRights(color, rights); }
+        setComment(comment) { return this.positionService.getGame().setComment(comment); }
+        setHeader(key, value) { return this.positionService.getGame().setHeader(key, value); }
+        validateFen(fen) { return this.positionService.getGame().validateFen(fen); }
+
+        // Implementazioni reali per highlight/dehighlight
+        highlightSquare(square) {
+            return this.boardService.highlight(square);
+        }
+        dehighlightSquare(square) {
+            return this.boardService.dehighlight(square);
+        }
+        forceSync() { this._updateBoardPieces(true, true); this._updateBoardPieces(true, false); }
+
+        // Metodi mancanti che causano fallimenti nei test
+        /**
+         * Move a piece from one square to another
+         * @param {string|Object} move - Move in format 'e2e4' or {from: 'e2', to: 'e4'}
+         * @param {Object} [opts] - Options
+         * @param {boolean} [opts.animate=true] - Whether to animate
+         * @returns {boolean} True if move was successful
+         */
+        movePiece(move, opts = {}) {
+            const animate = opts.animate !== undefined ? opts.animate : true;
+
+            // --- API: accetta id/stringhe, ma converte subito in oggetti ---
+            let fromSquareObj, toSquareObj, promotion;
+            if (typeof move === 'string') {
+                if (move.length === 4) {
+                    fromSquareObj = this.boardService.getSquare(move.substring(0, 2));
+                    toSquareObj = this.boardService.getSquare(move.substring(2, 4));
+                } else if (move.length === 5) {
+                    fromSquareObj = this.boardService.getSquare(move.substring(0, 2));
+                    toSquareObj = this.boardService.getSquare(move.substring(2, 4));
+                    promotion = move.substring(4, 5);
+                } else {
+                    throw new Error(`Invalid move format: ${move}`);
+                }
+            } else if (typeof move === 'object' && move.from && move.to) {
+                // Se sono id, converto in oggetti; se sono già oggetti, li uso direttamente
+                fromSquareObj = typeof move.from === 'string' ? this.boardService.getSquare(move.from) : move.from;
+                toSquareObj = typeof move.to === 'string' ? this.boardService.getSquare(move.to) : move.to;
+                promotion = move.promotion;
+            } else {
+                throw new Error(`Invalid move: ${move}`);
+            }
+
+            if (!fromSquareObj || !toSquareObj) {
+                throw new Error(`Invalid squares: ${move.from || move.substring(0, 2)} or ${move.to || move.substring(2, 4)}`);
+            }
+
+            // --- Internamente: lavora solo con oggetti ---
+            const result = this._onMove(fromSquareObj, toSquareObj, promotion, animate);
+            // Dopo ogni mossa, forza la sincronizzazione della board
+            this._updateBoardPieces(true, false);
+            return result;
+        }
+
+        // Aliases for backward compatibility
+        move(move, animate = true) {
+            // On any new move, clear the redo stack
+            this._undoneMoves = [];
+            return this.movePiece(move, { animate });
+        }
+        get(square) { return this.getPiece(square); }
+        piece(square) { return this.getPiece(square); }
+        put(piece, square, opts = {}) { return this.putPiece(piece, square, opts); }
+        remove(square, opts = {}) { return this.removePiece(square, opts); }
+        load(position, opts = {}) { return this.setPosition(position, opts); }
+        resize(size) { return this.resizeBoard(size); }
+        start(opts = {}) { return this.reset(opts); }
+        clearBoard(opts = {}) { return this.clear(opts); }
+    };
 
     /**
      * Structured logging system for Chessboard.js
@@ -9090,7 +9014,6 @@ var Chessboard = (function (exports) {
                 hints: true,
                 clickable: true,
                 moveHighlight: true,
-                animationStyle: 'simultaneous'
             });
 
             // Tournament template
@@ -9101,7 +9024,6 @@ var Chessboard = (function (exports) {
                 clickable: true,
                 moveHighlight: true,
                 onlyLegalMoves: true,
-                animationStyle: 'sequential'
             });
 
             // Analysis template
@@ -9112,7 +9034,6 @@ var Chessboard = (function (exports) {
                 clickable: true,
                 moveHighlight: true,
                 mode: 'analysis',
-                animationStyle: 'simultaneous'
             });
 
             // Puzzle template
@@ -9123,7 +9044,6 @@ var Chessboard = (function (exports) {
                 clickable: true,
                 moveHighlight: true,
                 onlyLegalMoves: true,
-                animationStyle: 'sequential'
             });
 
             // Demo template
@@ -9133,7 +9053,6 @@ var Chessboard = (function (exports) {
                 hints: false,
                 clickable: false,
                 moveHighlight: true,
-                animationStyle: 'simultaneous'
             });
         }
 
@@ -9179,7 +9098,7 @@ var Chessboard = (function (exports) {
                 this.validationService.validateConfig(finalConfig);
 
                 // Create chessboard instance
-                const chessboard = new Chessboard(finalConfig);
+                const chessboard = new Chessboard$1(finalConfig);
 
                 // Store instance for management
                 this.instances.set(containerId, {
@@ -9439,13 +9358,44 @@ var Chessboard = (function (exports) {
      */
 
 
+    /**
+     * Main Chessboard factory function for backward compatibility
+     * Supports both legacy and modern calling conventions
+     * @param {string|Object} containerElm - Container element ID or configuration object
+     * @param {Object} [config={}] - Configuration options (when first param is string)
+     * @returns {ChessboardClass} Chessboard instance
+     */
+    function Chessboard(containerElm, config = {}) {
+        const factoryLogger = logger.child('ChessboardFactory');
+
+        try {
+            // If first parameter is an object, treat it as config
+            if (typeof containerElm === 'object' && containerElm !== null) {
+                factoryLogger.debug('Creating chessboard with config object');
+                return new Chessboard$1(containerElm);
+            }
+
+            // Otherwise, treat first parameter as element ID
+            if (typeof containerElm === 'string') {
+                factoryLogger.debug('Creating chessboard with element ID', { elementId: containerElm });
+                const fullConfig = { ...config, id: containerElm };
+                return new Chessboard$1(fullConfig);
+            }
+
+            throw new Error('Invalid parameters: first parameter must be string or object');
+        } catch (error) {
+            factoryLogger.error('Failed to create chessboard instance', { error });
+            throw error;
+        }
+    }
+
     /**
      * Wrapper class that handles both calling conventions
      * Provides enhanced error handling and logging
      * @class
      * @extends ChessboardClass
      */
-    class ChessboardWrapper extends Chessboard {
+    class ChessboardWrapper extends Chessboard$1 {
         /**
          * Creates a new ChessboardWrapper instance
          * @param {string|Object} containerElm - Container element ID or configuration object
@@ -9474,32 +9424,53 @@ var Chessboard = (function (exports) {
         }
     }
 
-    // Attach classes and utilities to the factory function for direct access
-    Chessboard.Class = ChessboardWrapper;
-    Chessboard.Chessboard = ChessboardWrapper;
-    Chessboard.Config = ChessboardConfig;
-    Chessboard.Factory = ChessboardFactory;
+    /**
+     * Refactored Chessboard API - see Chessboard.js for full method docs
+     * @typedef {import('./Chessboard.js').Chessboard} Chessboard
+     */
 
-    // Attach factory methods
+    // --- STATIC/FACTORY METHODS ---
+    /**
+     * Create a new Chessboard instance
+     * @param {string|Object} containerElm
+     * @param {Object} [config]
+     * @returns {Chessboard}
+     */
     Chessboard.create = createChessboard;
-    Chessboard.createFromTemplate = createChessboardFromTemplate;
+    /**
+     * Create a Chessboard from a template
+     * @param {string|Object} containerElm
+     * @param {string} templateName
+     * @param {Object} [config]
+     * @returns {Chessboard}
+     */
+    Chessboard.fromTemplate = createChessboardFromTemplate;
     Chessboard.factory = chessboardFactory;
 
-    // Static methods for instance management
+    // --- INSTANCE MANAGEMENT ---
     Chessboard.getInstance = (containerId) => chessboardFactory.getInstance(containerId);
     Chessboard.destroyInstance = (containerId) => chessboardFactory.destroy(containerId);
     Chessboard.destroyAll = () => chessboardFactory.destroyAll();
     Chessboard.listInstances = () => chessboardFactory.listInstances();
 
-    // Template management
+    // --- TEMPLATE MANAGEMENT ---
     Chessboard.registerTemplate = (name, config) => chessboardFactory.registerTemplate(name, config);
     Chessboard.removeTemplate = (name) => chessboardFactory.removeTemplate(name);
     Chessboard.getTemplate = (name) => chessboardFactory.getTemplate(name);
     Chessboard.listTemplates = () => chessboardFactory.listTemplates();
 
-    // Statistics and debugging
+    // --- STATS & DEBUG ---
     Chessboard.getStats = () => chessboardFactory.getStats();
 
+    // --- DEPRECATED/LEGACY ALIASES ---
+    /**
+     * @deprecated Use Chessboard.create instead
+     */
+    Chessboard.Class = ChessboardWrapper;
+    Chessboard.Chessboard = ChessboardWrapper;
+    Chessboard.Config = ChessboardConfig;
+    Chessboard.Factory = ChessboardFactory;
+
     /**
      * Coordinate utilities for Chessboard.js
      */
@@ -9889,11 +9860,7 @@ var Chessboard = (function (exports) {
         if (config.moveAnimation && !isValidEasing(config.moveAnimation)) {
             errors.push('Invalid moveAnimation. Must be a valid easing function');
         }
-        
-        if (config.animationStyle && !['sequential', 'simultaneous'].includes(config.animationStyle)) {
-            errors.push('Invalid animationStyle. Must be "sequential" or "simultaneous"');
-        }
-        
+            
         return {
             success: errors.length === 0,
             errors