URL Parameter Decoder

Changelog

2.8

• Updated XSS prevention via escaping and Parameter validation

2.7

• Added original base64-encoded values as shortcodes
• Improved handling of spaces in decoded content

2.6

• Switched to urlencode() instead of raw base64 encoding to ensure the decoded content is properly URL-encoded.

2.5

• Replaced atob() with decodeURIComponent() to properly handle URL-encoded content.
• Implemented a MutationObserver to handle dynamically added content without causing repeated full-page scans.
• Removed the execution count and timeout mechanisms, as the MutationObserver should handle updates more efficiently.

2.4

• Added a decodedUrls Set to keep track of URLs that have already been processed.
• Modified the processing logic to ignore script and link elements that have already been processed.
• Prevented re-decoding of content that has already been decoded.

2.3

• Removed automatic rescheduling of decoding.
• Added a manual trigger function (window.manuallyTriggerDecode()) for cases where dynamic content needs decoding.
• Improved logging to help identify the source of repeated calls.
• Added a wrapper around setTimeout to log all calls, helping identify which script is causing the repeated executions.

2.2

• Uses a MutationObserver to watch for dynamically added content.
• Processes new nodes as they’re added to the DOM.
• Keeps track of already processed nodes to avoid re-processing.
• Provides a cleanup function to stop observing when needed.

2.1

• Reduced maxExecutions to 5 for safety.
• Added a decodedNodes WeakSet to prevent re-processing of already decoded nodes.
• Changed for loops to Array.from().forEach() for better readability and to avoid potential issues with live NodeLists.
• Increased the delay in setTimeout to 100ms to give other scripts more time to run between our executions.
• Added an additional check to prevent rescheduling if maxExecutions is reached.

2.0

• Redesign and improvements
• Processes the DOM tree only once, preventing continuous reprocessing.
• Handles both text nodes and element attributes, ensuring all placeholders are replaced.
• Modifies content in-place without changing the DOM structure.
• Runs only once when the page loads, reducing computational overhead.

1.14

• It defines a safeAtob function to handle potential decoding errors gracefully.
• Instead of modifying the entire HTML content at once, it processes the DOM tree node by node, focusing only on text nodes.
• It uses a recursive function processTextNodes to traverse the DOM tree and replace placeholders only in text content.
• The replacement is done directly on the text nodes, avoiding the need to re-parse the entire HTML content.
• The function runs only once when the page loads, preventing any continuous reprocessing.

1.13

• The shortcode handler now wraps the decoded content with HTML comments containing unique identifiers, instead of span tags.
• The AJAX handler in PHP now returns both the decoded content and the unique identifier for each parameter.

1.12

• It searches for the HTML comments that mark the beginning and end of each decoded parameter.
• It collects all the parameters and sends them to the server for decoding.
• When it receives the decoded data, it replaces everything between the start and end comments with the raw decoded content.
• Finally, it removes the comments themselves, leaving only the raw decoded content.

1.11

• The main plugin file now registers a REST API endpoint instead of using shortcodes.
• The options page has been updated to show usage instructions for the new HTML placeholder method.
• The JavaScript file has been completely rewritten to use the REST API for decoding parameters.

1.10

• Filter out unexpected placeholders.
• Provide more detailed logging to help identify where the unexpected placeholders are coming from.
• Only process the expected parameters (xname, avatar, vip).

1.9

• Properly detect and handle the placeholders on the page.
• Ignore any unexpected parameters like «index_template».
• Improve error logging and debugging.

1.8

• Improve error handling and debugging for the AJAX request

1.7

• Resolve the deprecation warning and improve error handling for the AJAX requests.

1.6

• Proper handling of both base64 encoded and non-encoded values
• Immediate display of values in shortcodes
• Detailed error logging
• Improved AJAX handling

1.5

• Properly register the shortcodes based on the parameters saved in the options.
• Modify the shortcode handler to work with both attribute-based and name-based shortcodes.
• Add a function to ensure that default parameters (xname, avatar, vip) are always included in the options.

1.4

• Add more detailed error logging on the server-side.
• Filter out empty parameters before sending the AJAX request.
• Improve error handling and logging in the JavaScript.

1.3

• URL Passing: We now pass the current URL from PHP to JavaScript, and then from JavaScript to the AJAX handler. This ensures we’re working with the correct URL parameters.
• Server-side URL Parsing: In the AJAX handler, we parse the URL on the server side to extract parameters. This is more reliable than relying on $_GET.
• Debugging Output: We’ve added console.log statements in the JavaScript to help identify where the process might be failing.
• Loading Placeholder: The shortcode now displays «Loading…» while waiting for the AJAX response.
• Error Handling: We’ve added error handling to the AJAX request to catch any failures.

1.2

• Unique Placeholder: The shortcode now outputs a span with a unique ID and a class url-decoder-placeholder. This ensures we can find our element even if it’s wrapped in additional spans.
• Single AJAX Request: Instead of making an AJAX request for each parameter, we now send all parameters in a single request. This improves performance, especially if there are multiple parameters to decode.
• Client-side Update: The JavaScript now finds all placeholders for each parameter and updates them with the decoded value. This works regardless of any additional wrapping elements.
• Parameter List: We’re now passing the list of parameters to decode from PHP to JavaScript, ensuring we only attempt to decode parameters that have been set up in the plugin settings.

1.1

• Server-side Decoding: We now decode the base64 strings on the server side. This is more secure and avoids potential JavaScript conflicts.
• WordPress Enqueue System: We’re using wp_enqueue_scripts to properly load our JavaScript file. This follows WordPress best practices and avoids conflicts with other scripts.
• AJAX for Dynamic Content: Instead of using document.write(), we’re using AJAX to fetch the decoded values. This is more compatible with various themes and doesn’t interfere with page rendering.
• jQuery Usage: We’re using jQuery, which is included with WordPress, to manipulate the DOM. This is generally more compatible with various themes and plugins.
• Shortcode Output: The shortcode now outputs a span with a data attribute, which our JavaScript then updates with the decoded value.
• Sanitization and Escaping: We’ve added proper sanitization for inputs and escaping for outputs to enhance security.

1.0

• Settings Registration: We use register_setting() to register our option in the WordPress database.
• Options Page: The options page now includes a form where users can add, edit, or remove parameters.
• Dynamic Shortcode Generation: Instead of hardcoding shortcodes for ‘name’ and ‘avatar’, we now generate shortcodes dynamically based on the parameters saved in the options.
• Shortcode Registration: We use the generate_decode_shortcode() function to create a new shortcode function for each parameter, which is then registered using add_shortcode().
• Available Shortcodes Display: The settings page now shows a list of available shortcodes based on the parameters the user has added.