@umbraco-cms/backoffice 16.1.1 → 16.2.0-rc

package/dist-cms/monaco-editor/vs/base/browser/ui/tree/media/tree.css

@@ -1,174 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-.monaco-tl-row {
-	display: flex;
-	height: 100%;
-	align-items: center;
-	position: relative;
-}
-
-.monaco-tl-row.disabled {
-	cursor: default;
-}
-.monaco-tl-indent {
-	height: 100%;
-	position: absolute;
-	top: 0;
-	left: 16px;
-	pointer-events: none;
-}
-
-.hide-arrows .monaco-tl-indent {
-	left: 12px;
-}
-
-.monaco-tl-indent > .indent-guide {
-	display: inline-block;
-	box-sizing: border-box;
-	height: 100%;
-	border-left: 1px solid transparent;
-}
-
-.monaco-workbench:not(.reduce-motion) .monaco-tl-indent > .indent-guide {
-	transition: border-color 0.1s linear;
-}
-
-.monaco-tl-twistie,
-.monaco-tl-contents {
-	height: 100%;
-}
-
-.monaco-tl-twistie {
-	font-size: 10px;
-	text-align: right;
-	padding-right: 6px;
-	flex-shrink: 0;
-	width: 16px;
-	display: flex !important;
-	align-items: center;
-	justify-content: center;
-	transform: translateX(3px);
-}
-
-.monaco-tl-contents {
-	flex: 1;
-	overflow: hidden;
-}
-
-.monaco-tl-twistie::before {
-	border-radius: 20px;
-}
-
-.monaco-tl-twistie.collapsed::before {
-	transform: rotate(-90deg);
-}
-
-.monaco-tl-twistie.codicon-tree-item-loading::before {
-	/* Use steps to throttle FPS to reduce CPU usage */
-	animation: codicon-spin 1.25s steps(30) infinite;
-}
-
-.monaco-tree-type-filter {
-	position: absolute;
-	top: 0;
-	display: flex;
-	padding: 3px;
-	max-width: 200px;
-	z-index: 100;
-	margin: 0 6px;
-	border: 1px solid var(--vscode-widget-border);
-	border-bottom-left-radius: 4px;
-	border-bottom-right-radius: 4px;
-}
-
-.monaco-workbench:not(.reduce-motion) .monaco-tree-type-filter {
-	transition: top 0.3s;
-}
-
-.monaco-tree-type-filter.disabled {
-	top: -40px !important;
-}
-
-.monaco-tree-type-filter-grab {
-	display: flex !important;
-	align-items: center;
-	justify-content: center;
-	cursor: grab;
-	margin-right: 2px;
-}
-
-.monaco-tree-type-filter-grab.grabbing {
-	cursor: grabbing;
-}
-
-.monaco-tree-type-filter-input {
-	flex: 1;
-}
-
-.monaco-tree-type-filter-input .monaco-inputbox {
-	height: 23px;
-}
-
-.monaco-tree-type-filter-input .monaco-inputbox > .ibwrapper > .input,
-.monaco-tree-type-filter-input .monaco-inputbox > .ibwrapper > .mirror {
-	padding: 2px 4px;
-}
-
-.monaco-tree-type-filter-input .monaco-findInput > .controls {
-	top: 2px;
-}
-
-.monaco-tree-type-filter-actionbar {
-	margin-left: 4px;
-}
-
-.monaco-tree-type-filter-actionbar .monaco-action-bar .action-label {
-	padding: 2px;
-}
-
-.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container{
-	position: absolute;
-	top: 0;
-	left: 0;
-	width: 100%;
-	height: 0;
-	z-index: 13; /* Settings editor uses z-index: 12 */
-
-	/* Backup color in case the tree does not provide the background color */
-	background-color: var(--vscode-sideBar-background);
-}
-
-.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-row.monaco-list-row{
-	position: absolute;
-	width: 100%;
-	opacity: 1 !important; /* Settings editor uses opacity < 1 */
-	overflow: hidden;
-
-	/* Backup color in case the tree does not provide the background color */
-	background-color: var(--vscode-sideBar-background);
-}
-
-.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-row:hover{
-	background-color: var(--vscode-list-hoverBackground) !important;
-	cursor: pointer;
-}
-
-.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container.empty,
-.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container.empty .monaco-tree-sticky-container-shadow {
-	display: none;
-}
-
-.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-container-shadow {
-	position: absolute;
-	bottom: -3px;
-	left: 0px;
-	height: 0px; /* heigt is 3px and only set when there is a treeStickyScrollShadow color */
-	width: 100%;
-}
-
-.monaco-list .monaco-scrollable-element .monaco-tree-sticky-container[tabindex="0"]:focus{
-	outline: none;
-}

package/dist-cms/monaco-editor/vs/base/browser/ui/tree/objectTree.js

@@ -1,201 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { AbstractTree } from './abstractTree.js';
-import { CompressibleObjectTreeModel } from './compressedObjectTreeModel.js';
-import { ObjectTreeModel } from './objectTreeModel.js';
-import { memoize } from '../../../common/decorators.js';
-import { Iterable } from '../../../common/iterator.js';
-export class ObjectTree extends AbstractTree {
-    get onDidChangeCollapseState() { return this.model.onDidChangeCollapseState; }
-    constructor(user, container, delegate, renderers, options = {}) {
-        super(user, container, delegate, renderers, options);
-        this.user = user;
-    }
-    setChildren(element, children = Iterable.empty(), options) {
-        this.model.setChildren(element, children, options);
-    }
-    rerender(element) {
-        if (element === undefined) {
-            this.view.rerender();
-            return;
-        }
-        this.model.rerender(element);
-    }
-    hasElement(element) {
-        return this.model.has(element);
-    }
-    createModel(user, view, options) {
-        return new ObjectTreeModel(user, view, options);
-    }
-}
-class CompressibleRenderer {
-    get compressedTreeNodeProvider() {
-        return this._compressedTreeNodeProvider();
-    }
-    constructor(_compressedTreeNodeProvider, stickyScrollDelegate, renderer) {
-        this._compressedTreeNodeProvider = _compressedTreeNodeProvider;
-        this.stickyScrollDelegate = stickyScrollDelegate;
-        this.renderer = renderer;
-        this.templateId = renderer.templateId;
-        if (renderer.onDidChangeTwistieState) {
-            this.onDidChangeTwistieState = renderer.onDidChangeTwistieState;
-        }
-    }
-    renderTemplate(container) {
-        const data = this.renderer.renderTemplate(container);
-        return { compressedTreeNode: undefined, data };
-    }
-    renderElement(node, index, templateData, height) {
-        let compressedTreeNode = this.stickyScrollDelegate.getCompressedNode(node);
-        if (!compressedTreeNode) {
-            compressedTreeNode = this.compressedTreeNodeProvider.getCompressedTreeNode(node.element);
-        }
-        if (compressedTreeNode.element.elements.length === 1) {
-            templateData.compressedTreeNode = undefined;
-            this.renderer.renderElement(node, index, templateData.data, height);
-        }
-        else {
-            templateData.compressedTreeNode = compressedTreeNode;
-            this.renderer.renderCompressedElements(compressedTreeNode, index, templateData.data, height);
-        }
-    }
-    disposeElement(node, index, templateData, height) {
-        if (templateData.compressedTreeNode) {
-            this.renderer.disposeCompressedElements?.(templateData.compressedTreeNode, index, templateData.data, height);
-        }
-        else {
-            this.renderer.disposeElement?.(node, index, templateData.data, height);
-        }
-    }
-    disposeTemplate(templateData) {
-        this.renderer.disposeTemplate(templateData.data);
-    }
-    renderTwistie(element, twistieElement) {
-        if (this.renderer.renderTwistie) {
-            return this.renderer.renderTwistie(element, twistieElement);
-        }
-        return false;
-    }
-}
-__decorate([
-    memoize
-], CompressibleRenderer.prototype, "compressedTreeNodeProvider", null);
-class CompressibleStickyScrollDelegate {
-    constructor(modelProvider) {
-        this.modelProvider = modelProvider;
-        this.compressedStickyNodes = new Map();
-    }
-    getCompressedNode(node) {
-        return this.compressedStickyNodes.get(node);
-    }
-    constrainStickyScrollNodes(stickyNodes, stickyScrollMaxItemCount, maxWidgetHeight) {
-        this.compressedStickyNodes.clear();
-        if (stickyNodes.length === 0) {
-            return [];
-        }
-        for (let i = 0; i < stickyNodes.length; i++) {
-            const stickyNode = stickyNodes[i];
-            const stickyNodeBottom = stickyNode.position + stickyNode.height;
-            const followingReachesMaxHeight = i + 1 < stickyNodes.length && stickyNodeBottom + stickyNodes[i + 1].height > maxWidgetHeight;
-            if (followingReachesMaxHeight || i >= stickyScrollMaxItemCount - 1 && stickyScrollMaxItemCount < stickyNodes.length) {
-                const uncompressedStickyNodes = stickyNodes.slice(0, i);
-                const overflowingStickyNodes = stickyNodes.slice(i);
-                const compressedStickyNode = this.compressStickyNodes(overflowingStickyNodes);
-                return [...uncompressedStickyNodes, compressedStickyNode];
-            }
-        }
-        return stickyNodes;
-    }
-    compressStickyNodes(stickyNodes) {
-        if (stickyNodes.length === 0) {
-            throw new Error('Can\'t compress empty sticky nodes');
-        }
-        const compressionModel = this.modelProvider();
-        if (!compressionModel.isCompressionEnabled()) {
-            return stickyNodes[0];
-        }
-        // Collect all elements to be compressed
-        const elements = [];
-        for (let i = 0; i < stickyNodes.length; i++) {
-            const stickyNode = stickyNodes[i];
-            const compressedNode = compressionModel.getCompressedTreeNode(stickyNode.node.element);
-            if (compressedNode.element) {
-                // if an element is incompressible, it can't be compressed with it's parent element
-                if (i !== 0 && compressedNode.element.incompressible) {
-                    break;
-                }
-                elements.push(...compressedNode.element.elements);
-            }
-        }
-        if (elements.length < 2) {
-            return stickyNodes[0];
-        }
-        // Compress the elements
-        const lastStickyNode = stickyNodes[stickyNodes.length - 1];
-        const compressedElement = { elements, incompressible: false };
-        const compressedNode = { ...lastStickyNode.node, children: [], element: compressedElement };
-        const stickyTreeNode = new Proxy(stickyNodes[0].node, {});
-        const compressedStickyNode = {
-            node: stickyTreeNode,
-            startIndex: stickyNodes[0].startIndex,
-            endIndex: lastStickyNode.endIndex,
-            position: stickyNodes[0].position,
-            height: stickyNodes[0].height,
-        };
-        this.compressedStickyNodes.set(stickyTreeNode, compressedNode);
-        return compressedStickyNode;
-    }
-}
-function asObjectTreeOptions(compressedTreeNodeProvider, options) {
-    return options && {
-        ...options,
-        keyboardNavigationLabelProvider: options.keyboardNavigationLabelProvider && {
-            getKeyboardNavigationLabel(e) {
-                let compressedTreeNode;
-                try {
-                    compressedTreeNode = compressedTreeNodeProvider().getCompressedTreeNode(e);
-                }
-                catch {
-                    return options.keyboardNavigationLabelProvider.getKeyboardNavigationLabel(e);
-                }
-                if (compressedTreeNode.element.elements.length === 1) {
-                    return options.keyboardNavigationLabelProvider.getKeyboardNavigationLabel(e);
-                }
-                else {
-                    return options.keyboardNavigationLabelProvider.getCompressedNodeKeyboardNavigationLabel(compressedTreeNode.element.elements);
-                }
-            }
-        }
-    };
-}
-export class CompressibleObjectTree extends ObjectTree {
-    constructor(user, container, delegate, renderers, options = {}) {
-        const compressedTreeNodeProvider = () => this;
-        const stickyScrollDelegate = new CompressibleStickyScrollDelegate(() => this.model);
-        const compressibleRenderers = renderers.map(r => new CompressibleRenderer(compressedTreeNodeProvider, stickyScrollDelegate, r));
-        super(user, container, delegate, compressibleRenderers, { ...asObjectTreeOptions(compressedTreeNodeProvider, options), stickyScrollDelegate });
-    }
-    setChildren(element, children = Iterable.empty(), options) {
-        this.model.setChildren(element, children, options);
-    }
-    createModel(user, view, options) {
-        return new CompressibleObjectTreeModel(user, view, options);
-    }
-    updateOptions(optionsUpdate = {}) {
-        super.updateOptions(optionsUpdate);
-        if (typeof optionsUpdate.compressionEnabled !== 'undefined') {
-            this.model.setCompressionEnabled(optionsUpdate.compressionEnabled);
-        }
-    }
-    getCompressedTreeNode(element = null) {
-        return this.model.getCompressedTreeNode(element);
-    }
-}

package/dist-cms/monaco-editor/vs/base/browser/ui/tree/objectTreeModel.js

@@ -1,196 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { IndexTreeModel } from './indexTreeModel.js';
-import { ObjectTreeElementCollapseState, TreeError } from './tree.js';
-import { Iterable } from '../../../common/iterator.js';
-export class ObjectTreeModel {
-    constructor(user, list, options = {}) {
-        this.user = user;
-        this.rootRef = null;
-        this.nodes = new Map();
-        this.nodesByIdentity = new Map();
-        this.model = new IndexTreeModel(user, list, null, options);
-        this.onDidSplice = this.model.onDidSplice;
-        this.onDidChangeCollapseState = this.model.onDidChangeCollapseState;
-        this.onDidChangeRenderNodeCount = this.model.onDidChangeRenderNodeCount;
-        if (options.sorter) {
-            this.sorter = {
-                compare(a, b) {
-                    return options.sorter.compare(a.element, b.element);
-                }
-            };
-        }
-        this.identityProvider = options.identityProvider;
-    }
-    setChildren(element, children = Iterable.empty(), options = {}) {
-        const location = this.getElementLocation(element);
-        this._setChildren(location, this.preserveCollapseState(children), options);
-    }
-    _setChildren(location, children = Iterable.empty(), options) {
-        const insertedElements = new Set();
-        const insertedElementIds = new Set();
-        const onDidCreateNode = (node) => {
-            if (node.element === null) {
-                return;
-            }
-            const tnode = node;
-            insertedElements.add(tnode.element);
-            this.nodes.set(tnode.element, tnode);
-            if (this.identityProvider) {
-                const id = this.identityProvider.getId(tnode.element).toString();
-                insertedElementIds.add(id);
-                this.nodesByIdentity.set(id, tnode);
-            }
-            options.onDidCreateNode?.(tnode);
-        };
-        const onDidDeleteNode = (node) => {
-            if (node.element === null) {
-                return;
-            }
-            const tnode = node;
-            if (!insertedElements.has(tnode.element)) {
-                this.nodes.delete(tnode.element);
-            }
-            if (this.identityProvider) {
-                const id = this.identityProvider.getId(tnode.element).toString();
-                if (!insertedElementIds.has(id)) {
-                    this.nodesByIdentity.delete(id);
-                }
-            }
-            options.onDidDeleteNode?.(tnode);
-        };
-        this.model.splice([...location, 0], Number.MAX_VALUE, children, { ...options, onDidCreateNode, onDidDeleteNode });
-    }
-    preserveCollapseState(elements = Iterable.empty()) {
-        if (this.sorter) {
-            elements = [...elements].sort(this.sorter.compare.bind(this.sorter));
-        }
-        return Iterable.map(elements, treeElement => {
-            let node = this.nodes.get(treeElement.element);
-            if (!node && this.identityProvider) {
-                const id = this.identityProvider.getId(treeElement.element).toString();
-                node = this.nodesByIdentity.get(id);
-            }
-            if (!node) {
-                let collapsed;
-                if (typeof treeElement.collapsed === 'undefined') {
-                    collapsed = undefined;
-                }
-                else if (treeElement.collapsed === ObjectTreeElementCollapseState.Collapsed || treeElement.collapsed === ObjectTreeElementCollapseState.PreserveOrCollapsed) {
-                    collapsed = true;
-                }
-                else if (treeElement.collapsed === ObjectTreeElementCollapseState.Expanded || treeElement.collapsed === ObjectTreeElementCollapseState.PreserveOrExpanded) {
-                    collapsed = false;
-                }
-                else {
-                    collapsed = Boolean(treeElement.collapsed);
-                }
-                return {
-                    ...treeElement,
-                    children: this.preserveCollapseState(treeElement.children),
-                    collapsed
-                };
-            }
-            const collapsible = typeof treeElement.collapsible === 'boolean' ? treeElement.collapsible : node.collapsible;
-            let collapsed;
-            if (typeof treeElement.collapsed === 'undefined' || treeElement.collapsed === ObjectTreeElementCollapseState.PreserveOrCollapsed || treeElement.collapsed === ObjectTreeElementCollapseState.PreserveOrExpanded) {
-                collapsed = node.collapsed;
-            }
-            else if (treeElement.collapsed === ObjectTreeElementCollapseState.Collapsed) {
-                collapsed = true;
-            }
-            else if (treeElement.collapsed === ObjectTreeElementCollapseState.Expanded) {
-                collapsed = false;
-            }
-            else {
-                collapsed = Boolean(treeElement.collapsed);
-            }
-            return {
-                ...treeElement,
-                collapsible,
-                collapsed,
-                children: this.preserveCollapseState(treeElement.children)
-            };
-        });
-    }
-    rerender(element) {
-        const location = this.getElementLocation(element);
-        this.model.rerender(location);
-    }
-    getFirstElementChild(ref = null) {
-        const location = this.getElementLocation(ref);
-        return this.model.getFirstElementChild(location);
-    }
-    has(element) {
-        return this.nodes.has(element);
-    }
-    getListIndex(element) {
-        const location = this.getElementLocation(element);
-        return this.model.getListIndex(location);
-    }
-    getListRenderCount(element) {
-        const location = this.getElementLocation(element);
-        return this.model.getListRenderCount(location);
-    }
-    isCollapsible(element) {
-        const location = this.getElementLocation(element);
-        return this.model.isCollapsible(location);
-    }
-    setCollapsible(element, collapsible) {
-        const location = this.getElementLocation(element);
-        return this.model.setCollapsible(location, collapsible);
-    }
-    isCollapsed(element) {
-        const location = this.getElementLocation(element);
-        return this.model.isCollapsed(location);
-    }
-    setCollapsed(element, collapsed, recursive) {
-        const location = this.getElementLocation(element);
-        return this.model.setCollapsed(location, collapsed, recursive);
-    }
-    expandTo(element) {
-        const location = this.getElementLocation(element);
-        this.model.expandTo(location);
-    }
-    refilter() {
-        this.model.refilter();
-    }
-    getNode(element = null) {
-        if (element === null) {
-            return this.model.getNode(this.model.rootRef);
-        }
-        const node = this.nodes.get(element);
-        if (!node) {
-            throw new TreeError(this.user, `Tree element not found: ${element}`);
-        }
-        return node;
-    }
-    getNodeLocation(node) {
-        return node.element;
-    }
-    getParentNodeLocation(element) {
-        if (element === null) {
-            throw new TreeError(this.user, `Invalid getParentNodeLocation call`);
-        }
-        const node = this.nodes.get(element);
-        if (!node) {
-            throw new TreeError(this.user, `Tree element not found: ${element}`);
-        }
-        const location = this.model.getNodeLocation(node);
-        const parentLocation = this.model.getParentNodeLocation(location);
-        const parent = this.model.getNode(parentLocation);
-        return parent.element;
-    }
-    getElementLocation(element) {
-        if (element === null) {
-            return [];
-        }
-        const node = this.nodes.get(element);
-        if (!node) {
-            throw new TreeError(this.user, `Tree element not found: ${element}`);
-        }
-        return this.model.getNodeLocation(node);
-    }
-}

package/dist-cms/monaco-editor/vs/base/browser/ui/tree/tree.js

@@ -1,43 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-export var ObjectTreeElementCollapseState;
-(function (ObjectTreeElementCollapseState) {
-    ObjectTreeElementCollapseState[ObjectTreeElementCollapseState["Expanded"] = 0] = "Expanded";
-    ObjectTreeElementCollapseState[ObjectTreeElementCollapseState["Collapsed"] = 1] = "Collapsed";
-    /**
-     * If the element is already in the tree, preserve its current state. Else, expand it.
-     */
-    ObjectTreeElementCollapseState[ObjectTreeElementCollapseState["PreserveOrExpanded"] = 2] = "PreserveOrExpanded";
-    /**
-     * If the element is already in the tree, preserve its current state. Else, collapse it.
-     */
-    ObjectTreeElementCollapseState[ObjectTreeElementCollapseState["PreserveOrCollapsed"] = 3] = "PreserveOrCollapsed";
-})(ObjectTreeElementCollapseState || (ObjectTreeElementCollapseState = {}));
-export var TreeMouseEventTarget;
-(function (TreeMouseEventTarget) {
-    TreeMouseEventTarget[TreeMouseEventTarget["Unknown"] = 0] = "Unknown";
-    TreeMouseEventTarget[TreeMouseEventTarget["Twistie"] = 1] = "Twistie";
-    TreeMouseEventTarget[TreeMouseEventTarget["Element"] = 2] = "Element";
-    TreeMouseEventTarget[TreeMouseEventTarget["Filter"] = 3] = "Filter";
-})(TreeMouseEventTarget || (TreeMouseEventTarget = {}));
-export class TreeError extends Error {
-    constructor(user, message) {
-        super(`TreeError [${user}] ${message}`);
-    }
-}
-export class WeakMapper {
-    constructor(fn) {
-        this.fn = fn;
-        this._map = new WeakMap();
-    }
-    map(key) {
-        let result = this._map.get(key);
-        if (!result) {
-            result = this.fn(key);
-            this._map.set(key, result);
-        }
-        return result;
-    }
-}

package/dist-cms/monaco-editor/vs/base/browser/ui/widget.js

@@ -1,41 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import * as dom from '../dom.js';
-import { StandardKeyboardEvent } from '../keyboardEvent.js';
-import { StandardMouseEvent } from '../mouseEvent.js';
-import { Gesture } from '../touch.js';
-import { Disposable } from '../../common/lifecycle.js';
-export class Widget extends Disposable {
-    onclick(domNode, listener) {
-        this._register(dom.addDisposableListener(domNode, dom.EventType.CLICK, (e) => listener(new StandardMouseEvent(dom.getWindow(domNode), e))));
-    }
-    onmousedown(domNode, listener) {
-        this._register(dom.addDisposableListener(domNode, dom.EventType.MOUSE_DOWN, (e) => listener(new StandardMouseEvent(dom.getWindow(domNode), e))));
-    }
-    onmouseover(domNode, listener) {
-        this._register(dom.addDisposableListener(domNode, dom.EventType.MOUSE_OVER, (e) => listener(new StandardMouseEvent(dom.getWindow(domNode), e))));
-    }
-    onmouseleave(domNode, listener) {
-        this._register(dom.addDisposableListener(domNode, dom.EventType.MOUSE_LEAVE, (e) => listener(new StandardMouseEvent(dom.getWindow(domNode), e))));
-    }
-    onkeydown(domNode, listener) {
-        this._register(dom.addDisposableListener(domNode, dom.EventType.KEY_DOWN, (e) => listener(new StandardKeyboardEvent(e))));
-    }
-    onkeyup(domNode, listener) {
-        this._register(dom.addDisposableListener(domNode, dom.EventType.KEY_UP, (e) => listener(new StandardKeyboardEvent(e))));
-    }
-    oninput(domNode, listener) {
-        this._register(dom.addDisposableListener(domNode, dom.EventType.INPUT, listener));
-    }
-    onblur(domNode, listener) {
-        this._register(dom.addDisposableListener(domNode, dom.EventType.BLUR, listener));
-    }
-    onfocus(domNode, listener) {
-        this._register(dom.addDisposableListener(domNode, dom.EventType.FOCUS, listener));
-    }
-    ignoreGesture(domNode) {
-        return Gesture.ignoreTarget(domNode);
-    }
-}

package/dist-cms/monaco-editor/vs/base/browser/window.js

@@ -1,14 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-export function ensureCodeWindow(targetWindow, fallbackWindowId) {
-    const codeWindow = targetWindow;
-    if (typeof codeWindow.vscodeWindowId !== 'number') {
-        Object.defineProperty(codeWindow, 'vscodeWindowId', {
-            get: () => fallbackWindowId
-        });
-    }
-}
-// eslint-disable-next-line no-restricted-globals
-export const mainWindow = window;