@codingame/monaco-vscode-api 8.0.3 → 9.0.0

package/vscode/src/vs/base/common/worker/simpleWorker.js

@@ -1,9 +1,10 @@
-import { transformErrorForSerialization } from '../errors.js';
+import { CharCode } from '../charCode.js';
+import { onUnexpectedError, transformErrorForSerialization } from '../errors.js';
 import { Emitter } from '../event.js';
 import { Disposable } from '../lifecycle.js';
-import { getAllMethodNames } from '../objects.js';
 import { isWeb } from '../platform.js';
 import { isUpperAsciiLetter } from '../strings.js';
+const DEFAULT_CHANNEL = 'default';
 const INITIALIZE = '$initialize';
 let webWorkerWarningLogged = false;
 function logOnceWebWorkerWarning(err) {
@@ -25,9 +26,10 @@ var MessageType;
     MessageType[MessageType["UnsubscribeEvent"] = 4] = "UnsubscribeEvent";
 })(MessageType || (MessageType = {})));
 class RequestMessage {
-    constructor(vsWorker, req, method, args) {
+    constructor(vsWorker, req, channel, method, args) {
         this.vsWorker = vsWorker;
         this.req = req;
+        this.channel = channel;
         this.method = method;
         this.args = args;
         this.type = MessageType.Request;
@@ -43,9 +45,10 @@ class ReplyMessage {
     }
 }
 class SubscribeEventMessage {
-    constructor(vsWorker, req, eventName, arg) {
+    constructor(vsWorker, req, channel, eventName, arg) {
         this.vsWorker = vsWorker;
         this.req = req;
+        this.channel = channel;
         this.eventName = eventName;
         this.arg = arg;
         this.type = MessageType.SubscribeEvent;
@@ -78,23 +81,23 @@ class SimpleWorkerProtocol {
     setWorkerId(workerId) {
         this._workerId = workerId;
     }
-    sendMessage(method, args) {
+    sendMessage(channel, method, args) {
         const req = String(++this._lastSentReq);
         return ( new Promise((resolve, reject) => {
             this._pendingReplies[req] = {
                 resolve: resolve,
                 reject: reject
             };
-            this._send(( new RequestMessage(this._workerId, req, method, args)));
+            this._send(( new RequestMessage(this._workerId, req, channel, method, args)));
         }));
     }
-    listen(eventName, arg) {
+    listen(channel, eventName, arg) {
         let req = null;
         const emitter = ( new Emitter({
             onWillAddFirstListener: () => {
                 req = String(++this._lastSentReq);
                 this._pendingEmitters.set(req, emitter);
-                this._send(( new SubscribeEventMessage(this._workerId, req, eventName, arg)));
+                this._send(( new SubscribeEventMessage(this._workerId, req, channel, eventName, arg)));
             },
             onDidRemoveLastListener: () => {
                 this._pendingEmitters.delete(req);
@@ -113,6 +116,30 @@ class SimpleWorkerProtocol {
         }
         this._handleMessage(message);
     }
+    createProxyToRemoteChannel(channel, sendMessageBarrier) {
+        const handler = {
+            get: (target, name) => {
+                if (typeof name === 'string' && !target[name]) {
+                    if (propertyIsDynamicEvent(name)) {
+                        target[name] = (arg) => {
+                            return this.listen(channel, name, arg);
+                        };
+                    }
+                    else if (propertyIsEvent(name)) {
+                        target[name] = this.listen(channel, name, undefined);
+                    }
+                    else if (name.charCodeAt(0) === CharCode.DollarSign) {
+                        target[name] = async (...myArgs) => {
+                            await sendMessageBarrier?.();
+                            return this.sendMessage(channel, name, myArgs);
+                        };
+                    }
+                }
+                return target[name];
+            }
+        };
+        return ( new Proxy(Object.create(null), handler));
+    }
     _handleMessage(msg) {
         switch (msg.type) {
             case MessageType.Reply:
@@ -149,7 +176,7 @@ class SimpleWorkerProtocol {
     }
     _handleRequestMessage(requestMessage) {
         const req = requestMessage.req;
-        const result = this._handler.handleMessage(requestMessage.method, requestMessage.args);
+        const result = this._handler.handleMessage(requestMessage.channel, requestMessage.method, requestMessage.args);
         result.then((r) => {
             this._send(( new ReplyMessage(this._workerId, req, r, undefined)));
         }, (e) => {
@@ -161,7 +188,7 @@ class SimpleWorkerProtocol {
     }
     _handleSubscribeEventMessage(msg) {
         const req = msg.req;
-        const disposable = this._handler.handleEvent(msg.eventName, msg.arg)((event) => {
+        const disposable = this._handler.handleEvent(msg.channel, msg.eventName, msg.arg)((event) => {
             this._send(( new EventMessage(this._workerId, req, event)));
         });
         this._pendingEvents.set(req, disposable);
@@ -199,45 +226,28 @@ class SimpleWorkerProtocol {
     }
 }
 class SimpleWorkerClient extends Disposable {
-    constructor(workerFactory, moduleId, host) {
+    constructor(workerFactory, workerDescriptor) {
         super();
-        let lazyProxyReject = null;
-        this._worker = this._register(workerFactory.create('vs/base/common/worker/simpleWorker', (msg) => {
+        this._localChannels = ( new Map());
+        this._remoteChannels = ( new Map());
+        this._worker = this._register(workerFactory.create({
+            amdModuleId: 'vs/base/common/worker/simpleWorker',
+            esmModuleLocation: workerDescriptor.esmModuleLocation,
+            label: workerDescriptor.label
+        }, (msg) => {
             this._protocol.handleMessage(msg);
         }, (err) => {
-            lazyProxyReject?.(err);
+            onUnexpectedError(err);
         }));
         this._protocol = ( new SimpleWorkerProtocol({
             sendMessage: (msg, transfer) => {
                 this._worker.postMessage(msg, transfer);
             },
-            handleMessage: (method, args) => {
-                if (typeof host[method] !== 'function') {
-                    return Promise.reject(( new Error('Missing method ' + method + ' on main thread host.')));
-                }
-                try {
-                    return Promise.resolve(host[method].apply(host, args));
-                }
-                catch (e) {
-                    return Promise.reject(e);
-                }
+            handleMessage: (channel, method, args) => {
+                return this._handleMessage(channel, method, args);
             },
-            handleEvent: (eventName, arg) => {
-                if (propertyIsDynamicEvent(eventName)) {
-                    const event = host[eventName].call(host, arg);
-                    if (typeof event !== 'function') {
-                        throw ( new Error(`Missing dynamic event ${eventName} on main thread host.`));
-                    }
-                    return event;
-                }
-                if (propertyIsEvent(eventName)) {
-                    const event = host[eventName];
-                    if (typeof event !== 'function') {
-                        throw ( new Error(`Missing event ${eventName} on main thread host.`));
-                    }
-                    return event;
-                }
-                throw ( new Error(`Malformed event name ${eventName}`));
+            handleEvent: (channel, eventName, arg) => {
+                return this._handleEvent(channel, eventName, arg);
             }
         }));
         this._protocol.setWorkerId(this._worker.getId());
@@ -245,38 +255,63 @@ class SimpleWorkerClient extends Disposable {
         if (typeof globalThis.requirejs !== 'undefined') {
             loaderConfiguration = globalThis.requirejs.s.contexts._.config;
         }
-        const hostMethods = getAllMethodNames(host);
-        this._onModuleLoaded = this._protocol.sendMessage(INITIALIZE, [
+        this._onModuleLoaded = this._protocol.sendMessage(DEFAULT_CHANNEL, INITIALIZE, [
             this._worker.getId(),
             JSON.parse(JSON.stringify(loaderConfiguration)),
-            moduleId,
-            hostMethods,
+            workerDescriptor.amdModuleId,
         ]);
-        const proxyMethodRequest = (method, args) => {
-            return this._request(method, args);
-        };
-        const proxyListen = (eventName, arg) => {
-            return this._protocol.listen(eventName, arg);
-        };
-        this._lazyProxy = ( new Promise((resolve, reject) => {
-            lazyProxyReject = reject;
-            this._onModuleLoaded.then((availableMethods) => {
-                resolve(createProxyObject(availableMethods, proxyMethodRequest, proxyListen));
-            }, (e) => {
-                reject(e);
-                this._onError('Worker failed to load ' + moduleId, e);
-            });
-        }));
+        this.proxy = this._protocol.createProxyToRemoteChannel(DEFAULT_CHANNEL, async () => { await this._onModuleLoaded; });
+        this._onModuleLoaded.catch((e) => {
+            this._onError('Worker failed to load ' + workerDescriptor.amdModuleId, e);
+        });
     }
-    getProxyObject() {
-        return this._lazyProxy;
+    _handleMessage(channelName, method, args) {
+        const channel = this._localChannels.get(channelName);
+        if (!channel) {
+            return Promise.reject(( new Error(`Missing channel ${channelName} on main thread`)));
+        }
+        if (typeof channel[method] !== 'function') {
+            return Promise.reject(( new Error(`Missing method ${method} on main thread channel ${channelName}`)));
+        }
+        try {
+            return Promise.resolve(channel[method].apply(channel, args));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
     }
-    _request(method, args) {
-        return ( new Promise((resolve, reject) => {
-            this._onModuleLoaded.then(() => {
-                this._protocol.sendMessage(method, args).then(resolve, reject);
-            }, reject);
-        }));
+    _handleEvent(channelName, eventName, arg) {
+        const channel = this._localChannels.get(channelName);
+        if (!channel) {
+            throw ( new Error(`Missing channel ${channelName} on main thread`));
+        }
+        if (propertyIsDynamicEvent(eventName)) {
+            const event = channel[eventName].call(channel, arg);
+            if (typeof event !== 'function') {
+                throw ( new Error(
+                    `Missing dynamic event ${eventName} on main thread channel ${channelName}.`
+                ));
+            }
+            return event;
+        }
+        if (propertyIsEvent(eventName)) {
+            const event = channel[eventName];
+            if (typeof event !== 'function') {
+                throw ( new Error(`Missing event ${eventName} on main thread channel ${channelName}.`));
+            }
+            return event;
+        }
+        throw ( new Error(`Malformed event name ${eventName}`));
+    }
+    setChannel(channel, handler) {
+        this._localChannels.set(channel, handler);
+    }
+    getChannel(channel) {
+        if (!( this._remoteChannels.has(channel))) {
+            const inst = this._protocol.createProxyToRemoteChannel(channel, async () => { await this._onModuleLoaded; });
+            this._remoteChannels.set(channel, inst);
+        }
+        return this._remoteChannels.get(channel);
     }
     _onError(message, error) {
         console.error(message);
@@ -289,74 +324,55 @@ function propertyIsEvent(name) {
 function propertyIsDynamicEvent(name) {
     return /^onDynamic/.test(name) && isUpperAsciiLetter(name.charCodeAt(9));
 }
-function createProxyObject(methodNames, invoke, proxyListen) {
-    const createProxyMethod = (method) => {
-        return function () {
-            const args = Array.prototype.slice.call(arguments, 0);
-            return invoke(method, args);
-        };
-    };
-    const createProxyDynamicEvent = (eventName) => {
-        return function (arg) {
-            return proxyListen(eventName, arg);
-        };
-    };
-    const result = {};
-    for (const methodName of methodNames) {
-        if (propertyIsDynamicEvent(methodName)) {
-            result[methodName] = createProxyDynamicEvent(methodName);
-            continue;
-        }
-        if (propertyIsEvent(methodName)) {
-            result[methodName] = proxyListen(methodName, undefined);
-            continue;
-        }
-        result[methodName] = createProxyMethod(methodName);
-    }
-    return result;
-}
 class SimpleWorkerServer {
     constructor(postMessage, requestHandlerFactory) {
+        this._localChannels = ( new Map());
+        this._remoteChannels = ( new Map());
         this._requestHandlerFactory = requestHandlerFactory;
         this._requestHandler = null;
         this._protocol = ( new SimpleWorkerProtocol({
             sendMessage: (msg, transfer) => {
                 postMessage(msg, transfer);
             },
-            handleMessage: (method, args) => this._handleMessage(method, args),
-            handleEvent: (eventName, arg) => this._handleEvent(eventName, arg)
+            handleMessage: (channel, method, args) => this._handleMessage(channel, method, args),
+            handleEvent: (channel, eventName, arg) => this._handleEvent(channel, eventName, arg)
         }));
     }
     onmessage(msg) {
         this._protocol.handleMessage(msg);
     }
-    _handleMessage(method, args) {
-        if (method === INITIALIZE) {
-            return this.initialize(args[0], args[1], args[2], args[3]);
+    _handleMessage(channel, method, args) {
+        if (channel === DEFAULT_CHANNEL && method === INITIALIZE) {
+            return this.initialize(args[0], args[1], args[2]);
         }
-        if (!this._requestHandler || typeof this._requestHandler[method] !== 'function') {
-            return Promise.reject(( new Error('Missing requestHandler or method: ' + method)));
+        const requestHandler = (channel === DEFAULT_CHANNEL ? this._requestHandler : this._localChannels.get(channel));
+        if (!requestHandler) {
+            return Promise.reject(( new Error(`Missing channel ${channel} on worker thread`)));
+        }
+        if (typeof requestHandler[method] !== 'function') {
+            return Promise.reject(( new Error(`Missing method ${method} on worker thread channel ${channel}`)));
         }
         try {
-            return Promise.resolve(this._requestHandler[method].apply(this._requestHandler, args));
+            return Promise.resolve(requestHandler[method].apply(requestHandler, args));
         }
         catch (e) {
             return Promise.reject(e);
         }
     }
-    _handleEvent(eventName, arg) {
-        if (!this._requestHandler) {
-            throw ( new Error(`Missing requestHandler`));
+    _handleEvent(channel, eventName, arg) {
+        const requestHandler = (channel === DEFAULT_CHANNEL ? this._requestHandler : this._localChannels.get(channel));
+        if (!requestHandler) {
+            throw ( new Error(`Missing channel ${channel} on worker thread`));
         }
         if (propertyIsDynamicEvent(eventName)) {
-            const event = this._requestHandler[eventName].call(this._requestHandler, arg);
+            const event = requestHandler[eventName].call(requestHandler, arg);
             if (typeof event !== 'function') {
                 throw ( new Error(`Missing dynamic event ${eventName} on request handler.`));
             }
             return event;
         }
         if (propertyIsEvent(eventName)) {
-            const event = this._requestHandler[eventName];
+            const event = requestHandler[eventName];
             if (typeof event !== 'function') {
                 throw ( new Error(`Missing event ${eventName} on request handler.`));
             }
@@ -364,18 +380,21 @@ class SimpleWorkerServer {
         }
         throw ( new Error(`Malformed event name ${eventName}`));
     }
-    initialize(workerId, loaderConfig, moduleId, hostMethods) {
+    setChannel(channel, handler) {
+        this._localChannels.set(channel, handler);
+    }
+    getChannel(channel) {
+        if (!( this._remoteChannels.has(channel))) {
+            const inst = this._protocol.createProxyToRemoteChannel(channel);
+            this._remoteChannels.set(channel, inst);
+        }
+        return this._remoteChannels.get(channel);
+    }
+    async initialize(workerId, loaderConfig, moduleId) {
         this._protocol.setWorkerId(workerId);
-        const proxyMethodRequest = (method, args) => {
-            return this._protocol.sendMessage(method, args);
-        };
-        const proxyListen = (eventName, arg) => {
-            return this._protocol.listen(eventName, arg);
-        };
-        const hostProxy = createProxyObject(hostMethods, proxyMethodRequest, proxyListen);
         if (this._requestHandlerFactory) {
-            this._requestHandler = this._requestHandlerFactory(hostProxy);
-            return Promise.resolve(getAllMethodNames(this._requestHandler));
+            this._requestHandler = this._requestHandlerFactory(this);
+            return;
         }
         if (loaderConfig) {
             if (typeof loaderConfig.baseUrl !== 'undefined') {
@@ -392,17 +411,7 @@ class SimpleWorkerServer {
             loaderConfig.catchError = true;
             globalThis.require.config(loaderConfig);
         }
-        return ( new Promise((resolve, reject) => {
-            const req = undefined;
-            req([moduleId], (module) => {
-                this._requestHandler = module.create(hostProxy);
-                if (!this._requestHandler) {
-                    reject(( new Error(`No RequestHandler!`)));
-                    return;
-                }
-                resolve(getAllMethodNames(this._requestHandler));
-            }, reject);
-        }));
+        return Promise.reject(( new Error(`Unexpected usage`)));
     }
 }
 export { SimpleWorkerClient, SimpleWorkerServer, logOnceWebWorkerWarning };

package/vscode/src/vs/editor/browser/controller/mouseHandler.js

@@ -16,8 +16,6 @@ class MouseHandler extends ViewEventHandler {
     constructor(context, viewController, viewHelper) {
         super();
         this._mouseLeaveMonitor = null;
-        this._mouseOnOverflowWidgetsDomNode = false;
-        this._mouseOnViewDomNode = false;
         this._context = context;
         this.viewController = viewController;
         this.viewHelper = viewHelper;
@@ -27,7 +25,7 @@ class MouseHandler extends ViewEventHandler {
             this.viewController,
             this.viewHelper,
             this.mouseTargetFactory,
-            (e, testEventTarget) => this._createMouseTargetForView(e, testEventTarget),
+            (e, testEventTarget) => this._createMouseTarget(e, testEventTarget),
             (e) => this._getMouseColumn(e)
         )));
         this.lastMouseLeaveTime = -1;
@@ -35,47 +33,17 @@ class MouseHandler extends ViewEventHandler {
         const mouseEvents = ( new EditorMouseEventFactory(this.viewHelper.viewDomNode));
         this._register(mouseEvents.onContextMenu(this.viewHelper.viewDomNode, (e) => this._onContextMenu(e, true)));
         this._register(mouseEvents.onMouseMove(this.viewHelper.viewDomNode, (e) => {
-            this._mouseOnViewDomNode = true;
-            this._onMouseMoveOverView(e);
+            this._onMouseMove(e);
             if (!this._mouseLeaveMonitor) {
                 this._mouseLeaveMonitor = addDisposableListener(this.viewHelper.viewDomNode.ownerDocument, 'mousemove', (e) => {
                     if (!this.viewHelper.viewDomNode.contains(e.target)) {
-                        this._mouseOnViewDomNode = false;
-                        setTimeout(() => {
-                            if (!this._mouseOnOverflowWidgetsDomNode) {
-                                this._onMouseLeave(( new EditorMouseEvent(e, false, this.viewHelper.viewDomNode)));
-                            }
-                        }, 0);
+                        this._onMouseLeave(( new EditorMouseEvent(e, false, this.viewHelper.viewDomNode)));
                     }
                 });
             }
         }));
         this._register(mouseEvents.onMouseUp(this.viewHelper.viewDomNode, (e) => this._onMouseUp(e)));
-        this._register(mouseEvents.onMouseLeave(this.viewHelper.viewDomNode, (e) => {
-            this._mouseOnViewDomNode = false;
-            setTimeout(() => {
-                if (!this._mouseOnOverflowWidgetsDomNode) {
-                    this._onMouseLeave(e);
-                }
-            }, 0);
-        }));
-        const overflowWidgetsDomNode = this.viewHelper.overflowWidgetsDomNode;
-        if (overflowWidgetsDomNode) {
-            this._register(mouseEvents.onMouseMove(overflowWidgetsDomNode, (e) => {
-                this._mouseOnOverflowWidgetsDomNode = true;
-                this._mouseLeaveMonitor?.dispose();
-                this._mouseLeaveMonitor = null;
-                this._onMouseMoveOverOverflowWidgetsDomNode(e);
-            }));
-            this._register(mouseEvents.onMouseLeave(overflowWidgetsDomNode, (e) => {
-                this._mouseOnOverflowWidgetsDomNode = false;
-                setTimeout(() => {
-                    if (!this._mouseOnViewDomNode) {
-                        this._onMouseLeave(e);
-                    }
-                }, 0);
-            }));
-        }
+        this._register(mouseEvents.onMouseLeave(this.viewHelper.viewDomNode, (e) => this._onMouseLeave(e)));
         let capturePointerId = 0;
         this._register(mouseEvents.onPointerDown(this.viewHelper.viewDomNode, (e, pointerId) => {
             capturePointerId = pointerId;
@@ -164,9 +132,9 @@ class MouseHandler extends ViewEventHandler {
             return null;
         }
         const relativePos = createCoordinatesRelativeToEditor(this.viewHelper.viewDomNode, editorPos, pos);
-        return this.mouseTargetFactory.createMouseTargetForView(this.viewHelper.getLastRenderData(), editorPos, pos, relativePos, null);
+        return this.mouseTargetFactory.createMouseTarget(this.viewHelper.getLastRenderData(), editorPos, pos, relativePos, null);
     }
-    _createMouseTargetForView(e, testEventTarget) {
+    _createMouseTarget(e, testEventTarget) {
         let target = e.target;
         if (!this.viewHelper.viewDomNode.contains(target)) {
             const shadowRoot = getShadowRoot(this.viewHelper.viewDomNode);
@@ -174,10 +142,7 @@ class MouseHandler extends ViewEventHandler {
                 target = shadowRoot.elementsFromPoint(e.posx, e.posy).find((el) => this.viewHelper.viewDomNode.contains(el));
             }
         }
-        return this.mouseTargetFactory.createMouseTargetForView(this.viewHelper.getLastRenderData(), e.editorPos, e.pos, e.relativePos, testEventTarget ? target : null);
-    }
-    _createMouseTargetForOverflowWidgetsDomNode(e) {
-        return this.mouseTargetFactory.createMouseTargetForOverflowWidgetsDomNode(this.viewHelper.getLastRenderData(), e.editorPos, e.pos, e.relativePos, e.target);
+        return this.mouseTargetFactory.createMouseTarget(this.viewHelper.getLastRenderData(), e.editorPos, e.pos, e.relativePos, testEventTarget ? target : null);
     }
     _getMouseColumn(e) {
         return this.mouseTargetFactory.getMouseColumn(e.relativePos);
@@ -185,38 +150,25 @@ class MouseHandler extends ViewEventHandler {
     _onContextMenu(e, testEventTarget) {
         this.viewController.emitContextMenu({
             event: e,
-            target: this._createMouseTargetForView(e, testEventTarget)
-        });
-    }
-    _onMouseMoveOverView(e) {
-        this._onMouseMove(e, this._createMouseTargetForView(e, true));
-    }
-    _onMouseMoveOverOverflowWidgetsDomNode(e) {
-        this._onMouseMove(e, this._createMouseTargetForOverflowWidgetsDomNode(e));
-    }
-    _onMouseMove(e, target) {
-        const shouldIgnoreMouseMoveEvent = this._shouldIgnoreMouseMoveEvent(e);
-        if (shouldIgnoreMouseMoveEvent) {
-            return undefined;
-        }
-        this.viewController.emitMouseMove({
-            event: e,
-            target
+            target: this._createMouseTarget(e, testEventTarget)
         });
     }
-    _shouldIgnoreMouseMoveEvent(e) {
+    _onMouseMove(e) {
         const targetIsWidget = this.mouseTargetFactory.mouseTargetIsWidget(e);
         if (!targetIsWidget) {
             e.preventDefault();
         }
         if (this._mouseDownOperation.isActive()) {
-            return true;
+            return;
         }
         const actualMouseMoveTime = e.timestamp;
         if (actualMouseMoveTime < this.lastMouseLeaveTime) {
-            return true;
+            return;
         }
-        return false;
+        this.viewController.emitMouseMove({
+            event: e,
+            target: this._createMouseTarget(e, true)
+        });
     }
     _onMouseLeave(e) {
         if (this._mouseLeaveMonitor) {
@@ -232,11 +184,11 @@ class MouseHandler extends ViewEventHandler {
     _onMouseUp(e) {
         this.viewController.emitMouseUp({
             event: e,
-            target: this._createMouseTargetForView(e, true)
+            target: this._createMouseTarget(e, true)
         });
     }
     _onMouseDown(e, pointerId) {
-        const t = this._createMouseTargetForView(e, true);
+        const t = this._createMouseTarget(e, true);
         const targetIsContent = (t.type === MouseTargetType.CONTENT_TEXT || t.type === MouseTargetType.CONTENT_EMPTY);
         const targetIsGutter = (t.type === MouseTargetType.GUTTER_GLYPH_MARGIN || t.type === MouseTargetType.GUTTER_LINE_NUMBERS || t.type === MouseTargetType.GUTTER_LINE_DECORATIONS);
         const targetIsLineNumbers = (t.type === MouseTargetType.GUTTER_LINE_NUMBERS);
@@ -578,7 +530,7 @@ class TopBottomDragScrollingOperation extends Disposable {
                 editorPos.y + editorPos.height - horizontalScrollbarHeight - 0.1
             ));
             const relativePos = createCoordinatesRelativeToEditor(this._viewHelper.viewDomNode, editorPos, pos);
-            mouseTarget = this._mouseTargetFactory.createMouseTargetForView(this._viewHelper.getLastRenderData(), editorPos, pos, relativePos, null);
+            mouseTarget = this._mouseTargetFactory.createMouseTarget(this._viewHelper.getLastRenderData(), editorPos, pos, relativePos, null);
         }
         if (!mouseTarget.position || mouseTarget.position.lineNumber !== edgeLineNumber) {
             if (this._position.outsidePosition === 'above') {

package/vscode/src/vs/editor/browser/controller/mouseTarget.js

@@ -182,7 +182,6 @@ class HitTestContext {
         const options = context.configuration.options;
         this.layoutInfo = options.get(EditorOption.layoutInfo);
         this.viewDomNode = viewHelper.viewDomNode;
-        this.overflowWidgetsDomNode = viewHelper.overflowWidgetsDomNode ?? null;
         this.lineHeight = options.get(EditorOption.lineHeight);
         this.stickyTabStops = options.get(EditorOption.stickyTabStops);
         this.typicalHalfwidthCharacterWidth = options.get(EditorOption.fontInfo).typicalHalfwidthCharacterWidth;
@@ -314,21 +313,19 @@ class HitTestRequest extends BareHitTestRequest {
         return this._eventTarget;
     }
     get targetPath() {
-        if (this._targetPathCacheElement !== this.target && this._targetElement) {
+        if (this._targetPathCacheElement !== this.target) {
             this._targetPathCacheElement = this.target;
-            this._targetPathCacheValue = PartFingerprints.collect(this.target, this._targetElement);
+            this._targetPathCacheValue = PartFingerprints.collect(this.target, this._ctx.viewDomNode);
         }
         return this._targetPathCacheValue;
     }
-    constructor(ctx, editorPos, pos, relativePos, eventTarget, targetElement = null) {
+    constructor(ctx, editorPos, pos, relativePos, eventTarget) {
         super(ctx, editorPos, pos, relativePos);
         this.hitTestResult = ( new Lazy(() => MouseTargetFactory.doHitTest(this._ctx, this)));
         this._targetPathCacheElement = null;
         this._targetPathCacheValue = ( new Uint8Array(0));
-        this._targetElement = null;
         this._ctx = ctx;
         this._eventTarget = eventTarget;
-        this._targetElement = targetElement;
         const hasEventTarget = Boolean(this._eventTarget);
         this._useHitTestTarget = !hasEventTarget;
     }
@@ -400,9 +397,9 @@ class MouseTargetFactory {
         }
         return false;
     }
-    createMouseTargetForView(lastRenderData, editorPos, pos, relativePos, target) {
+    createMouseTarget(lastRenderData, editorPos, pos, relativePos, target) {
         const ctx = ( new HitTestContext(this._context, this._viewHelper, lastRenderData));
-        const request = ( new HitTestRequest(ctx, editorPos, pos, relativePos, target, ctx.viewDomNode));
+        const request = ( new HitTestRequest(ctx, editorPos, pos, relativePos, target));
         try {
             const r = MouseTargetFactory._createMouseTarget(ctx, request);
             if (r.type === MouseTargetType.CONTENT_TEXT) {
@@ -418,16 +415,6 @@ class MouseTargetFactory {
             return request.fulfillUnknown();
         }
     }
-    createMouseTargetForOverflowWidgetsDomNode(lastRenderData, editorPos, pos, relativePos, target) {
-        const ctx = ( new HitTestContext(this._context, this._viewHelper, lastRenderData));
-        const request = ( new HitTestRequest(ctx, editorPos, pos, relativePos, target, ctx.overflowWidgetsDomNode));
-        try {
-            return MouseTargetFactory._createMouseTarget(ctx, request);
-        }
-        catch (err) {
-            return request.fulfillUnknown();
-        }
-    }
     static _createMouseTarget(ctx, request) {
         if (request.target === null) {
             return request.fulfillUnknown();

package/vscode/src/vs/editor/browser/controller/pointerHandler.js

@@ -31,7 +31,7 @@ class PointerEventHandler extends MouseHandler {
             }
         }));
         const pointerEvents = ( new EditorPointerEventFactory(this.viewHelper.viewDomNode));
-        this._register(pointerEvents.onPointerMove(this.viewHelper.viewDomNode, (e) => this._onMouseMoveOverView(e)));
+        this._register(pointerEvents.onPointerMove(this.viewHelper.viewDomNode, (e) => this._onMouseMove(e)));
         this._register(pointerEvents.onPointerUp(this.viewHelper.viewDomNode, (e) => this._onMouseUp(e)));
         this._register(pointerEvents.onPointerLeave(this.viewHelper.viewDomNode, (e) => this._onMouseLeave(e)));
         this._register(pointerEvents.onPointerDown(this.viewHelper.viewDomNode, (e, pointerId) => this._onMouseDown(e, pointerId)));
@@ -53,7 +53,7 @@ class PointerEventHandler extends MouseHandler {
         }
     }
     _dispatchGesture(event, inSelectionMode) {
-        const target = this._createMouseTargetForView(( new EditorMouseEvent(event, false, this.viewHelper.viewDomNode)), false);
+        const target = this._createMouseTarget(( new EditorMouseEvent(event, false, this.viewHelper.viewDomNode)), false);
         if (target.position) {
             this.viewController.dispatchMouse({
                 position: target.position,
@@ -90,7 +90,7 @@ class TouchHandler extends MouseHandler {
     onTap(event) {
         event.preventDefault();
         this.viewHelper.focusTextArea();
-        const target = this._createMouseTargetForView(( new EditorMouseEvent(event, false, this.viewHelper.viewDomNode)), false);
+        const target = this._createMouseTarget(( new EditorMouseEvent(event, false, this.viewHelper.viewDomNode)), false);
         if (target.position) {
             const event = document.createEvent('CustomEvent');
             event.initEvent(TextAreaSyntethicEvents.Tap, false, true);