applyOnce(
        // true if the applyOnce() call came from the fallbackInterval cycle
        isFromFallbackInterval
    ) {
        if (this.isLeader) {
            return sleep(0, true);
        }
        if (this.isDead) {
            return sleep(0, false);
        }

        /**
         * Already applying more than once,
         * -> wait for the apply queue to be finished.
         */
        if (this._aplQC > 1) {
            return this._aplQ;
        }

        /**
         * Add a new apply-run
         */
        const applyRun = () => {
            /**
             * Optimization shortcuts.
             * Directly return if a previous run
             * has already elected a leader.
             */
            if (this.isLeader) {
                return PROMISE_RESOLVED_TRUE;
            }
            let stopCriteria = false;
            let stopCriteriaPromiseResolve;
            /**
             * Resolves when a stop criteria is reached.
             * Uses as a performance shortcut so we do not
             * have to await the responseTime when it is already clear
             * that the election failed.
             */
            const stopCriteriaPromise = new Promise(res => {
                stopCriteriaPromiseResolve = () => {
                    stopCriteria = true;
                    res();
                };
            });
            const handleMessage = (msg) => {
                if (msg.context === 'leader' && msg.token != this.token) {
                    if (msg.action === 'apply') {
                        // other is applying
                        if (msg.token > this.token) {
                            /**
                             * other has higher token
                             * -> stop applying and let other become leader.
                             */
                            stopCriteriaPromiseResolve();
                        }
                    }

                    if (msg.action === 'tell') {
                        // other is already leader
                        stopCriteriaPromiseResolve();
                        this._hasLeader = true;
                    }
                }
            };
            this.broadcastChannel.addEventListener('internal', handleMessage);

            /**
             * If the applyOnce() call came from the fallbackInterval,
             * we can assume that the election runs in the background and
             * not critical process is waiting for it.
             * When this is true, we give the other instances
             * more time to answer to messages in the election cycle.
             * This makes it less likely to elect duplicate leaders.
             * But also it takes longer which is not a problem because we anyway
             * run in the background.
             */
            const waitForAnswerTime = isFromFallbackInterval ? this._options.responseTime * 4 : this._options.responseTime;

            return sendLeaderMessage(this, 'apply') // send out that this one is applying
                .then(() => Promise.race([
                    sleep(waitForAnswerTime),
                    stopCriteriaPromise.then(() => Promise.reject(new Error()))
                ]))
                // send again in case another instance was just created
                .then(() => sendLeaderMessage(this, 'apply'))
                // let others time to respond
                .then(() => Promise.race([
                    sleep(waitForAnswerTime),
                    stopCriteriaPromise.then(() => Promise.reject(new Error()))
                ]))
                .catch(() => { })
                .then(() => {
                    this.broadcastChannel.removeEventListener('internal', handleMessage);
                    if (!stopCriteria) {
                        // no stop criteria -> own is leader
                        return beLeader(this).then(() => true);
                    } else {
                        // other is leader
                        return false;
                    }
                });
        };
        this._aplQC = this._aplQC + 1;
        this._aplQ = this._aplQ
            .then(() => applyRun())
            .then(() => {
                this._aplQC = this._aplQC - 1;
            });
        return this._aplQ.then(() => this.isLeader);
    }
Returns true if the instance is leader,
false if not.
@async