@finsemble/finsemble-ui 8.3.0-beta.8 → 8.3.1

package/platform/services/window/Docking/dockingCalculator.js

@@ -1,3438 +0,0 @@
-import { queue } from "async";
-import DockableGroup from "./dockableGroup";
-import DockableBox from "./dockableBox";
-import BoxMath from "./boxMath";
-import { mousePosToBounds, mouseDown } from "./maskBoundsCalculator";
-import { MonitorPoolSingleton, GroupPoolSingleton, DockingPoolSingleton } from "../Common/Pools/PoolSingletons";
-import { fastClone, checkIfBoundsAreEqual } from "../../../../common/util";
-import { CORNERS, OPPOSITE_EDGE_MAP } from "./constants";
-import { WINDOWSTATE } from "../../../../common/constants";
-import { adjustBoundsToBeOnMonitor, getBoundsWhenMovedOffDockedWindow, getMonitorByBounds, getMonitorFromScaledXY, } from "../../../../common/Monitors";
-import { Logger } from "../../../../clients/logger";
-import { RouterClient } from "../../../../clients/routerClient";
-import uuidv4 from "uuid-random";
-let MINIMUM_HEIGHT;
-let MINIMUM_WIDTH;
-let ALLOW_GROUPS_TO_SNAP;
-let SNAPPING_OPACITY = 0.8;
-/**
- * The pools are just the collection of windows that the DockingCalculator is concerned with
- */
-const groupPool = GroupPoolSingleton;
-// Stationary and moving window are cached onMouseDown and cleared onMouseUp.
-let globalStationaryWindow = null;
-// Windows to ignore for grouping functions (e.g., toolbar - it can snap, but shouldn't group)
-const groupBlacklist = [];
-// Changing the taskbar icon has a single entry point that requires
-// a reason in order to hide or show the taskbar icon.
-// these are the valid reasons to do so.
-const TASKBAR_ICON_CHANGE_REASONS = {
-    IS_MOVE_ANCHOR: "Window is in a movable group and is the move anchor.",
-    MOVABLE_GROUP_BEING_DESTROYED: "Window is in a movable group that's being destroyed.",
-    NOT_MOVE_ANCHOR: "Window is in a movable group and is NOT the move anchor.",
-    LEAVING_MOVABLE_GROUP: "Window is leaving a movable group.",
-};
-/**
- * Expands BoxCoordinates to the requested width/height, keeping the requested edge fixed.
- */
-const expandBoundsAgainstFixedEdge = (bounds, edge) => {
-    var _a, _b;
-    const width = (_a = bounds.width) !== null && _a !== void 0 ? _a : 0;
-    const height = (_b = bounds.height) !== null && _b !== void 0 ? _b : 0;
-    if (edge === "left")
-        bounds.right = bounds.left + width;
-    if (edge === "right")
-        bounds.left = bounds.right - width;
-    if (edge === "top")
-        bounds.bottom = bounds.top + height;
-    if (edge === "bottom")
-        bounds.top = bounds.bottom - height;
-};
-/**
- *
- *
- * @returns
- */
-class DockingCalculator {
-    constructor(monitorsInstance) {
-        // This allows us to defer adding windows/removing windows from a group until onMouseDown. It's modified onMouseMove.
-        this.groupAction = {
-            name: null,
-            windows: [],
-        };
-        //win?: FSBLWindow;
-        //monitorDockablePositions: MonitorDockablePositions = {};
-        //dockingOptions: DockingConfigOptions = {};
-        //dockedPosition: number | undefined;
-        //ignoreSnappingRequests: boolean = false;
-        //undockedPosition!: DockedDimensions;
-        //primaryMonitor?: MonitorInfoDetail;
-        //isHidden: boolean = false;
-        //dockedParams: DockingConfigOptions = {};
-        //dockedHeight: number = 0;
-        //snappedEdge: string = "left";
-        //monitor?: DockableMonitor;
-        //onboundschanged: number = 0;
-        //previouslySnappedEdge?: boolean;
-        //dockedBounds?: DockingBounds;
-        //justDocked?: boolean;
-        //vertices: Record<string, Vertex> = {};
-        this.groups = [];
-        // object that's created onMouseDown. Used to cache potentially expensive operations and common information needed across functions.
-        this.resizeObject = {};
-        this.groupMode = {
-            enabled: true,
-        };
-        this.groupMask = null;
-        // Placeholder for the moveRequest.
-        this.moveRequest = null;
-        //stationaryWindow: DockableWindow | null = null;
-        this.movingWindow = null;
-        this.bufferSize = 15;
-        this.resizeEventThrottlePeriod = 0;
-        this.moveCount = 0;
-        this.intersection = null;
-        // The group mask operations are asynchronous and take a variable amount of time. Generally speaking, show takes longer to complete than hide. So if you call show, and 4ms later call hide, you can finish hiding the group mask before the show has completed. This boolean tells the calculator whether the mask should be hidden or shown. Before calling .show or .hide, we check to see if the last function called matches. So if we expect the mask to be hidden, but we're about to call .show, we exit early.
-        this.groupMaskExpectedState = "hidden";
-        this.shiftKey = false;
-        this.movingGroup = null;
-        this.groupMaskIsVisible = false;
-        this.movingAGroupOfWindows = false;
-        this.groupTileBuffer = 0;
-        this.headerHeight = 40;
-        this.enableWindowsAeroSnap = false;
-        this.claimSpace = false;
-        this.preventOverlapClaimSpace = false;
-        this.persistedOpacity = {};
-        this.monitorsInstance = monitorsInstance;
-        this.groupMaskQueue = queue((task, callback) => {
-            task(callback);
-        });
-    }
-    // Overridden by DockingMain
-    updateGroupData() { }
-    setBoundsErrorCB(err) {
-        Logger.system.error(err);
-    }
-    removeUserRequestFromGroup(userRequest) {
-        var _a;
-        // Remove from group and move
-        const groupNames = fastClone((_a = userRequest.groupNames) !== null && _a !== void 0 ? _a : []);
-        groupNames.forEach((groupName) => {
-            this.removeWindowFromGroup(userRequest.name, groupName);
-            this.wipeSnapRelationships(userRequest.name);
-        });
-        this.updateGroupData();
-        userRequest.groupName = null;
-    }
-    /**
-     * 5/20/19 Joe: Previously group was not set sometimes. In the event that the maximize request comes
-     * into a window that is a group, this will throw an error.
-     */
-    ensureMovingGroupIsSet(moveRequest) {
-        // We reset the moving group in here in cases some request details
-        // have changed since last time we've set it
-        this.movingGroup = this.getMovingGroup(moveRequest);
-        /**
-         * 6/5/19 Joe: If the moving window is in a group (movingGroup is defined)
-         * and any windows in the group that aren't the moving window are maximized
-         * then restore them.
-         */
-        if (this.movingGroup) {
-            Object.keys(this.movingGroup.windows).forEach((windowName) => {
-                var _a;
-                const movingWin = (_a = this.movingGroup) === null || _a === void 0 ? void 0 : _a.windows[windowName];
-                if (movingWin &&
-                    this.isDockableWindowMaximized(movingWin) &&
-                    this.movingWindow &&
-                    movingWin.name !== this.movingWindow.name) {
-                    movingWin.restore();
-                }
-            });
-        }
-    }
-    ensureNotOffMonitor(movingWindow) {
-        const currentBounds = {
-            top: movingWindow.top,
-            bottom: movingWindow.bottom,
-            left: movingWindow.left,
-            right: movingWindow.right,
-            width: movingWindow.width,
-            height: movingWindow.height,
-            name: movingWindow.name,
-        };
-        const newBounds = adjustBoundsToBeOnMonitor(this.monitorsInstance, currentBounds);
-        if (newBounds.top !== currentBounds.top || newBounds.left !== currentBounds.left) {
-            Logger.system.debug("Dockable component was dropped outside of a monitor. Finsemble pushed it back onto monitor. Requested position:", currentBounds, ". Actual position:", newBounds);
-            this.moveWindow(newBounds);
-        }
-    }
-    /**
-     * Check if the window or group being dropped is overlapping a docked window (currently only the toolbar).
-     * If so, move it directly adjacent to the docked window.
-     * @param movingWindow
-     * @param dockedWindowPosition - "edge"
-     */
-    async ensureNotOverlappingDockedWindow(movingWindow, dockedWindowPosition) {
-        var _a;
-        const currentBounds = {
-            top: movingWindow.top,
-            bottom: movingWindow.bottom,
-            left: movingWindow.left,
-            right: movingWindow.right,
-            width: movingWindow.width,
-            height: movingWindow.height,
-            name: movingWindow.name,
-        };
-        // Use the top two corners of the window to determine which monitor to use for the check. If the top of the window is straddling
-        // two monitors, we want to check the monitor that is shared with the docked toolbar.
-        const topLeftMonitor = await getMonitorFromScaledXY(currentBounds.left, currentBounds.top);
-        const topRightMonitor = await getMonitorFromScaledXY(currentBounds.right, currentBounds.top);
-        const sharedMonitors = [topLeftMonitor, topRightMonitor].filter((monitor) => (monitor === null || monitor === void 0 ? void 0 : monitor.name) === dockedWindowPosition.monitorName);
-        // Neither top corner is on the same monitor as the docked toolbar, no need to check
-        if (sharedMonitors.length === 0) {
-            return currentBounds;
-        }
-        const monitorToCheck = sharedMonitors[0];
-        // calculate the new location of the window if it needs to move
-        const { shouldMove, newBounds } = getBoundsWhenMovedOffDockedWindow((_a = monitorToCheck === null || monitorToCheck === void 0 ? void 0 : monitorToCheck.rawMonitor) !== null && _a !== void 0 ? _a : monitorToCheck, currentBounds, dockedWindowPosition.edge);
-        if (shouldMove) {
-            Logger.system.debug("Dockable component was dropped overlapping docked window. Finsemble moved it adjacent to the docked window. Requested position:", currentBounds, ". Actual position:", newBounds);
-            const group = this.getMovableGroup(movingWindow.name);
-            if (group) {
-                const sourceMoveRequest = {
-                    name: movingWindow.name,
-                    changeType: 0,
-                };
-                Object.assign(sourceMoveRequest, newBounds);
-                this.requestMove(sourceMoveRequest, () => {
-                    group.updateBounds();
-                });
-            }
-            else {
-                this.moveWindow(newBounds);
-            }
-        }
-    }
-    endMovingGroup(group) {
-        this.resizeObject = this.correctResizeObject(this.movingWindow, this.resizeObject);
-        if (this.groupMask && this.resizeObject.handle)
-            group.scale(this.groupMask.getBounds(), this.resizeObject.handle, this);
-        this.hideGroupMask();
-        const groupIter = this.groupWindowIterator(group);
-        for (const win of groupIter) {
-            win.show();
-        }
-        this.movingAGroupOfWindows = false;
-    }
-    maybeMakeOrBreakGroups(systemMoved) {
-        let dockingPoolIterator = DockingPoolSingleton.iterator();
-        for (const win of dockingPoolIterator) {
-            // Only break and remake the groups if a user initiated the move action. If the OS moved the group, there is no reason to break it
-            if (!systemMoved) {
-                this.buildSnapRelationships(win);
-                if (win.snappedWindows.length === 0 && win.groupNames.length) {
-                    this.removeWindowFromAllGroups(win);
-                    this.updateGroupData();
-                }
-            }
-            // If this window is in a movable group, get the window in the
-            // top right and show only its taskbar icon.
-            // This is typically only done when windows join or leave a group
-            // However, in a non-rectangular group, you could resize one of
-            // the windows such that the top-right window changes.
-            const movableGroup = this.getMovableGroup(win.name);
-            if (movableGroup) {
-                this.setTaskbarIconForGroup(movableGroup);
-            }
-        }
-    }
-    stopMovingGroup(group) {
-        // When we have finished acting on the group, update each individual window's 'finished' property. Then call the function to complete the move.
-        for (const windowName in group.windows) {
-            const win = this.getWindow(windowName);
-            win.finished = true;
-        }
-        group.stopMove();
-        // When we have finished acting on the group, update each individual window's 'finishedMove' property. Then call the function to complete the move.
-        for (const windowName in group.windows) {
-            const win = this.getWindow(windowName);
-            win.win._stopMove();
-        }
-    }
-    maybeDockWindow(moveRequest, movingWindow, monitor) {
-        var _a;
-        moveRequest.dockedHeight = movingWindow.dockedParams.height; // This will only work when docking top/bottom (which is all that's allowed for now)
-        const { width: oldWidth, height: oldHeight } = moveRequest;
-        moveRequest.dockableEdges = (_a = movingWindow.dockingOptions) === null || _a === void 0 ? void 0 : _a.dockable;
-        const newMoveRequest = monitor.getDockedPosition(moveRequest);
-        if (newMoveRequest) {
-            this.moveWindow(newMoveRequest, () => {
-                monitor.dockWindowToMonitor(newMoveRequest, movingWindow, oldWidth, oldHeight);
-                // Initially, the "bounds-changed" event is used to broadcast an Electron level events such as "windowMoved" and "mouseUp".
-                // But the docking occurs at the Finsemble API level, so needed to additionally trigger the "bounds-changed" event here with new bounds.
-                movingWindow.win.eventManager.trigger("bounds-changed", movingWindow.getBounds());
-            });
-        }
-    }
-    ensureNotInTwoGroups(win, group) {
-        // You can only be in two groups at a time. a movable one, and a resizable one.
-        if (group.isMovable) {
-            const movableGroup = this.getMovableGroup(win.name);
-            if (movableGroup) {
-                this.removeWindowFromGroup(win.name, movableGroup.name, true, false);
-            }
-        }
-        else {
-            const immobileGroup = this.getImmobileGroup(win.name);
-            if (immobileGroup) {
-                this.removeWindowFromGroup(win.name, immobileGroup.name, true, false);
-            }
-        }
-    }
-    // This should probably be moved to DockableWindow but we do not seem
-    // to be relying on windowState on the maximized event handler there...
-    isDockableWindowMaximized(dockableWindow) {
-        return dockableWindow.win.windowState === WINDOWSTATE.MAXIMIZED;
-    }
-    groupContainsMaximizedWindows(group) {
-        return Object.keys(group).some((windowName) => this.isDockableWindowMaximized(group[windowName]));
-    }
-    /** **************************************
-     * Core Loop
-     * Docking works like this:
-     * A dockableWindow receives a `bounds-change-request` event from the window object that it wraps (e.g., an Electron window). Then the docking calculator gets to work.
-     * 1. `this.requestMove`.
-     * 2. `this.onMouseDown`.
-     * 3. `this.onMouseMove`.
-     *
-     * As the user moves her mouse around, steps 1 and 3 are executed.When she releases her mouse, the dockableWindow throws a `bounds-changed` event, which in turn calls `this.onMouseUp`.
-     * The general idea is that the user says "Hey, I'd like to move my window 10px to the right of this window. The calculator spins through, notices that the window that the user is moving is within a snapping buffer around the other window. So it responds, "You're too close to that window, sorry, but we're snapping you.". If the movingWindow isn't within the stationaryWindow's buffer, we give the window the all clear to proceed.
-     *************************************** */
-    /**
-     * This is the core controller of the program. It routes the window's moveRequest to the appropriate place, and it receives the modified bounds afterwards. It communicates the modified bounds to the window via the CB.
-     * @param  {moveRequest} Request from the `dockableWindow`.
-     * @param  {function} cb What to do after the window's new bounds have been calculated.
-     */
-    async requestMove(userRequest, cb) {
-        return new Promise((resolve) => {
-            if (!userRequest) {
-                Logger.system.warn("userRequest null or undefined in requestMove.");
-                cb === null || cb === void 0 ? void 0 : cb(null);
-                resolve(null);
-                return;
-            }
-            const win = this.getWindow(userRequest.name);
-            if (!win) {
-                Logger.system.warn("Got Move Request From Window Not Registered With Docking", userRequest.name);
-                cb === null || cb === void 0 ? void 0 : cb(null);
-                resolve(null);
-                return;
-            }
-            // TPina - 12/05/2022 - We are disabling the dragging of maximized windows (grouped and not grouped).
-            // Ideally we would mimic the OS which restores the window before the drag, but our code
-            // it is not robust enough that allow us to do that at this point.
-            // Electron may also have some bugs related to this since other electron apps behave oddly when we drag
-            // maximized windows.
-            if (win.win.windowState === WINDOWSTATE.MAXIMIZED) {
-                cb === null || cb === void 0 ? void 0 : cb(null);
-                resolve(null);
-                return;
-            }
-            this.movingGroup = this.getMovingGroup(userRequest);
-            if (this.movingGroup &&
-                this.movingGroup.windows &&
-                this.groupContainsMaximizedWindows(this.movingGroup.windows)) {
-                cb === null || cb === void 0 ? void 0 : cb(null);
-                resolve(null);
-                return;
-            }
-            // Occasionally the system bubbles up an incorrect change type.
-            // A resize from the top right would start with a changeType of 0.
-            // The next move will have the proper change type. If we detect that scenario, we need to reset the resizeObject.
-            if (this.moveRequest && this.moveRequest.changeType === 0 && userRequest.changeType !== 0) {
-                this.resizeObject = this.constructResizeObject(userRequest);
-            }
-            // Force minimum height and width even if not in group.
-            if (userRequest.changeType !== 0)
-                userRequest = this.checkShortCircuits(userRequest);
-            const shouldRemoveFromGroup = this.shiftKey && userRequest.changeType === 0;
-            if (shouldRemoveFromGroup)
-                this.removeUserRequestFromGroup(userRequest);
-            this.groupAction = {
-                name: null,
-                windows: [],
-            };
-            /** *
-             * The check below is to see whether we should call onMouseDown, which resets a lot of cached information for docking. There are a couple of cases where we want to call onMouseDown.
-                1. We don't have a cached movingWindow reference. This can mean that onMouseDown hasn't been called, _or_ the moving window was removed from docking before onMouseUp was called. This can be triggered by tiling operations.
-                2. We don't have a cached moveRequest.
-                3. We have a moverequest, but the incoming request has a different change type. The only time we've seen that is in the case of aero-snap. if you aero-snap a window to the side or top of a monitor, then move it, it sends in a changeType of 2 - change in position in size. In any normal world, this is a resize. But it comes in as though a user moved the window. That confuses docking.
-            */
-            const changeTypesAreDifferent = this.moveRequest && this.moveRequest.changeType !== userRequest.changeType;
-            if (!this.movingWindow || !this.moveRequest || changeTypesAreDifferent) {
-                this.onMouseDown(userRequest);
-            }
-            const moveRequest = this.setMoveRequest(userRequest);
-            if (moveRequest.changeType === undefined) {
-                moveRequest.changeType = 0;
-            }
-            if (!this.movingWindow)
-                this.movingWindow = this.getWindow(moveRequest.name);
-            moveRequest.groupNames = this.movingWindow.groupNames;
-            moveRequest.movingRegion = this.resizeObject.correctedHandle;
-            moveRequest.resizeHandle = moveRequest.forceResizeHandle
-                ? moveRequest.resizeHandle
-                : this.resizeObject.correctedHandle;
-            this.ensureMovingGroupIsSet(moveRequest);
-            const afterMove = (bounds) => {
-                this.onMouseMove(bounds, () => {
-                    cb === null || cb === void 0 ? void 0 : cb(null);
-                    resolve(null);
-                });
-            };
-            if (this.groupMode.enabled && moveRequest.groupNames.length) {
-                // /Do something if in a group.
-                this.handleGroup(moveRequest, afterMove);
-                return;
-            }
-            this.checkBuffers(moveRequest, afterMove);
-        });
-    }
-    /**
-     * Windows can be part of two groups - one that can move, and one that allows shared border resizing/group resizing. When N windows are snapped together but not explicitly grouped together, they form an "immobileGroup". A movable group is one that the user has explicitly formed. This function returns the appropriate group, given a moveRequest.
-     * @param {object} moveRequest moverequest.
-     */
-    getMovingGroup(moveRequest) {
-        // If snapped windows can't resize, we always want to return the movable group first.
-        if (this.groupMode.allowSnappedWindowsToResize && moveRequest.changeType !== 0) {
-            return this.getImmobileGroup(moveRequest.name) || this.getMovableGroup(moveRequest.name);
-        }
-        return this.getMovableGroup(moveRequest.name) || this.getImmobileGroup(moveRequest.name);
-    }
-    /**
-     * Loops through all DockableGroups and reconstitutes gaps. This is to clean up an issue where
-     * grouped windows containing a single pixel gap would break on mouse down as the system would
-     * no longer consider them snapped, and therefore would break and remove the group
-     */
-    fixAllGroupGaps() {
-        Object.values(this.getGroups()).forEach((group) => {
-            this.cleanupGroupGaps(group);
-        });
-    }
-    /**
-     * Given a group, will clean up the gaps and reconstitute the groups
-     * @param {object} group An object containing groups, with groupName as key
-     */
-    cleanupGroupGaps(group) {
-        let windowBounds = this.getBoundsOfGroupWindows(group);
-        windowBounds = this.cleanupGaps(group, windowBounds);
-        this.setBoundsOfGroupWindows(group, windowBounds);
-    }
-    /**
-     * This function caches information in the resizeObject so that it doesn't need to be calculated onMouseMove.
-     */
-    onMouseDown(moveRequest) {
-        RouterClient.transmit("Assimilation.taskbar", { visible: false });
-        if (this.moveCount === 0) {
-            /*
-             * JC 7/26/19 - Cleanup group gaps on first move to solve an issue where grouped
-             * windows with a single pixel gap would break when the group was moved
-             */
-            this.fixAllGroupGaps();
-            this.recalculateSnaps();
-        }
-        this.moveCount++;
-        this.movingWindow = this.getWindow(moveRequest.name);
-        this.movingWindow.resizeHandle = null;
-        if (!this.movingWindow) {
-            throw new Error("Window not found");
-        }
-        // save window opacity before moving
-        this.saveWindowsOpacity();
-        // When we mouse down on a dockable component, we need to store the monitor its on immediately.
-        // Sometimes, in a multi-monitor configuration, when the window undocks it will momentarily
-        // jump to another monitor (since the grabber when docked is always near a monitor edge).
-        // To prevent the moveAllWindowsOutOfClaimedSpace calculation from using the
-        // wrong monitor, we store it on the window to remove it later.
-        if (this.movingWindow.isDockableComponent && this.movingWindow.win.isDocked) {
-            this.movingWindow.dockedMonitor = this.getMonitorForWindow(this.movingWindow); // Not sure why this.movingWindow.monitor is wrong on restart (is always display1)
-        }
-        this.movingGroup = this.getMovingGroup(moveRequest);
-        if (this.movingGroup) {
-            // If this is a group move and there are maximized windows we do not perform the move
-            // since the window movement code is quite frail and it causes a vast array of issues
-            // Group moves are only allowed if all windows in the group are not maximized.
-            if (this.groupContainsMaximizedWindows(this.movingGroup.windows)) {
-                return;
-            }
-            for (const windowName in this.movingGroup.windows) {
-                this.getWindow(windowName).bringToFront();
-            }
-            // Call bringToFront after the loop because the moving window should always be on top of the others windows in the group
-            this.movingWindow.bringToFront();
-            this.movingGroup.startMove();
-        }
-        else {
-            this.movingWindow.win.startMove();
-        }
-        // If there's no moving group, then we're moving an individual window. if it's part of a resizableGroup, it needs to be removed from that group.
-        if (this.groupMode.behavior === "explicit" &&
-            moveRequest.changeType === 0 &&
-            this.movingGroup &&
-            !this.movingGroup.isMovable) {
-            this.removeWindowFromGroup(moveRequest.name, this.movingGroup.name);
-            this.wipeSnapRelationships(moveRequest.name);
-            this.updateGroupData();
-        }
-        this.resizeObject = this.constructResizeObject(moveRequest);
-        if (this.resizeObject.scalingGroup && this.movingGroup) {
-            const groupIter = this.groupWindowIterator(this.movingGroup);
-            for (const win of groupIter) {
-                win.hide();
-            }
-            mouseDown(this.movingGroup.getBounds(), moveRequest.mousePosition, this.resizeObject);
-            this.showGroupMask({ bounds: this.movingGroup.getBounds(), opacity: 0.5 }, () => { });
-        }
-    }
-    hideGroupMask(cb = Function.prototype) {
-        this.groupMaskExpectedState = "hidden";
-        this.groupMaskQueue.push((done) => {
-            var _a;
-            if (this.groupMaskExpectedState === "shown" || this.groupMaskIsVisible === false) {
-                cb();
-                return done();
-            }
-            (_a = this.groupMask) === null || _a === void 0 ? void 0 : _a.win._hide({}, () => {
-                this.groupMaskIsVisible = false;
-                cb();
-                done();
-            });
-        });
-    }
-    /**
-     * Transparency breaks often with group mask. So use this to show it.
-     *
-     * @param {any} bounds
-     * @param {number} [opacity=0.5]
-     * @param {any} [cb=Function.prototype]
-     * @memberof DockingCalculator
-     */
-    showGroupMask(params, cb = Function.prototype) {
-        this.groupMaskExpectedState = "shown";
-        if (!this.groupMask)
-            return;
-        const { bounds } = params;
-        const groupMaskBounds = this.groupMask.getBounds();
-        if (this.groupMaskIsVisible &&
-            groupMaskBounds.top == bounds.top &&
-            groupMaskBounds.left == bounds.left &&
-            groupMaskBounds.height == bounds.height &&
-            groupMaskBounds.width == bounds.width) {
-            return cb();
-        }
-        this.groupMask.setBounds(params.bounds, () => {
-            var _a;
-            (_a = this.groupMask) === null || _a === void 0 ? void 0 : _a.win._updateOptions({ opacity: params.opacity }, () => {
-                this.groupMaskQueue.push((done) => {
-                    var _a;
-                    if (this.groupMaskExpectedState === "hidden" || this.groupMaskIsVisible === true) {
-                        cb();
-                        return done();
-                    }
-                    (_a = this.groupMask) === null || _a === void 0 ? void 0 : _a.win._show({}, () => {
-                        var _a;
-                        (_a = this.groupMask) === null || _a === void 0 ? void 0 : _a.win._bringToFront({}, () => {
-                            this.groupMaskIsVisible = true;
-                            cb();
-                            done();
-                        });
-                    });
-                });
-            });
-        });
-    }
-    /**
-     * This function happens _after_ the calculations have been made. The request comes in, `this.requestMove` routes the request to the appropriate place, and modified bounds are passed into this function. It's a choke point for all docking-sanctioned window movement.
-     */
-    onMouseMove(bounds, cb) {
-        var _a;
-        this.fixWindowOpacity({
-            checkForSnappability: true,
-        });
-        // We might get here via fillHoles or some other programatic action, in which case we don't want
-        // to move the group mask. We can check whether mousePosition exists to determine this.
-        if (this.resizeObject.scalingGroup && ((_a = this.moveRequest) === null || _a === void 0 ? void 0 : _a.mousePosition)) {
-            this.moveGroupMask();
-        }
-        if (bounds.finished) {
-            if (typeof bounds.top !== "undefined") {
-                this.moveWindow(bounds);
-            }
-            cb(null);
-        }
-    }
-    /**
-     * When the user lifts her mouse, this is fired. It cleans up opacity, shows windows if we were moving a group, and cleans up global variables.
-     *
-     * @param {} params - Optional. Possible parameters:
-     *									systemMoved: If true, indicates the OS initiated the group move
-     *									triggeredByAutoArrange: If true, indicate the move was initiated by auto-arrange
-     */
-    async onMouseUp(params = {}) {
-        var _a, _b;
-        if (!this.movingWindow)
-            return;
-        if (this.movingWindow && this.movingWindow.win.windowState === WINDOWSTATE.MAXIMIZED)
-            return;
-        RouterClient.transmit("Assimilation.taskbar", { visible: true });
-        if (this.movingAGroupOfWindows && this.movingGroup)
-            this.endMovingGroup(this.movingGroup);
-        this.maybeMakeOrBreakGroups(params.systemMoved);
-        const isUndockedDockableComponent = this.movingWindow.isDockableComponent && !this.movingWindow.win.isDocked;
-        // Dockable components cannot be dropped off monitor. This code will push the back onto
-        // the monitor if the user dropped them off monitor.
-        if (isUndockedDockableComponent)
-            this.ensureNotOffMonitor(this.movingWindow);
-        const monitorForWindow = this.getMonitorForWindow(this.movingWindow);
-        const movedWin = {
-            name: this.movingWindow.name,
-            monitor: monitorForWindow,
-        };
-        globalStationaryWindow = null;
-        let dockedWindowPosition = {};
-        const dockingPoolIterator = DockingPoolSingleton.iterator();
-        // Iterate through all known windows, saving information about a docked window (e.g. the toolbar)
-        // and also updating the bounds of all groups in case any have changed.
-        for (const win of dockingPoolIterator) {
-            if (win.win.isDocked) {
-                dockedWindowPosition.edge = win.snappedEdge;
-                ({ name: dockedWindowPosition.monitorName } = await this.getMonitorForWindow(win));
-            }
-            win.resizeHandle = null;
-            win.groupNames.forEach((groupName) => {
-                const group = this.getGroup(groupName);
-                group.updateBounds();
-            });
-        }
-        // If we did a group operation, call stopMove, which triggers a bounds save.
-        if (this.movingGroup) {
-            this.stopMovingGroup(this.movingGroup);
-        }
-        else {
-            this.movingWindow.win.stopMove();
-        }
-        // moveRequest is null on group mask resizes..sometimes.
-        if (!this.moveRequest)
-            return;
-        // Reposition the window if it overlaps a docked window (the toolbar). Since only the toolbar can be docked, we only need to do this
-        // check if (1) the toolbar is docked and (2) the movingWindow is not the toolbar
-        if (this.claimSpace &&
-            this.preventOverlapClaimSpace &&
-            !((_a = this.movingWindow) === null || _a === void 0 ? void 0 : _a.isDockableComponent) &&
-            dockedWindowPosition !== {})
-            this.ensureNotOverlappingDockedWindow(this.movingWindow, dockedWindowPosition);
-        // If we mouse up on a dockable component we need to check if it should be docked. If it should, we have to call to move the window since we also want to expand one side or another, since a docked window expands to take the width (or height) of the monitor.
-        if (isUndockedDockableComponent && this.movingWindow.snappedMonitor)
-            this.maybeDockWindow(this.moveRequest, this.movingWindow, monitorForWindow);
-        this.hideGroupMask();
-        // When we eject a tab from a tabbed group it should be brought to front
-        this.movingWindow.bringToFront();
-        this.movingGroup = null;
-        this.movingWindow = null;
-        this.resizeObject = {};
-        if (this.groupMode.enabled && this.groupAction.name) {
-            this.formGroup(this.moveRequest.name, { isMovable: false });
-        }
-        this.moveRequest = null;
-        this.fixWindowOpacity({
-            checkForSnappability: false,
-            persist: true,
-        });
-        // restore the initial window opacity
-        this.restoreWindowsOpacity();
-        // function below defined by the service. Tell it which monitor the window was on when it moved.
-        (_b = this.onMoveComplete) === null || _b === void 0 ? void 0 : _b.call(this, movedWin, params.triggeredByAutoArrange);
-    }
-    static get NO_CHANGE() {
-        return -1;
-    }
-    /** **************************************
-     *	  Calculators - Window Collections 	*
-     *************************************** */
-    formGroup(name, params) {
-        let { isMovable, whitelist, isAlwaysOnTop } = params;
-        const self = this;
-        if (!whitelist) {
-            whitelist = this.getWindowNames();
-        }
-        const win = this.getWindow(name);
-        let windows = win.snappedWindows.map((snapObj) => snapObj.name).filter((snapName) => whitelist.includes(snapName));
-        const processed = [win.name];
-        function getSnappedWindows(windo) {
-            processed.push(windo.name);
-            let snappedWindows = windo.snappedWindows
-                .map((snapObj) => snapObj.name)
-                .filter((snapName) => whitelist.includes(snapName));
-            windo.snappedWindows.forEach((snapObj) => {
-                if (!processed.includes(snapObj.name) && whitelist.includes(snapObj.name)) {
-                    const snapWin = self.getWindow(snapObj.name);
-                    const grandSnaps = getSnappedWindows(snapWin);
-                    snappedWindows = snappedWindows.concat(grandSnaps);
-                }
-            });
-            return snappedWindows;
-        }
-        win.snappedWindows.forEach((snapObj) => {
-            if (whitelist.includes(snapObj.name)) {
-                const snapWin = self.getWindow(snapObj.name);
-                const snappedWindows = getSnappedWindows(snapWin);
-                windows = windows.concat(snappedWindows);
-            }
-        });
-        // dedupe.
-        windows = windows.filter((el, i, arr) => arr.indexOf(el) === i);
-        if (windows.length) {
-            this.groupWindows({ windows, isMovable, isAlwaysOnTop });
-        }
-        return windows;
-    }
-    /**
-     * Spins through all of the windows that can group and creates groups based on window position.
-     */
-    constituteGroups() {
-        for (const groupName in this.getGroups()) {
-            this.removeGroup(groupName);
-        }
-        this.eliminateGaps();
-        const dockingPoolIterator = DockingPoolSingleton.iterator();
-        for (let win of dockingPoolIterator) {
-            if (groupBlacklist.includes(win.name) || !win.canGroup) {
-                continue;
-            }
-            const groupList = this.getGroupNames();
-            if (!Object.keys(groupList).length) {
-                this.addWindowToGroup({
-                    groupName: uuidv4(),
-                    win,
-                });
-                continue;
-            }
-            this.buildSnapRelationships(win);
-            const { snappedWindows } = win;
-            for (let i = 0, len = snappedWindows.length; i < len; i++) {
-                const snapObj = snappedWindows[i];
-                var snappedWindow = this.getWindow(snapObj.name);
-                if (win.groupNames.length) {
-                    win.groupNames.forEach((groupName) => {
-                        this.addWindowToGroup({
-                            groupName,
-                            win: snappedWindow,
-                        });
-                    });
-                }
-                else if (snappedWindow && snappedWindow.groupNames.length) {
-                    snappedWindow.groupNames.forEach((groupName) => {
-                        this.addWindowToGroup({
-                            groupName,
-                            win,
-                        });
-                    });
-                }
-                else {
-                    const groupParams = {
-                        name: uuidv4(),
-                        MINIMUM_HEIGHT: this.MINIMUM_HEIGHT,
-                        MINIMUM_WIDTH: this.MINIMUM_WIDTH,
-                    };
-                    const newGroup = new DockableGroup(groupParams);
-                    this.addGroup(newGroup);
-                    this.addWindowToGroup({
-                        groupName: newGroup.name,
-                        win,
-                    });
-                    this.addWindowToGroup({
-                        groupName: newGroup.name,
-                        win: snappedWindow,
-                    });
-                }
-            }
-        }
-    }
-    /**
-     * Given a moveRequest, it returns an array of windowNames. The check essentially boils down to "is this window within my snapping buffer?"
-     * @param  {moveRequest} moveRequest
-     */
-    getSnappableWindows(moveRequest) {
-        const snappableWindows = [];
-        const windowIter = DockingPoolSingleton.iterator();
-        for (const win of windowIter) {
-            // if moveRequest puts the window inside of the stationary window's buffer, snap.
-            if (moveRequest.name === win.name) {
-                continue;
-            }
-            if (!win.ignoreSnappingRequests && win.canSnapToWindow(moveRequest) && !moveRequest.ignoreSnappingRequests) {
-                snappableWindows.push(win.name);
-            }
-        }
-        return snappableWindows;
-    }
-    /**
-     * Checks to see if the window is within the snapping region of any monitor.
-     */
-    getSnappableMonitors(moveRequest) {
-        const monitorNames = Object.keys(MonitorPoolSingleton.getAll());
-        const snappableMonitors = [];
-        for (let i = 0, len = monitorNames.length; i < len; i++) {
-            const monitorName = monitorNames[i];
-            const monitor = MonitorPoolSingleton.get(monitorName);
-            if (monitor.canSnapToWindow(moveRequest)) {
-                snappableMonitors.push(monitorName);
-            }
-        }
-        return snappableMonitors;
-    }
-    /**
-     * Returns an object that describes the edges and corners that are shared between two windows.
-     */
-    getSnapObj(win1, win2) {
-        return {
-            canGroup: !groupBlacklist.includes(win2.name),
-            name: win2.name,
-            edges: win1.getSharedEdges(win2),
-            corners: win1.getSharedCorners(win2),
-        };
-    }
-    /**
-     * Snaps two windows..
-     */
-    snapTwoWindows(win1, win2) {
-        if (groupBlacklist.includes(win1.name) || groupBlacklist.includes(win2.name)) {
-            return;
-        }
-        win1.addSnappedWindow(this.getSnapObj(win1, win2));
-        win2.addSnappedWindow(this.getSnapObj(win2, win1));
-    }
-    /**
-     * Wipes all relationships between windows and recalculates them.
-     */
-    recalculateSnaps() {
-        const windowIter = DockingPoolSingleton.iterator();
-        for (const win of windowIter) {
-            this.buildSnapRelationships(win);
-            if (win.groupNames.length) {
-                win.groupNames.forEach((groupName) => {
-                    const group = this.getGroup(groupName);
-                    group.updateBounds();
-                });
-            }
-        }
-    }
-    /**
-     * Updates the snappedWindows array for window. The snappedWindow object contains: name, shared edges, shared corners, and whether the window canGroup.
-     * @param  {dockableWindow} win
-     */
-    buildSnapRelationships(win) {
-        if (win.snappedWindows.length) {
-            this.wipeSnapRelationships(win.name);
-        }
-        const dockingPoolIterator = DockingPoolSingleton.iterator();
-        for (const snappedWindow of dockingPoolIterator) {
-            if (snappedWindow.name === win.name) {
-                continue;
-            }
-            const isOneGroup = win.groupNames.filter((groupName) => snappedWindow.groupNames.includes(groupName)).length > 0;
-            const isOneWindowMaximized = win.win.windowState === WINDOWSTATE.MAXIMIZED || snappedWindow.win.windowState === WINDOWSTATE.MAXIMIZED;
-            // snap windows if they have:
-            // 1) shared edge OR
-            // 2) shared corner OR
-            // 3) one of them is maximized and they both in the same group. That case prevents ungrouping on toolbar docking/undocking
-            if (win.sharesAnEdgeWith(snappedWindow) ||
-                win.sharesACornerWith(snappedWindow) ||
-                (isOneGroup && isOneWindowMaximized)) {
-                this.snapTwoWindows(win, snappedWindow);
-            }
-        }
-    }
-    /**
-     * Returns any window with a vertex on a segment.
-     * @param  {segment} segment A line segment. An array with 2 points in it (start and end).
-     * @return {type}
-     */
-    getWindowBoxesOnSegment(segment) {
-        const windowsOnSegment = [];
-        const dockingPoolIterator = DockingPoolSingleton.iterator();
-        const points = [segment.min, segment.max];
-        for (const win of dockingPoolIterator) {
-            for (let p = 0, len = points.length; p < len; p++) {
-                const point = points[p];
-                if (win.pointIsOnBoundingBox(point)) {
-                    const snapObj = {
-                        name: win.name,
-                        edge: win.getEdgeByPoint(point),
-                        win,
-                    };
-                    snapObj.segment = win.getEdges("obj")[snapObj.edge];
-                    windowsOnSegment.push(snapObj);
-                    break;
-                }
-            }
-        }
-        return windowsOnSegment;
-    }
-    windowsOnEdgeFromPool(win, edge, includeCorners) {
-        let windowsOnEdge = [];
-        const oppEdge = OPPOSITE_EDGE_MAP[edge];
-        const windowSegment = win.getEdges("obj", includeCorners)[edge];
-        const dockingPoolIterator = DockingPoolSingleton.iterator();
-        for (const possibleSnapper of dockingPoolIterator) {
-            // Current window isn't a candidate
-            if (possibleSnapper.name === win.name)
-                continue;
-            const segment = possibleSnapper.getEdges("obj", includeCorners)[oppEdge];
-            let points = [
-                {
-                    name: possibleSnapper.name,
-                    val: segment.min,
-                },
-                {
-                    name: possibleSnapper.name,
-                    val: segment.max,
-                },
-                {
-                    name: win.name,
-                    val: windowSegment.min,
-                },
-                {
-                    name: win.name,
-                    val: windowSegment.max,
-                },
-            ];
-            if (["top", "bottom"].includes(edge)) {
-                if (segment.min.y !== windowSegment.min.y)
-                    continue;
-                points = points.sort((a, b) => b.val.x - a.val.x);
-            }
-            if (["left", "right"].includes(edge)) {
-                if (segment.min.x !== windowSegment.min.x)
-                    continue;
-                points = points.sort((a, b) => b.val.y - a.val.y);
-            }
-            if (points[0].name === points[1].name)
-                continue;
-            windowsOnEdge.push({
-                name: possibleSnapper.name,
-                edge: oppEdge,
-            });
-        }
-        return windowsOnEdge;
-    }
-    /**
-     * Similar to getWindowBoxesOnSegment but you can pass in a string instead of a line segment.
-     * @param  {dockableWindow} win
-     * @param  {string} edge E.g., 'left', 'right', etc.
-     * @return {array}
-     */
-    getWindowsOnEdge(win, edge, includeCorners = false) {
-        if (!edge)
-            return [];
-        const splitEdge = edge.split(/(?=[A-Z])/).map((s) => s.toLowerCase());
-        if (splitEdge.length > 1) {
-            const cornerPoint = win.getPointByVertex(edge);
-            const windowsAtCorner = this.getWindowsAtPoint(cornerPoint);
-            const windowToPossibleSnapper = (windowName) => {
-                var _a;
-                const possibleSnapper = this.getWindow(windowName);
-                return {
-                    name: possibleSnapper.name,
-                    edge: (_a = possibleSnapper.getVertexByPoint(cornerPoint)) !== null && _a !== void 0 ? _a : "undefined",
-                };
-            };
-            return windowsAtCorner.map((windowName) => windowToPossibleSnapper(windowName));
-        }
-        return this.windowsOnEdgeFromPool(win, edge, includeCorners);
-    }
-    /**
-     * Returns a list of windows that straddle a given edge.
-     *	+-----------+------------+
-     *	|           |            |
-     *	|           |            |
-     *	|    A      |     B      |
-     *	|           |            |
-     *	+-----------+--+---------+
-     *	|              |         |
-     *	|    C         |   D     |
-     *	|              |         |
-     *	+--------------+---------+
-     *
-     * In the drawing above, B straddles the left edge of D and the right Edge of C.
-     * @param  {dockableWindow} win
-     * @param  {string} edge E.g., 'left', 'right', etc.
-     */
-    getStraddlers(win) {
-        const straddlers = [];
-        const dockingPoolIterator = DockingPoolSingleton.iterator();
-        for (const straddler of dockingPoolIterator) {
-            if (straddler.name === win.name) {
-                continue;
-            }
-            const corners = straddler.vertices;
-            for (const corner in corners) {
-                if (win.pointIsOnBoundingBox(corners[corner], false)) {
-                    straddlers.push({
-                        name: straddler.name,
-                        edge: win.getEdgeByPoint(corners[corner]),
-                    });
-                }
-            }
-        }
-        return straddlers;
-    }
-    /**
-     * Given an X, Y point, it returns a list of windows with that point on their boundingBox.
-     * @param  {object} point
-     * @return {array}
-     */
-    getWindowsAtPoint(point) {
-        const windows = [];
-        const dockingPoolIterator = DockingPoolSingleton.iterator();
-        for (const win of dockingPoolIterator) {
-            if (groupBlacklist.includes(win.name)) {
-                continue;
-            }
-            if (win.pointIsOnBoundingBox(point)) {
-                windows.push(win.name);
-            }
-        }
-        return windows;
-    }
-    /**
-     * Just a helper to say whether a window has an edge on the edge of the group.
-     * @param  {dockableWindow} win
-     * @param  {dockableGroup} group
-     */
-    windowIsOnExteriorEdgeOfGroup(win, group) {
-        const winBounds = win.windowBoundingBox;
-        const groupBounds = group.bounds;
-        // left
-        if (winBounds.min.x === groupBounds.min.x) {
-            return true;
-        }
-        // bottom
-        if (winBounds.max.y === groupBounds.max.y) {
-            return true;
-        }
-        // right
-        if (winBounds.max.x === groupBounds.max.x) {
-            return true;
-        }
-        // top
-        return winBounds.min.y === groupBounds.min.y;
-    }
-    /**
-     * Lets the program know that shift is being held down. This is used when moving a window that's explicitly grouped (if assimilation is turned on). In that case, the window moves out of the group.
-     */
-    setShift(bool) {
-        this.shiftKey = bool;
-    }
-    /**
-     * Returns an ordered Object. Sorts by Top, then Left.
-     * @return {Object} Object where the keys are names of the window.
-     */
-    orderWindows(windowList, anchor) {
-        // sort windows by top so that when we constitute groups it won't randomly compare windows in the bottom to ones in the top of the monitor.
-        const sortableArray = [];
-        if (windowList === undefined) {
-            windowList = DockingPoolSingleton.getAll();
-        }
-        for (const windowName in windowList) {
-            const win = this.getWindow(windowName);
-            sortableArray.push(win);
-        }
-        sortableArray.sort((a, b) => {
-            const aTop = a.top;
-            const aLeft = a.left;
-            const bTop = b.top;
-            const bLeft = b.left;
-            // if the window's top is above the anchor's top, compare its bottom to the anchor's top. In a 3x3 grid, this will ensure that windows in row 2 end up after windows in row 3. Looking at the grid below, if we just compared the window's top to the anchor's top, window D would appear in the array before D, even though D is closer to G. By comparing the bottoms of windows above the anchor, we force the algorithm to look at the left instead of the top. That all may be a crock of shit, too. I Basically, if I resize from the top-right of this group I want it to go: G, H, I, D, E, F, A, B, C. The algorithm below does that.
-            /**
-             * +-----------+--------------+-------------+
-             * |           |              |             |
-             * |           |              |             |
-             * |    A      |      B       |     C       |
-             * |           |              |             |
-             * |           |              |             |
-             * +-----------+              +-------------+
-             * |           +--------------+             |
-             * |           |              |             |
-             * |    D      |      E       |      F      |
-             * |           |              |             |
-             * +----------------------------------------+
-             * |           |              |             |
-             * |           |              |             |
-             * |   G       |       H      |      I      |
-             * |           |              |             |
-             * |           |              |             |
-             * +-----------+--------------+-------------+
-             */
-            if (anchor) {
-                const aDelta = {
-                    left: Math.abs(anchor.left - a.left),
-                    top: a.bottom === anchor.top ? Math.abs(anchor.top - a.bottom) : Math.abs(anchor.top - a.top),
-                };
-                const bDelta = {
-                    left: Math.abs(anchor.left - b.left),
-                    top: b.bottom === anchor.top ? Math.abs(anchor.top - b.bottom) : Math.abs(anchor.top - b.top),
-                };
-                if (aDelta.left === bDelta.left) {
-                    return aDelta.top - bDelta.top;
-                }
-                return aDelta.left - bDelta.left;
-            }
-            // orders windows ascending by their Top values.
-            if (aTop === bTop) {
-                return aLeft - bLeft;
-            }
-            return aTop - bTop;
-        });
-        return sortableArray;
-    }
-    /** **************************************
-     *			Getters/Setters				*
-     *************************************** */
-    /**
-     * Registers the window with the calculator
-     * @param  {string} name
-     * @param  {dockableWindow} val
-     */
-    addWindowInternal(name, val) {
-        var _a, _b, _c, _d;
-        val.setBufferSize(this.bufferSize);
-        val.setResizeThrottlePeriod(this.resizeEventThrottlePeriod);
-        DockingPoolSingleton.add(name, val);
-        // if the window is not resisable then the limits need to be set correctly
-        val.limits = {
-            minHeight: val.win.windowOptions.resizable === false ? val.win.windowOptions.height : (_a = val.dockingOptions) === null || _a === void 0 ? void 0 : _a.minHeight,
-            minWidth: val.win.windowOptions.resizable === false ? val.win.windowOptions.width : (_b = val.dockingOptions) === null || _b === void 0 ? void 0 : _b.minWidth,
-            maxHeight: val.win.windowOptions.resizable === false ? val.win.windowOptions.height : (_c = val.dockingOptions) === null || _c === void 0 ? void 0 : _c.maxHeight,
-            maxWidth: val.win.windowOptions.resizable === false ? val.win.windowOptions.width : (_d = val.dockingOptions) === null || _d === void 0 ? void 0 : _d.maxWidth,
-        };
-        if (val.win.windowDescriptor) {
-            if (val.win.windowDescriptor.minWidth && val.win.windowDescriptor.minWidth < val.limits.minWidth) {
-                Logger.system.warn(`addWindow [${name}] minWidth ${val.win.windowDescriptor.minWidth} less than system minimum ${val.limits.minWidth}`);
-            }
-            if (val.win.windowDescriptor.minHeight && val.win.windowDescriptor.minHeight < val.limits.minHeight) {
-                Logger.system.warn(`addWindow [${name}] minHeight ${val.win.windowDescriptor.minHeight} less than system minimum ${val.limits.minHeight}`);
-            }
-        }
-        val.monitor = this.getMonitorForWindow(val);
-        /* Does not appear to be used
-        if (val.groupName) {
-            const group = this.getGroup(val.groupName);
-            group.addWindow(val);
-        }
-        */
-        this.buildSnapRelationships(val);
-    }
-    /**
-     * Virtually unsnaps a window from all other windows. This doesn't affect physical positioning. Only the relationships that Docking is a aware of.
-     */
-    wipeSnapRelationships(name) {
-        const win = this.getWindow(name);
-        if (win && win.snappedWindows) {
-            const snappedWindows = fastClone(win.snappedWindows);
-            for (let i = 0, len = snappedWindows.length; i < len; i++) {
-                const snapObj = snappedWindows[i];
-                const snappedWindow = this.getWindow(snapObj.name);
-                win.removeSnappedWindow(snappedWindow.name);
-                if (snappedWindow) {
-                    snappedWindow.removeSnappedWindow(win.name);
-                }
-            }
-        }
-    }
-    /**
-     * Removes a window from all groups.
-     */
-    removeWindowFromAllGroups(win, deleteGroupsWithOneWindow = true) {
-        if (!win) {
-            Logger.system.warn("INVESTIGATE: No win passed to removeWindowFromAllGroups.");
-            return;
-        }
-        const groupNames = fastClone(win.groupNames);
-        for (let i = 0, len = groupNames.length; i < len; i++) {
-            const groupName = groupNames[i];
-            this.removeWindowFromGroup(win.name, groupName, deleteGroupsWithOneWindow);
-        }
-    }
-    /**
-     * Unregisters the window.
-     * @param  {string} name
-     */
-    removeWindowInternal(name, removeListeners = true) {
-        const win = this.getWindow(name);
-        if (!win) {
-            Logger.system.warn("window was not found:", name);
-            return;
-        }
-        // Removes event listeners from the window.
-        if (removeListeners) {
-            win.removeEventListeners();
-        }
-        if (!win) {
-            Logger.system.warn(`INVESTIGATE: No win found for ${name} in removeWindow.`);
-        }
-        if (win && win.groupNames.length) {
-            // If we aren't removing listeners, we're removing the window for tiling purposes (so it doesn't mess up other windows resizing). In that case, we don't want to remove groups with a single window, which is what the 2nd param here does.
-            this.removeWindowFromAllGroups(win, !removeListeners);
-        }
-        // If we're removing the window that was last cached on mouseDown, wipe the reference. This way, onMouseUp, the window's bounds-changed event will not trigger, and it will not break everything.
-        if (this.movingWindow && this.movingWindow.name === win.name) {
-            this.movingWindow = null;
-        }
-        this.wipeSnapRelationships(win.name);
-        DockingPoolSingleton.remove(name);
-    }
-    /**
-     * Returns an array of window names.
-     */
-    getWindowNames() {
-        return Object.keys(DockingPoolSingleton.getAll());
-    }
-    /**
-     * @return {dockingPool}
-     */
-    getWindows() {
-        return DockingPoolSingleton.getAll();
-    }
-    getUnignoredWindows() {
-        const windowIter = DockingPoolSingleton.iterator();
-        const ret = [];
-        for (const win of windowIter) {
-            ret.push(win);
-        }
-        return ret;
-    }
-    /**
-     * Gets a window object by name.
-     * @param  {type} name
-     * @param  {type} throwError Usually we want to throw the error, but sometimes we use this function to filter (e.g., autoarrange).
-     * @return {type}
-     */
-    getWindow(name, throwError) {
-        const win = DockingPoolSingleton.get(name, throwError);
-        if (!win && (typeof throwError === "undefined" || throwError)) {
-            Logger.system.warn(`No win found for ${name}.`, Object.keys(DockingPoolSingleton.getAll()));
-        }
-        return win;
-    }
-    /**
-     * returns the monitor that the window is on. If the left edge of the window is on two or more monitors, we calculate the monitor that houses the majority of the window.
-     * @param {string} windowName
-     */
-    getMonitorForWindow(win) {
-        // Sometimes bad objects get passed into this function. They shouldn't, but they do. if we can't retrieve bounds, it's not a window. Try to get a window. If there's no window, return the first monitor.
-        if (!win.getBounds && win.name)
-            win = this.getWindow(win.name);
-        if (!win.getBounds)
-            return this.getMonitorArray()[0];
-        const boundingBox = win.getBounds();
-        return getMonitorByBounds(boundingBox);
-    }
-    /**
-     * Returns a monitor object.
-     * @param {string} name name of monitor.
-     */
-    getMonitor(name) {
-        return MonitorPoolSingleton.get(name);
-    }
-    /**
-     * Unregisters a monitor with the calculator.
-     * @param  {type} name
-     * @return {type}
-     */
-    removeMonitor(name) {
-        MonitorPoolSingleton.remove(name);
-    }
-    /**
-     * @return {MonitorPoolSingleton}
-     */
-    getMonitors() {
-        return MonitorPoolSingleton.getAll();
-    }
-    /**
-     * Returns a list of 'rawMonitors' from the container. These are only available when they are actually passed into the DockableMonitor when its instantiated.
-     */
-    getRawMonitors() {
-        const rawMonitors = [];
-        const iterator = MonitorPoolSingleton.iterator();
-        for (const monitor of iterator) {
-            rawMonitors.push(monitor.rawMonitor);
-        }
-        return rawMonitors;
-    }
-    /**
-     * Returns the monitors in an array
-     */
-    getMonitorArray() {
-        const monitors = [];
-        const iterator = MonitorPoolSingleton.iterator();
-        for (const monitor of iterator) {
-            monitors.push(monitor);
-        }
-        return monitors;
-    }
-    /**
-     *
-     */
-    removeAllMonitors() {
-        const iterator = MonitorPoolSingleton.iterator();
-        for (const monitor of iterator) {
-            this.removeMonitor(monitor.name);
-        }
-    }
-    /**
-     * Sets the resize throttle period. This allows the system to drop events that occur too quickly.
-     */
-    setResizeThrottlePeriod(throttlePeriod) {
-        Logger.system.log("DockingService.SetThrottle", JSON.stringify(throttlePeriod));
-        this.resizeEventThrottlePeriod = throttlePeriod;
-        const windowIter = DockingPoolSingleton.iterator();
-        for (const win of windowIter) {
-            win.setResizeThrottlePeriod(throttlePeriod);
-        }
-    }
-    /**
-     * Sets the opacity that windows take when entering another window's snapping region.
-     */
-    setSnappingOpacity(opacity) {
-        SNAPPING_OPACITY = opacity;
-    }
-    /**
-     * At one point we weren't sure if we were going to allow groups to snap because of bugs. This is vestigial and should be removed at some point.
-     */
-    setAllowGroupsToSnap(bool) {
-        ALLOW_GROUPS_TO_SNAP = bool;
-    }
-    /**
-     * Sets the size of the region around windows that will trigger a snap.
-     */
-    setBufferSize(buffer) {
-        Logger.system.info("Setting buffer size", `${buffer}`);
-        this.bufferSize = buffer;
-        const dockingPoolIterator = DockingPoolSingleton.iterator();
-        for (const win of dockingPoolIterator) {
-            win.setBufferSize(buffer);
-        }
-        const monitorIterator = MonitorPoolSingleton.iterator();
-        let monitor;
-        for (monitor in monitorIterator) {
-            monitor.setBufferSize(buffer);
-        }
-    }
-    /**
-     * Will prevent a window from being added to groups.
-     */
-    addToGroupBlacklist(windowName) {
-        groupBlacklist.push(windowName);
-    }
-    /**
-     * Will allow a window previously blacklisted to be included in group operations.
-     */
-    removeFromGroupBlacklist(windowName) {
-        if (groupBlacklist.includes(windowName)) {
-            groupBlacklist.splice(groupBlacklist.indexOf(windowName), 1);
-        }
-    }
-    /**
-     * Adds a group to the calculator.
-     * @param  {type} group
-     */
-    addGroup(group) {
-        groupPool.add(group.name, group);
-    }
-    /**
-     * Removes a group from the calculator.
-     * @param  {type} groupName
-     * @param {Boolean} willReform Whether the group is going to be reformed. This will
-     * tell removeWindowFromGroup if it should modify window taskbar icon visibility.
-     */
-    removeGroup(groupName, willReform = false) {
-        const group = this.getGroup(groupName);
-        if (group) {
-            const groupIter = this.groupWindowIterator(group);
-            group.willReform = willReform;
-            if (group.getWindowNames().length) {
-                for (const win of groupIter) {
-                    this.removeWindowFromGroup(win.name, groupName);
-                }
-            }
-            groupPool.remove(groupName, false);
-            console.warn(`Tried removing a group that was already removed. ${groupName}.`);
-        }
-    }
-    /**
-     * Returns a list of groups that are capable of moving together.
-     */
-    getMovableGroups() {
-        const groupNames = this.getGroupNames();
-        const groups = {};
-        for (let i = 0, len = groupNames.length; i < len; i++) {
-            const groupName = groupNames[i];
-            const group = this.getGroup(groupName);
-            if (group.isMovable) {
-                groups[groupName] = group;
-            }
-        }
-        return groups;
-    }
-    /**
-     * Returns the group Pool
-     * @return {type}
-     */
-    getGroups() {
-        return groupPool.getAll();
-    }
-    /**
-     * Gets a group by name.
-     * @param  {type} name
-     * @return {type}
-     */
-    getGroup(name) {
-        return groupPool.get(name, false);
-    }
-    /**
-     * Gets an array of group names.
-     * @return {type}
-     */
-    getGroupNames() {
-        const names = [];
-        const iter = groupPool.iterator();
-        for (const group of iter) {
-            names.push(group.name);
-        }
-        return names;
-    }
-    /**
-     * Imagine 3 windows snapped horizontally. All are grouped ([A][B][C]). You ungroup B. This function will remove A and C. It iterates through all of the windows in the group and makes sure it's still attached to the group.
-     */
-    checkGroupMembership(win) {
-        if (!win) {
-            Logger.system.warn("INVESTIGATE: No win passed in to checkGroupMembership.");
-            return;
-        }
-        const groupNames = fastClone(win.groupNames);
-        const snappedWindowGroupNames = win.snappedWindows.map((snapObj) => {
-            const snapWin = this.getWindow(snapObj.name);
-            if (snapWin) {
-                return snapWin.groupNames;
-            }
-            Logger.system.warn(`INVESTIGATE: SnapWin does not exist. ${JSON.stringify(snapObj)}.`);
-            return [];
-        });
-        groupNames.forEach((groupName) => {
-            const hasSnappedWindowAttachedToGroup = snappedWindowGroupNames.some((arr) => arr.includes(groupName));
-            if (!hasSnappedWindowAttachedToGroup) {
-                this.removeWindowFromGroup(win.name, groupName);
-            }
-        });
-    }
-    /**
-     * Removes a window from a group. When tiling, we do not delete groups with only one window. We could be doing an operation on a group with two windows, and we want to retain group membership so that hole-filling works appropriately.
-     */
-    removeWindowFromGroup(windowName, groupName, deleteGroupsWithOneWindow = true, updateAOT = true) {
-        const win = this.getWindow(windowName);
-        if (!win || !groupName || !win.groupNames.includes(groupName)) {
-            return;
-        }
-        win.groupNames.splice(win.groupNames.indexOf(groupName), 1);
-        const group = this.getGroup(groupName);
-        if (!group) {
-            return;
-        }
-        group.removeWindow(win.name, updateAOT);
-        if (group.isMovable) {
-            // if the window was in a movable group, it's likely its taskbar icon was hidden. Show it.
-            this.setTaskbarIconVisiblityForWindow({
-                win,
-                reason: group.willReform
-                    ? TASKBAR_ICON_CHANGE_REASONS.MOVABLE_GROUP_BEING_DESTROYED
-                    : TASKBAR_ICON_CHANGE_REASONS.LEAVING_MOVABLE_GROUP,
-            });
-            // When a window leaves a group, we call 'fixGroupMembership', which destroys and reforms all
-            // of the groups. When we do this, we don't need to modify the taskbar icon's visibility.
-            // It'll be handled when the groups are reformed.
-            if (!group.willReform) {
-                this.setTaskbarIconForGroup(group);
-            }
-        }
-        if (deleteGroupsWithOneWindow && group.getWindowNames().length === 1) {
-            const lastWindowName = group.getWindowNames()[0];
-            const lastWindow = this.getWindow(lastWindowName);
-            if (group.isMovable) {
-                // If the window is the last in the group, make sure it has a visible taskbar icon.
-                this.setTaskbarIconVisiblityForWindow({
-                    win: lastWindow,
-                    reason: TASKBAR_ICON_CHANGE_REASONS.MOVABLE_GROUP_BEING_DESTROYED,
-                });
-            }
-            this.removeWindowFromGroup(lastWindowName, group.name, true, updateAOT);
-            this.removeGroup(group.name);
-        }
-        if (!group.getWindowNames().length) {
-            this.removeGroup(group.name);
-        }
-    }
-    /**
-     * Single entry point for changing the taskbar icon's visibility.
-     * At present, taskbar icon status is only changed when a window leaves or joins a movable group.
-     */
-    setTaskbarIconVisiblityForWindow(params) {
-        const { win, reason } = params;
-        switch (reason) {
-            case TASKBAR_ICON_CHANGE_REASONS.IS_MOVE_ANCHOR:
-            case TASKBAR_ICON_CHANGE_REASONS.MOVABLE_GROUP_BEING_DESTROYED:
-            case TASKBAR_ICON_CHANGE_REASONS.LEAVING_MOVABLE_GROUP: {
-                win.showTaskbarIcon(true);
-                break;
-            }
-            case TASKBAR_ICON_CHANGE_REASONS.NOT_MOVE_ANCHOR: {
-                win.hideTaskbarIcon();
-                break;
-            }
-            default: {
-                Logger.system.error("SetTaskbarIconVisibility, no case statement found for", reason);
-                break;
-            }
-        }
-    }
-    /**
-     * Groups n-Windows.
-     *
-     * @param {any} params
-     * @param {any} cb
-     */
-    groupWindows(params, cb) {
-        const groupName = params.groupName || uuidv4();
-        const isMovable = typeof params.isMovable !== "undefined" ? params.isMovable : false;
-        // There must be at least two windows to create a group
-        if (params.windows.length <= 1)
-            return;
-        for (let i = 0, len = params.windows.length; i < len; i++) {
-            const windowName = params.windows[i];
-            const win = this.getWindow(windowName);
-            // Only group windows if they are allowed to. e.g. prevent docking of toolbar.
-            if (win.canGroup) {
-                // Don't set icon visibility inside of addWindowToGroup.
-                // We'll handle that once the group is formed.
-                this.addWindowToGroup({
-                    win,
-                    groupName,
-                    isMovable,
-                    handleIcons: false,
-                });
-            }
-        }
-        if (isMovable) {
-            const group = this.getGroup(groupName);
-            this.setTaskbarIconForGroup(group);
-        }
-        if (cb) {
-            cb(null);
-        }
-    }
-    /**
-     * Given a group, this method will make sure only one window (the top right window) has a visible taskbar icon.
-     * This method is called whenever a window is added to or removed from a group.
-     * @param {DockableGroup} group
-     */
-    setTaskbarIconForGroup(group) {
-        const iter = this.groupWindowIterator(group);
-        // It's possible to get into this case...we don't want to.
-        if (group.getWindowArray().length === 0)
-            return;
-        const groupAnchor = group.getMoveAnchor("BottomLeft");
-        // see below for why we're doing everything in this order.
-        for (const win of iter) {
-            if (groupAnchor.name !== win.name) {
-                this.setTaskbarIconVisiblityForWindow({
-                    win,
-                    reason: TASKBAR_ICON_CHANGE_REASONS.NOT_MOVE_ANCHOR,
-                });
-            }
-        }
-        /**
-         * There is a timing gap in stack creation.
-         * Step 1: Stack joins docking.
-         * Step 2: Stack joins any group that the visible window is part of.
-         * **At this point, both the stack and the visible window are in the same group.**
-         * Step 3: Visible window deregisters.
-         * Before the visible window deregisters, we start trying to figure out which taskbar
-         * icon should be visible. What was happening here was that
-         * we'd try to find the group anchor for this group, and it would come back as
-         * the visible window in the stack.
-         * So we'd show it's taskbar icon.
-         * Then we kept looping.
-         * When we got to the stack, we'd say 'Oh, this isn't the anchor', so its taskbar icon would
-         * be hidden. As a result, the group could end up without a visible taskbar icon.
-         *
-         * Docking knows nothing about stacks and not stacks. In order to keep that separated,
-         * we will hide all non-group anchor icons first, and then show the group anchor's icon.
-         */
-        this.setTaskbarIconVisiblityForWindow({
-            win: this.getWindow(groupAnchor.name),
-            reason: TASKBAR_ICON_CHANGE_REASONS.IS_MOVE_ANCHOR,
-        });
-    }
-    /**
-     * @param  {type} groupName
-     * @param  {dockableWindow} win
-     */
-    addWindowToGroup(params, cb) {
-        let { groupName, win, ungroupedAlwaysOnTopState } = params;
-        if (!win) {
-            Logger.system.warn("INVESTIGATE: No win passed in to addWindowToGroup.");
-            return;
-        }
-        // in the explicit paradigm, groups default to not being immobile, but resizable.
-        const isMovable = typeof params.isMovable !== "undefined" ? params.isMovable : false;
-        const isAlwaysOnTop = typeof params.isAlwaysOnTop !== "undefined" ? params.isAlwaysOnTop : false;
-        if (groupBlacklist.includes(win.name))
-            return;
-        // If window is already part of the group then don't do anything
-        if (win.groupNames.includes(groupName))
-            return;
-        const groupParams = {
-            name: groupName,
-            isMovable,
-            isAlwaysOnTop,
-            ungroupedAlwaysOnTopState,
-            MINIMUM_HEIGHT: 0,
-            MINIMUM_WIDTH: 0,
-        };
-        let group = this.getGroup(groupName);
-        if (!group) {
-            if (!groupName) {
-                groupName = uuidv4();
-            }
-            groupParams.name = groupName;
-            groupParams.MINIMUM_HEIGHT = this.MINIMUM_HEIGHT;
-            groupParams.MINIMUM_WIDTH = this.MINIMUM_WIDTH;
-            group = new DockableGroup(groupParams);
-            this.addGroup(group);
-        }
-        this.ensureNotInTwoGroups(win, group);
-        win.groupNames.push(groupName);
-        group.addWindow(win);
-        if (group.isMovable) {
-            // if this param is undefined or true, change the icon visibility.
-            if (params.handleIcons !== false) {
-                this.setTaskbarIconForGroup(group);
-            }
-            group.bringToFront({});
-        }
-        cb === null || cb === void 0 ? void 0 : cb(group);
-        return group;
-    }
-    /**
-     * Checks if windows in a group are on monitor. If not move the group on monitor so at least one window in the group
-     * is fully on monitor.
-     * Currently this is used on spawn to handle monitor changes when Finsemble wasn't running or a different workspace was loaded.
-     * @param {*} name
-     */
-    async checkAndFixGroupPosition(name) {
-        const dockableWindow = this.getWindow(name);
-        const group = this.getMovableGroup(name);
-        if (dockableWindow && group) {
-            const currentBounds = {
-                top: dockableWindow.top,
-                bottom: dockableWindow.bottom,
-                left: dockableWindow.left,
-                right: dockableWindow.right,
-                width: dockableWindow.width,
-                height: dockableWindow.height,
-                name: dockableWindow.name,
-            };
-            const newBounds = adjustBoundsToBeOnMonitor(this.monitorsInstance, currentBounds);
-            if (!checkIfBoundsAreEqual(currentBounds, newBounds)) {
-                group.deferSystemMove({ name, bounds: newBounds }, this);
-            }
-        }
-    }
-    /**
-     * Vestigial function; used to pop a window out of a group. Can likely be removed in the future.
-     */
-    ejectWindow(name) {
-        const win = this.getWindow(name);
-        const newBounds = win;
-        newBounds.left = newBounds.left + 40;
-        newBounds.top = newBounds.top - 40;
-        newBounds.name = win.name;
-        this.moveWindow(newBounds);
-    }
-    /**
-     * @return {boolean}
-     */
-    getGroupMode() {
-        return this.groupMode;
-    }
-    /**
-     * @param  {object} groupMade
-     * @param  {boolean} groupMade.enabled Whether group mode is enabled.
-     * @param  {number} groupMode.headerHeight How large the header is in windows. This shouldn't be in this config. So bad.
-     * @param  {number} groupMode.groupTileBuffer How large the buffer is on the edge of a group to trigger a group-tile operation.
-     * @param  {boolean} groupMode.allowSnappedWindowsToResize Whether snapped windows will resize as a group.
-     * @param  {boolean} groupMode.fillHolesOnUndock Whether leaving a group triggers a hole-filling operation
-     * @param  {boolean} groupMode.undockDisbandsEntireGroup Whether clicking the undock button on one window will disband the entire group.
-     * @param  {boolean} groupMode.requireRectangularityForGroupResize Whether a group must be a rectangle to scale the individual windows as a unit.
-     */
-    setGroupMode(groupMode) {
-        const bool = groupMode.enabled;
-        if (!bool) {
-            this.getGroupNames().forEach((groupName) => {
-                this.removeGroup(groupName);
-            });
-        }
-        else if (bool) {
-            this.constituteGroups();
-            if (groupMode.groupTileBuffer)
-                this.groupTileBuffer = groupMode.groupTileBuffer;
-            if (groupMode.headerHeight)
-                this.headerHeight = groupMode.headerHeight;
-        }
-        if (typeof groupMode.allowSnappedWindowsToResize === "undefined")
-            groupMode.allowSnappedWindowsToResize = true;
-        if (typeof groupMode.fillHolesOnUndock === "undefined")
-            groupMode.fillHolesOnUndock = true;
-        if (typeof groupMode.undockDisbandsEntireGroup === "undefined")
-            groupMode.undockDisbandsEntireGroup = false;
-        if (typeof groupMode.requireRectangularityForGroupResize === "undefined")
-            groupMode.requireRectangularityForGroupResize = true;
-        this.groupMode = groupMode;
-    }
-    /**
-     * Adds useful properties to a raw request.
-     * @param  {moveRequest} req
-     * @return {moveRequest}
-     */
-    setMoveRequest(req, win) {
-        if (!win) {
-            win = this.getWindow(req.name);
-        }
-        /**
-         * If you call setBounds on a window that is maximized, subsequent move requests will come in as though the window's
-         * left edge never moved, until mouseUp happens. This boolean helps us get around this bug.
-         */
-        if (win.shouldOffsetByMouse) {
-            req.left = req.mousePosition.left - req.width / 2;
-            req.right = req.left + req.width;
-        }
-        req.windowBoundingBox = BoxMath.getWindowBoundingBox(req);
-        req.innerBuffer = this.getInnerBoundingBox(req);
-        req.snappingRegions = BoxMath.getSnappingRegions(req, this.bufferSize);
-        this.moveRequest = req;
-        return req;
-    }
-    /**
-     * @param  {dockableWindow} win
-     */
-    setStationaryWindow(win) {
-        globalStationaryWindow = win;
-    }
-    /**
-     * @param  {dockableWindow} win
-     */
-    setMovingWindow(win) {
-        this.movingWindow = win;
-    }
-    /**
-     * Convenience function I used for like 2 minutes.
-     * @param  {dockableWindow} stationary
-     * @param  {dockableWindow} moving
-     */
-    setWindows(stationary, moving) {
-        globalStationaryWindow = stationary;
-        this.movingWindow = moving;
-    }
-    /** **************************************************
-     *													*
-     *		Calculators - Multiple Positions/Sizes		*
-     *													*
-     *************************************************** */
-    /**
-     * when a non-docking movement is made, we don't grab the bounds changing events.
-     * So this updates everything. Example: auto-arrange.
-     */
-    updateWindowPositions() {
-        const dockingPoolIterator = DockingPoolSingleton.iterator();
-        for (const win of dockingPoolIterator) {
-            win.updateState();
-        }
-    }
-    /**
-     * Returns the movableGroup for a window.
-     */
-    getMovableGroup(windowName) {
-        const win = this.getWindow(windowName, false);
-        if (!win) {
-            Logger.system.debug(`INVESTIGATE: getMovableGroup failure. No win found for ${windowName}`);
-            return null;
-        }
-        for (let i = 0, len = win.groupNames.length; i < len; i++) {
-            const groupName = win.groupNames[i];
-            const group = this.getGroup(groupName);
-            if (group.isMovable) {
-                return group;
-            }
-        }
-        return null;
-    }
-    /**
-     * Returns the immobile group for a window. This is one where it is snapped to other windows, but not explicitly grouped by the user.
-     */
-    getImmobileGroup(windowName) {
-        const win = this.getWindow(windowName, false);
-        if (!win) {
-            Logger.system.debug(`INVESTIGATE: getImmobileGroup failure. No win found for ${windowName}`);
-            return null;
-        }
-        for (let i = 0, len = win.groupNames.length; i < len; i++) {
-            const groupName = win.groupNames[i];
-            const group = this.getGroup(groupName);
-            if (group.isMovable) {
-                continue;
-            }
-            return group;
-        }
-        return null;
-    }
-    /**
-     * Basically just code flow controller. Figures out whether the move will affect just a couple, a single window, or all windows in the group.
-     * @param  {moveRequest} moveRequest
-     * @param  {function} cb
-     */
-    handleGroup(moveRequest, cb) {
-        this.setMoveRequest(moveRequest);
-        if (!this.movingGroup)
-            return;
-        // Before beginning a group's move function set each individual window's 'finishedMove' property
-        // This is necessary because the logic which determines whether to set a window's internal bounds after a window aero movement will check to make sure the _user_ is not physically moving the window. As long as the mouse is not causing the movement, and instead the system, we mark all the windows as finished = true. This is just the opposite of that, the group is beginning a movement, so we set finishedMove = false.
-        for (const windowName in this.movingGroup.windows) {
-            const win = this.getWindow(windowName);
-            win.win._startMove();
-        }
-        if (this.movingGroup.isMovable && this.moveRequest && this.moveRequest.changeType === 0) {
-            // Before beginning a group's move function set each individual window's 'finished' property
-            // This is necessary because the logic which determines whether to set a window's internal bounds after a window aero movement will check to make sure the _user_ is not physically moving the window. As long as the mouse is not causing the movement, and instead the system, we mark all the windows as finished = true. This is just the opposite of that, the group is beginning a movement, so we set finished = false.
-            for (const windowName in this.movingGroup.windows) {
-                const win = this.getWindow(windowName);
-                win.finished = false;
-            }
-            this.handleGroupMove(this.moveRequest, cb); // Move a group
-        }
-        else {
-            if (this.resizeObject.scalingGroup) {
-                this.movingAGroupOfWindows = true;
-            }
-            else {
-                this.resizeInteriorWindow(this.moveRequest);
-            }
-            cb({ finished: true });
-        }
-    }
-    /**
-     * Kills any gaps that may have happened after scaling a group proportionately.
-     */
-    eliminateGaps() {
-        const adjustWindow = (win, windowName, bounds) => {
-            const snappedWin = this.getWindow(windowName);
-            const sharedEdges = win.getSharedEdges(snappedWin, this.bufferSize);
-            for (const edge in sharedEdges) {
-                const oppEdge = OPPOSITE_EDGE_MAP[edge];
-                if (!sharedEdges[edge] || win[edge] === snappedWin[oppEdge])
-                    continue;
-                bounds[edge] = snappedWin[oppEdge];
-                expandBoundsAgainstFixedEdge(bounds, edge);
-            }
-            bounds.name = win.name;
-            this.moveWindow(bounds);
-        };
-        const dockingPoolIterator = DockingPoolSingleton.iterator();
-        for (let win of dockingPoolIterator) {
-            const snappableWindows = this.getSnappableWindows(win);
-            let bounds = win.getBounds();
-            snappableWindows.forEach((windowName) => {
-                adjustWindow(win, windowName, bounds);
-            });
-        }
-    }
-    /**
-     * Helper function for snapWindow
-     */
-    getIntersection({ request, stationaryWindow, region, stationaryBoundingBoxes, movingBoundingBoxes, }) {
-        if (request.changeType === 0) {
-            request.movingRegion = this.getIntersections(request, stationaryWindow, region)[0];
-        }
-        if (!request.movingRegion)
-            return null;
-        let edgesToCheck = [];
-        // When we have diagonal resizes of windows we need to check if we have
-        // intersections against two edges instead of one eg. topLeft requires to check for
-        // both top AND left
-        switch (request.movingRegion) {
-            case "topLeft":
-            case "leftTop":
-                edgesToCheck.push("top", "left");
-                break;
-            case "topRight":
-            case "rightTop":
-                edgesToCheck.push("top", "right");
-                break;
-            case "bottomLeft":
-            case "leftBottom":
-                edgesToCheck.push("bottom", "left");
-                break;
-            case "bottomRight":
-            case "rightBottom":
-                edgesToCheck.push("bottom", "right");
-                break;
-            default:
-                edgesToCheck.push(request.movingRegion);
-                break;
-        }
-        const intersectionExists = edgesToCheck.some((edge) => BoxMath.intersectBoundingBoxes(stationaryBoundingBoxes[region], movingBoundingBoxes[edge]));
-        if (intersectionExists) {
-            return {
-                stationaryRegion: region,
-                movingRegion: request.movingRegion,
-            };
-        }
-        return null;
-    }
-    /**
-     * Helper function for snapWindow
-     */
-    processIntersection(request, stationaryWindow, intersection) {
-        this.intersection = intersection;
-        // changeType 0 is a move (so get new coordinates) otherwise it's a resize (so adjust its size)
-        const updatedRequest = request.changeType === 0
-            ? this.getNewCoordinates({
-                intersection,
-                stationaryWindow: stationaryWindow,
-                request,
-            })
-            : this.adjustSize({
-                intersection,
-                stationaryWindow: stationaryWindow,
-                request,
-            });
-        // if moving window isn't in a group, see if stationary window is. if so, add moving to the stationary group. if not, create a new group with them.
-        // GroupAction is just a placeholder. We only modify groups on mouseDown defers this
-        const sharedEdges = stationaryWindow.getSharedEdges(request);
-        const sharedEdgesArr = Object.keys(sharedEdges).map((edge) => {
-            return { edge: sharedEdges[edge] };
-        });
-        if (!sharedEdgesArr.some((obj) => obj.edge)) {
-            const sharedCorners = stationaryWindow.getSharedCorners(request);
-            const sharedCornersArr = Object.keys(sharedCorners).map((corner) => {
-                return { corner: sharedCorners[corner] };
-            });
-            // Successful modified request
-            if (!sharedCornersArr.some((obj) => obj.corner)) {
-                return {
-                    updatedRequest: request,
-                    match: true,
-                };
-            }
-        }
-        if (!groupBlacklist.includes(stationaryWindow.name)) {
-            this.groupAction = this.getDeferredGroupAction(globalStationaryWindow, this.movingWindow);
-        }
-        return {
-            updatedRequest,
-            match: false,
-        };
-    }
-    /** **************************************************
-     *													*
-     *	Calculators - Individual Window Position/Size	*
-     *													*
-     *************************************************** */
-    /**
-     * Returns a modified moveRequest. If the code gets here, it's because the moving window was inside of the stationary window's buffer, and a snap needed to occur.
-     * @param  {moveRequest} request
-     * @return {moveRequest}
-     */
-    snapWindow(request) {
-        // order matters here. corners should take precedence, as they'll also handle the vanilla bottom/top/left/right order. The algorithm stops with the first intersection.
-        const regions = [
-            "bottomLeft",
-            "bottomRight",
-            "topLeft",
-            "topRight",
-            "leftTop",
-            "leftBottom",
-            "rightTop",
-            "rightBottom",
-            "top",
-            "left",
-            "right",
-            "bottom",
-        ];
-        if (!globalStationaryWindow)
-            return;
-        const stationaryBoundingBoxes = globalStationaryWindow.snappingRegions;
-        const movingBoundingBoxes = request.snappingRegions;
-        const stationaryWindow = globalStationaryWindow;
-        let intersection = null;
-        for (let i = 0; i < regions.length; i++) {
-            const region = regions[i];
-            if (intersection && request.changeType !== 0)
-                break;
-            intersection = null;
-            // Two checks:
-            // 1) Is it inside of the stationary window? If so, exit.
-            // 2) Is it within one of the region bounding boxes.
-            if (BoxMath.intersectBoundingBoxes(stationaryBoundingBoxes[region], request.windowBoundingBox)) {
-                intersection = this.getIntersection({
-                    request,
-                    stationaryWindow: stationaryWindow,
-                    region,
-                    stationaryBoundingBoxes,
-                    movingBoundingBoxes,
-                });
-            }
-            if (intersection) {
-                const { updatedRequest, match } = this.processIntersection(request, stationaryWindow, intersection);
-                request = updatedRequest;
-                if (match)
-                    break;
-            }
-            else {
-                this.intersection = {
-                    stationaryRegion: null,
-                    movingRegion: null,
-                };
-            }
-        }
-        return request;
-    }
-    /**
-     * When moving a window, we don't want to add it to a group until all the calculations are complete. If two windows snap, this function is called. It figures out which group that the windows should form. Note: It always forms an immobile group (one that allows shared-border resizing). This is because a snap is not an explicit group.
-     */
-    getDeferredGroupAction(stationaryWin, movingWin) {
-        var _a;
-        const action = this.groupAction;
-        const stationaryGroup = this.getImmobileGroup(stationaryWin.name);
-        const movingWindowGroup = this.getImmobileGroup(movingWin.name);
-        if (stationaryGroup && !movingWindowGroup) {
-            action.name = stationaryGroup.name;
-            action.windows[movingWin.name] = true;
-        }
-        else if (movingWindowGroup && !stationaryGroup) {
-            action.name = movingWindowGroup.name;
-            action.windows[stationaryWin.name] = true;
-        }
-        else if (!movingWindowGroup && !stationaryGroup) {
-            action.name = uuidv4();
-            action.windows[stationaryWin.name] = true;
-            action.windows[movingWin.name] = true;
-        }
-        else {
-            action.name = (_a = stationaryGroup === null || stationaryGroup === void 0 ? void 0 : stationaryGroup.name) !== null && _a !== void 0 ? _a : "unknown";
-            action.windows[stationaryWin.name] = true;
-            action.windows[movingWin.name] = true;
-        }
-        return action;
-    }
-    /**
-     * Calculates resize bounds.
-     * @param  {object} params
-     * @return {moveRequest}
-     */
-    // eslint-disable-next-line sonarjs/cognitive-complexity
-    adjustSize(params) {
-        let { request } = params;
-        const { stationaryWindow: adjustingStationaryWindow } = params;
-        const { stationaryRegion } = params.intersection;
-        const intersections = this.getIntersections(request, adjustingStationaryWindow, stationaryRegion)
-            .toString()
-            .toLowerCase();
-        if (!intersections) {
-            return request;
-        }
-        switch (stationaryRegion) {
-            case "leftBottom":
-            case "bottomLeft":
-                if (intersections.includes("top") || intersections.includes("topleft") || intersections.includes("topright")) {
-                    request.top = adjustingStationaryWindow.bottom;
-                }
-                if (intersections.includes("topright") || intersections.includes("right")) {
-                    request.right = adjustingStationaryWindow.left;
-                }
-                if (intersections.includes("topleft") || intersections.includes("left")) {
-                    request.left = adjustingStationaryWindow.left;
-                }
-                if (intersections.includes("bottom")) {
-                    request.bottom = adjustingStationaryWindow.bottom;
-                }
-                break;
-            case "rightBottom":
-            case "bottomRight":
-                if (intersections.includes("top") || intersections.includes("topleft") || intersections.includes("topright")) {
-                    request.top = adjustingStationaryWindow.bottom;
-                }
-                if (intersections.includes("topleft") || intersections.includes("left")) {
-                    request.left = adjustingStationaryWindow.right;
-                }
-                if (intersections.includes("topright") || intersections.includes("right")) {
-                    request.right = adjustingStationaryWindow.right;
-                }
-                if (intersections.includes("bottom")) {
-                    request.bottom = adjustingStationaryWindow.bottom;
-                }
-                break;
-            case "topLeft":
-            case "leftTop":
-                if (intersections.includes("bottom") ||
-                    intersections.includes("bottomleft") ||
-                    intersections.includes("bottomright")) {
-                    request.bottom = adjustingStationaryWindow.top;
-                }
-                if (intersections.includes("bottomleft") || intersections.includes("left")) {
-                    request.bottom = adjustingStationaryWindow.top;
-                    request.left = adjustingStationaryWindow.left;
-                }
-                if (intersections.includes("bottomright") || intersections.includes("right")) {
-                    request.right = adjustingStationaryWindow.left;
-                }
-                if (intersections.includes("top")) {
-                    request.top = adjustingStationaryWindow.top;
-                }
-                break;
-            case "rightTop":
-            case "topRight":
-                if (intersections.includes("bottom") ||
-                    intersections.includes("bottomleft") ||
-                    intersections.includes("bottomright")) {
-                    request.bottom = adjustingStationaryWindow.top;
-                }
-                if (intersections.includes("bottomleft") || intersections.includes("left")) {
-                    request.left = adjustingStationaryWindow.right;
-                }
-                if (intersections.includes("bottomright") || intersections.includes("right")) {
-                    request.right = adjustingStationaryWindow.right;
-                }
-                if (intersections.includes("top")) {
-                    request.top = adjustingStationaryWindow.top;
-                }
-                break;
-            case "top":
-                if (intersections.includes("bottom")) {
-                    request.bottom = adjustingStationaryWindow.top;
-                }
-                break;
-            case "right":
-                if (intersections.includes("left")) {
-                    request.left = adjustingStationaryWindow.right;
-                }
-                break;
-            case "bottom":
-                if (intersections.includes("top")) {
-                    request.top = adjustingStationaryWindow.bottom;
-                }
-                break;
-            case "left":
-                if (intersections.includes("right")) {
-                    request.right = adjustingStationaryWindow.left;
-                }
-                break;
-            default:
-        }
-        request.width = request.right - request.left;
-        request.height = request.bottom - request.top;
-        request = this.checkShortCircuits(request);
-        return request;
-    }
-    /**
-     * Checks to see if a window has gotten too narrow, or too short.
-     */
-    checkShortCircuitsWithEdge(request, edge) {
-        let win = this.getWindow(request.name);
-        // The code for resizing groups goes through here. It just passes bounds, not a window. Here, use the global minimums and no maximums (until a global max is allowed...).
-        if (!win || !win.limits) {
-            return {
-                limits: {
-                    minHeight: MINIMUM_HEIGHT,
-                    minWidth: MINIMUM_WIDTH,
-                    maxHeight: Infinity,
-                    maxWidth: Infinity,
-                },
-            };
-        }
-        // Checks to see if the height/widths are below the window's minimum height/width. If so, it sets them to the minimum values.
-        switch (edge) {
-            case "top":
-                if (request.height <= win.limits.minHeight) {
-                    request.height = win.limits.minHeight;
-                    request.bottom = request.top + win.limits.minHeight;
-                }
-                else if (request.height >= win.limits.maxHeight) {
-                    request.height = win.limits.maxHeight;
-                    request.bottom = request.top + win.limits.maxHeight;
-                }
-                break;
-            case "bottom":
-                if (request.height <= win.limits.minHeight) {
-                    request.height = win.limits.minHeight;
-                    request.top = request.bottom - win.limits.minHeight;
-                }
-                else if (request.height >= win.limits.maxHeight) {
-                    request.height = win.limits.maxHeight;
-                    request.top = request.bottom - win.limits.maxHeight;
-                }
-                break;
-            case "left":
-                if (request.width < win.limits.minWidth) {
-                    request.width = win.limits.minWidth;
-                    request.right = request.left + win.limits.minWidth;
-                }
-                else if (request.width > win.limits.maxWidth) {
-                    request.width = win.limits.maxWidth;
-                    request.right = request.left + win.limits.maxWidth;
-                }
-                break;
-            case "right":
-                if (request.width < win.limits.minWidth) {
-                    request.width = win.limits.minWidth;
-                    request.left = request.right - win.limits.minWidth;
-                }
-                else if (request.width > win.limits.maxWidth) {
-                    request.width = win.limits.maxWidth;
-                    request.left = request.right - win.limits.maxWidth;
-                }
-                break;
-            default:
-        }
-        return request;
-    }
-    /**
-     * Checks to see if a request is allowed. Are you trying to make my window -20px? or 10px? Get out of here.
-     */
-    checkShortCircuits(request, win) {
-        var _a, _b;
-        let currentBounds;
-        const defaultLimits = {
-            minHeight: MINIMUM_HEIGHT,
-            minWidth: MINIMUM_WIDTH,
-            maxHeight: Infinity,
-            maxWidth: Infinity,
-        };
-        if (typeof win === "undefined") {
-            win = this.getWindow(request.name);
-        }
-        // Note: from Daniel, PR Review on 12/4. Address this at some point.
-        // Looking at the code isolated from it's calling context, it's not obvious to me that this won't throw a null reference error. You're checking to see if request.name is truthy, which to me implies it's optional, but you're accessing it before this check, which looks really dangerous.We should switch the order, and only access request.name when we've confirmed it's really there.
-        if (request.name) {
-            currentBounds = win.getBounds();
-        }
-        else {
-            currentBounds = request;
-            // The code for resizing groups goes through here. It just passes bounds, not a window. Here, use the global minimums and no maximums (until a global max is allowed...).
-            win = {};
-        }
-        if (((_b = (_a = win === null || win === void 0 ? void 0 : win.win) === null || _a === void 0 ? void 0 : _a.windowOptions) === null || _b === void 0 ? void 0 : _b.resizable) === false && (win.limits == null || win.limits.maxHeight == null)) {
-            // non-resizable windows are showing up with undefined limits when Finsemble starts
-            // limits are correctly populated on workspace reloads
-            // in here we just enforce non resizable windows to have the correct dimensions
-            win.limits = {
-                minHeight: win.win.windowOptions.height,
-                minWidth: win.win.windowOptions.width,
-                maxHeight: win.win.windowOptions.height,
-                maxWidth: win.win.windowOptions.width,
-            };
-        }
-        else {
-            win.limits = Object.assign(defaultLimits, win.limits || {});
-        }
-        // CASE: WINDOW IS TOO NARROW
-        // handles shortCircuits for the moving window.
-        if (request.width <= win.limits.minWidth) {
-            request.width = win.limits.minWidth;
-            // If we're dragging the left edge around, anchor the right edge.
-            if (request.left !== currentBounds.left) {
-                request.right = currentBounds.right;
-                request.left = request.right - request.width;
-            }
-            else if (request.right !== currentBounds.right) {
-                // If we're dragging the right edge around, anchor the left edge.
-                request.left = currentBounds.left;
-                request.right = request.left + request.width;
-            }
-        }
-        else if (request.width >= win.limits.maxWidth) {
-            // CASE: WINDOW IS TOO WIDE
-            request.width = win.limits.maxWidth;
-            // If we're dragging the left edge around, anchor the right edge.
-            if (request.left !== currentBounds.left) {
-                request.right = currentBounds.right;
-                request.left = request.right - request.width;
-            }
-            else if (request.right !== currentBounds.right) {
-                // If we're dragging the right edge around, anchor the left edge.
-                request.left = currentBounds.left;
-                request.right = request.left + request.width;
-            }
-        }
-        // CASE: WINDOW IS TOO SHORT
-        if (request.height <= win.limits.minHeight) {
-            request.height = win.limits.minHeight;
-            // If we're dragging the top edge around, anchor on the bottom.
-            if (request.top !== currentBounds.top) {
-                request.bottom = currentBounds.bottom;
-                request.top = request.bottom - request.height;
-            }
-            else if (request.bottom !== currentBounds.bottom) {
-                // If we're dragging the bottom edge around, anchor on the top.
-                request.top = currentBounds.top;
-                request.bottom = request.top + request.height;
-            }
-        }
-        else if (request.height >= win.limits.maxHeight) {
-            // CASE: WINDOW IS TOO TALL
-            request.height = win.limits.maxHeight;
-            // If we're dragging the top edge around, anchor on the bottom.
-            if (request.top !== currentBounds.top) {
-                request.bottom = currentBounds.bottom;
-                request.top = request.bottom - request.height;
-            }
-            else if (request.bottom !== currentBounds.bottom) {
-                // If we're dragging the bottom edge around, anchor on the top.
-                request.top = currentBounds.top;
-                request.bottom = request.top + request.height;
-            }
-        }
-        return request;
-    }
-    /**
-     * Use when a window is moving and needs to be snapped. Width/Height aren't modified like in `this.adjustSize`.
-     * @param  {type} params
-     * @return {type}
-     */
-    // eslint-disable-next-line sonarjs/cognitive-complexity
-    getNewCoordinates(params) {
-        const { request } = params;
-        const { stationaryWindow } = params;
-        const { movingRegion } = params.intersection;
-        const { stationaryRegion } = params.intersection;
-        switch (stationaryRegion) {
-            case "bottomLeft":
-                if (movingRegion.toLowerCase().includes("top")) {
-                    request.top = stationaryWindow.bottom;
-                }
-                if (movingRegion.toLowerCase().includes("right")) {
-                    request.left = stationaryWindow.left - request.width;
-                }
-                if (movingRegion.toLowerCase().includes("left")) {
-                    request.left = stationaryWindow.left;
-                }
-                if (movingRegion.toLowerCase().includes("bottom")) {
-                    request.top = stationaryWindow.bottom - request.height;
-                }
-                break;
-            case "bottomRight":
-                if (movingRegion.toLowerCase().includes("top")) {
-                    request.top = stationaryWindow.bottom;
-                }
-                if (movingRegion.toLowerCase().includes("left")) {
-                    request.left = stationaryWindow.right;
-                }
-                if (movingRegion.toLowerCase().includes("right")) {
-                    request.left = stationaryWindow.right - request.width;
-                }
-                if (movingRegion.toLowerCase().includes("bottom")) {
-                    request.top = stationaryWindow.bottom - request.height;
-                }
-                break;
-            case "topLeft":
-                if (movingRegion.toLowerCase().includes("bottom")) {
-                    request.top = stationaryWindow.top - request.height;
-                }
-                if (movingRegion.toLowerCase().includes("left")) {
-                    request.left = stationaryWindow.left;
-                }
-                if (movingRegion.toLowerCase().includes("right")) {
-                    request.left = stationaryWindow.left - request.width;
-                }
-                if (movingRegion.toLowerCase().includes("top")) {
-                    request.top = stationaryWindow.top;
-                }
-                break;
-            case "topRight":
-                if (movingRegion.toLowerCase().includes("bottom")) {
-                    request.top = stationaryWindow.top - request.height;
-                }
-                if (movingRegion.toLowerCase().includes("left")) {
-                    request.left = stationaryWindow.right;
-                }
-                if (movingRegion.toLowerCase().includes("right")) {
-                    request.left = stationaryWindow.right - request.width;
-                }
-                if (movingRegion.toLowerCase().includes("top")) {
-                    request.top = stationaryWindow.top;
-                }
-                break;
-            case "leftTop":
-                if (movingRegion.toLowerCase().includes("right")) {
-                    request.left = stationaryWindow.left - request.width;
-                }
-                if (movingRegion.toLowerCase().includes("top")) {
-                    request.top = stationaryWindow.top;
-                }
-                if (movingRegion.toLowerCase().includes("bottom")) {
-                    request.top = stationaryWindow.top - request.height;
-                }
-                break;
-            case "leftBottom":
-                if (movingRegion.toLowerCase().includes("right")) {
-                    request.left = stationaryWindow.left - request.width;
-                }
-                if (movingRegion.toLowerCase().includes("bottom")) {
-                    request.top = stationaryWindow.bottom - request.height;
-                }
-                if (movingRegion.toLowerCase().includes("top")) {
-                    request.top = stationaryWindow.bottom;
-                }
-                break;
-            case "rightTop":
-                if (movingRegion.toLowerCase().includes("left")) {
-                    request.left = stationaryWindow.right;
-                }
-                if (movingRegion.toLowerCase().includes("top")) {
-                    request.top = stationaryWindow.top;
-                }
-                if (movingRegion.toLowerCase().includes("bottom")) {
-                    request.top = stationaryWindow.top - request.height;
-                }
-                break;
-            case "rightBottom":
-                if (movingRegion.toLowerCase().includes("left")) {
-                    request.left = stationaryWindow.right;
-                }
-                if (movingRegion.toLowerCase().includes("bottom")) {
-                    request.top = stationaryWindow.bottom - request.height;
-                }
-                if (movingRegion.toLowerCase().includes("top")) {
-                    request.top = stationaryWindow.bottom;
-                }
-                break;
-            case "top":
-                if (movingRegion.toLowerCase().includes("bottom")) {
-                    request.top = stationaryWindow.top - request.height;
-                }
-                break;
-            case "right":
-                if (movingRegion.toLowerCase().includes("left")) {
-                    request.left = stationaryWindow.right;
-                }
-                break;
-            case "bottom":
-                if (movingRegion.toLowerCase().includes("top")) {
-                    request.top = stationaryWindow.bottom;
-                }
-                break;
-            case "left":
-                if (movingRegion.toLowerCase().includes("right")) {
-                    request.left = stationaryWindow.left - request.width;
-                }
-                break;
-            default:
-        }
-        request.right = request.left + request.width;
-        request.bottom = request.top + request.height;
-        return request;
-    }
-    /**
-     * Helper to return an object that says which edges are moving.
-     * @function this.getMovingEdgesFromResizeHandle
-     * @param  {type} handle
-     * @return {type}
-     */
-    getMovingEdgesFromResizeHandle(handle) {
-        const edges = {
-            top: false,
-            right: false,
-            left: false,
-            bottom: false,
-        };
-        if (!handle) {
-            return edges;
-        }
-        handle = handle.toLowerCase();
-        for (const edge in edges) {
-            if (handle.includes(edge)) {
-                edges[edge] = true;
-            }
-        }
-        return edges;
-    }
-    /**
-     * Bounds are calculated in maskBoundsCalculator.js
-     */
-    moveGroupMask() {
-        var _a;
-        if (this.moveRequest) {
-            const newBounds = mousePosToBounds(this.moveRequest.mousePosition);
-            console.log(newBounds, this.moveRequest);
-            (_a = this.groupMask) === null || _a === void 0 ? void 0 : _a.setBounds(newBounds);
-        }
-    }
-    /**
-     * NOT CURRENTLY USED.
-     * Will be like `onMouseMove`, but for groups. Goal is to only move all grouped windows `onMouseUp`. In the interim, just move the mask around. Right now I move every window on every resizeEvent
-     */
-    _moveGroupMaskOld() {
-        if (!this.groupMask)
-            return;
-        const moveRequest = fastClone(this.moveRequest);
-        const bounds = this.groupMask.getBounds();
-        if (moveRequest.changeType !== 0) {
-            const resizeHandle = this.resizeObject.correctedHandle;
-            if (resizeHandle) {
-                const splitHandle = resizeHandle.split(/(?=[A-Z])/).map((s) => s.toLowerCase());
-                splitHandle.forEach((handle) => {
-                    if (handle === "top" || handle === "bottom") {
-                        bounds[handle] = moveRequest.mousePosition.y || moveRequest.mousePosition.top;
-                    }
-                    if (handle === "right" || handle === "left") {
-                        bounds[handle] = moveRequest.mousePosition.x || moveRequest.mousePosition.left;
-                    }
-                });
-            }
-        }
-        bounds.width = bounds.right - bounds.left;
-        bounds.height = bounds.bottom - bounds.top;
-        bounds.name = "groupMask";
-        this.groupMask.setBounds(bounds);
-    }
-    /**
-     * This returns an object with all of the bounds of all of the windows in a given group. This should be moved in to the dockableGroup.
-     */
-    getBoundsOfGroupWindows(group) {
-        const groupIter = this.groupWindowIterator(group);
-        const bounds = {};
-        for (const win of groupIter) {
-            bounds[win.name] = win.getBounds();
-            // bounds[win.name].name = win.name;
-        }
-        return bounds;
-    }
-    /**
-     * For a group, it will iterate through its windows and set bounds on each of them.
-     */
-    setBoundsOfGroupWindows(group, windowBounds, stopMove = false) {
-        const groupIter = this.groupWindowIterator(group);
-        for (const win of groupIter) {
-            windowBounds[win.name].name = win.name;
-            this.moveWindow(windowBounds[win.name]);
-            if (stopMove) {
-                win.win.stopMove();
-                win.win._saveWindowOptions({});
-            }
-        }
-    }
-    /**
-     * Exports an array of bounds for the windows that are currently being managed by docking. This makes it easy to generate oddball test cases.
-     */
-    export() {
-        const windowList = this.getWindowNames().map((name, i) => {
-            const win = this.getWindow(name);
-            const bounds = win.getBounds();
-            bounds.name = `window${i}`;
-            return bounds;
-        });
-        if (windowList) {
-            return JSON.stringify(windowList);
-        }
-        return "";
-    }
-    /**
-     * Cleans up shared edges of windows in a group
-     * @param {*} group The group to operate on
-     * @param {*} windowBounds An object containing bounds key'ed by window name
-     * @param {*} triggeredByAutoArrange Wether or not this cleanup was trigger by auto arrange (if true will fire stopMove())
-     */
-    cleanupSharedEdges(group, windowBounds, triggeredByAutoArrange = false) {
-        const groupIter = this.groupWindowIterator(group);
-        for (const win of groupIter) {
-            const edges = {
-                right: 0,
-                left: 0,
-                top: 0,
-                bottom: 0,
-            };
-            // How many things is this window snapped to on each edge??
-            win.snappedWindows.forEach((sWin) => {
-                for (const i in sWin.edges) {
-                    if (sWin.edges[i])
-                        edges[i]++;
-                }
-            });
-            const maybeAdjustWindow = (sWin, edge) => {
-                const snappedWin = windowBounds[sWin.name];
-                // if a window is snapped to a window (but not grouped with it), that window won't be in the movable group's window bounds. So make sure it exists first.
-                if (!snappedWin || win[edge] === snappedWin[OPPOSITE_EDGE_MAP[edge]])
-                    return;
-                windowBounds[win.name][edge] = snappedWin[OPPOSITE_EDGE_MAP[edge]];
-                if (["right", "left"].includes(edge)) {
-                    windowBounds[win.name].width = windowBounds[win.name].right - windowBounds[win.name].left;
-                }
-                else {
-                    windowBounds[win.name].height = windowBounds[win.name].bottom - windowBounds[win.name].top;
-                }
-            };
-            // If we are only snapped to one thing and are disconnected, reconnect:
-            win.snappedWindows.forEach((sWin) => {
-                for (const edge in sWin.edges) {
-                    if (sWin.edges[edge] && edges[edge] === 1) {
-                        maybeAdjustWindow(sWin, edge);
-                    }
-                }
-            });
-        }
-        this.setBoundsOfGroupWindows(group, windowBounds, triggeredByAutoArrange);
-        return windowBounds;
-    }
-    /**
-     * Run after everything, it removes any gaps that might have occurred (e.g., from fractional pixels, rounding, etc). It needs better inline documentation.
-     */
-    cleanupGaps(group, windowBounds) {
-        const groupIter = this.groupWindowIterator(group);
-        const xs = [];
-        const ys = [];
-        for (const win of groupIter) {
-            const bounds = windowBounds[win.name];
-            if (!xs.some((x) => {
-                if (Math.abs(bounds.left - x) < 5) {
-                    bounds.left = x;
-                    return true;
-                }
-                return false;
-            })) {
-                xs.push(bounds.left);
-            }
-            if (!xs.some((x) => {
-                if (Math.abs(bounds.right - x) < 5) {
-                    bounds.right = x;
-                    return true;
-                }
-                return false;
-            })) {
-                xs.push(bounds.right);
-            }
-            bounds.width = bounds.right - bounds.left;
-            if (!ys.some((y) => {
-                if (Math.abs(bounds.top - y) < 5) {
-                    bounds.top = y;
-                    return true;
-                }
-                return false;
-            })) {
-                ys.push(bounds.top);
-            }
-            if (!ys.some((y) => {
-                if (Math.abs(bounds.bottom - y) < 5) {
-                    bounds.bottom = y;
-                    return true;
-                }
-                return false;
-            })) {
-                ys.push(bounds.bottom);
-            }
-            bounds.height = bounds.bottom - bounds.top;
-        }
-        return windowBounds;
-    }
-    shouldShortCircuit(request) {
-        const shouldShortCircuit = {
-            width: false,
-            height: false,
-        };
-        const win = this.getWindow(request.name);
-        if (win) {
-            if (request.width <= win.limits.minWidth || request.width >= win.limits.maxWidth) {
-                shouldShortCircuit.width = true;
-            }
-            if (request.height <= win.limits.minHeight || request.height >= win.limits.maxHeight) {
-                shouldShortCircuit.height = true;
-            }
-        }
-        return shouldShortCircuit;
-    }
-    recurse({ snapObjectNames, movingWindowSnappedWindows, snappedWindows, handle, originalHandle, }) {
-        const oppEdge = OPPOSITE_EDGE_MAP[handle];
-        for (let i = 0, len = snappedWindows.length; i < len; i++) {
-            const snapObj = snappedWindows[i];
-            const snappedWindow = this.getWindow(snapObj.name);
-            if (!snapObjectNames.includes(snapObj.name + oppEdge)) {
-                snapObjectNames.push(snapObj.name + oppEdge);
-                movingWindowSnappedWindows.push({
-                    name: snapObj.name,
-                    edge: oppEdge,
-                    handle: originalHandle,
-                    win: snappedWindow,
-                });
-                this.recurse({
-                    snapObjectNames,
-                    movingWindowSnappedWindows,
-                    snappedWindows: this.getWindowsOnEdge(snappedWindow, oppEdge),
-                    handle: oppEdge,
-                    originalHandle,
-                });
-            }
-        }
-    }
-    recurseCorner({ snapObjectNames, movingWindowSnappedWindows, cornerWindows, originalHandle, }) {
-        for (let i = 0, len = cornerWindows.length; i < len; i++) {
-            const snapObj = cornerWindows[i];
-            const snappedWindow = this.getWindow(snapObj.name);
-            if (snapObj.corner && !snapObjectNames.includes(snapObj.name + snapObj.corner)) {
-                const dragHandleArray = snapObj.corner.split(/(?=[A-Z])/).map((s) => s.toLowerCase());
-                dragHandleArray.forEach((dragHandle) => {
-                    // if handle == bottomLeft and the originalHandle is bottom, we don't want to do anything with the Left edge. The algorithm will run through this function twice.
-                    const doStuff = dragHandle === originalHandle || dragHandle === OPPOSITE_EDGE_MAP[originalHandle];
-                    if (doStuff && !snapObjectNames.includes(snapObj.name + dragHandle)) {
-                        movingWindowSnappedWindows.push({
-                            name: snapObj.name,
-                            edge: dragHandle,
-                            handle: originalHandle,
-                            win: snappedWindow,
-                        });
-                        this.recurse({
-                            snapObjectNames,
-                            movingWindowSnappedWindows,
-                            snappedWindows: this.getWindowsOnEdge(snappedWindow, dragHandle),
-                            handle: dragHandle,
-                            originalHandle,
-                        });
-                        snapObjectNames.push(snapObj.name + dragHandle);
-                    }
-                });
-            }
-        }
-    }
-    maybeSnapToOtherWindows(moveRequest, snappableWindows, resizeHandle) {
-        if (!this.movingWindow)
-            return moveRequest;
-        const splitHandle = resizeHandle.split(/(?=[A-Z])/).map((s) => s.toLowerCase());
-        const snappedWindowNames = this.movingWindow.snappedWindows.flatMap((snapObj) => {
-            for (let handle in splitHandle) {
-                if (snapObj.edges[handle] || snapObj.corners[resizeHandle])
-                    return [snapObj.name];
-            }
-            return [];
-        });
-        // will snap the window to other windows before going and modifying the rest of it
-        let modifiedRequest = fastClone(moveRequest);
-        // will snap the window to other windows before going and modifying the rest of it
-        for (let i = 0; i < snappableWindows.length; i++) {
-            const snappableWindow = snappableWindows[i];
-            if (snappedWindowNames.includes(snappableWindow) ||
-                snappableWindow === this.movingWindow.name ||
-                groupBlacklist.includes(snappableWindow)) {
-                continue;
-            }
-            const win = this.getWindow(snappableWindow);
-            this.setStationaryWindow(win);
-            modifiedRequest = this.snapWindow(Object.assign(Object.assign({}, modifiedRequest), { movingRegion: resizeHandle }));
-            // Check if the side being dragged has been changed, if it's different return the modifiedRequest
-            let shouldContinue = splitHandle.some((handle) => modifiedRequest[handle] === moveRequest[handle]);
-            if (shouldContinue)
-                continue;
-            return modifiedRequest;
-        }
-        return moveRequest;
-    }
-    moveInteriorWindows(moveRequest, movingWindowSnappedWindows) {
-        let movements = {
-            [moveRequest.name]: moveRequest,
-        };
-        let shortCircuits = this.shouldShortCircuit(moveRequest);
-        movingWindowSnappedWindows.forEach((snapObj) => {
-            var _a;
-            const snappedWindow = this.getWindow(snapObj.name);
-            let newBounds = movements[snapObj.name] ? movements[snapObj.name] : snappedWindow.getBounds();
-            newBounds.name = snapObj.name;
-            newBounds[snapObj.edge] = moveRequest[(_a = snapObj.handle) !== null && _a !== void 0 ? _a : "undefined"];
-            // we force non re-sizable windows to keep their original dimensions
-            if (snappedWindow.win.windowOptions.resizable === false) {
-                newBounds.width = snappedWindow.win.windowOptions.width;
-                newBounds.height = snappedWindow.win.windowOptions.height;
-            }
-            else {
-                newBounds.width = newBounds.right - newBounds.left;
-                newBounds.height = newBounds.bottom - newBounds.top;
-            }
-            if (newBounds.width <= snappedWindow.limits.minWidth || newBounds.width >= snappedWindow.limits.maxWidth) {
-                shortCircuits.width = true;
-            }
-            if (newBounds.height <= snappedWindow.limits.minHeight || newBounds.width >= snappedWindow.limits.maxHeight) {
-                shortCircuits.height = true;
-            }
-            newBounds = this.checkShortCircuits(newBounds, snappedWindow);
-            movements[newBounds.name] = newBounds;
-        });
-        Object.entries(movements).forEach(([windowName, movement]) => {
-            if (groupBlacklist.includes(windowName))
-                return;
-            const win = this.getWindow(windowName);
-            if (shortCircuits.width) {
-                movement.width = win.width;
-                movement.left = win.left;
-                movement.right = win.right;
-            }
-            if (shortCircuits.height) {
-                movement.height = win.height;
-                movement.top = win.top;
-                movement.bottom = win.bottom;
-            }
-            this.moveWindow(movement);
-        });
-    }
-    /**
-     * Resizes a window or group of windows on the interior of a group
-     * @param {moveRequest} moveRequest
-     */
-    resizeInteriorWindow(moveRequest) {
-        var _a;
-        // Hole filling algorithm for tiling calls this method.
-        // It passes in the resize handle. It'll never be a corner. No need for the resizeObject here.
-        const resizeHandle = (_a = (moveRequest.forceResizeHandle ? moveRequest.resizeHandle : undefined)) !== null && _a !== void 0 ? _a : this.resizeObject.correctedHandle;
-        if (!this.movingWindow || !resizeHandle)
-            return;
-        const snappableWindows = this.getSnappableWindows(moveRequest);
-        moveRequest = this.maybeSnapToOtherWindows(moveRequest, snappableWindows, resizeHandle);
-        const movingWindowSnappedWindows = [];
-        const snapObjectNames = [];
-        const movingCorner = CORNERS.includes(resizeHandle);
-        if (movingCorner) {
-            const cornerPoint = this.movingWindow.getPointByVertex(resizeHandle);
-            const cornerWindows = this.getWindowsAtPoint(cornerPoint).map((val) => {
-                return {
-                    name: val,
-                    corner: this.getWindow(val).getVertexByPoint(cornerPoint),
-                    edge: this.getWindow(val).getEdgeByPoint(cornerPoint),
-                };
-            });
-            const splitHandle = resizeHandle.split(/(?=[A-Z])/).map((s) => s.toLowerCase());
-            splitHandle.forEach((handle) => {
-                this.recurseCorner({ snapObjectNames, movingWindowSnappedWindows, cornerWindows, originalHandle: handle });
-            });
-        }
-        else {
-            const clonedSnaps = this.getWindowsOnEdge(this.movingWindow, resizeHandle);
-            this.recurse({
-                snapObjectNames,
-                movingWindowSnappedWindows,
-                snappedWindows: clonedSnaps,
-                handle: resizeHandle,
-                originalHandle: resizeHandle,
-            });
-        }
-        this.moveInteriorWindows(moveRequest, movingWindowSnappedWindows);
-    }
-    /**
-     * function for debugging a 3x3 grid.
-     */
-    logger() {
-        const boundingBoxes = {};
-        const dockingPoolIterator = DockingPoolSingleton.iterator();
-        for (const win of dockingPoolIterator) {
-            boundingBoxes[window.name] = JSON.stringify(win.windowBoundingBox);
-        }
-        let box = "";
-        box = `${box}+----------------------------------------+\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}|   ${boundingBoxes.A}          |    ${boundingBoxes.B}         |   ${boundingBoxes.C}         |\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}+----------------------------------------+\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}|   ${boundingBoxes.D}          |    ${boundingBoxes.E}         |   ${boundingBoxes.F}         |\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}+----------------------------------------+\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}|   ${boundingBoxes.G}          |    ${boundingBoxes.H}         |   ${boundingBoxes.I}         |\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}|             |             |            |\n`;
-        box = `${box}+----------------------------------------+\n`;
-        Logger.system.verbose(box);
-    }
-    /**
-     * Helper to determine whether a moveRequest will affect a window, the group, or just a local collection of windows that are snapped to the movingWindow.
-     */
-    shouldScaleGroup(moveRequest) {
-        var _a;
-        if (!moveRequest.name) {
-            Logger.warn("DockingCalculator.shouldScaleGroup() no name provided in moveRequest", moveRequest);
-            return false;
-        }
-        if (this.groupMode.requireRectangularityForGroupResize) {
-            return (_a = this.shouldMoveAffectGroup(moveRequest)) !== null && _a !== void 0 ? _a : false;
-        }
-        if (!this.groupMode.enabled) {
-            return false;
-        }
-        const win = this.getWindow(moveRequest.name);
-        if (!win || !win.groupNames.length) {
-            return false;
-        }
-        const group = this.getMovingGroup(moveRequest);
-        if (!group) {
-            return false;
-        }
-        const req = new DockableBox(moveRequest);
-        // if the handle that's being dragged is on an exterior edge of a group resizing all.
-        // This used to be derived from the window because it was only calculated on mouseDown. Now that it can be calculated at any time, we need to derive the handle from the request that's coming in. On group resizes, window bounds are only modified on mouse up.
-        const resizeHandle = req.getResizeHandle(moveRequest);
-        if (moveRequest.changeType !== 0 && CORNERS.includes(resizeHandle)) {
-            const cornerPoint = win.getPointByVertex(resizeHandle);
-            const cornersThatCauseScaling = group.getCornersThatCauseScaling();
-            return cornersThatCauseScaling.some((corner) => corner.x === cornerPoint.x && corner.y === cornerPoint.y);
-        }
-        return false;
-    }
-    /**
-     * Helper to determine whether a moveRequest will affect a window, the group, or just a local collection of windows that are snapped to the movingWindow.
-     */
-    shouldMoveAffectGroup(moveRequest) {
-        if (!this.groupMode.enabled) {
-            return false;
-        }
-        if (!moveRequest.name) {
-            return false;
-        }
-        const win = this.getWindow(moveRequest.name);
-        if (!win || !win.groupNames.length) {
-            return false;
-        }
-        const group = this.getMovingGroup(moveRequest);
-        if (!group) {
-            return false;
-        }
-        // A decision here was made that if we have at least one non-resizable window in the group then
-        // We can't resize the whole group as this would also resize the non-resizable window.
-        // This is specially problematic if we ungroup as the non resizable window won't be able to get its original size.
-        const { windows: groupWindows } = group;
-        if (Object.keys(groupWindows).some((key) => groupWindows[key].win.windowOptions.resizable === false)) {
-            return false;
-        }
-        if (!group.isARectangle()) {
-            return false;
-        }
-        // if the handle that's being dragged is on an exterior edge of a group resizing all.
-        const resizeHandle = this.resizeObject.correctedHandle || win.getResizeHandle(moveRequest);
-        const edges = ["top", "left", "right", "bottom"];
-        if (moveRequest.changeType !== 0 && CORNERS.includes(resizeHandle)) {
-            const cornerPoint = win.getPointByVertex(resizeHandle);
-            return group.pointIsOnBoundingBox(cornerPoint);
-        }
-        if (moveRequest.changeType !== 0) {
-            return win[resizeHandle] === group[resizeHandle];
-        }
-        // never used, but could be used if you wanted to only allow exterior windows the ability to move the group.
-        for (let i = 0, len = edges.length; i < len; i++) {
-            const edge = edges[i];
-            if (win[edge] === group[edge]) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Should use this. Computes the difference between two boundsObjects.
-     * @param {moveRequest} newBounds
-     * @param {moveRequest} old
-     */
-    getBoundsDelta(newBounds, old) {
-        const boundsDelta = { right: 0, left: 0 };
-        const widthDelta = newBounds.width - old.width;
-        const heightDelta = newBounds.height - old.height;
-        boundsDelta.width = widthDelta;
-        boundsDelta.height = heightDelta;
-        boundsDelta.top = Math.abs(newBounds.top - old.top);
-        boundsDelta.left = Math.abs(newBounds.left - old.left);
-        if (newBounds.top < old.top) {
-            boundsDelta.top = -boundsDelta.top;
-        }
-        if (newBounds.left < old.left) {
-            boundsDelta.left = -boundsDelta.left;
-        }
-        return boundsDelta;
-    }
-    /**
-     * Will move a group of windows.
-     * @param  {moveRequest} moveRequest
-     * @param  {function} cb
-     */
-    handleGroupMove(moveRequest, cb) {
-        const invokeCallback = function () {
-            cb({ finished: true });
-        };
-        const self = this;
-        const group = this.getMovableGroup(moveRequest.name);
-        if (typeof moveRequest.anchor === "undefined") {
-            const movingDirection = this.getMovingDirection(moveRequest, this.movingWindow);
-            // If there is no moving direction (the window and the bounds are the same)
-            // then there is nothing to do
-            if (!movingDirection) {
-                return invokeCallback();
-            }
-            moveRequest.anchor = group === null || group === void 0 ? void 0 : group.getMoveAnchor(movingDirection);
-        }
-        const updateGroupWindowsByDelta = function (delta, moveWindows, updateCB) {
-            if (!group)
-                return;
-            const groupIter = self.groupWindowIterator(group, moveRequest.anchor);
-            // don't need to add anything if the delta is 0.
-            const modifyBounds = delta.x || delta.y;
-            for (const win of groupIter) {
-                const bounds = win.getBounds();
-                if (modifyBounds) {
-                    const newLeft = win.left + delta.x;
-                    const newTop = win.top + delta.y;
-                    bounds.left = newLeft;
-                    bounds.top = newTop;
-                    bounds.bottom = newTop + bounds.height;
-                    bounds.right = newLeft + bounds.width;
-                    bounds.name = win.name;
-                }
-                // don't want wrappers saving here..
-                bounds.persistBounds = false;
-                if (moveWindows) {
-                    // I'm breaking my own rule by calling setBounds directly. Sadly, isJiggling was being triggered (I think...didn't really investigate), and the window wasn't moving with small adjustments. Set bounds fixes that.
-                    win.setBounds(bounds);
-                }
-                else {
-                    win.setInternalBounds(bounds);
-                }
-            }
-            group === null || group === void 0 ? void 0 : group.updateBounds();
-            if (updateCB) {
-                updateCB();
-            }
-        };
-        const delta = self.getMoveDelta(moveRequest);
-        // processSnaps was added for moving groups out of claimed space. When you snapped a window to a movable group, the movable group would snap to the top of the other window rather than being dumped below the claimed space. Basically the first request would shift it down 40px, but then it'd snap to the top of the other window. When we move windows out of claimed space, processSnaps is false.
-        if (ALLOW_GROUPS_TO_SNAP) {
-            // make the group get its new bounds, but don't move the windows until the snap calculation is finished.
-            updateGroupWindowsByDelta(delta, false);
-            if (group) {
-                const preSnapBounds = group.getBounds();
-                let mr = group.getBounds();
-                mr.name = moveRequest.name;
-                mr.mousePosition = moveRequest.mousePosition;
-                const groupMoveRequest = this.setMoveRequest(mr);
-                groupMoveRequest.changeType = 0;
-                this.checkBuffers(groupMoveRequest, (modifiedRequest) => {
-                    if (modifiedRequest.finished) {
-                        const moveDelta = self.getMoveDelta(modifiedRequest, preSnapBounds);
-                        updateGroupWindowsByDelta(moveDelta, true, invokeCallback);
-                    }
-                });
-            }
-        }
-        else {
-            updateGroupWindowsByDelta(delta, true, invokeCallback);
-        }
-    }
-    /**
-     * Calculates the % change that a moveRequest inflicts on a group of windows.
-     * @param  {moveRequest} moveRequest
-     * @return {type}
-     */
-    getGroupDelta(groupName, moveRequest) {
-        const group = this.getGroup(groupName);
-        const win = this.getWindow(moveRequest.name);
-        const widthDelta = moveRequest.width - win.width;
-        const heightDelta = moveRequest.height - win.height;
-        return {
-            height: BoxMath.getPercentChange(group.height, group.height + heightDelta),
-            width: BoxMath.getPercentChange(group.width, group.width + widthDelta),
-        };
-    }
-    /**
-     * Creates the resizeObject. Put anything here that should be cached onMouseDown. Will be cleared onMouseUp.
-     * @param {moveRequest} moveRequest
-     * @return {resizeObject}
-     */
-    constructResizeObject(moveRequest) {
-        var _a;
-        const win = this.getWindow(moveRequest.name);
-        const req = new DockableBox(moveRequest);
-        const handle = req.getResizeHandle(moveRequest);
-        // if the handle that's being dragged is on an exterior edge of a group resizing all.
-        let resizeObject = {
-            // This used to be derived from the window because it was only calculated on mouseDown. Now that it can be calculated at any time, we need to derive the handle from the request that's coming in. On group resizes, window bounds are only modified on mouse up.
-            handle,
-            type: "edge",
-            scalingGroup: moveRequest.changeType !== 0 ? this.shouldScaleGroup(moveRequest) : false,
-            correctedHandle: req.getResizeHandle(moveRequest),
-            movingEdges: {
-                top: false,
-                right: false,
-                left: false,
-                bottom: false,
-            },
-        };
-        if (CORNERS.includes(handle)) {
-            resizeObject.type = "corner";
-            if (resizeObject.scalingGroup) {
-                resizeObject = this.correctResizeObject(win, resizeObject);
-            }
-        }
-        resizeObject.movingEdges = this.getMovingEdgesFromResizeHandle(resizeObject.correctedHandle);
-        win.resizeHandle = (_a = resizeObject.correctedHandle) !== null && _a !== void 0 ? _a : null;
-        return resizeObject;
-    }
-    /**
-     * If a corner of a window is on the edge of the group, but it's not an actual corner, we need to treat that as an edge resize. See inline documentation for more. This is basically correcting errant resize-handles.
-     * Note: this behavior is locked behind `requireRectangularityForGroupResize`. Without that flag turned on, there's no need to change the resize handle.
-     */
-    correctResizeObject(win, resizeObject) {
-        // If we don't require rectangularity, we don't need to  change the resize handle.
-        if (this.movingGroup &&
-            resizeObject.handle &&
-            this.groupMode.requireRectangularityForGroupResize &&
-            CORNERS.includes(resizeObject.handle)) {
-            const cornerPoint = win.getPointByVertex(resizeObject.handle);
-            if (this.movingGroup.pointIsOnBoundingBox(cornerPoint, false)) {
-                const splitHandle = resizeObject.handle.split(/(?=[A-Z])/).map((s) => s.toLowerCase());
-                if (this.moveRequest) {
-                    // E.g., 'bottomRight'. Takes and resets the bottom to whatever it was before the user started moving. So even if I grab the bottom right corner and drag it down, the window's bottom edge will not shift.
-                    if (this.movingWindow)
-                        this.moveRequest[splitHandle[0]] = this.movingWindow[splitHandle[0]];
-                    this.moveRequest.height = this.moveRequest.bottom - this.moveRequest.top;
-                    this.moveRequest.width = this.moveRequest.right - this.moveRequest.left;
-                }
-                resizeObject.type = "edge";
-                // e.g., bottomRight; this will just choose 'right'. This happens when you grab the corner of a window that's also on the edge of the window...but isn't the corner of the group.
-                const groupEdge = this.movingGroup.getWindow(win).getEdgeByPoint(cornerPoint);
-                resizeObject.correctedHandle = groupEdge;
-            }
-        }
-        return resizeObject;
-    }
-    /**
-     * Resizes a window based on some delta.
-     * @param  {dockableWindow} win
-     * @param  {Object} delta Object with a width/height change.
-     * @return {type}
-     */
-    resizeByDelta(win, delta) {
-        const bounds = win.getBounds();
-        bounds.width = BoxMath.scaleProportionately(win.width, delta.width);
-        bounds.height = BoxMath.scaleProportionately(win.height, delta.height);
-        if (win.resizeHandle.toLowerCase().includes("right")) {
-            bounds.right = bounds.left + bounds.width;
-        }
-        if (win.resizeHandle.toLowerCase().includes("bottom")) {
-            bounds.bottom = bounds.top + bounds.height;
-        }
-        if (win.resizeHandle.toLowerCase().includes("top")) {
-            bounds.top = bounds.bottom - bounds.height;
-        }
-        if (win.resizeHandle.toLowerCase().includes("left")) {
-            bounds.left = bounds.right - bounds.width;
-        }
-        return bounds;
-    }
-    getMovingDirection(bounds, win) {
-        if (!win) {
-            win = this.getWindow(bounds.name);
-        }
-        let direction = "";
-        if (win.left > bounds.left) {
-            direction = "Left";
-        }
-        if (win.left < bounds.left) {
-            direction = `${direction}Right`;
-        }
-        if (win.top > bounds.top) {
-            direction = `${direction}Top`;
-        }
-        if (win.top < bounds.top) {
-            direction = `${direction}Bottom`;
-        }
-        return direction;
-    }
-    /**
-     * Does the dirty work of actually moving windows.
-     * @param  {moveRequest} bounds
-     * @param  {function} callback
-     */
-    moveWindow(bounds, callback) {
-        // if window resize causes ANY window to be smaller than the minimum_width, quit that shit.
-        if (!bounds) {
-            if (callback) {
-                callback();
-            }
-            return;
-        }
-        if (!callback) {
-            callback = function noop() { };
-        }
-        const win = this.getWindow(bounds.name);
-        if (win) {
-            bounds.persistBounds = false;
-            //Fixing the toolbar height on Mac. When Toolbar is running with dashbar on Mac it should be resizable only by X axis.
-            let isMacOs = navigator.platform.indexOf("Mac") != -1;
-            if (isMacOs && bounds.name.indexOf("Toolbar") != -1) {
-                bounds.height = win.limits.maxHeight;
-            }
-            win.setBounds(bounds, callback);
-        }
-    }
-    checkMoveDockedCommponent(moveRequest, movingWindow) {
-        if (movingWindow.dockedPosition === movingWindow.monitorDockablePositions.TOP) {
-            moveRequest.top = movingWindow.top + this.bufferSize * 2;
-            moveRequest.bottom = moveRequest.top + movingWindow.height;
-        }
-        else if (movingWindow.dockedPosition === movingWindow.monitorDockablePositions.BOTTOM) {
-            moveRequest.bottom = movingWindow.bottom - this.bufferSize * 2;
-            moveRequest.top = moveRequest.bottom - movingWindow.height;
-        }
-        moveRequest.height = movingWindow.undockedPosition.height;
-        moveRequest.width = movingWindow.undockedPosition.width;
-        const { monitor } = movingWindow;
-        if (movingWindow.dockedMonitor) {
-            moveRequest.dockedMonitor = movingWindow.dockedMonitor;
-            delete movingWindow.dockedMonitor;
-        }
-        monitor.undockWindowFromMonitor(movingWindow);
-        this.hideGroupMask();
-    }
-    /**
-     * Checks to see whether a window can be snapped to other windows/monitors.
-     * @param  {moveRequest} bounds
-     * @param  {function} callback
-     */
-    checkBuffers(moveRequest, cb) {
-        var _a, _b;
-        if (this.movingWindow && this.movingWindow.ignoreSnappingRequests) {
-            moveRequest.ignoreSnappingRequests = true;
-        }
-        let snappableWindows = this.getSnappableWindows(moveRequest);
-        let snappableMonitors = this.getSnappableMonitors(moveRequest);
-        // When a window is moved (ends up inside checkBuffers) and it is docked, we can safely assume the window is being undocked (why else would you move a window that takes up the width of the window (or height)?). Here, we set the new bounds of the move request and call to undock the window, which will propagate to all the necessary items changing (the window will shrink, undock, etc).
-        if (this.movingWindow && this.movingWindow.win.isDocked) {
-            // if the user tries to resize a docked component, ignore it.
-            if (moveRequest.changeType !== 0) {
-                const req = this.movingWindow.getBounds();
-                req.name = this.movingWindow.name;
-                req.finished = true;
-                this.hideGroupMask();
-                cb(req);
-                return;
-            }
-            this.checkMoveDockedCommponent(moveRequest, this.movingWindow);
-            // Force exit
-            delete this.movingWindow.snappedMonitor;
-            snappableWindows = [];
-            snappableMonitors = [];
-        }
-        // processSnaps was added for moving groups out of claimed space. When you snapped a window to a movable group, the movable group would snap to the top of the other window rather than being dumped below the claimed space. Basically the first request would shift it down 40px, but then it'd snap to the top of the other window. When we move windows out of claimed space, processSnaps is false.
-        const snappable = snappableWindows.length || snappableMonitors.length;
-        if (moveRequest.processSnaps === false || !snappable) {
-            moveRequest.finished = true;
-            this.hideGroupMask();
-            cb(moveRequest);
-            return;
-        }
-        const checkDocked = (movingWindow, monitor, snapRequest) => {
-            var _a;
-            // If we've made it this far we're moving a dockable component and it isn't already docked (which means we're constantly checking for whether we need to dock). Here we do calculations to determine if a 'dockable mask' should be shown.
-            movingWindow.snappedMonitor = monitor;
-            const clonedRequest = fastClone(snapRequest);
-            snapRequest.dockedMonitor = monitor.name;
-            // The weird math of determining dashbar + toolbar height on initialization will cause the
-            // calculated height of the docking mask to be incorrect. Resetting it here with the
-            // params on the window tells the docking mask to be the correct docked height
-            if (movingWindow.dockedParams) {
-                clonedRequest.dockedHeight = movingWindow.dockedParams.height;
-            }
-            clonedRequest.dockableEdges = (_a = movingWindow.dockingOptions) === null || _a === void 0 ? void 0 : _a.dockable;
-            const newBounds = monitor.getDockedPosition(clonedRequest);
-            if (newBounds) {
-                this.showGroupMask({ bounds: newBounds });
-            }
-        };
-        for (let i = 0, len = snappableMonitors.length; i < len; i++) {
-            const monitor = MonitorPoolSingleton.get(snappableMonitors[i]);
-            const snapRequest = monitor.snapWindow(moveRequest);
-            if ((_a = this.movingWindow) === null || _a === void 0 ? void 0 : _a.isDockableComponent) {
-                checkDocked(this.movingWindow, monitor, snapRequest);
-                snappableWindows = []; // Force exit if window docks to monitor
-            }
-            moveRequest = snapRequest !== null && snapRequest !== void 0 ? snapRequest : moveRequest;
-            // If only a monitor is a possible snap then return here (otherwise continue on to add the snappable windows)
-            if (i === snappableMonitors.length - 1 && snappableWindows.length === 0) {
-                moveRequest.finished = true;
-                cb(moveRequest);
-                return;
-            }
-        }
-        for (let i = 0, len = snappableWindows.length; i < len; i++) {
-            const win = this.getWindow(snappableWindows[i]);
-            this.setStationaryWindow(win);
-            win.setOpacity({ opacity: SNAPPING_OPACITY });
-            // The original request has been changed because of a snap to a straddler window. replace the reference so new comparisons are made against the newly snapped window.
-            moveRequest = (_b = this.snapWindow(moveRequest)) !== null && _b !== void 0 ? _b : moveRequest;
-            moveRequest.windowBoundingBox = BoxMath.getWindowBoundingBox(moveRequest);
-        }
-        moveRequest.finished = true;
-        cb(moveRequest);
-    }
-    /**
-     * Spins through windows and fixes opacity. For onMouseMove, we skip any windows that could be snapped to the movingWindow. onMouseUp, everything gets hit.
-     * @param  {object} params
-     * @param  {object} params.checkForSnappability
-     */
-    fixWindowOpacity(params) {
-        const dockingPoolIterator = DockingPoolSingleton.iterator();
-        for (const win of dockingPoolIterator) {
-            if (params.checkForSnappability && this.moveRequest && win.canSnapToWindow(this.moveRequest)) {
-                continue;
-            }
-            params.opacity = 1;
-            win.setOpacity(params);
-        }
-    }
-    saveWindowsOpacity() {
-        const dockingPoolIterator = DockingPoolSingleton.iterator();
-        for (const win of dockingPoolIterator) {
-            this.persistedOpacity[win.name] = win.win.windowOptions.opacity;
-        }
-    }
-    restoreWindowsOpacity() {
-        const dockingPoolIterator = DockingPoolSingleton.iterator();
-        for (const win of dockingPoolIterator) {
-            const params = {
-                opacity: this.persistedOpacity[win.name] || 1,
-            };
-            win.setOpacity(params);
-        }
-    }
-    /**
-     * Happens when config is loaded from the configClient.
-     */
-    setGlobalMinimums(serviceConfig) {
-        this.MINIMUM_HEIGHT = serviceConfig.MINIMUM_HEIGHT;
-        this.MINIMUM_WIDTH = serviceConfig.MINIMUM_WIDTH;
-        const groups = this.getGroupNames();
-        groups.forEach((name) => {
-            const group = this.getGroup(name);
-            group.setMinimums(serviceConfig);
-        });
-    }
-    /** **************************************
-     *			Calculators - general		*
-     *************************************** */
-    /**
-     * Given an object, will set boundingboxes on it. If it's a dockableWindow, it'll let the window set itself up.
-     * @param  {dockableWindow} win
-     * @return {type}
-     */
-    setBoundingBoxes(win) {
-        if (win.setBoundingBoxes) {
-            win.setBoundingBoxes();
-        }
-        else {
-            win.buffer = this.getBuffer(win);
-            win.snappingRegions = BoxMath.getSnappingRegions(win, this.bufferSize);
-            win.windowBoundingBox = BoxMath.getWindowBoundingBox(win);
-            win.innerBuffer = this.getInnerBoundingBox(win);
-        }
-        return win;
-    }
-    /**
-     * Returns the difference between the movingWindow's location and the requested movement.
-     * @param  {moveRequest} moveRequest
-     * @return {type}
-     */
-    getMoveDelta(moveRequest, oldBounds) {
-        const movingWin = oldBounds || this.getWindow(moveRequest.name);
-        return {
-            x: moveRequest.left - movingWin.left,
-            y: moveRequest.top - movingWin.top,
-        };
-    }
-    /**
-     * Returns the inner bounds. We use this to give the windows some internal stickiness.
-     * @param  {type} bounds
-     * @return {object}
-     */
-    getInnerBoundingBox(bounds) {
-        return {
-            min: {
-                x: bounds.left + this.bufferSize,
-                y: bounds.top + this.bufferSize,
-            },
-            max: {
-                x: bounds.right - this.bufferSize,
-                y: bounds.bottom - this.bufferSize,
-            },
-        };
-    }
-    /**
-     * Gets the snapping buffer of a request.
-     * @param  {type} request
-     * @return {type}
-     */
-    getBuffer(request) {
-        return {
-            min: {
-                x: request.left - this.bufferSize,
-                y: request.top - this.bufferSize,
-            },
-            max: {
-                x: request.right + this.bufferSize,
-                y: request.bottom + this.bufferSize,
-            },
-        };
-    }
-    /**
-     * Given a request, a window, and a region, it'll tell you whether they intersect. We use this to figure out which corner/edge to snap to.
-     * @param  {moveRequest} moveRequest
-     * @param  {dockableWindow} stationaryWindow
-     * @param  {string} stationaryRegion
-     * @return {object}
-     */
-    getIntersections(moveRequest, stationaryWindow, stationaryRegion) {
-        const movingBoundingBoxes = moveRequest.snappingRegions;
-        const stationaryBoundingBoxes = stationaryWindow.snappingRegions;
-        const intersections = [];
-        for (const movingRegion in movingBoundingBoxes) {
-            if (movingRegion === "inner") {
-                continue;
-            }
-            if (BoxMath.intersectBoundingBoxes(stationaryBoundingBoxes[stationaryRegion], movingBoundingBoxes[movingRegion])) {
-                intersections.push(movingRegion);
-            }
-        }
-        return intersections;
-    }
-    /** **************************************
-     *				Iterators				*
-     *************************************** */
-    *groupWindowIterator(group, orderAnchor = this.movingWindow) {
-        const windows = this.orderWindows(group.windows, orderAnchor);
-        // preserves order..for .. in does not.
-        for (let i = 0; i < windows.length; i++) {
-            yield windows[i];
-        }
-    }
-}
-export default DockingCalculator;
-//# sourceMappingURL=dockingCalculator.js.map