MZ - Cae_Tweaks - lots of little features

// Q47) Adds in-game option to toggle full-screen.
void (() => { if (!CAE.Tweaks.Q47) return;
'use strict';

    /** Internal label for new option. @type {string} */
    const KEY = CAE.Tweaks.Q47.KEY; // "fullscreen";

    /** Display value for new option. @type {string} */
    const TXT = CAE.Tweaks.Q47.TXT; // "Full Screen";

    /** Default value: `true` = full-screen, `false` = windowed. @type {boolean} */
    const DFAULT = Graphics._isFullScreen();

    /** Private value storage for new option. @type {boolean} */
    let isOn = DFAULT;

    /**
     * If `true`, skip usual `updateConfig` process.
     * Designed to work around NWJS `adjustWindow` pulling the game out of full-screen.
     * Approach chosen due to async request structure for fullscreen API.
     * @type {boolean} @since v15
     */
    let skipConfig = false;

    /**
     * Updates config to match full-screen status.
     * @returns {boolean}
     * `true` iff config was updated.
     */
    const updateConfig = function() {
        if (skipConfig)
            return Graphics._requestFullScreen(), skipConfig = false;
        const v = ConfigManager[KEY];
        const f = !!Graphics._isFullScreen();
        if (!f) { // for proper resize in case boot adjustment was done in fullscreen
            const sb = Scene_Boot.prototype;
            sb.adjustWindow.call(sb);
        }
        if (v === f)
            return false;
        ConfigManager[KEY] = f;
        const sc = SceneManager._scene;
        if (sc instanceof Scene_Options) {
            const w = sc._optionsWindow;
            w.redrawItem(w.findSymbol(KEY));
        } else
            ConfigManager.save();   // Scene_Options saves on exit
        return true;
    };

    /**
     * Updates full-screen status to match config value.
     * @returns {boolean}
     * `true` (in theory, `false` if request not sent - async makes that tricky).
     */
    const updateScreen = function() {
        const v = ConfigManager[KEY];
        if (v)
            Graphics._requestFullScreen();
        else
            Graphics._cancelFullScreen();
        return true;
    };

    // Sync config to full-screen state.
    for (const e of [
        // modern standard
        "fullscreenchange",
        // back-compatibility
        "webkitfullscreenchange",
        "mozfullscreenchange"
    ])
        document.addEventListener(e, updateConfig);

    // Update full-screen status when config value is changed.
    Object.defineProperty(ConfigManager, KEY, {
        get: function( ) { return isOn; },
        set: function(v) { isOn = !!v; updateScreen(); },
        configurable: true
    });

    // Patch - add new option.
    void (alias => {
        Window_Options.prototype.addGeneralOptions = function() {
            alias.apply(this, arguments);
            this.addCommand(TXT, KEY);
        };
    })(Window_Options.prototype.addGeneralOptions);

    // Patch - accommodate new option.
    void (alias => {
        Scene_Options.prototype.maxCommands = function() {
            return alias.apply(this, arguments) + 1;
        };
    })(Scene_Options.prototype.maxCommands);

    // Patch - add new option to config file data.
    void (alias => {
        ConfigManager.makeData = function() {
            const o = alias.apply(this, arguments);
            o[KEY] = this[KEY];
            return o;
        };
    })(ConfigManager.makeData);

    // Patch - read new option from config file data.
    void (alias => {
        ConfigManager.applyData = function(config) {
            alias.apply(this, arguments);
            this[KEY] = this.readFlag(config, KEY, DFAULT);
        };
    })(ConfigManager.applyData);

    // Patch - prevent window resize/movement from pulling game out of full-screen.
    void (alias => { // v15
        Scene_Boot.prototype.adjustWindow = function() {
            if (Utils.isNwjs() && ConfigManager[KEY])
                skipConfig = true;
            alias.apply(this, arguments);
        };
    })(Scene_Boot.prototype.adjustWindow);

})();

    const mergeLongChoices = function(list) {
        /** Deep clone of command list, to avoid mutating map data. @type {EventCommand[]} */
        const r = JsonEx.makeDeepCopy(list);
        /** Commands to merge at next opportunity. @type {EventCommand[][]} */
        const e = [];   // v15 - account for indent
        // Merge (End, Show) choice command pairs.
        for (let n = r.length; n--;) {
            const c = r[n];
            if (c.code === 102) {   // Show Choices
                if (n > 0 && r[n - 1].code === 404) {   // End Choices
                    (e[c.indent] ??= []).unshift(c);
                    r.splice(--n, 2);
                } else if (e[c.indent]?.length) {
                    merge102(c, ...e[c.indent]);
                    delete e[c.indent];
                }
            }
        }
        // Now tidy up the When indices.
        const p = [];   // v15 - account for indent
        for (const c of r)
            switch (c.code) {
                case 102:   // Show Choices
                    p[c.indent] = 0; break;
                case 402:   // When
                    p[c.indent] ??= 0;
                    c.parameters[0] = p[c.indent]++;
                    break;
            }
        return r;
    };