Simulating Tab and Enter Key Press Events in the Browser Console

// Modern approach with comprehensive properties
const event = new KeyboardEvent("keydown", {
  key: "Tab", // The key value
  code: "Tab", // Physical key code
  keyCode: 9, // Legacy key code (deprecated but sometimes needed)
  which: 9, // Legacy property
  bubbles: true, // Event bubbles up the DOM
  cancelable: true, // Event can be cancelled
  composed: true // Event crosses shadow DOM boundaries
});

// Basic Tab key simulation
document.dispatchEvent(
  new KeyboardEvent("keydown", {
    key: "Tab",
    code: "Tab",
    keyCode: 9,
    bubbles: true,
    cancelable: true
  })
);

// Function to simulate Tab and actually move focus
function simulateTab(reverse = false) {
  const event = new KeyboardEvent("keydown", {
    key: "Tab",
    code: "Tab",
    keyCode: 9,
    shiftKey: reverse, // Shift+Tab for reverse navigation
    bubbles: true,
    cancelable: true
  });

  document.activeElement.dispatchEvent(event);

  // If default behavior wasn't prevented, manually move focus
  if (!event.defaultPrevented) {
    const focusableElements = Array.from(
      document.querySelectorAll(
        'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
      )
    ).filter((el) => !el.disabled && el.offsetParent !== null);

    const currentIndex = focusableElements.indexOf(document.activeElement);
    const nextIndex = reverse
      ? (currentIndex - 1 + focusableElements.length) % focusableElements.length
      : (currentIndex + 1) % focusableElements.length;

    focusableElements[nextIndex]?.focus();
  }
}

// Usage examples
simulateTab(); // Move to next focusable element
simulateTab(true); // Move to previous focusable element (Shift+Tab)

// Simple Enter key simulation
document.dispatchEvent(
  new KeyboardEvent("keydown", {
    key: "Enter",
    code: "Enter",
    keyCode: 13,
    bubbles: true,
    cancelable: true
  })
);

// Intelligent Enter simulation that considers context
function simulateEnter(targetElement = document.activeElement) {
  const event = new KeyboardEvent("keydown", {
    key: "Enter",
    code: "Enter",
    keyCode: 13,
    bubbles: true,
    cancelable: true
  });

  targetElement.dispatchEvent(event);

  // Handle specific element types if default behavior wasn't triggered
  if (!event.defaultPrevented) {
    const tagName = targetElement.tagName.toLowerCase();
    const type = targetElement.type?.toLowerCase();

    switch (tagName) {
      case "button":
        targetElement.click();
        break;
      case "input":
        if (type === "submit") {
          targetElement.click();
        } else if (type === "text" || type === "email" || type === "password") {
          // Find and submit parent form
          const form = targetElement.closest("form");
          if (form) {
            const submitButton = form.querySelector(
              'input[type="submit"], button[type="submit"]'
            );
            if (submitButton) {
              submitButton.click();
            } else {
              form.submit();
            }
          }
        }
        break;
      case "a":
        if (targetElement.href) {
          targetElement.click();
        }
        break;
    }
  }
}

// Usage examples
simulateEnter(); // On currently focused element
simulateEnter(document.getElementById("submitBtn")); // On specific element

// Ctrl+Enter simulation
function simulateCtrlEnter() {
  document.dispatchEvent(
    new KeyboardEvent("keydown", {
      key: "Enter",
      code: "Enter",
      keyCode: 13,
      ctrlKey: true,
      bubbles: true,
      cancelable: true
    })
  );
}

// Shift+Tab simulation (reverse tab)
function simulateShiftTab() {
  document.dispatchEvent(
    new KeyboardEvent("keydown", {
      key: "Tab",
      code: "Tab",
      keyCode: 9,
      shiftKey: true,
      bubbles: true,
      cancelable: true
    })
  );
}

// Alt+Enter simulation
function simulateAltEnter() {
  document.dispatchEvent(
    new KeyboardEvent("keydown", {
      key: "Enter",
      code: "Enter",
      keyCode: 13,
      altKey: true,
      bubbles: true,
      cancelable: true
    })
  );
}

// Comprehensive keyboard event simulation
function simulateKeyEvent(keyConfig) {
  const defaultConfig = {
    type: "keydown",
    key: "",
    code: "",
    keyCode: 0,
    bubbles: true,
    cancelable: true,
    ctrlKey: false,
    shiftKey: false,
    altKey: false,
    metaKey: false,
    repeat: false,
    location: KeyboardEvent.DOM_KEY_LOCATION_STANDARD
  };

  const config = { ...defaultConfig, ...keyConfig };
  const event = new KeyboardEvent(config.type, config);

  const target = config.target || document.activeElement || document;
  target.dispatchEvent(event);

  return event;
}

// Usage examples
simulateKeyEvent({
  key: "Tab",
  keyCode: 9,
  target: document.getElementById("myInput")
});

simulateKeyEvent({
  key: "Enter",
  keyCode: 13,
  ctrlKey: true,
  target: document.querySelector("#submitButton")
});

// Simulate Tab on a specific input field
const inputField = document.querySelector("#username");
inputField.dispatchEvent(
  new KeyboardEvent("keydown", {
    key: "Tab",
    keyCode: 9,
    bubbles: true,
    cancelable: true
  })
);

// Simulate Enter on a form
const form = document.querySelector("#loginForm");
form.dispatchEvent(
  new KeyboardEvent("keydown", {
    key: "Enter",
    keyCode: 13,
    bubbles: true,
    cancelable: true
  })
);

// Comprehensive form navigation utilities
class FormNavigator {
  static getFormElements(form) {
    return Array.from(
      form.querySelectorAll(
        'input:not([type="hidden"]):not([disabled]), ' +
          "select:not([disabled]), " +
          "textarea:not([disabled]), " +
          "button:not([disabled])"
      )
    );
  }

  static focusNext(currentElement) {
    const form = currentElement.closest("form");
    if (!form) return false;

    const elements = this.getFormElements(form);
    const currentIndex = elements.indexOf(currentElement);
    const nextElement = elements[currentIndex + 1];

    if (nextElement) {
      nextElement.focus();
      return true;
    }
    return false;
  }

  static focusPrevious(currentElement) {
    const form = currentElement.closest("form");
    if (!form) return false;

    const elements = this.getFormElements(form);
    const currentIndex = elements.indexOf(currentElement);
    const prevElement = elements[currentIndex - 1];

    if (prevElement) {
      prevElement.focus();
      return true;
    }
    return false;
  }

  static simulateTabNavigation(form, direction = "forward") {
    const currentElement = document.activeElement;

    if (direction === "forward") {
      if (!this.focusNext(currentElement)) {
        // If at the end, focus on submit button or first element
        const elements = this.getFormElements(form);
        const submitButton = form.querySelector(
          'input[type="submit"], button[type="submit"]'
        );
        (submitButton || elements[0])?.focus();
      }
    } else {
      if (!this.focusPrevious(currentElement)) {
        // If at the beginning, focus on last element
        const elements = this.getFormElements(form);
        elements[elements.length - 1]?.focus();
      }
    }
  }
}

// Usage examples
const myForm = document.querySelector("#registrationForm");
FormNavigator.simulateTabNavigation(myForm, "forward");
FormNavigator.simulateTabNavigation(myForm, "backward");

// Accessibility testing utilities
class AccessibilityTester {
  static async testTabNavigation(containerSelector = "body") {
    const container = document.querySelector(containerSelector);
    const focusableElements = Array.from(
      container.querySelectorAll(
        "a[href], button:not([disabled]), input:not([disabled]), " +
          "select:not([disabled]), textarea:not([disabled]), " +
          '[tabindex]:not([tabindex="-1"])'
      )
    );

    console.log(`Found ${focusableElements.length} focusable elements`);

    for (let i = 0; i < focusableElements.length; i++) {
      focusableElements[i].focus();

      // Highlight current element
      focusableElements[i].style.outline = "3px solid red";

      console.log(`Element ${i + 1}:`, {
        tag: focusableElements[i].tagName,
        id: focusableElements[i].id,
        class: focusableElements[i].className,
        text: focusableElements[i].textContent?.substring(0, 50)
      });

      // Wait for visual inspection
      await new Promise((resolve) => setTimeout(resolve, 1000));

      // Remove highlight
      focusableElements[i].style.outline = "";

      // Simulate Tab
      simulateTab();
    }
  }

  static testEnterKeyBehavior() {
    const buttons = document.querySelectorAll('button, input[type="submit"]');

    buttons.forEach((button, index) => {
      button.addEventListener("click", (e) => {
        console.log(`Button ${index + 1} clicked:`, {
          text: button.textContent || button.value,
          id: button.id,
          type: button.type
        });
      });
    });

    console.log(
      "Click listeners added to all buttons. Test Enter key behavior."
    );
  }
}

// Run accessibility tests
// AccessibilityTester.testTabNavigation();
// AccessibilityTester.testEnterKeyBehavior();

// Form automation utilities
class FormAutomator {
  static async fillAndSubmitForm(formData, formSelector = "form") {
    const form = document.querySelector(formSelector);
    if (!form) {
      console.error("Form not found");
      return false;
    }

    // Fill form fields
    for (const [fieldName, value] of Object.entries(formData)) {
      const field = form.querySelector(`[name="${fieldName}"], #${fieldName}`);
      if (field) {
        field.value = value;
        field.focus();

        // Simulate typing by dispatching input events
        field.dispatchEvent(new Event("input", { bubbles: true }));
        field.dispatchEvent(new Event("change", { bubbles: true }));

        // Wait briefly between fields
        await new Promise((resolve) => setTimeout(resolve, 100));

        // Simulate Tab to next field
        simulateTab();
      }
    }

    // Submit form with Enter key
    await new Promise((resolve) => setTimeout(resolve, 500));
    simulateEnter();

    return true;
  }

  static validateFormSubmission(formSelector = "form") {
    const form = document.querySelector(formSelector);
    if (!form) return false;

    form.addEventListener("submit", (e) => {
      console.log("Form submission detected:", {
        action: form.action,
        method: form.method,
        data: new FormData(form)
      });
    });

    return true;
  }
}

// Example usage
// FormAutomator.fillAndSubmitForm({
//   username: 'testuser',
//   email: '[email protected]',
//   password: 'password123'
// }, '#loginForm');

// Modal keyboard behavior testing
class ModalTester {
  static testModalFocusTrap(modalSelector) {
    const modal = document.querySelector(modalSelector);
    if (!modal) {
      console.error('Modal not found');
      return;
    }

    const focusableElements = Array.from(modal.querySelectorAll(
      'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
    ));

    if (focusableElements.length === 0) {
      console.warn('No focusable elements found in modal');
      return;
    }

    // Focus first element
    focusableElements[0].focus();

    // Test Tab cycling
    let currentIndex = 0;
    const testCycles = focusableElements.length + 2; // Test wrapping

    for (let i = 0; i < testCycles; i++) {
      setTimeout(() => {
        simulateTab();
        const expectedIndex = (i + 1) % focusableElements.length;

        if (document.activeElement === focusableElements[expectedIndex]) {
          console.log(`✓ Tab cycle ${i + 1}: Focus correctly moved to element ${expectedIndex}`);
        } else {
          console.warn(`✗ Tab cycle ${i + 1}: Focus not properly trapped`);
        }
      }, i * 500);
    }
  }

  static testEscapeKey(modalSelector) {
    const modal = document.querySelector(modalSelector);
    if (!modal) return;

    // Add escape key listener
    document.addEventListener('keydown', (e) => {
      if (e.key === 'Escape') {
        console.log('Escape key detected - modal should close');
      }
    });

    // Simulate Escape key
    setTimeout(() => {
      document.dispatchEvent(new KeyboardEvent('keydown', {
        key: 'Escape',
        code: 'Escape',
        keyCode: 27,
        bubbles: true,
        cancelable: true
      }));
    }, 1000);
  }
}

## Troubleshooting Common Issues {#troubleshooting}

### Events Not Triggering Expected Behavior

**Problem**: Simulated events don't trigger the same behavior as real user input.

**Solutions**:

```javascript
// Issue: Event doesn't bubble or isn't cancelable
// ❌ Insufficient event properties
document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab' }));

// ✅ Complete event properties
document.dispatchEvent(new KeyboardEvent('keydown', {
  key: 'Tab',
  code: 'Tab',
  keyCode: 9,
  bubbles: true,
  cancelable: true,
  composed: true
}));

// Issue: Framework-specific event handling
// Some frameworks (React, Vue) may not respond to synthetic events
function triggerReactEvent(element, eventType, eventProperties) {
  const event = new KeyboardEvent(eventType, eventProperties);

  // Set additional properties that React might expect
  Object.defineProperty(event, 'target', {
    writable: false,
    value: element
  });

  // Trigger both native and React synthetic events
  element.dispatchEvent(event);

  // For React specifically, you might need to access the fiber
  const reactFiber = element._reactInternalFiber || element._reactInternalInstance;
  if (reactFiber && reactFiber.memoizedProps) {
    const handler = reactFiber.memoizedProps[`on${eventType.charAt(0).toUpperCase() + eventType.slice(1)}`];
    if (handler) {
      handler(event);
    }
  }
}

// Custom focus management when default behavior fails
function forceFocusNavigation(direction = "forward") {
  const focusableSelectors = [
    'a[href]:not([tabindex="-1"])',
    'button:not([disabled]):not([tabindex="-1"])',
    'input:not([disabled]):not([tabindex="-1"])',
    'select:not([disabled]):not([tabindex="-1"])',
    'textarea:not([disabled]):not([tabindex="-1"])',
    '[tabindex]:not([tabindex="-1"])'
  ].join(", ");

  const focusableElements = Array.from(
    document.querySelectorAll(focusableSelectors)
  )
    .filter((el) => {
      // Additional visibility checks
      const style = window.getComputedStyle(el);
      return (
        style.display !== "none" &&
        style.visibility !== "hidden" &&
        el.offsetParent !== null
      );
    })
    .sort((a, b) => {
      // Sort by tabindex, then by document order
      const aIndex = parseInt(a.getAttribute("tabindex")) || 0;
      const bIndex = parseInt(b.getAttribute("tabindex")) || 0;

      if (aIndex !== bIndex) {
        return aIndex - bIndex;
      }

      // Use document position for elements with same tabindex
      return a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING
        ? -1
        : 1;
    });

  const currentIndex = focusableElements.indexOf(document.activeElement);
  let nextIndex;

  if (direction === "forward") {
    nextIndex =
      currentIndex < focusableElements.length - 1 ? currentIndex + 1 : 0;
  } else {
    nextIndex =
      currentIndex > 0 ? currentIndex - 1 : focusableElements.length - 1;
  }

  focusableElements[nextIndex]?.focus();
  return focusableElements[nextIndex];
}

// Check for CSP restrictions
function checkCSPRestrictions() {
  try {
    // Try to create a function dynamically
    new Function("return true")();
    console.log("✓ No CSP restrictions detected");
    return false;
  } catch (e) {
    console.warn("⚠ CSP restrictions may prevent some functionality");
    return true;
  }
}

// Alternative approach for CSP-restricted environments
function CSPSafeKeySimulation() {
  // Use only DOM APIs that don't require script evaluation
  const methods = {
    simulateTab() {
      const currentElement = document.activeElement;
      if (currentElement && typeof currentElement.blur === "function") {
        currentElement.blur();
      }

      // Find next focusable element manually
      const nextElement = this.getNextFocusableElement();
      if (nextElement) {
        nextElement.focus();
      }
    },

    getNextFocusableElement() {
      const walker = document.createTreeWalker(
        document.body,
        NodeFilter.SHOW_ELEMENT,
        {
          acceptNode(node) {
            return node.tabIndex >= 0 && !node.disabled
              ? NodeFilter.FILTER_ACCEPT
              : NodeFilter.FILTER_SKIP;
          }
        }
      );

      let current = walker.currentNode;
      while (current && current !== document.activeElement) {
        current = walker.nextNode();
      }

      return walker.nextNode();
    }
  };

  return methods;
}

// Feature detection for keyboard event support
function detectKeyboardEventSupport() {
  const support = {
    KeyboardEvent: typeof KeyboardEvent !== "undefined",
    keyProperty: false,
    codeProperty: false,
    modernEvents: false
  };

  try {
    const testEvent = new KeyboardEvent("keydown", { key: "Tab" });
    support.keyProperty = testEvent.key === "Tab";
    support.codeProperty = "code" in testEvent;
    support.modernEvents = support.KeyboardEvent && support.keyProperty;
  } catch (e) {
    // Fallback for older browsers
  }

  return support;
}

// Cross-browser compatible event creation
function createKeyboardEvent(type, options) {
  const support = detectKeyboardEventSupport();

  if (support.modernEvents) {
    return new KeyboardEvent(type, options);
  }

  // Fallback for older browsers
  const event = document.createEvent("KeyboardEvent");

  if (event.initKeyboardEvent) {
    // Firefox, older WebKit
    event.initKeyboardEvent(
      type,
      options.bubbles || false,
      options.cancelable || false,
      window,
      options.key || "",
      options.location || 0,
      options.ctrlKey || false,
      options.altKey || false,
      options.shiftKey || false,
      options.metaKey || false
    );
  } else if (event.initKeyEvent) {
    // Very old browsers
    event.initKeyEvent(
      type,
      options.bubbles || false,
      options.cancelable || false,
      window,
      options.ctrlKey || false,
      options.altKey || false,
      options.shiftKey || false,
      options.metaKey || false,
      options.keyCode || 0,
      options.charCode || 0
    );
  }

  // Set additional properties if supported
  if (options.keyCode && !event.keyCode) {
    try {
      Object.defineProperty(event, "keyCode", { value: options.keyCode });
    } catch (e) {
      // Read-only property in some browsers
    }
  }

  return event;
}

// Browser-specific utilities
const BrowserUtils = {
  isFirefox: navigator.userAgent.toLowerCase().includes("firefox"),
  isChrome: navigator.userAgent.toLowerCase().includes("chrome"),
  isSafari:
    navigator.userAgent.toLowerCase().includes("safari") &&
    !navigator.userAgent.toLowerCase().includes("chrome"),
  isEdge: navigator.userAgent.toLowerCase().includes("edge"),

  // Firefox-specific Tab simulation
  firefoxTabSimulation(element = document.activeElement) {
    const event = createKeyboardEvent("keydown", {
      key: "Tab",
      keyCode: 9,
      bubbles: true,
      cancelable: true
    });

    element.dispatchEvent(event);

    // Firefox sometimes requires additional focus management
    if (!event.defaultPrevented) {
      const nextElement = this.getNextTabElement(element);
      if (nextElement) {
        nextElement.focus();
      }
    }
  },

  // Safari-specific handling
  safariKeySimulation(key, keyCode, element = document.activeElement) {
    // Safari may require both keydown and keyup events
    const keydownEvent = createKeyboardEvent("keydown", {
      key: key,
      keyCode: keyCode,
      bubbles: true,
      cancelable: true
    });

    const keyupEvent = createKeyboardEvent("keyup", {
      key: key,
      keyCode: keyCode,
      bubbles: true,
      cancelable: true
    });

    element.dispatchEvent(keydownEvent);
    setTimeout(() => element.dispatchEvent(keyupEvent), 10);
  },

  getNextTabElement(current) {
    // Implementation depends on browser-specific focus management
    const tabbableElements = Array.from(
      document.querySelectorAll(
        "input, button, select, textarea, a[href], [tabindex]"
      )
    ).filter((el) => {
      const tabIndex = parseInt(el.getAttribute("tabindex") || "0");
      return tabIndex >= 0 && !el.disabled;
    });

    const currentIndex = tabbableElements.indexOf(current);
    return tabbableElements[currentIndex + 1] || tabbableElements[0];
  }
};

// Safe key simulation that respects CSP
class SecureKeySimulator {
  constructor() {
    this.cspRestricted = this.detectCSPRestrictions();
  }

  detectCSPRestrictions() {
    try {
      new Function("return true")();
      return false;
    } catch (e) {
      return true;
    }
  }

  safeSimulateKey(key, keyCode, targetElement = document.activeElement) {
    if (this.cspRestricted) {
      // Use only DOM APIs, no dynamic code execution
      return this.domOnlySimulation(key, keyCode, targetElement);
    } else {
      // Full featured simulation
      return this.fullSimulation(key, keyCode, targetElement);
    }
  }

  domOnlySimulation(key, keyCode, targetElement) {
    // Limited functionality but CSP-safe
    const event = document.createEvent("KeyboardEvent");

    if (event.initKeyboardEvent) {
      event.initKeyboardEvent(
        "keydown",
        true,
        true,
        window,
        key,
        0,
        false,
        false,
        false,
        false
      );
    }

    // Manually set properties
    Object.defineProperty(event, "keyCode", {
      value: keyCode,
      writable: false
    });
    Object.defineProperty(event, "which", { value: keyCode, writable: false });

    targetElement.dispatchEvent(event);
    return event;
  }

  fullSimulation(key, keyCode, targetElement) {
    const event = new KeyboardEvent("keydown", {
      key: key,
      keyCode: keyCode,
      bubbles: true,
      cancelable: true
    });

    targetElement.dispatchEvent(event);
    return event;
  }
}

// Rate limiting and validation for key simulation
class SafeKeySimulator {
  constructor(maxEventsPerSecond = 10) {
    this.eventQueue = [];
    this.maxEventsPerSecond = maxEventsPerSecond;
    this.lastCleanup = Date.now();
  }

  isAllowedKey(key) {
    // Whitelist of safe keys for simulation
    const allowedKeys = [
      "Tab",
      "Enter",
      "Escape",
      "ArrowUp",
      "ArrowDown",
      "ArrowLeft",
      "ArrowRight"
    ];
    return allowedKeys.includes(key);
  }

  simulateKey(key, keyCode, options = {}) {
    // Rate limiting
    const now = Date.now();
    if (now - this.lastCleanup > 1000) {
      this.eventQueue = this.eventQueue.filter(
        (timestamp) => now - timestamp < 1000
      );
      this.lastCleanup = now;
    }

    if (this.eventQueue.length >= this.maxEventsPerSecond) {
      console.warn("Rate limit exceeded for key simulation");
      return false;
    }

    // Key validation
    if (!this.isAllowedKey(key)) {
      console.warn(`Key "${key}" is not allowed for simulation`);
      return false;
    }

    // Target validation
    const target = options.target || document.activeElement;
    if (!target || !target.dispatchEvent) {
      console.warn("Invalid target for key simulation");
      return false;
    }

    this.eventQueue.push(now);

    // Safe simulation
    const event = new KeyboardEvent("keydown", {
      key: key,
      keyCode: keyCode,
      bubbles: true,
      cancelable: true,
      ...options
    });

    return target.dispatchEvent(event);
  }
}

// Usage with built-in safety measures
const safeSimulator = new SafeKeySimulator(5); // Max 5 events per second

// Safe simulation functions
function safeSimulateTab(target) {
  return safeSimulator.simulateKey("Tab", 9, { target });
}

function safeSimulateEnter(target) {
  return safeSimulator.simulateKey("Enter", 13, { target });
}

/**
 * Production-ready keyboard event simulator
 * Handles cross-browser compatibility, security, and edge cases
 */
class KeyboardSimulator {
  constructor(options = {}) {
    this.options = {
      maxEventsPerSecond: options.maxEventsPerSecond || 10,
      allowedKeys: options.allowedKeys || [
        "Tab",
        "Enter",
        "Escape",
        "ArrowUp",
        "ArrowDown",
        "ArrowLeft",
        "ArrowRight"
      ],
      enableFocusManagement: options.enableFocusManagement !== false,
      enableLogging: options.enableLogging || false,
      ...options
    };

    this.eventQueue = [];
    this.browserSupport = this.detectBrowserSupport();

    if (this.options.enableLogging) {
      console.log("KeyboardSimulator initialized:", this.browserSupport);
    }
  }

  detectBrowserSupport() {
    return {
      modernEvents: typeof KeyboardEvent !== "undefined",
      keyProperty: this.testKeyProperty(),
      cspRestricted: this.testCSPRestrictions()
    };
  }

  testKeyProperty() {
    try {
      const event = new KeyboardEvent("keydown", { key: "Test" });
      return event.key === "Test";
    } catch (e) {
      return false;
    }
  }

  testCSPRestrictions() {
    try {
      new Function("return true")();
      return false;
    } catch (e) {
      return true;
    }
  }

  // Main simulation method
  simulate(key, options = {}) {
    if (!this.validateRequest(key, options)) {
      return false;
    }

    const config = this.prepareEventConfig(key, options);
    const event = this.createEvent(config);
    const target = options.target || document.activeElement || document;

    // Dispatch event
    const result = target.dispatchEvent(event);

    // Handle focus management if needed
    if (this.options.enableFocusManagement && !event.defaultPrevented) {
      this.handleFocusManagement(key, target, options);
    }

    if (this.options.enableLogging) {
      console.log(`Simulated ${key} key:`, { target: target.tagName, result });
    }

    return result;
  }

  // Convenience methods
  tab(options = {}) {
    return this.simulate("Tab", { keyCode: 9, ...options });
  }

  enter(options = {}) {
    return this.simulate("Enter", { keyCode: 13, ...options });
  }

  escape(options = {}) {
    return this.simulate("Escape", { keyCode: 27, ...options });
  }

  // Validation and rate limiting
  validateRequest(key, options) {
    // Rate limiting
    const now = Date.now();
    this.eventQueue = this.eventQueue.filter(
      (timestamp) => now - timestamp < 1000
    );

    if (this.eventQueue.length >= this.options.maxEventsPerSecond) {
      console.warn("KeyboardSimulator: Rate limit exceeded");
      return false;
    }

    // Key validation
    if (!this.options.allowedKeys.includes(key)) {
      console.warn(`KeyboardSimulator: Key "${key}" not allowed`);
      return false;
    }

    this.eventQueue.push(now);
    return true;
  }

  prepareEventConfig(key, options) {
    const keyCodeMap = {
      Tab: 9,
      Enter: 13,
      Escape: 27,
      ArrowUp: 38,
      ArrowDown: 40,
      ArrowLeft: 37,
      ArrowRight: 39
    };

    return {
      type: "keydown",
      key: key,
      code: key,
      keyCode: options.keyCode || keyCodeMap[key] || 0,
      bubbles: true,
      cancelable: true,
      ctrlKey: options.ctrlKey || false,
      shiftKey: options.shiftKey || false,
      altKey: options.altKey || false,
      metaKey: options.metaKey || false,
      ...options
    };
  }

  createEvent(config) {
    if (
      this.browserSupport.modernEvents &&
      !this.browserSupport.cspRestricted
    ) {
      return new KeyboardEvent(config.type, config);
    } else {
      return this.createLegacyEvent(config);
    }
  }

  createLegacyEvent(config) {
    const event = document.createEvent("KeyboardEvent");

    if (event.initKeyboardEvent) {
      event.initKeyboardEvent(
        config.type,
        config.bubbles,
        config.cancelable,
        window,
        config.key,
        config.location || 0,
        config.ctrlKey,
        config.altKey,
        config.shiftKey,
        config.metaKey
      );
    }

    // Set additional properties
    try {
      Object.defineProperty(event, "keyCode", { value: config.keyCode });
    } catch (e) {
      // Property might be read-only
    }

    return event;
  }

  handleFocusManagement(key, target, options) {
    if (key === "Tab" && !options.preventDefault) {
      const direction = options.shiftKey ? "backward" : "forward";
      this.manageFocus(direction, target);
    }
  }

  manageFocus(direction, currentElement) {
    const focusableElements = this.getFocusableElements();
    const currentIndex = focusableElements.indexOf(currentElement);

    let nextIndex;
    if (direction === "forward") {
      nextIndex = (currentIndex + 1) % focusableElements.length;
    } else {
      nextIndex =
        (currentIndex - 1 + focusableElements.length) %
        focusableElements.length;
    }

    const nextElement = focusableElements[nextIndex];
    if (nextElement) {
      nextElement.focus();
    }
  }

  getFocusableElements() {
    const selector = [
      'a[href]:not([tabindex="-1"])',
      'button:not([disabled]):not([tabindex="-1"])',
      'input:not([disabled]):not([tabindex="-1"])',
      'select:not([disabled]):not([tabindex="-1"])',
      'textarea:not([disabled]):not([tabindex="-1"])',
      '[tabindex]:not([tabindex="-1"])'
    ].join(", ");

    return Array.from(document.querySelectorAll(selector)).filter((el) => {
      const style = window.getComputedStyle(el);
      return (
        style.display !== "none" &&
        style.visibility !== "hidden" &&
        el.offsetParent !== null
      );
    });
  }
}

// Create global instance with safe defaults
const keyboardSimulator = new KeyboardSimulator({
  enableLogging: false,
  enableFocusManagement: true,
  maxEventsPerSecond: 5
});

// Export convenient global functions
window.simulateTab = (options) => keyboardSimulator.tab(options);
window.simulateEnter = (options) => keyboardSimulator.enter(options);
window.simulateEscape = (options) => keyboardSimulator.escape(options);

// Usage examples:
// simulateTab();
// simulateEnter({ target: document.getElementById('submitBtn') });
// simulateTab({ shiftKey: true }); // Shift+Tab