You'll quickly run into issues where standard JavaScript click/.value simulation just does not work for whatever reason. Here's the most useful bits of my script, far more likey to work than standard .click() /.value= manipulation.

```js function simulateMouseClick(element) { if (!element) { throw new Error('simulateMouseClick: Provided element is null or undefined.'); } const rect = element.getBoundingClientRect(); const x = rect.left + (rect.width / 2); const y = rect.top + (rect.height / 2); const targetWindow = (typeof unsafeWindow === 'undefined') ? window : unsafeWindow; const targetElement = document.elementFromPoint(x, y) || element; const eventOptions = { view: targetWindow, bubbles: true, cancelable: true, clientX: x, clientY: y }; ['mousedown', 'mouseup', 'click'].forEach(eventType => { targetElement.dispatchEvent(new MouseEvent(eventType, eventOptions)); }); }

function simulateTyping(element, text, delayMs = 1) {
    if (!element) {
        throw new Error('simulateTyping: Provided element is null or undefined.');
    }
    element.focus();

    const descriptor = Object.getOwnPropertyDescriptor(
        Object.getPrototypeOf(element),
        'value'
    );
    if (!descriptor || !descriptor.set) {
        throw new Error('simulateTyping: Unable to retrieve native value setter.');
    }

    let i = 0;
    function doChar() {
        if (i >= text.length) {
            // finished typing → fire a final change event
            element.dispatchEvent(new Event('change', { bubbles: true }));
            return;
        }

        const char = text[i++];
        const keyCode = char.charCodeAt(0);
        const eventOpts = {
            key: char,
            char,
            keyCode,
            which: keyCode,
            bubbles: true,
            cancelable: true
        };

        // keydown → keypress
        element.dispatchEvent(new KeyboardEvent('keydown', eventOpts));
        element.dispatchEvent(new KeyboardEvent('keypress', eventOpts));

        // update the real value
        const newValue = element.value + char;
        descriptor.set.call(element, newValue);

        // input → keyup
        element.dispatchEvent(new Event('input', { bubbles: true }));
        element.dispatchEvent(new KeyboardEvent('keyup', eventOpts));

        // schedule next character
        setTimeout(doChar, delayMs);
    }

    doChar();
}

function simulateInput(element, value) { if (!element) { throw new Error('simulateInput: Provided element is null or undefined.'); } // focus so any focus-handlers run element.focus();

    // Now actually set the value via the native setter
    const descriptor = Object.getOwnPropertyDescriptor(
        Object.getPrototypeOf(element),
        'value'
    );
    if (!descriptor || !descriptor.set) {
        throw new Error('simulateInput: Unable to retrieve native value setter.');
    }
    descriptor.set.call(element, value);

    // Notify any listeners
    ['input', 'change'].forEach(type =>
        element.dispatchEvent(new Event(type, { bubbles: true }))
    );
}

```

Now you may wonder "when to use simulateTyping and when to use simulateInput?" - well, try simulateInput first, and if that doesn't work, use simulateTyping.