@codingame/monaco-vscode-api 4.4.1 → 4.5.0-improve-code-splitting.1

package/vscode/src/vs/base/browser/ui/grid/gridview.js

@@ -1,1110 +0,0 @@
-import { $ } from '../../dom.js';
-import { Sizing, SplitView } from '../splitview/splitview.js';
-import { tail2, equals } from '../../../common/arrays.js';
-import { Color } from '../../../common/color.js';
-import { Event, Relay, Emitter } from '../../../common/event.js';
-import { Disposable, DisposableStore, toDisposable } from '../../../common/lifecycle.js';
-import { rot } from '../../../common/numbers.js';
-import { isUndefined } from '../../../common/types.js';
-import './gridview.css.js';
-import '../sash/sash.js';
-const defaultStyles = {
-    separatorBorder: Color.transparent
-};
-function orthogonal(orientation) {
-    return orientation === 0  ? 1  : 0 ;
-}
-class LayoutController {
-    constructor(isLayoutEnabled) {
-        this.isLayoutEnabled = isLayoutEnabled;
-    }
-}
-function toAbsoluteBoundarySashes(sashes, orientation) {
-    if (orientation === 1 ) {
-        return { left: sashes.start, right: sashes.end, top: sashes.orthogonalStart, bottom: sashes.orthogonalEnd };
-    }
-    else {
-        return { top: sashes.start, bottom: sashes.end, left: sashes.orthogonalStart, right: sashes.orthogonalEnd };
-    }
-}
-function fromAbsoluteBoundarySashes(sashes, orientation) {
-    if (orientation === 1 ) {
-        return { start: sashes.left, end: sashes.right, orthogonalStart: sashes.top, orthogonalEnd: sashes.bottom };
-    }
-    else {
-        return { start: sashes.top, end: sashes.bottom, orthogonalStart: sashes.left, orthogonalEnd: sashes.right };
-    }
-}
-function validateIndex(index, numChildren) {
-    if (Math.abs(index) > numChildren) {
-        throw new Error('Invalid index');
-    }
-    return rot(index, numChildren + 1);
-}
-class BranchNode {
-    get size() { return this._size; }
-    get orthogonalSize() { return this._orthogonalSize; }
-    get absoluteOffset() { return this._absoluteOffset; }
-    get absoluteOrthogonalOffset() { return this._absoluteOrthogonalOffset; }
-    get styles() { return this._styles; }
-    get width() {
-        return this.orientation === 1  ? this.size : this.orthogonalSize;
-    }
-    get height() {
-        return this.orientation === 1  ? this.orthogonalSize : this.size;
-    }
-    get top() {
-        return this.orientation === 1  ? this._absoluteOffset : this._absoluteOrthogonalOffset;
-    }
-    get left() {
-        return this.orientation === 1  ? this._absoluteOrthogonalOffset : this._absoluteOffset;
-    }
-    get minimumSize() {
-        return this.children.length === 0 ? 0 : Math.max(...( this.children.map(
-            (c, index) => this.splitview.isViewVisible(index) ? c.minimumOrthogonalSize : 0
-        )));
-    }
-    get maximumSize() {
-        return Math.min(...( this.children.map(
-            (c, index) => this.splitview.isViewVisible(index) ? c.maximumOrthogonalSize : Number.POSITIVE_INFINITY
-        )));
-    }
-    get priority() {
-        if (this.children.length === 0) {
-            return 0 ;
-        }
-        const priorities = ( this.children.map(
-            c => typeof c.priority === 'undefined' ? 0  : c.priority
-        ));
-        if (( priorities.some(p => p === 2 ))) {
-            return 2 ;
-        }
-        else if (( priorities.some(p => p === 1 ))) {
-            return 1 ;
-        }
-        return 0 ;
-    }
-    get proportionalLayout() {
-        if (this.children.length === 0) {
-            return true;
-        }
-        return this.children.every(c => c.proportionalLayout);
-    }
-    get minimumOrthogonalSize() {
-        return this.splitview.minimumSize;
-    }
-    get maximumOrthogonalSize() {
-        return this.splitview.maximumSize;
-    }
-    get minimumWidth() {
-        return this.orientation === 1  ? this.minimumOrthogonalSize : this.minimumSize;
-    }
-    get minimumHeight() {
-        return this.orientation === 1  ? this.minimumSize : this.minimumOrthogonalSize;
-    }
-    get maximumWidth() {
-        return this.orientation === 1  ? this.maximumOrthogonalSize : this.maximumSize;
-    }
-    get maximumHeight() {
-        return this.orientation === 1  ? this.maximumSize : this.maximumOrthogonalSize;
-    }
-    get boundarySashes() { return this._boundarySashes; }
-    set boundarySashes(boundarySashes) {
-        if (this._boundarySashes.start === boundarySashes.start
-            && this._boundarySashes.end === boundarySashes.end
-            && this._boundarySashes.orthogonalStart === boundarySashes.orthogonalStart
-            && this._boundarySashes.orthogonalEnd === boundarySashes.orthogonalEnd) {
-            return;
-        }
-        this._boundarySashes = boundarySashes;
-        this.splitview.orthogonalStartSash = boundarySashes.orthogonalStart;
-        this.splitview.orthogonalEndSash = boundarySashes.orthogonalEnd;
-        for (let index = 0; index < this.children.length; index++) {
-            const child = this.children[index];
-            const first = index === 0;
-            const last = index === this.children.length - 1;
-            child.boundarySashes = {
-                start: boundarySashes.orthogonalStart,
-                end: boundarySashes.orthogonalEnd,
-                orthogonalStart: first ? boundarySashes.start : child.boundarySashes.orthogonalStart,
-                orthogonalEnd: last ? boundarySashes.end : child.boundarySashes.orthogonalEnd,
-            };
-        }
-    }
-    get edgeSnapping() { return this._edgeSnapping; }
-    set edgeSnapping(edgeSnapping) {
-        if (this._edgeSnapping === edgeSnapping) {
-            return;
-        }
-        this._edgeSnapping = edgeSnapping;
-        for (const child of this.children) {
-            if (child instanceof BranchNode) {
-                child.edgeSnapping = edgeSnapping;
-            }
-        }
-        this.updateSplitviewEdgeSnappingEnablement();
-    }
-    constructor(orientation, layoutController, styles, splitviewProportionalLayout, size = 0, orthogonalSize = 0, edgeSnapping = false, childDescriptors) {
-        this.orientation = orientation;
-        this.layoutController = layoutController;
-        this.splitviewProportionalLayout = splitviewProportionalLayout;
-        this.children = [];
-        this._absoluteOffset = 0;
-        this._absoluteOrthogonalOffset = 0;
-        this.absoluteOrthogonalSize = 0;
-        this._onDidChange = ( new Emitter());
-        this.onDidChange = this._onDidChange.event;
-        this._onDidVisibilityChange = ( new Emitter());
-        this.onDidVisibilityChange = this._onDidVisibilityChange.event;
-        this.childrenVisibilityChangeDisposable = ( new DisposableStore());
-        this._onDidScroll = ( new Emitter());
-        this.onDidScrollDisposable = Disposable.None;
-        this.onDidScroll = this._onDidScroll.event;
-        this.childrenChangeDisposable = Disposable.None;
-        this._onDidSashReset = ( new Emitter());
-        this.onDidSashReset = this._onDidSashReset.event;
-        this.splitviewSashResetDisposable = Disposable.None;
-        this.childrenSashResetDisposable = Disposable.None;
-        this._boundarySashes = {};
-        this._edgeSnapping = false;
-        this._styles = styles;
-        this._size = size;
-        this._orthogonalSize = orthogonalSize;
-        this.element = $('.monaco-grid-branch-node');
-        if (!childDescriptors) {
-            this.splitview = ( new SplitView(
-                this.element,
-                { orientation, styles, proportionalLayout: splitviewProportionalLayout }
-            ));
-            this.splitview.layout(size, { orthogonalSize, absoluteOffset: 0, absoluteOrthogonalOffset: 0, absoluteSize: size, absoluteOrthogonalSize: orthogonalSize });
-        }
-        else {
-            const descriptor = {
-                views: ( childDescriptors.map(childDescriptor => {
-                    return {
-                        view: childDescriptor.node,
-                        size: childDescriptor.node.size,
-                        visible: childDescriptor.visible !== false
-                    };
-                })),
-                size: this.orthogonalSize
-            };
-            const options = { proportionalLayout: splitviewProportionalLayout, orientation, styles };
-            this.children = ( childDescriptors.map(c => c.node));
-            this.splitview = ( new SplitView(this.element, { ...options, descriptor }));
-            this.children.forEach((node, index) => {
-                const first = index === 0;
-                const last = index === this.children.length;
-                node.boundarySashes = {
-                    start: this.boundarySashes.orthogonalStart,
-                    end: this.boundarySashes.orthogonalEnd,
-                    orthogonalStart: first ? this.boundarySashes.start : this.splitview.sashes[index - 1],
-                    orthogonalEnd: last ? this.boundarySashes.end : this.splitview.sashes[index],
-                };
-            });
-        }
-        const onDidSashReset = ( Event.map(this.splitview.onDidSashReset, i => [i]));
-        this.splitviewSashResetDisposable = onDidSashReset(this._onDidSashReset.fire, this._onDidSashReset);
-        this.updateChildrenEvents();
-    }
-    style(styles) {
-        this._styles = styles;
-        this.splitview.style(styles);
-        for (const child of this.children) {
-            if (child instanceof BranchNode) {
-                child.style(styles);
-            }
-        }
-    }
-    layout(size, offset, ctx) {
-        if (!this.layoutController.isLayoutEnabled) {
-            return;
-        }
-        if (typeof ctx === 'undefined') {
-            throw new Error('Invalid state');
-        }
-        this._size = ctx.orthogonalSize;
-        this._orthogonalSize = size;
-        this._absoluteOffset = ctx.absoluteOffset + offset;
-        this._absoluteOrthogonalOffset = ctx.absoluteOrthogonalOffset;
-        this.absoluteOrthogonalSize = ctx.absoluteOrthogonalSize;
-        this.splitview.layout(ctx.orthogonalSize, {
-            orthogonalSize: size,
-            absoluteOffset: this._absoluteOrthogonalOffset,
-            absoluteOrthogonalOffset: this._absoluteOffset,
-            absoluteSize: ctx.absoluteOrthogonalSize,
-            absoluteOrthogonalSize: ctx.absoluteSize
-        });
-        this.updateSplitviewEdgeSnappingEnablement();
-    }
-    setVisible(visible) {
-        for (const child of this.children) {
-            child.setVisible(visible);
-        }
-    }
-    addChild(node, size, index, skipLayout) {
-        index = validateIndex(index, this.children.length);
-        this.splitview.addView(node, size, index, skipLayout);
-        this.children.splice(index, 0, node);
-        this.updateBoundarySashes();
-        this.onDidChildrenChange();
-    }
-    removeChild(index, sizing) {
-        index = validateIndex(index, this.children.length);
-        const result = this.splitview.removeView(index, sizing);
-        this.children.splice(index, 1);
-        this.updateBoundarySashes();
-        this.onDidChildrenChange();
-        return result;
-    }
-    removeAllChildren() {
-        const result = this.splitview.removeAllViews();
-        this.children.splice(0, this.children.length);
-        this.updateBoundarySashes();
-        this.onDidChildrenChange();
-        return result;
-    }
-    moveChild(from, to) {
-        from = validateIndex(from, this.children.length);
-        to = validateIndex(to, this.children.length);
-        if (from === to) {
-            return;
-        }
-        if (from < to) {
-            to -= 1;
-        }
-        this.splitview.moveView(from, to);
-        this.children.splice(to, 0, this.children.splice(from, 1)[0]);
-        this.updateBoundarySashes();
-        this.onDidChildrenChange();
-    }
-    swapChildren(from, to) {
-        from = validateIndex(from, this.children.length);
-        to = validateIndex(to, this.children.length);
-        if (from === to) {
-            return;
-        }
-        this.splitview.swapViews(from, to);
-        [this.children[from].boundarySashes, this.children[to].boundarySashes]
-            = [this.children[from].boundarySashes, this.children[to].boundarySashes];
-        [this.children[from], this.children[to]] = [this.children[to], this.children[from]];
-        this.onDidChildrenChange();
-    }
-    resizeChild(index, size) {
-        index = validateIndex(index, this.children.length);
-        this.splitview.resizeView(index, size);
-    }
-    isChildExpanded(index) {
-        return this.splitview.isViewExpanded(index);
-    }
-    distributeViewSizes(recursive = false) {
-        this.splitview.distributeViewSizes();
-        if (recursive) {
-            for (const child of this.children) {
-                if (child instanceof BranchNode) {
-                    child.distributeViewSizes(true);
-                }
-            }
-        }
-    }
-    getChildSize(index) {
-        index = validateIndex(index, this.children.length);
-        return this.splitview.getViewSize(index);
-    }
-    isChildVisible(index) {
-        index = validateIndex(index, this.children.length);
-        return this.splitview.isViewVisible(index);
-    }
-    setChildVisible(index, visible) {
-        index = validateIndex(index, this.children.length);
-        if (this.splitview.isViewVisible(index) === visible) {
-            return;
-        }
-        const wereAllChildrenHidden = this.splitview.contentSize === 0;
-        this.splitview.setViewVisible(index, visible);
-        const areAllChildrenHidden = this.splitview.contentSize === 0;
-        if ((visible && wereAllChildrenHidden) || (!visible && areAllChildrenHidden)) {
-            this._onDidVisibilityChange.fire(visible);
-        }
-    }
-    getChildCachedVisibleSize(index) {
-        index = validateIndex(index, this.children.length);
-        return this.splitview.getViewCachedVisibleSize(index);
-    }
-    updateBoundarySashes() {
-        for (let i = 0; i < this.children.length; i++) {
-            this.children[i].boundarySashes = {
-                start: this.boundarySashes.orthogonalStart,
-                end: this.boundarySashes.orthogonalEnd,
-                orthogonalStart: i === 0 ? this.boundarySashes.start : this.splitview.sashes[i - 1],
-                orthogonalEnd: i === this.children.length - 1 ? this.boundarySashes.end : this.splitview.sashes[i],
-            };
-        }
-    }
-    onDidChildrenChange() {
-        this.updateChildrenEvents();
-        this._onDidChange.fire(undefined);
-    }
-    updateChildrenEvents() {
-        const onDidChildrenChange = ( Event.map(Event.any(...( this.children.map(c => c.onDidChange))), () => undefined));
-        this.childrenChangeDisposable.dispose();
-        this.childrenChangeDisposable = onDidChildrenChange(this._onDidChange.fire, this._onDidChange);
-        const onDidChildrenSashReset = Event.any(...( this.children.map((c, i) => ( Event.map(c.onDidSashReset, location => [i, ...location])))));
-        this.childrenSashResetDisposable.dispose();
-        this.childrenSashResetDisposable = onDidChildrenSashReset(this._onDidSashReset.fire, this._onDidSashReset);
-        const onDidScroll = Event.any(Event.signal(this.splitview.onDidScroll), ...( this.children.map(c => c.onDidScroll)));
-        this.onDidScrollDisposable.dispose();
-        this.onDidScrollDisposable = onDidScroll(this._onDidScroll.fire, this._onDidScroll);
-        this.childrenVisibilityChangeDisposable.clear();
-        this.children.forEach((child, index) => {
-            if (child instanceof BranchNode) {
-                this.childrenVisibilityChangeDisposable.add(child.onDidVisibilityChange((visible) => {
-                    this.setChildVisible(index, visible);
-                }));
-            }
-        });
-    }
-    trySet2x2(other) {
-        if (this.children.length !== 2 || other.children.length !== 2) {
-            return Disposable.None;
-        }
-        if (this.getChildSize(0) !== other.getChildSize(0)) {
-            return Disposable.None;
-        }
-        const [firstChild, secondChild] = this.children;
-        const [otherFirstChild, otherSecondChild] = other.children;
-        if (!(firstChild instanceof LeafNode) || !(secondChild instanceof LeafNode)) {
-            return Disposable.None;
-        }
-        if (!(otherFirstChild instanceof LeafNode) || !(otherSecondChild instanceof LeafNode)) {
-            return Disposable.None;
-        }
-        if (this.orientation === 0 ) {
-            secondChild.linkedWidthNode = otherFirstChild.linkedHeightNode = firstChild;
-            firstChild.linkedWidthNode = otherSecondChild.linkedHeightNode = secondChild;
-            otherSecondChild.linkedWidthNode = firstChild.linkedHeightNode = otherFirstChild;
-            otherFirstChild.linkedWidthNode = secondChild.linkedHeightNode = otherSecondChild;
-        }
-        else {
-            otherFirstChild.linkedWidthNode = secondChild.linkedHeightNode = firstChild;
-            otherSecondChild.linkedWidthNode = firstChild.linkedHeightNode = secondChild;
-            firstChild.linkedWidthNode = otherSecondChild.linkedHeightNode = otherFirstChild;
-            secondChild.linkedWidthNode = otherFirstChild.linkedHeightNode = otherSecondChild;
-        }
-        const mySash = this.splitview.sashes[0];
-        const otherSash = other.splitview.sashes[0];
-        mySash.linkedSash = otherSash;
-        otherSash.linkedSash = mySash;
-        this._onDidChange.fire(undefined);
-        other._onDidChange.fire(undefined);
-        return toDisposable(() => {
-            mySash.linkedSash = otherSash.linkedSash = undefined;
-            firstChild.linkedHeightNode = firstChild.linkedWidthNode = undefined;
-            secondChild.linkedHeightNode = secondChild.linkedWidthNode = undefined;
-            otherFirstChild.linkedHeightNode = otherFirstChild.linkedWidthNode = undefined;
-            otherSecondChild.linkedHeightNode = otherSecondChild.linkedWidthNode = undefined;
-        });
-    }
-    updateSplitviewEdgeSnappingEnablement() {
-        this.splitview.startSnappingEnabled = this._edgeSnapping || this._absoluteOrthogonalOffset > 0;
-        this.splitview.endSnappingEnabled = this._edgeSnapping || this._absoluteOrthogonalOffset + this._size < this.absoluteOrthogonalSize;
-    }
-    dispose() {
-        for (const child of this.children) {
-            child.dispose();
-        }
-        this._onDidChange.dispose();
-        this._onDidSashReset.dispose();
-        this._onDidVisibilityChange.dispose();
-        this.childrenVisibilityChangeDisposable.dispose();
-        this.splitviewSashResetDisposable.dispose();
-        this.childrenSashResetDisposable.dispose();
-        this.childrenChangeDisposable.dispose();
-        this.onDidScrollDisposable.dispose();
-        this.splitview.dispose();
-    }
-}
-function createLatchedOnDidChangeViewEvent(view) {
-    const [onDidChangeViewConstraints, onDidSetViewSize] = Event.split(view.onDidChange, isUndefined);
-    return Event.any(onDidSetViewSize, ( Event.map(Event.latch(( Event.map(
-        onDidChangeViewConstraints,
-        _ => ([view.minimumWidth, view.maximumWidth, view.minimumHeight, view.maximumHeight])
-    )), equals), _ => undefined)));
-}
-class LeafNode {
-    get size() { return this._size; }
-    get orthogonalSize() { return this._orthogonalSize; }
-    get linkedWidthNode() { return this._linkedWidthNode; }
-    set linkedWidthNode(node) {
-        this._onDidLinkedWidthNodeChange.input = node ? node._onDidViewChange : Event.None;
-        this._linkedWidthNode = node;
-        this._onDidSetLinkedNode.fire(undefined);
-    }
-    get linkedHeightNode() { return this._linkedHeightNode; }
-    set linkedHeightNode(node) {
-        this._onDidLinkedHeightNodeChange.input = node ? node._onDidViewChange : Event.None;
-        this._linkedHeightNode = node;
-        this._onDidSetLinkedNode.fire(undefined);
-    }
-    constructor(view, orientation, layoutController, orthogonalSize, size = 0) {
-        this.view = view;
-        this.orientation = orientation;
-        this.layoutController = layoutController;
-        this._size = 0;
-        this.absoluteOffset = 0;
-        this.absoluteOrthogonalOffset = 0;
-        this.onDidScroll = Event.None;
-        this.onDidSashReset = Event.None;
-        this._onDidLinkedWidthNodeChange = ( new Relay());
-        this._linkedWidthNode = undefined;
-        this._onDidLinkedHeightNodeChange = ( new Relay());
-        this._linkedHeightNode = undefined;
-        this._onDidSetLinkedNode = ( new Emitter());
-        this.disposables = ( new DisposableStore());
-        this._boundarySashes = {};
-        this.cachedWidth = 0;
-        this.cachedHeight = 0;
-        this.cachedTop = 0;
-        this.cachedLeft = 0;
-        this._orthogonalSize = orthogonalSize;
-        this._size = size;
-        const onDidChange = createLatchedOnDidChangeViewEvent(view);
-        this._onDidViewChange = ( Event.map(
-            onDidChange,
-            e => e && (this.orientation === 0  ? e.width : e.height),
-            this.disposables
-        ));
-        this.onDidChange = Event.any(this._onDidViewChange, this._onDidSetLinkedNode.event, this._onDidLinkedWidthNodeChange.event, this._onDidLinkedHeightNodeChange.event);
-    }
-    get width() {
-        return this.orientation === 1  ? this.orthogonalSize : this.size;
-    }
-    get height() {
-        return this.orientation === 1  ? this.size : this.orthogonalSize;
-    }
-    get top() {
-        return this.orientation === 1  ? this.absoluteOffset : this.absoluteOrthogonalOffset;
-    }
-    get left() {
-        return this.orientation === 1  ? this.absoluteOrthogonalOffset : this.absoluteOffset;
-    }
-    get element() {
-        return this.view.element;
-    }
-    get minimumWidth() {
-        return this.linkedWidthNode ? Math.max(this.linkedWidthNode.view.minimumWidth, this.view.minimumWidth) : this.view.minimumWidth;
-    }
-    get maximumWidth() {
-        return this.linkedWidthNode ? Math.min(this.linkedWidthNode.view.maximumWidth, this.view.maximumWidth) : this.view.maximumWidth;
-    }
-    get minimumHeight() {
-        return this.linkedHeightNode ? Math.max(this.linkedHeightNode.view.minimumHeight, this.view.minimumHeight) : this.view.minimumHeight;
-    }
-    get maximumHeight() {
-        return this.linkedHeightNode ? Math.min(this.linkedHeightNode.view.maximumHeight, this.view.maximumHeight) : this.view.maximumHeight;
-    }
-    get minimumSize() {
-        return this.orientation === 1  ? this.minimumHeight : this.minimumWidth;
-    }
-    get maximumSize() {
-        return this.orientation === 1  ? this.maximumHeight : this.maximumWidth;
-    }
-    get priority() {
-        return this.view.priority;
-    }
-    get proportionalLayout() {
-        return this.view.proportionalLayout ?? true;
-    }
-    get snap() {
-        return this.view.snap;
-    }
-    get minimumOrthogonalSize() {
-        return this.orientation === 1  ? this.minimumWidth : this.minimumHeight;
-    }
-    get maximumOrthogonalSize() {
-        return this.orientation === 1  ? this.maximumWidth : this.maximumHeight;
-    }
-    get boundarySashes() { return this._boundarySashes; }
-    set boundarySashes(boundarySashes) {
-        this._boundarySashes = boundarySashes;
-        this.view.setBoundarySashes?.(toAbsoluteBoundarySashes(boundarySashes, this.orientation));
-    }
-    layout(size, offset, ctx) {
-        if (!this.layoutController.isLayoutEnabled) {
-            return;
-        }
-        if (typeof ctx === 'undefined') {
-            throw new Error('Invalid state');
-        }
-        this._size = size;
-        this._orthogonalSize = ctx.orthogonalSize;
-        this.absoluteOffset = ctx.absoluteOffset + offset;
-        this.absoluteOrthogonalOffset = ctx.absoluteOrthogonalOffset;
-        this._layout(this.width, this.height, this.top, this.left);
-    }
-    _layout(width, height, top, left) {
-        if (this.cachedWidth === width && this.cachedHeight === height && this.cachedTop === top && this.cachedLeft === left) {
-            return;
-        }
-        this.cachedWidth = width;
-        this.cachedHeight = height;
-        this.cachedTop = top;
-        this.cachedLeft = left;
-        this.view.layout(width, height, top, left);
-    }
-    setVisible(visible) {
-        this.view.setVisible?.(visible);
-    }
-    dispose() {
-        this.disposables.dispose();
-    }
-}
-function flipNode(node, size, orthogonalSize) {
-    if (node instanceof BranchNode) {
-        const result = ( new BranchNode(
-            orthogonal(node.orientation),
-            node.layoutController,
-            node.styles,
-            node.splitviewProportionalLayout,
-            size,
-            orthogonalSize,
-            node.edgeSnapping
-        ));
-        let totalSize = 0;
-        for (let i = node.children.length - 1; i >= 0; i--) {
-            const child = node.children[i];
-            const childSize = child instanceof BranchNode ? child.orthogonalSize : child.size;
-            let newSize = node.size === 0 ? 0 : Math.round((size * childSize) / node.size);
-            totalSize += newSize;
-            if (i === 0) {
-                newSize += size - totalSize;
-            }
-            result.addChild(flipNode(child, orthogonalSize, newSize), newSize, 0, true);
-        }
-        node.dispose();
-        return result;
-    }
-    else {
-        const result = ( new LeafNode(
-            node.view,
-            orthogonal(node.orientation),
-            node.layoutController,
-            orthogonalSize
-        ));
-        node.dispose();
-        return result;
-    }
-}
-class GridView {
-    get root() { return this._root; }
-    set root(root) {
-        const oldRoot = this._root;
-        if (oldRoot) {
-            this.element.removeChild(oldRoot.element);
-            oldRoot.dispose();
-        }
-        this._root = root;
-        this.element.appendChild(root.element);
-        this.onDidSashResetRelay.input = root.onDidSashReset;
-        this._onDidChange.input = ( Event.map(root.onDidChange, () => undefined));
-        this._onDidScroll.input = root.onDidScroll;
-    }
-    get width() { return this.root.width; }
-    get height() { return this.root.height; }
-    get minimumWidth() { return this.root.minimumWidth; }
-    get minimumHeight() { return this.root.minimumHeight; }
-    get maximumWidth() { return this.root.maximumHeight; }
-    get maximumHeight() { return this.root.maximumHeight; }
-    get orientation() { return this._root.orientation; }
-    get boundarySashes() { return this._boundarySashes; }
-    set orientation(orientation) {
-        if (this._root.orientation === orientation) {
-            return;
-        }
-        const { size, orthogonalSize, absoluteOffset, absoluteOrthogonalOffset } = this._root;
-        this.root = flipNode(this._root, orthogonalSize, size);
-        this.root.layout(size, 0, { orthogonalSize, absoluteOffset: absoluteOrthogonalOffset, absoluteOrthogonalOffset: absoluteOffset, absoluteSize: size, absoluteOrthogonalSize: orthogonalSize });
-        this.boundarySashes = this.boundarySashes;
-    }
-    set boundarySashes(boundarySashes) {
-        this._boundarySashes = boundarySashes;
-        this.root.boundarySashes = fromAbsoluteBoundarySashes(boundarySashes, this.orientation);
-    }
-    set edgeSnapping(edgeSnapping) {
-        this.root.edgeSnapping = edgeSnapping;
-    }
-    constructor(options = {}) {
-        this.onDidSashResetRelay = ( new Relay());
-        this._onDidScroll = ( new Relay());
-        this._onDidChange = ( new Relay());
-        this._boundarySashes = {};
-        this.disposable2x2 = Disposable.None;
-        this.onDidSashReset = this.onDidSashResetRelay.event;
-        this.onDidScroll = this._onDidScroll.event;
-        this.onDidChange = this._onDidChange.event;
-        this.maximizedNode = undefined;
-        this._onDidChangeViewMaximized = ( new Emitter());
-        this.onDidChangeViewMaximized = this._onDidChangeViewMaximized.event;
-        this.element = $('.monaco-grid-view');
-        this.styles = options.styles || defaultStyles;
-        this.proportionalLayout = typeof options.proportionalLayout !== 'undefined' ? !!options.proportionalLayout : true;
-        this.layoutController = ( new LayoutController(false));
-        this.root = ( new BranchNode(
-            0 ,
-            this.layoutController,
-            this.styles,
-            this.proportionalLayout
-        ));
-    }
-    style(styles) {
-        this.styles = styles;
-        this.root.style(styles);
-    }
-    layout(width, height, top = 0, left = 0) {
-        this.layoutController.isLayoutEnabled = true;
-        const [size, orthogonalSize, offset, orthogonalOffset] = this.root.orientation === 1  ? [height, width, top, left] : [width, height, left, top];
-        this.root.layout(size, 0, { orthogonalSize, absoluteOffset: offset, absoluteOrthogonalOffset: orthogonalOffset, absoluteSize: size, absoluteOrthogonalSize: orthogonalSize });
-    }
-    addView(view, size, location) {
-        if (this.hasMaximizedView()) {
-            this.exitMaximizedView();
-        }
-        this.disposable2x2.dispose();
-        this.disposable2x2 = Disposable.None;
-        const [rest, index] = tail2(location);
-        const [pathToParent, parent] = this.getNode(rest);
-        if (parent instanceof BranchNode) {
-            const node = ( new LeafNode(
-                view,
-                orthogonal(parent.orientation),
-                this.layoutController,
-                parent.orthogonalSize
-            ));
-            try {
-                parent.addChild(node, size, index);
-            }
-            catch (err) {
-                node.dispose();
-                throw err;
-            }
-        }
-        else {
-            const [, grandParent] = tail2(pathToParent);
-            const [, parentIndex] = tail2(rest);
-            let newSiblingSize = 0;
-            const newSiblingCachedVisibleSize = grandParent.getChildCachedVisibleSize(parentIndex);
-            if (typeof newSiblingCachedVisibleSize === 'number') {
-                newSiblingSize = Sizing.Invisible(newSiblingCachedVisibleSize);
-            }
-            const oldChild = grandParent.removeChild(parentIndex);
-            oldChild.dispose();
-            const newParent = ( new BranchNode(
-                parent.orientation,
-                parent.layoutController,
-                this.styles,
-                this.proportionalLayout,
-                parent.size,
-                parent.orthogonalSize,
-                grandParent.edgeSnapping
-            ));
-            grandParent.addChild(newParent, parent.size, parentIndex);
-            const newSibling = ( new LeafNode(parent.view, grandParent.orientation, this.layoutController, parent.size));
-            newParent.addChild(newSibling, newSiblingSize, 0);
-            if (typeof size !== 'number' && size.type === 'split') {
-                size = Sizing.Split(0);
-            }
-            const node = ( new LeafNode(view, grandParent.orientation, this.layoutController, parent.size));
-            newParent.addChild(node, size, index);
-        }
-        this.trySet2x2();
-    }
-    removeView(location, sizing) {
-        if (this.hasMaximizedView()) {
-            this.exitMaximizedView();
-        }
-        this.disposable2x2.dispose();
-        this.disposable2x2 = Disposable.None;
-        const [rest, index] = tail2(location);
-        const [pathToParent, parent] = this.getNode(rest);
-        if (!(parent instanceof BranchNode)) {
-            throw new Error('Invalid location');
-        }
-        const node = parent.children[index];
-        if (!(node instanceof LeafNode)) {
-            throw new Error('Invalid location');
-        }
-        parent.removeChild(index, sizing);
-        node.dispose();
-        if (parent.children.length === 0) {
-            throw new Error('Invalid grid state');
-        }
-        if (parent.children.length > 1) {
-            this.trySet2x2();
-            return node.view;
-        }
-        if (pathToParent.length === 0) {
-            const sibling = parent.children[0];
-            if (sibling instanceof LeafNode) {
-                return node.view;
-            }
-            parent.removeChild(0);
-            parent.dispose();
-            this.root = sibling;
-            this.boundarySashes = this.boundarySashes;
-            this.trySet2x2();
-            return node.view;
-        }
-        const [, grandParent] = tail2(pathToParent);
-        const [, parentIndex] = tail2(rest);
-        const isSiblingVisible = parent.isChildVisible(0);
-        const sibling = parent.removeChild(0);
-        const sizes = ( grandParent.children.map((_, i) => grandParent.getChildSize(i)));
-        grandParent.removeChild(parentIndex, sizing);
-        parent.dispose();
-        if (sibling instanceof BranchNode) {
-            sizes.splice(parentIndex, 1, ...( sibling.children.map(c => c.size)));
-            const siblingChildren = sibling.removeAllChildren();
-            for (let i = 0; i < siblingChildren.length; i++) {
-                grandParent.addChild(siblingChildren[i], siblingChildren[i].size, parentIndex + i);
-            }
-        }
-        else {
-            const newSibling = ( new LeafNode(
-                sibling.view,
-                orthogonal(sibling.orientation),
-                this.layoutController,
-                sibling.size
-            ));
-            const sizing = isSiblingVisible ? sibling.orthogonalSize : Sizing.Invisible(sibling.orthogonalSize);
-            grandParent.addChild(newSibling, sizing, parentIndex);
-        }
-        sibling.dispose();
-        for (let i = 0; i < sizes.length; i++) {
-            grandParent.resizeChild(i, sizes[i]);
-        }
-        this.trySet2x2();
-        return node.view;
-    }
-    moveView(parentLocation, from, to) {
-        if (this.hasMaximizedView()) {
-            this.exitMaximizedView();
-        }
-        const [, parent] = this.getNode(parentLocation);
-        if (!(parent instanceof BranchNode)) {
-            throw new Error('Invalid location');
-        }
-        parent.moveChild(from, to);
-        this.trySet2x2();
-    }
-    swapViews(from, to) {
-        if (this.hasMaximizedView()) {
-            this.exitMaximizedView();
-        }
-        const [fromRest, fromIndex] = tail2(from);
-        const [, fromParent] = this.getNode(fromRest);
-        if (!(fromParent instanceof BranchNode)) {
-            throw new Error('Invalid from location');
-        }
-        const fromSize = fromParent.getChildSize(fromIndex);
-        const fromNode = fromParent.children[fromIndex];
-        if (!(fromNode instanceof LeafNode)) {
-            throw new Error('Invalid from location');
-        }
-        const [toRest, toIndex] = tail2(to);
-        const [, toParent] = this.getNode(toRest);
-        if (!(toParent instanceof BranchNode)) {
-            throw new Error('Invalid to location');
-        }
-        const toSize = toParent.getChildSize(toIndex);
-        const toNode = toParent.children[toIndex];
-        if (!(toNode instanceof LeafNode)) {
-            throw new Error('Invalid to location');
-        }
-        if (fromParent === toParent) {
-            fromParent.swapChildren(fromIndex, toIndex);
-        }
-        else {
-            fromParent.removeChild(fromIndex);
-            toParent.removeChild(toIndex);
-            fromParent.addChild(toNode, fromSize, fromIndex);
-            toParent.addChild(fromNode, toSize, toIndex);
-        }
-        this.trySet2x2();
-    }
-    resizeView(location, size) {
-        if (this.hasMaximizedView()) {
-            this.exitMaximizedView();
-        }
-        const [rest, index] = tail2(location);
-        const [pathToParent, parent] = this.getNode(rest);
-        if (!(parent instanceof BranchNode)) {
-            throw new Error('Invalid location');
-        }
-        if (!size.width && !size.height) {
-            return;
-        }
-        const [parentSize, grandParentSize] = parent.orientation === 1  ? [size.width, size.height] : [size.height, size.width];
-        if (typeof grandParentSize === 'number' && pathToParent.length > 0) {
-            const [, grandParent] = tail2(pathToParent);
-            const [, parentIndex] = tail2(rest);
-            grandParent.resizeChild(parentIndex, grandParentSize);
-        }
-        if (typeof parentSize === 'number') {
-            parent.resizeChild(index, parentSize);
-        }
-        this.trySet2x2();
-    }
-    getViewSize(location) {
-        if (!location) {
-            return { width: this.root.width, height: this.root.height };
-        }
-        const [, node] = this.getNode(location);
-        return { width: node.width, height: node.height };
-    }
-    getViewCachedVisibleSize(location) {
-        const [rest, index] = tail2(location);
-        const [, parent] = this.getNode(rest);
-        if (!(parent instanceof BranchNode)) {
-            throw new Error('Invalid location');
-        }
-        return parent.getChildCachedVisibleSize(index);
-    }
-    expandView(location) {
-        if (this.hasMaximizedView()) {
-            this.exitMaximizedView();
-        }
-        const [ancestors, node] = this.getNode(location);
-        if (!(node instanceof LeafNode)) {
-            throw new Error('Invalid location');
-        }
-        for (let i = 0; i < ancestors.length; i++) {
-            ancestors[i].resizeChild(location[i], Number.POSITIVE_INFINITY);
-        }
-    }
-    isViewExpanded(location) {
-        if (this.hasMaximizedView()) {
-            return false;
-        }
-        const [ancestors, node] = this.getNode(location);
-        if (!(node instanceof LeafNode)) {
-            throw new Error('Invalid location');
-        }
-        for (let i = 0; i < ancestors.length; i++) {
-            if (!ancestors[i].isChildExpanded(location[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    maximizeView(location) {
-        const [, nodeToMaximize] = this.getNode(location);
-        if (!(nodeToMaximize instanceof LeafNode)) {
-            throw new Error('Location is not a LeafNode');
-        }
-        if (this.maximizedNode === nodeToMaximize) {
-            return;
-        }
-        if (this.hasMaximizedView()) {
-            this.exitMaximizedView();
-        }
-        function hideAllViewsBut(parent, exclude) {
-            for (let i = 0; i < parent.children.length; i++) {
-                const child = parent.children[i];
-                if (child instanceof LeafNode) {
-                    if (child !== exclude) {
-                        parent.setChildVisible(i, false);
-                    }
-                }
-                else {
-                    hideAllViewsBut(child, exclude);
-                }
-            }
-        }
-        hideAllViewsBut(this.root, nodeToMaximize);
-        this.maximizedNode = nodeToMaximize;
-        this._onDidChangeViewMaximized.fire(true);
-    }
-    exitMaximizedView() {
-        if (!this.maximizedNode) {
-            return;
-        }
-        this.maximizedNode = undefined;
-        function showViewsInReverseOrder(parent) {
-            for (let index = parent.children.length - 1; index >= 0; index--) {
-                const child = parent.children[index];
-                if (child instanceof LeafNode) {
-                    parent.setChildVisible(index, true);
-                }
-                else {
-                    showViewsInReverseOrder(child);
-                }
-            }
-        }
-        showViewsInReverseOrder(this.root);
-        this._onDidChangeViewMaximized.fire(false);
-    }
-    hasMaximizedView() {
-        return this.maximizedNode !== undefined;
-    }
-    isViewMaximized(location) {
-        const [, node] = this.getNode(location);
-        if (!(node instanceof LeafNode)) {
-            throw new Error('Location is not a LeafNode');
-        }
-        return node === this.maximizedNode;
-    }
-    distributeViewSizes(location) {
-        if (this.hasMaximizedView()) {
-            this.exitMaximizedView();
-        }
-        if (!location) {
-            this.root.distributeViewSizes(true);
-            return;
-        }
-        const [, node] = this.getNode(location);
-        if (!(node instanceof BranchNode)) {
-            throw new Error('Invalid location');
-        }
-        node.distributeViewSizes();
-        this.trySet2x2();
-    }
-    isViewVisible(location) {
-        const [rest, index] = tail2(location);
-        const [, parent] = this.getNode(rest);
-        if (!(parent instanceof BranchNode)) {
-            throw new Error('Invalid from location');
-        }
-        return parent.isChildVisible(index);
-    }
-    setViewVisible(location, visible) {
-        if (this.hasMaximizedView()) {
-            this.exitMaximizedView();
-            return;
-        }
-        const [rest, index] = tail2(location);
-        const [, parent] = this.getNode(rest);
-        if (!(parent instanceof BranchNode)) {
-            throw new Error('Invalid from location');
-        }
-        parent.setChildVisible(index, visible);
-    }
-    getView(location) {
-        const node = location ? this.getNode(location)[1] : this._root;
-        return this._getViews(node, this.orientation);
-    }
-    static deserialize(json, deserializer, options = {}) {
-        if (typeof json.orientation !== 'number') {
-            throw new Error('Invalid JSON: \'orientation\' property must be a number.');
-        }
-        else if (typeof json.width !== 'number') {
-            throw new Error('Invalid JSON: \'width\' property must be a number.');
-        }
-        else if (typeof json.height !== 'number') {
-            throw new Error('Invalid JSON: \'height\' property must be a number.');
-        }
-        else if (json.root?.type !== 'branch') {
-            throw new Error('Invalid JSON: \'root\' property must have \'type\' value of branch.');
-        }
-        const orientation = json.orientation;
-        const height = json.height;
-        const result = ( new GridView(options));
-        result._deserialize(json.root, orientation, deserializer, height);
-        return result;
-    }
-    _deserialize(root, orientation, deserializer, orthogonalSize) {
-        this.root = this._deserializeNode(root, orientation, deserializer, orthogonalSize);
-    }
-    _deserializeNode(node, orientation, deserializer, orthogonalSize) {
-        let result;
-        if (node.type === 'branch') {
-            const serializedChildren = node.data;
-            const children = ( serializedChildren.map(serializedChild => {
-                return {
-                    node: this._deserializeNode(serializedChild, orthogonal(orientation), deserializer, node.size),
-                    visible: serializedChild.visible
-                };
-            }));
-            result = ( new BranchNode(
-                orientation,
-                this.layoutController,
-                this.styles,
-                this.proportionalLayout,
-                node.size,
-                orthogonalSize,
-                undefined,
-                children
-            ));
-        }
-        else {
-            result = ( new LeafNode(
-                deserializer.fromJSON(node.data),
-                orientation,
-                this.layoutController,
-                orthogonalSize,
-                node.size
-            ));
-            if (node.maximized && !this.maximizedNode) {
-                this.maximizedNode = result;
-                this._onDidChangeViewMaximized.fire(true);
-            }
-        }
-        return result;
-    }
-    _getViews(node, orientation, cachedVisibleSize) {
-        const box = { top: node.top, left: node.left, width: node.width, height: node.height };
-        if (node instanceof LeafNode) {
-            return { view: node.view, box, cachedVisibleSize, maximized: this.maximizedNode === node };
-        }
-        const children = [];
-        for (let i = 0; i < node.children.length; i++) {
-            const child = node.children[i];
-            const cachedVisibleSize = node.getChildCachedVisibleSize(i);
-            children.push(this._getViews(child, orthogonal(orientation), cachedVisibleSize));
-        }
-        return { children, box };
-    }
-    getNode(location, node = this.root, path = []) {
-        if (location.length === 0) {
-            return [path, node];
-        }
-        if (!(node instanceof BranchNode)) {
-            throw new Error('Invalid location');
-        }
-        const [index, ...rest] = location;
-        if (index < 0 || index >= node.children.length) {
-            throw new Error('Invalid location');
-        }
-        const child = node.children[index];
-        path.push(node);
-        return this.getNode(rest, child, path);
-    }
-    trySet2x2() {
-        this.disposable2x2.dispose();
-        this.disposable2x2 = Disposable.None;
-        if (this.root.children.length !== 2) {
-            return;
-        }
-        const [first, second] = this.root.children;
-        if (!(first instanceof BranchNode) || !(second instanceof BranchNode)) {
-            return;
-        }
-        this.disposable2x2 = first.trySet2x2(second);
-    }
-    getViewMap(map, node) {
-        if (!node) {
-            node = this.root;
-        }
-        if (node instanceof BranchNode) {
-            node.children.forEach(child => this.getViewMap(map, child));
-        }
-        else {
-            map.set(node.view, node.element);
-        }
-    }
-    dispose() {
-        this.onDidSashResetRelay.dispose();
-        this.root.dispose();
-        this.element.parentElement?.removeChild(this.element);
-    }
-}
-export { GridView, Sizing, orthogonal };