Add JSDoc comments to various utility functions and core files.

This change adds JSDoc-style comments to several functions and classes across the codebase to improve readability and maintainability.

Comments were added to:
- `src/SEQTA.ts`: Explained the `init()` function.
- `src/seqta/utils/waitForElm.ts`: Detailed the `waitForElm()` function, its parameters, and behavior.
- `src/seqta/utils/stringToHTML.ts`: Clarified the `stringToHTML()` function, including its sanitization and styling features.
- `src/seqta/utils/delay.ts`: Added a brief explanation for the `delay()` utility.
- `src/seqta/utils/mutex.ts`: Documented the `Mutex` class and its `acquire` method (renamed from `lock`), explaining its asynchronous locking mechanism and the role of the returned unlock function.

src/seqta/utils/delay.ts

@@ -1,3 +1,12 @@
+/**
+ * Pauses execution for a specified number of milliseconds.
+ *
+ * This function returns a Promise that resolves after the given delay,
+ * allowing it to be used with `async/await` to pause asynchronous operations.
+ *
+ * @param {number} ms The number of milliseconds to delay.
+ * @returns {Promise<void>} A Promise that resolves after the specified delay.
+ */
 export function delay(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }

src/seqta/utils/mutex.ts

@@ -1,12 +1,51 @@
-// Simple mutex implementation
+/**
+ * @callback UnlockFunction
+ * @description A function that must be called to release the mutex.
+ * @returns {void}
+ */
+
+/**
+ * A simple mutex implementation for managing asynchronous operations.
+ * It ensures that only one operation can hold the lock at a time.
+ * Operations queue up and are granted access sequentially.
+ */
 export class Mutex {
   private mutex = Promise.resolve();
 
-  lock(): PromiseLike<() => void> {
-    let begin: (unlock: () => void) => void;
+  /**
+   * Acquires the mutex.
+   *
+   * This method returns a Promise that resolves with an {@link UnlockFunction}.
+   * The calling code *must* call this {@link UnlockFunction} to release the mutex
+   * once the critical section of code has completed.
+   *
+   * If the mutex is already locked, this method will wait until it is released
+   * before resolving the Promise.
+   *
+   * @returns {Promise<UnlockFunction>} A Promise that resolves with the function to call to release the lock.
+   */
+  acquire(): Promise<() => void> {
+    let begin: (unlock: () => void) => void = () => {}; // Initialize with a no-op
 
-    this.mutex = this.mutex.then(() => new Promise(begin));
+    const newPromise = new Promise<void>((resolve) => {
+      begin = resolve;
+    });
 
-    return new Promise((res) => (begin = res));
+    const chainedPromise = this.mutex.then(() => {
+      return new Promise<() => void>((resolveOuter) => {
+        // The 'begin' function, when called, will resolve the newPromise,
+        // effectively passing control to the next then() in the chain.
+        // We pass 'begin' itself as the unlock function.
+        // So, when the user calls unlock (which is 'begin'), newPromise resolves.
+        resolveOuter(begin);
+      });
+    });
+    
+    this.mutex = newPromise;
+
+    return chainedPromise;
   }
+
+  // Note: There isn't a separate `release()` method in this pattern.
+  // The lock is released by calling the function returned by `acquire()`.
 }

src/seqta/utils/stringToHTML.ts

@@ -1,5 +1,17 @@
 import DOMPurify from "dompurify";
 
+/**
+ * Converts an HTML string into a DOM element, with sanitization and optional styling.
+ *
+ * This function first sanitizes the input HTML string using DOMPurify to prevent XSS attacks.
+ * The sanitization process allows 'onclick' attributes and specific URI schemes.
+ * Then, it parses the sanitized string into an HTML document and returns its body.
+ * Optionally, it can apply predefined CSS styles to the body element.
+ *
+ * @param {string} str The HTML string to convert.
+ * @param {boolean} [styles=false] Whether to apply predefined styles to the document body.
+ * @returns {HTMLElement} The body element of the parsed and sanitized HTML document.
+ */
 export default function stringToHTML(str: string, styles = false) {
   const parser = new DOMParser();
 

src/seqta/utils/waitForElm.ts

@@ -1,6 +1,20 @@
 import { eventManager } from "@/seqta/utils/listeners/EventManager";
 import { delay } from "@/seqta/utils/delay";
 
+/**
+ * Asynchronously waits for an element to be present in the DOM.
+ *
+ * This function can use either a polling mechanism (via `setTimeout`) or
+ * a `MutationObserver` (via `eventManager.register`) to detect the element.
+ * By default, it uses the `eventManager` which is more efficient.
+ *
+ * @param {string} selector The CSS selector for the target element.
+ * @param {boolean} [usePolling=false] If true, forces the use of `setTimeout` for polling.
+ * @param {number} [interval=100] The polling interval in milliseconds (only applicable if `usePolling` is true).
+ * @param {number} [maxIterations] Optional. The maximum number of polling attempts before rejecting (only applicable if `usePolling` is true).
+ * @returns {Promise<Element>} A Promise that resolves with the found DOM Element.
+ * If `usePolling` is true and `maxIterations` is reached, the Promise rejects with an Error.
+ */
 export async function waitForElm(
   selector: string,
   usePolling: boolean = false,