@fanboynz/network-scanner 2.0.58 → 2.0.59

package/README.md

@@ -59,8 +59,11 @@ A Puppeteer-based tool for scanning websites to find third-party (or optionally
 | `--compress-logs`           | Compress log files with gzip (requires `--dumpurls`) |
 | `--sub-domains`             | Output full subdomains instead of collapsing to root |
 | `--no-interact`             | Disable page interactions globally |
+| `--ghost-cursor`            | Use ghost-cursor Bezier mouse movements globally (requires `npm i ghost-cursor`) |
 | `--custom-json <file>`      | Use a custom config JSON file instead of config.json |
 | `--headful`                 | Launch browser with GUI (not headless) |
+| `--keep-open`               | Keep browser and tabs open after scan completes (use with `--headful` for debugging) |
+| `--use-puppeteer-core`      | Use `puppeteer-core` with system Chrome instead of bundled Chromium |
 | `--cdp`                     | Enable Chrome DevTools Protocol logging (now per-page if enabled) |
 | `--remove-dupes`            | Remove duplicate domains from output (only with `-o`) |
 | `--dry-run`                 | Console output only: show matching regex, titles, whois/dig/searchstring results, and adblock rules |
@@ -267,6 +270,11 @@ When a page redirects to a new domain, first-party/third-party detection is base
 | `interact_clicks`    | Boolean | `false` | Enable element clicking simulation |
 | `interact_typing`    | Boolean | `false` | Enable typing simulation |
 | `interact_intensity` | String | `"medium"` | Interaction simulation intensity: "low", "medium", "high" |
+| `cursor_mode`        | `"ghost"` | - | Use ghost-cursor Bezier mouse movements (requires `npm i ghost-cursor`) |
+| `ghost_cursor_speed` | Number | auto | Ghost-cursor movement speed multiplier |
+| `ghost_cursor_hesitate` | Milliseconds | `50` | Delay before ghost-cursor clicks |
+| `ghost_cursor_overshoot` | Pixels | auto | Max ghost-cursor overshoot distance before correcting |
+| `ghost_cursor_duration` | Milliseconds | `interact_duration` or `2000` | How long ghost-cursor movements run |
 | `dnsmasq`            | Boolean | `false` | Force dnsmasq output for this site |
 | `dnsmasq_old`        | Boolean | `false` | Force dnsmasq old format output for this site |
 | `unbound`            | Boolean | `false` | Force unbound output for this site |
@@ -523,6 +531,27 @@ node nwss.js --max-concurrent 12 --cleanup-interval 300 -o rules.txt
 }
 ```
 
+#### Ghost Cursor (Advanced Bezier Mouse)
+```json
+{
+  "url": "https://anti-bot-site.com",
+  "interact": true,
+  "cursor_mode": "ghost",
+  "ghost_cursor_duration": 3000,
+  "ghost_cursor_speed": 1.2,
+  "fingerprint_protection": "random",
+  "filterRegex": "tracking|analytics",
+  "comments": "ghost-cursor uses Bezier curves with overshoot for realistic mouse paths"
+}
+```
+
+Or enable globally via CLI:
+```bash
+node nwss.js --ghost-cursor --debug -o rules.txt
+```
+
+> **Note:** ghost-cursor is an optional dependency. Install with `npm install ghost-cursor`. If not installed, the scanner falls back to the built-in mouse simulation automatically.
+
 #### E-commerce Site Scanning
 ```json
 {
@@ -698,5 +727,7 @@ your_username ALL=(root) NOPASSWD: /usr/bin/wg-quick, /usr/bin/wg
 - If an `.ovpn` file contains embedded credentials, no additional auth config is needed in the JSON
 - VPN affects system-level routing — all concurrent scans will route through the active tunnel
 - Both `vpn` (WireGuard) and `openvpn` can be set, but `vpn` takes precedence
+- Ghost-cursor (`cursor_mode: "ghost"`) is optional — install with `npm i ghost-cursor`. Falls back to built-in mouse if not installed
+- Ghost-cursor duration defaults to `interact_duration` (or 2000ms), capped by the 15s hard timeout
 
 ---

package/lib/cdp.js

@@ -28,15 +28,19 @@
 const { formatLogMessage } = require('./colorize');
 
 /**
- * Creates a reusable timeout promise to reduce function allocation overhead
+ * Race a promise against a timeout, clearing the timer when the promise settles.
+ * Prevents leaked setTimeout handles that hold closure references until they fire.
+ * @param {Promise} promise - The operation to race
  * @param {number} ms - Timeout in milliseconds
  * @param {string} message - Error message for timeout
- * @returns {Promise} Promise that rejects after timeout
+ * @returns {Promise} Resolves/rejects with the operation result, or rejects on timeout
  */
-function createTimeoutPromise(ms, message) {
-  return new Promise((_, reject) => 
-    setTimeout(() => reject(new Error(message)), ms)
-  );
+function raceWithTimeout(promise, ms, message) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => reject(new Error(message)), ms);
+  });
+  return Promise.race([promise, timeoutPromise]).finally(() => clearTimeout(timeoutId));
 }
 
 /**
@@ -59,10 +63,7 @@ const createSessionResult = (session = null, cleanup = async () => {}, isEnhance
  * @returns {Promise<import('puppeteer').Page>} Page instance
  */
 async function createPageWithTimeout(browser, timeout = 30000) {
-  return Promise.race([
-    browser.newPage(),
-    createTimeoutPromise(timeout, 'Page creation timeout - browser may be unresponsive')
-  ]);
+  return raceWithTimeout(browser.newPage(), timeout, 'Page creation timeout - browser may be unresponsive');
 }
 
 /**
@@ -73,24 +74,18 @@ async function createPageWithTimeout(browser, timeout = 30000) {
  */
 async function setRequestInterceptionWithTimeout(page, timeout = 15000) {
   try {
-    await Promise.race([
-      page.setRequestInterception(true),
-      createTimeoutPromise(timeout, 'Request interception timeout - first attempt')
-    ]);
+    await raceWithTimeout(page.setRequestInterception(true), timeout, 'Request interception timeout - first attempt');
   } catch (firstError) {
     // Check for immediate critical failures
-    if (firstError.message.includes('Target closed') || 
+    if (firstError.message.includes('Target closed') ||
         firstError.message.includes('Session closed') ||
         firstError.message.includes('Browser has been closed')) {
       throw new Error('CRITICAL_BROWSER_ERROR: ' + firstError.message);
     }
-    
+
     // Retry with extended timeout
     try {
-      await Promise.race([
-        page.setRequestInterception(true),
-        createTimeoutPromise(timeout * 2, 'Request interception timeout - retry failed')
-      ]);
+      await raceWithTimeout(page.setRequestInterception(true), timeout * 2, 'Request interception timeout - retry failed');
     } catch (retryError) {
       if (retryError.message.includes('Network.enable timed out') || 
           retryError.message.includes('ProtocolError')) {
@@ -168,10 +163,7 @@ async function createCDPSession(page, currentUrl, options = {}) {
   try {
     // Create CDP session using modern Puppeteer 20+ API
     // Add timeout protection for CDP session creation
-    cdpSession = await Promise.race([
-      page.createCDPSession(),
-      createTimeoutPromise(20000, 'CDP session creation timeout')
-    ]);
+    cdpSession = await raceWithTimeout(page.createCDPSession(), 20000, 'CDP session creation timeout');
     
     // Enable network domain - required for network event monitoring  
     await cdpSession.send('Network.enable');
@@ -255,150 +247,6 @@ async function createCDPSession(page, currentUrl, options = {}) {
   }
 }
 
-/**
- * Validates CDP availability and configuration
- * 
- * USAGE IN YOUR APPLICATION:
- *   const validation = validateCDPConfig(siteConfig, globalCDPFlag);
- *   if (!validation.isValid) {
- *     console.warn('CDP configuration issues detected');
- *   }
- *   validation.recommendations.forEach(rec => console.log('Recommendation:', rec));
- *
- * @param {object} siteConfig - Site configuration object
- * @param {boolean} globalCDP - Global CDP flag
- * @param {Array} cdpSpecificDomains - Array of domains for cdp_specific feature
- * @returns {object} Validation result with recommendations
- */
-function validateCDPConfig(siteConfig, globalCDP, cdpSpecificDomains = []) {
-  const warnings = [];
-  const recommendations = [];
-  
-  // Check for conflicting configurations
-  if (globalCDP && siteConfig.cdp === false) {
-    warnings.push('Site-specific CDP disabled but global CDP is enabled - global setting will override');
-  }
-  
-  // Validate cdp_specific configuration
-  if (siteConfig.cdp_specific) {
-    if (!Array.isArray(siteConfig.cdp_specific)) {
-      warnings.push('cdp_specific must be an array of domain strings');
-    } else if (siteConfig.cdp_specific.length === 0) {
-      warnings.push('cdp_specific is empty - no domains will have CDP enabled');
-    } else {
-      // Validate domain format
-      const hasInvalidDomains = siteConfig.cdp_specific.some(domain => 
-        typeof domain !== 'string' || domain.trim() === ''
-      );
-      
-      if (hasInvalidDomains) {
-        // Only filter invalid domains if we need to show them
-        const invalidDomains = siteConfig.cdp_specific.filter(domain => 
-          typeof domain !== 'string' || domain.trim() === ''
-        );
-        warnings.push(`cdp_specific contains invalid domains: ${invalidDomains.join(', ')}`);
-      }
-    }
-  }
-  
-  // Performance recommendations
-  const cdpEnabled = globalCDP || siteConfig.cdp === true || 
-    (Array.isArray(siteConfig.cdp_specific) && siteConfig.cdp_specific.length > 0);
-  
-  if (cdpEnabled) {
-    recommendations.push('CDP logging enabled - this may impact performance for high-traffic sites');
-    
-    if (siteConfig.timeout && siteConfig.timeout < 30000) {
-      recommendations.push('Consider increasing timeout when using CDP logging to avoid protocol timeouts');
-    }
-  }
-  
-  return {
-    isValid: true,
-    warnings,
-    recommendations
-  };
-}
-
-/**
- * Enhanced CDP session with additional network monitoring features
- * 
- * ADVANCED FEATURES:
- *   - JavaScript exception monitoring
- *   - Security state change detection  
- *   - Failed network request tracking
- *   - Enhanced error reporting
- *
- * USE CASES:
- *   - Security analysis requiring comprehensive monitoring
- *   - Debugging complex single-page applications
- *   - Performance analysis of web applications
- *   - Research requiring detailed browser insights
- *
- * PERFORMANCE IMPACT:
- *   - Adds additional CDP domain subscriptions
- *   - Higher memory usage due to more event listeners
- *   - Recommended only for detailed analysis scenarios
- *
- * @param {import('puppeteer').Page} page - The Puppeteer page instance
- * @param {string} currentUrl - The URL being processed
- * @param {object} options - Configuration options (same as createCDPSession)
- * @returns {Promise<object>} Enhanced CDP session object with isEnhanced flag
- */
-async function createEnhancedCDPSession(page, currentUrl, options = {}) {
-  const basicSession = await createCDPSession(page, currentUrl, options);
-  
-  if (!basicSession.session) {
-    // Ensure enhanced flag is set even for null sessions
-    return { ...basicSession, isEnhanced: false };
-  }
-
-  const { session } = basicSession;
-  const { forceDebug } = options;
-
-  try {
-    // Enable additional CDP domains for enhanced monitoring
-    await session.send('Runtime.enable');  // For JavaScript exceptions
-    await session.send('Security.enable'); // For security state changes
-    
-    // Monitor JavaScript exceptions - useful for debugging problematic sites
-    session.on('Runtime.exceptionThrown', (params) => {
-      if (forceDebug) {
-        console.log(formatLogMessage('debug', `[cdp][exception] ${params.exceptionDetails.text}`));
-      }
-    });
-
-    // Monitor security state changes - detect mixed content, certificate issues, etc.
-    session.on('Security.securityStateChanged', (params) => {
-      if (forceDebug && params.securityState !== 'secure') {
-        console.log(formatLogMessage('debug', `[cdp][security] Security state: ${params.securityState}`));
-      }
-    });
-
-    // Monitor failed network requests - useful for understanding site issues
-    session.on('Network.loadingFailed', (params) => {
-      if (forceDebug) {
-        console.log(formatLogMessage('debug', `[cdp][failed] ${params.errorText}: ${params.requestId}`));
-      }
-    });
-
-    return {
-      session,
-      cleanup: basicSession.cleanup,
-      isEnhanced: true // Flag to indicate enhanced features are active
-    };
-
-  } catch (enhancedErr) {
-    if (forceDebug) {
-      console.log(formatLogMessage('debug', `Enhanced CDP features failed, falling back to basic session: ${enhancedErr.message}`));
-    }
-    
-    // Graceful degradation: return basic session if enhanced features fail
-    // This ensures your application continues working even if advanced features break
-    return { ...basicSession, isEnhanced: false };
-  }
-}
-
 // EXPORT INTERFACE FOR OTHER APPLICATIONS:
 // This module provides a clean, reusable interface for CDP integration.
 // Simply require this module and use the exported functions.
@@ -406,7 +254,7 @@ async function createEnhancedCDPSession(page, currentUrl, options = {}) {
 // CUSTOMIZATION TIPS:
 // 1. Replace './colorize' import with your own logging system
 // 2. Modify the request logging format in the Network.requestWillBeSent handler
-// 3. Add additional CDP domain subscriptions in createEnhancedCDPSession
+// 3. Add additional CDP domain subscriptions in createCDPSession
 // 4. Customize error categorization in the catch blocks
 //
 // TROUBLESHOOTING:

package/lib/fingerprint.js

@@ -1697,7 +1697,7 @@ async function applyUserAgentSpoofing(page, siteConfig, forceDebug, currentUrl)
               const x = Math.floor(Math.random() * 800) + 100;
               const y = Math.floor(Math.random() * 400) + 100;
               window.dispatchEvent(new MouseEvent('mousemove', {
-                clientX: x, clientY: y, bubbles: true, cancelable: true, view: window
+                clientX: x, clientY: y, pageX: x, pageY: y, bubbles: true, cancelable: true, view: window
               }));
               window.dispatchEvent(new Event('scroll', { bubbles: true }));
               document.dispatchEvent(new KeyboardEvent('keydown', {
@@ -2013,6 +2013,10 @@ async function simulateHumanBehavior(page, forceDebug) {
             document.dispatchEvent(new MouseEvent('mousemove', {
               clientX: mouseX,
               clientY: mouseY,
+              pageX: mouseX + (window.scrollX || 0),
+              pageY: mouseY + (window.scrollY || 0),
+              screenX: mouseX + (window.screenX || 0),
+              screenY: mouseY + (window.screenY || 0),
               bubbles: true,
               cancelable: true,
               view: window,
@@ -2026,6 +2030,10 @@ async function simulateHumanBehavior(page, forceDebug) {
               document.dispatchEvent(new MouseEvent('click', {
                 clientX: mouseX,
                 clientY: mouseY,
+                pageX: mouseX + (window.scrollX || 0),
+                pageY: mouseY + (window.scrollY || 0),
+                screenX: mouseX + (window.screenX || 0),
+                screenY: mouseY + (window.screenY || 0),
                 bubbles: true,
                 cancelable: true,
                 view: window

package/lib/ghost-cursor.js

@@ -0,0 +1,258 @@
+// === Ghost Cursor Module ===
+// Optional wrapper around the ghost-cursor npm package for advanced Bezier-based mouse movements.
+// Falls back gracefully to built-in interaction.js mouse if ghost-cursor is not installed.
+//
+// USAGE (JSON config):
+//   "cursor_mode": "ghost"              Enable ghost-cursor for this site
+//   "ghost_cursor_speed": 1.5           Movement speed multiplier (default: 1.0)
+//   "ghost_cursor_hesitate": 100        Delay (ms) before clicking (default: 50)
+//   "ghost_cursor_overshoot": 500       Max overshoot distance in px (default: auto)
+//
+// USAGE (CLI):
+//   --ghost-cursor                      Enable ghost-cursor globally
+//
+// INSTALL:
+//   npm install ghost-cursor            (optional dependency)
+
+const { formatLogMessage } = require('./colorize');
+
+let ghostCursorModule = null;
+let ghostCursorAvailable = false;
+
+// Attempt to load ghost-cursor at module init — optional dependency
+try {
+  ghostCursorModule = require('ghost-cursor');
+  ghostCursorAvailable = true;
+} catch {
+  // ghost-cursor not installed — this is fine, built-in mouse will be used
+}
+
+/**
+ * Check if ghost-cursor is available
+ * @returns {boolean}
+ */
+function isGhostCursorAvailable() {
+  return ghostCursorAvailable;
+}
+
+/**
+ * Create a ghost-cursor instance bound to a Puppeteer page
+ * @param {import('puppeteer').Page} page - Puppeteer page instance
+ * @param {object} options - Configuration options
+ * @param {boolean} options.forceDebug - Enable debug logging
+ * @param {number} options.startX - Starting X coordinate (default: 0)
+ * @param {number} options.startY - Starting Y coordinate (default: 0)
+ * @returns {object|null} Ghost cursor instance or null if unavailable
+ */
+function createGhostCursor(page, options = {}) {
+  if (!ghostCursorAvailable) {
+    return null;
+  }
+
+  const { forceDebug, startX = 0, startY = 0 } = options;
+
+  try {
+    const cursor = ghostCursorModule.createCursor(page, { x: startX, y: startY });
+
+    if (forceDebug) {
+      console.log(formatLogMessage('debug', '[ghost-cursor] Cursor instance created'));
+    }
+
+    return cursor;
+  } catch (err) {
+    if (forceDebug) {
+      console.log(formatLogMessage('debug', `[ghost-cursor] Failed to create cursor: ${err.message}`));
+    }
+    return null;
+  }
+}
+
+/**
+ * Move cursor to coordinates using ghost-cursor Bezier paths
+ * Drop-in replacement for humanLikeMouseMove when ghost-cursor is active
+ *
+ * @param {object} cursor - Ghost cursor instance from createGhostCursor()
+ * @param {number} toX - Target X coordinate
+ * @param {number} toY - Target Y coordinate
+ * @param {object} options - Movement options
+ * @param {number} options.moveSpeed - Speed multiplier (default: auto/random)
+ * @param {number} options.moveDelay - Delay after movement in ms (default: 0)
+ * @param {boolean} options.randomizeMoveDelay - Randomize move delay (default: true)
+ * @param {number} options.overshootThreshold - Max overshoot distance in px
+ * @param {boolean} options.forceDebug - Enable debug logging
+ * @returns {Promise<boolean>} true if movement succeeded
+ */
+async function ghostMove(cursor, toX, toY, options = {}) {
+  if (!cursor) return false;
+
+  const {
+    moveSpeed,
+    moveDelay = 0,
+    randomizeMoveDelay = true,
+    overshootThreshold,
+    forceDebug
+  } = options;
+
+  try {
+    const moveOpts = {};
+    if (moveSpeed !== undefined) moveOpts.moveSpeed = moveSpeed;
+    if (moveDelay > 0) moveOpts.moveDelay = moveDelay;
+    if (randomizeMoveDelay !== undefined) moveOpts.randomizeMoveDelay = randomizeMoveDelay;
+    if (overshootThreshold !== undefined) moveOpts.overshootThreshold = overshootThreshold;
+
+    await cursor.moveTo({ x: toX, y: toY }, moveOpts);
+
+    if (forceDebug) {
+      console.log(formatLogMessage('debug', `[ghost-cursor] Moved to (${Math.round(toX)}, ${Math.round(toY)})`));
+    }
+
+    return true;
+  } catch (err) {
+    if (forceDebug) {
+      console.log(formatLogMessage('debug', `[ghost-cursor] Move failed: ${err.message}`));
+    }
+    return false;
+  }
+}
+
+/**
+ * Click on a CSS selector or coordinates using ghost-cursor
+ *
+ * @param {object} cursor - Ghost cursor instance
+ * @param {string|{x: number, y: number}} target - CSS selector or {x, y} coordinates
+ * @param {object} options - Click options
+ * @param {number} options.hesitate - Delay (ms) before clicking (default: 50)
+ * @param {number} options.waitForClick - Delay (ms) between mousedown/mouseup (default: auto)
+ * @param {number} options.moveDelay - Delay (ms) after moving to target
+ * @param {number} options.paddingPercentage - Click point within element (0=edge, 100=center)
+ * @param {boolean} options.forceDebug - Enable debug logging
+ * @returns {Promise<boolean>} true if click succeeded
+ */
+async function ghostClick(cursor, target, options = {}) {
+  if (!cursor) return false;
+
+  const {
+    hesitate = 50,
+    waitForClick,
+    moveDelay,
+    paddingPercentage,
+    forceDebug
+  } = options;
+
+  try {
+    const clickOpts = { hesitate };
+    if (waitForClick !== undefined) clickOpts.waitForClick = waitForClick;
+    if (moveDelay !== undefined) clickOpts.moveDelay = moveDelay;
+    if (paddingPercentage !== undefined) clickOpts.paddingPercentage = paddingPercentage;
+
+    if (typeof target === 'string') {
+      await cursor.click(target, clickOpts);
+    } else {
+      // For coordinate clicks, move first then use page click
+      await cursor.moveTo(target);
+      // Small hesitation before clicking
+      if (hesitate > 0) {
+        await new Promise(resolve => setTimeout(resolve, hesitate));
+      }
+      const page = cursor._page || cursor.page;
+      if (page && typeof page.mouse?.click === 'function') {
+        await page.mouse.click(target.x, target.y);
+      }
+    }
+
+    if (forceDebug) {
+      const label = typeof target === 'string' ? target : `(${Math.round(target.x)}, ${Math.round(target.y)})`;
+      console.log(formatLogMessage('debug', `[ghost-cursor] Clicked ${label}`));
+    }
+
+    return true;
+  } catch (err) {
+    if (forceDebug) {
+      console.log(formatLogMessage('debug', `[ghost-cursor] Click failed: ${err.message}`));
+    }
+    return false;
+  }
+}
+
+/**
+ * Perform a random idle mouse movement using ghost-cursor
+ *
+ * @param {object} cursor - Ghost cursor instance
+ * @param {object} options - Options
+ * @param {boolean} options.forceDebug - Enable debug logging
+ * @returns {Promise<boolean>} true if movement succeeded
+ */
+async function ghostRandomMove(cursor, options = {}) {
+  if (!cursor) return false;
+
+  try {
+    await cursor.randomMove();
+    if (options.forceDebug) {
+      console.log(formatLogMessage('debug', '[ghost-cursor] Random movement performed'));
+    }
+    return true;
+  } catch (err) {
+    if (options.forceDebug) {
+      console.log(formatLogMessage('debug', `[ghost-cursor] Random move failed: ${err.message}`));
+    }
+    return false;
+  }
+}
+
+/**
+ * Generate a Bezier path between two points (standalone, no browser needed)
+ *
+ * @param {{x: number, y: number}} from - Start point
+ * @param {{x: number, y: number}} to - End point
+ * @param {object} options - Path options
+ * @param {number} options.spreadOverride - Override curve spread
+ * @param {number} options.moveSpeed - Movement speed
+ * @returns {Array<{x: number, y: number}>|null} Array of path points or null
+ */
+function ghostPath(from, to, options = {}) {
+  if (!ghostCursorAvailable || !ghostCursorModule.path) return null;
+
+  try {
+    return ghostCursorModule.path(from, to, options);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve ghost-cursor settings from site config and CLI flags.
+ * Returns null if ghost-cursor should not be used.
+ *
+ * @param {object} siteConfig - Per-site JSON configuration
+ * @param {boolean} globalGhostCursor - CLI --ghost-cursor flag
+ * @param {boolean} forceDebug - Debug logging flag
+ * @returns {object|null} Resolved ghost-cursor options or null
+ */
+function resolveGhostCursorConfig(siteConfig, globalGhostCursor, forceDebug) {
+  const enabled = globalGhostCursor || siteConfig.cursor_mode === 'ghost';
+
+  if (!enabled) return null;
+
+  if (!ghostCursorAvailable) {
+    console.warn(formatLogMessage('warn', '[ghost-cursor] cursor_mode "ghost" requested but ghost-cursor package is not installed. Run: npm install ghost-cursor'));
+    return null;
+  }
+
+  return {
+    moveSpeed: siteConfig.ghost_cursor_speed || undefined,
+    hesitate: siteConfig.ghost_cursor_hesitate ?? 50,
+    overshootThreshold: siteConfig.ghost_cursor_overshoot || undefined,
+    duration: siteConfig.ghost_cursor_duration || siteConfig.interact_duration || 2000,
+    forceDebug
+  };
+}
+
+module.exports = {
+  isGhostCursorAvailable,
+  createGhostCursor,
+  ghostMove,
+  ghostClick,
+  ghostRandomMove,
+  ghostPath,
+  resolveGhostCursorConfig
+};