@codingame/monaco-vscode-api 22.1.8 → 23.0.0

package/vscode/src/vs/base/common/types.js

@@ -5,7 +5,10 @@ function isString(str) {
     return (typeof str === 'string');
 }
 function isStringArray(value) {
-    return Array.isArray(value) && value.every(elem => isString(elem));
+    return isArrayOf(value, isString);
+}
+function isArrayOf(value, check) {
+    return Array.isArray(value) && value.every(check);
 }
 function isObject(obj) {
     return typeof obj === 'object'
@@ -48,7 +51,7 @@ function assertReturnsDefined(arg) {
 }
 function assertDefined(value, error) {
     if (value === null || value === undefined) {
-        const errorToThrow = typeof error === 'string' ? ( new Error(error)) : error;
+        const errorToThrow = ( new Error(error)) ;
         throw errorToThrow;
     }
 }
@@ -115,5 +118,13 @@ function validateConstraint(arg, constraint) {
 function upcast(x) {
     return x;
 }
+function hasKey(x, key) {
+    for (const k in key) {
+        if (!(k in x)) {
+            return false;
+        }
+    }
+    return true;
+}
 
-export { areFunctions, assertDefined, assertReturnsAllDefined, assertReturnsDefined, assertType, isBoolean, isDefined, isEmptyObject, isFunction, isIterable, isNumber, isObject, isString, isStringArray, isTypedArray, isUndefined, isUndefinedOrNull, upcast, validateConstraint, validateConstraints };
+export { areFunctions, assertDefined, assertReturnsAllDefined, assertReturnsDefined, assertType, hasKey, isArrayOf, isBoolean, isDefined, isEmptyObject, isFunction, isIterable, isNumber, isObject, isString, isStringArray, isTypedArray, isUndefined, isUndefinedOrNull, upcast, validateConstraint, validateConstraints };

package/vscode/src/vs/base/common/validation.d.ts

@@ -0,0 +1,62 @@
+import { IJSONSchema } from "./jsonSchema.js";
+export interface IValidator<T> {
+    validate(content: unknown): {
+        content: T;
+        error: undefined;
+    } | {
+        content: undefined;
+        error: ValidationError;
+    };
+    getJSONSchema(): IJSONSchema;
+}
+export declare abstract class ValidatorBase<T> implements IValidator<T> {
+    abstract validate(content: unknown): {
+        content: T;
+        error: undefined;
+    } | {
+        content: undefined;
+        error: ValidationError;
+    };
+    abstract getJSONSchema(): IJSONSchema;
+    validateOrThrow(content: unknown): T;
+}
+export type ValidatorType<T> = T extends IValidator<infer U> ? U : never;
+export interface ValidationError {
+    message: string;
+}
+export declare function vString(): ValidatorBase<string>;
+export declare function vNumber(): ValidatorBase<number>;
+export declare function vBoolean(): ValidatorBase<boolean>;
+export declare function vObjAny(): ValidatorBase<object>;
+export declare function vUnchecked<T>(): ValidatorBase<T>;
+export declare function vUndefined(): ValidatorBase<undefined>;
+export declare function vUnknown(): ValidatorBase<unknown>;
+export type ObjectProperties = Record<string, unknown>;
+export declare class Optional<T extends IValidator<unknown>> {
+    readonly validator: T;
+    constructor(validator: T);
+}
+export declare function vOptionalProp<T>(validator: IValidator<T>): Optional<IValidator<T>>;
+type ExtractOptionalKeys<T> = {
+    [K in keyof T]: T[K] extends Optional<IValidator<unknown>> ? K : never;
+}[keyof T];
+type ExtractRequiredKeys<T> = {
+    [K in keyof T]: T[K] extends Optional<IValidator<unknown>> ? never : K;
+}[keyof T];
+export type vObjType<T extends Record<string, IValidator<unknown> | Optional<IValidator<unknown>>>> = {
+    [K in ExtractRequiredKeys<T>]: T[K] extends IValidator<infer U> ? U : never;
+} & {
+    [K in ExtractOptionalKeys<T>]?: T[K] extends Optional<IValidator<infer U>> ? U : never;
+};
+export declare function vObj<T extends Record<string, IValidator<unknown> | Optional<IValidator<unknown>>>>(properties: T): ValidatorBase<vObjType<T>>;
+export declare function vArray<T>(validator: IValidator<T>): ValidatorBase<T[]>;
+type vTupleType<T extends IValidator<unknown>[]> = {
+    [K in keyof T]: ValidatorType<T[K]>;
+};
+export declare function vTuple<T extends IValidator<unknown>[]>(...validators: T): ValidatorBase<vTupleType<T>>;
+export declare function vUnion<T extends IValidator<unknown>[]>(...validators: T): ValidatorBase<ValidatorType<T[number]>>;
+export declare function vEnum<T extends string[]>(...values: T): ValidatorBase<T[number]>;
+export declare function vLiteral<T extends string>(value: T): ValidatorBase<T>;
+export declare function vLazy<T>(fn: () => IValidator<T>): ValidatorBase<T>;
+export declare function vWithJsonSchemaRef<T>(ref: string, validator: IValidator<T>): ValidatorBase<T>;
+export {};

package/vscode/src/vs/base/common/validation.js

@@ -0,0 +1,182 @@
+
+import { mapFilter } from './arrays.js';
+
+class ValidatorBase {
+    validateOrThrow(content) {
+        const result = this.validate(content);
+        if (result.error) {
+            throw ( new Error(result.error.message));
+        }
+        return result.content;
+    }
+}
+class TypeofValidator extends ValidatorBase {
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+    validate(content) {
+        if (typeof content !== this.type) {
+            return { content: undefined, error: { message: `Expected ${this.type}, but got ${typeof content}` } };
+        }
+        return { content: content, error: undefined };
+    }
+    getJSONSchema() {
+        return { type: this.type };
+    }
+}
+const vStringValidator = ( new TypeofValidator('string'));
+function vString() { return vStringValidator; }
+const vNumberValidator = ( new TypeofValidator('number'));
+function vNumber() { return vNumberValidator; }
+const vBooleanValidator = ( new TypeofValidator('boolean'));
+function vBoolean() { return vBooleanValidator; }
+const vObjAnyValidator = ( new TypeofValidator('object'));
+function vObjAny() { return vObjAnyValidator; }
+class UndefinedValidator extends ValidatorBase {
+    validate(content) {
+        if (content !== undefined) {
+            return { content: undefined, error: { message: `Expected undefined, but got ${typeof content}` } };
+        }
+        return { content: undefined, error: undefined };
+    }
+    getJSONSchema() {
+        return {};
+    }
+}
+function vUndefined() {
+    return ( new UndefinedValidator());
+}
+class Optional {
+    constructor(validator) {
+        this.validator = validator;
+    }
+}
+function vOptionalProp(validator) {
+    return ( new Optional(validator));
+}
+class ObjValidator extends ValidatorBase {
+    constructor(properties) {
+        super();
+        this.properties = properties;
+    }
+    validate(content) {
+        if (typeof content !== 'object' || content === null) {
+            return { content: undefined, error: { message: 'Expected object' } };
+        }
+        const result = {};
+        for (const key in this.properties) {
+            const prop = this.properties[key];
+            const fieldValue = content[key];
+            const isOptional = prop instanceof Optional;
+            const validator = isOptional ? prop.validator : prop;
+            if (isOptional && fieldValue === undefined) {
+                continue;
+            }
+            const { content: value, error } = validator.validate(fieldValue);
+            if (error) {
+                return { content: undefined, error: { message: `Error in property '${key}': ${error.message}` } };
+            }
+            result[key] = value;
+        }
+        return { content: result, error: undefined };
+    }
+    getJSONSchema() {
+        const requiredFields = [];
+        const schemaProperties = {};
+        for (const [key, prop] of Object.entries(this.properties)) {
+            const isOptional = prop instanceof Optional;
+            const validator = isOptional ? prop.validator : prop;
+            schemaProperties[key] = validator.getJSONSchema();
+            if (!isOptional) {
+                requiredFields.push(key);
+            }
+        }
+        const schema = {
+            type: 'object',
+            properties: schemaProperties,
+            ...(requiredFields.length > 0 ? { required: requiredFields } : {})
+        };
+        return schema;
+    }
+}
+function vObj(properties) {
+    return ( new ObjValidator(properties));
+}
+class ArrayValidator extends ValidatorBase {
+    constructor(validator) {
+        super();
+        this.validator = validator;
+    }
+    validate(content) {
+        if (!Array.isArray(content)) {
+            return { content: undefined, error: { message: 'Expected array' } };
+        }
+        const result = [];
+        for (let i = 0; i < content.length; i++) {
+            const { content: value, error } = this.validator.validate(content[i]);
+            if (error) {
+                return { content: undefined, error: { message: `Error in element ${i}: ${error.message}` } };
+            }
+            result.push(value);
+        }
+        return { content: result, error: undefined };
+    }
+    getJSONSchema() {
+        return {
+            type: 'array',
+            items: this.validator.getJSONSchema(),
+        };
+    }
+}
+function vArray(validator) {
+    return ( new ArrayValidator(validator));
+}
+class UnionValidator extends ValidatorBase {
+    constructor(validators) {
+        super();
+        this.validators = validators;
+    }
+    validate(content) {
+        let lastError;
+        for (const validator of this.validators) {
+            const { content: value, error } = validator.validate(content);
+            if (!error) {
+                return { content: value, error: undefined };
+            }
+            lastError = error;
+        }
+        return { content: undefined, error: lastError };
+    }
+    getJSONSchema() {
+        return {
+            oneOf: mapFilter(this.validators, validator => {
+                if (validator instanceof UndefinedValidator) {
+                    return undefined;
+                }
+                return validator.getJSONSchema();
+            }),
+        };
+    }
+}
+function vUnion(...validators) {
+    return ( new UnionValidator(validators));
+}
+class UseRefSchemaValidator extends ValidatorBase {
+    constructor(_ref, _validator) {
+        super();
+        this._ref = _ref;
+        this._validator = _validator;
+    }
+    validate(content) {
+        return this._validator.validate(content);
+    }
+    getJSONSchema() {
+        return { $ref: this._ref };
+    }
+}
+function vWithJsonSchemaRef(ref, validator) {
+    return ( new UseRefSchemaValidator(ref, validator));
+}
+
+export { Optional, ValidatorBase, vArray, vBoolean, vNumber, vObj, vObjAny, vOptionalProp, vString, vUndefined, vUnion, vWithJsonSchemaRef };

package/vscode/src/vs/base/common/worker/webWorker.d.ts

@@ -1,12 +1,13 @@
+import { SerializedError } from "../errors.js";
 import { Event } from "../event.js";
 import { Disposable, IDisposable } from "../lifecycle.js";
 export interface IWebWorker extends IDisposable {
     getId(): number;
-    onMessage: Event<Message>;
-    onError: Event<any>;
+    readonly onMessage: Event<Message>;
+    readonly onError: Event<unknown>;
     postMessage(message: Message, transfer: ArrayBuffer[]): void;
 }
-export declare function logOnceWebWorkerWarning(err: any): void;
+export declare function logOnceWebWorkerWarning(err: unknown): void;
 declare enum MessageType {
     Request = 0,
     Reply = 1,
@@ -19,33 +20,33 @@ declare class RequestMessage {
     readonly req: string;
     readonly channel: string;
     readonly method: string;
-    readonly args: any[];
+    readonly args: unknown[];
     readonly type = MessageType.Request;
-    constructor(vsWorker: number, req: string, channel: string, method: string, args: any[]);
+    constructor(vsWorker: number, req: string, channel: string, method: string, args: unknown[]);
 }
 declare class ReplyMessage {
     readonly vsWorker: number;
     readonly seq: string;
-    readonly res: any;
-    readonly err: any;
+    readonly res: unknown;
+    readonly err: unknown | SerializedError;
     readonly type = MessageType.Reply;
-    constructor(vsWorker: number, seq: string, res: any, err: any);
+    constructor(vsWorker: number, seq: string, res: unknown, err: unknown | SerializedError);
 }
 declare class SubscribeEventMessage {
     readonly vsWorker: number;
     readonly req: string;
     readonly channel: string;
     readonly eventName: string;
-    readonly arg: any;
+    readonly arg: unknown;
     readonly type = MessageType.SubscribeEvent;
-    constructor(vsWorker: number, req: string, channel: string, eventName: string, arg: any);
+    constructor(vsWorker: number, req: string, channel: string, eventName: string, arg: unknown);
 }
 declare class EventMessage {
     readonly vsWorker: number;
     readonly req: string;
-    readonly event: any;
+    readonly event: unknown;
     readonly type = MessageType.Event;
-    constructor(vsWorker: number, req: string, event: any);
+    constructor(vsWorker: number, req: string, event: unknown);
 }
 declare class UnsubscribeEventMessage {
     readonly vsWorker: number;
@@ -86,7 +87,7 @@ export declare class WebWorkerClient<W extends object> extends Disposable implem
     private _onError;
 }
 export interface IWebWorkerServerRequestHandler {
-    _requestHandlerBrand: any;
+    _requestHandlerBrand: void;
     [prop: string]: any;
 }
 export interface IWebWorkerServerRequestHandlerFactory<T extends IWebWorkerServerRequestHandler> {
@@ -101,7 +102,7 @@ export declare class WebWorkerServer<T extends IWebWorkerServerRequestHandler> i
     private readonly _localChannels;
     private readonly _remoteChannels;
     constructor(postMessage: (msg: Message, transfer?: ArrayBuffer[]) => void, requestHandlerFactory: IWebWorkerServerRequestHandlerFactory<T>);
-    onmessage(msg: any): void;
+    onmessage(msg: unknown): void;
     private _handleMessage;
     private _handleEvent;
     setChannel<T extends object>(channel: string, handler: T): void;

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

@@ -83,7 +83,7 @@ class WebWorkerProtocol {
     setWorkerId(workerId) {
         this._workerId = workerId;
     }
-    sendMessage(channel, method, args) {
+    async sendMessage(channel, method, args) {
         const req = String(++this._lastSentReq);
         return ( new Promise((resolve, reject) => {
             this._pendingReplies[req] = {
@@ -166,10 +166,11 @@ class WebWorkerProtocol {
         if (replyMessage.err) {
             let err = replyMessage.err;
             if (replyMessage.err.$isError) {
-                err = ( new Error());
-                err.name = replyMessage.err.name;
-                err.message = replyMessage.err.message;
-                err.stack = replyMessage.err.stack;
+                const newErr = ( new Error());
+                newErr.name = replyMessage.err.name;
+                newErr.message = replyMessage.err.message;
+                newErr.stack = replyMessage.err.stack;
+                err = newErr;
             }
             reply.reject(err);
             return;
@@ -214,8 +215,9 @@ class WebWorkerProtocol {
         const transfer = [];
         if (msg.type === MessageType.Request) {
             for (let i = 0; i < msg.args.length; i++) {
-                if (msg.args[i] instanceof ArrayBuffer) {
-                    transfer.push(msg.args[i]);
+                const arg = msg.args[i];
+                if (arg instanceof ArrayBuffer) {
+                    transfer.push(arg);
                 }
             }
         }
@@ -254,7 +256,7 @@ class WebWorkerClient extends Disposable {
         this._protocol.setWorkerId(this._worker.getId());
         this._onModuleLoaded = this._protocol.sendMessage(DEFAULT_CHANNEL, INITIALIZE, [
             this._worker.getId(),
-        ]);
+        ]).then(() => { });
         this.proxy = this._protocol.createProxyToRemoteChannel(DEFAULT_CHANNEL, async () => { await this._onModuleLoaded; });
         this._onModuleLoaded.catch((e) => {
             this._onError('Worker failed to load ', e);
@@ -265,11 +267,12 @@ class WebWorkerClient extends Disposable {
         if (!channel) {
             return Promise.reject(( new Error(`Missing channel ${channelName} on main thread`)));
         }
-        if (typeof channel[method] !== 'function') {
+        const fn = channel[method];
+        if (typeof fn !== 'function') {
             return Promise.reject(( new Error(`Missing method ${method} on main thread channel ${channelName}`)));
         }
         try {
-            return Promise.resolve(channel[method].apply(channel, args));
+            return Promise.resolve(fn.apply(channel, args));
         }
         catch (e) {
             return Promise.reject(e);
@@ -281,7 +284,13 @@ class WebWorkerClient extends Disposable {
             throw ( new Error(`Missing channel ${channelName} on main thread`));
         }
         if (propertyIsDynamicEvent(eventName)) {
-            const event = channel[eventName].call(channel, arg);
+            const fn = channel[eventName];
+            if (typeof fn !== 'function') {
+                throw ( new Error(
+                    `Missing dynamic event ${eventName} on main thread channel ${channelName}.`
+                ));
+            }
+            const event = fn.call(channel, arg);
             if (typeof event !== 'function') {
                 throw ( new Error(
                     `Missing dynamic event ${eventName} on main thread channel ${channelName}.`
@@ -343,11 +352,12 @@ class WebWorkerServer {
         if (!requestHandler) {
             return Promise.reject(( new Error(`Missing channel ${channel} on worker thread`)));
         }
-        if (typeof requestHandler[method] !== 'function') {
+        const fn = requestHandler[method];
+        if (typeof fn !== 'function') {
             return Promise.reject(( new Error(`Missing method ${method} on worker thread channel ${channel}`)));
         }
         try {
-            return Promise.resolve(requestHandler[method].apply(requestHandler, args));
+            return Promise.resolve(fn.apply(requestHandler, args));
         }
         catch (e) {
             return Promise.reject(e);
@@ -359,7 +369,11 @@ class WebWorkerServer {
             throw ( new Error(`Missing channel ${channel} on worker thread`));
         }
         if (propertyIsDynamicEvent(eventName)) {
-            const event = requestHandler[eventName].call(requestHandler, arg);
+            const fn = requestHandler[eventName];
+            if (typeof fn !== 'function') {
+                throw ( new Error(`Missing dynamic event ${eventName} on request handler.`));
+            }
+            const event = fn.call(requestHandler, arg);
             if (typeof event !== 'function') {
                 throw ( new Error(`Missing dynamic event ${eventName} on request handler.`));
             }

package/vscode/src/vs/base/parts/storage/common/storage.js

@@ -164,7 +164,7 @@ class Storage extends Disposable {
         try {
             await this.doFlush(0 );
         }
-        catch (error) {
+        catch {
         }
         await this.database.close(() => this.cache);
     }

package/vscode/src/vs/editor/browser/config/editorConfiguration.js

@@ -12,7 +12,7 @@ import { migrateOptions } from './migrateOptions.js';
 import { TabFocus } from './tabFocus.js';
 import { ComputeOptionsMemory, EditorOption, editorOptionsRegistry, ConfigurationChangedEvent } from '../../common/config/editorOptions.js';
 import { EditorZoom } from '../../common/config/editorZoom.js';
-import { BareFontInfo } from '../../common/config/fontInfo.js';
+import { createBareFontInfoFromValidatedSettings } from '../../common/config/fontInfoFromSettings.js';
 import { AccessibilitySupport } from '../../../platform/accessibility/common/accessibility.js';
 import { IAccessibilityService } from '../../../platform/accessibility/common/accessibility.service.js';
 import { getWindow, getWindowById } from '../../../base/browser/dom.js';
@@ -64,7 +64,7 @@ let EditorConfiguration = class EditorConfiguration extends Disposable {
     }
     _computeOptions() {
         const partialEnv = this._readEnvConfiguration();
-        const bareFontInfo = BareFontInfo.createFromValidatedSettings(this._validatedOptions, partialEnv.pixelRatio, this.isSimpleWidget);
+        const bareFontInfo = createBareFontInfoFromValidatedSettings(this._validatedOptions, partialEnv.pixelRatio, this.isSimpleWidget);
         const fontInfo = this._readFontInfo(bareFontInfo);
         const env = {
             memory: this._computeOptionsMemory,

package/vscode/src/vs/editor/browser/config/migrateOptions.d.ts

@@ -1,16 +1,16 @@
 import { IEditorOptions } from "../../common/config/editorOptions.js";
 export interface ISettingsReader {
-    (key: string): any;
+    (key: string): unknown;
 }
 export interface ISettingsWriter {
-    (key: string, value: any): void;
+    (key: string, value: unknown): void;
 }
 export declare class EditorSettingMigration {
     readonly key: string;
-    readonly migrate: (value: any, read: ISettingsReader, write: ISettingsWriter) => void;
+    readonly migrate: (value: unknown, read: ISettingsReader, write: ISettingsWriter) => void;
     static items: EditorSettingMigration[];
-    constructor(key: string, migrate: (value: any, read: ISettingsReader, write: ISettingsWriter) => void);
-    apply(options: any): void;
+    constructor(key: string, migrate: (value: unknown, read: ISettingsReader, write: ISettingsWriter) => void);
+    apply(options: unknown): void;
     private static _read;
     private static _write;
 }

package/vscode/src/vs/editor/browser/config/migrateOptions.js

@@ -13,7 +13,7 @@ class EditorSettingMigration {
         this.migrate(value, read, write);
     }
     static _read(source, key) {
-        if (typeof source === 'undefined') {
+        if (typeof source === 'undefined' || source === null) {
             return undefined;
         }
         const firstDotIndex = key.indexOf('.');

package/vscode/src/vs/editor/browser/controller/editContext/native/nativeEditContext.d.ts

@@ -19,7 +19,7 @@ export declare class NativeEditContext extends AbstractEditContext {
     private readonly _screenReaderSupport;
     private _previousEditContextSelection;
     private _editContextPrimarySelection;
-    private _parent;
+    private readonly _parent;
     private _decorations;
     private _primarySelection;
     private _targetWindowId;
@@ -31,6 +31,7 @@ export declare class NativeEditContext extends AbstractEditContext {
     setAriaOptions(options: IEditorAriaOptions): void;
     getLastRenderData(): Position | null;
     prepareRender(ctx: RenderingContext): void;
+    onDidRender(): void;
     render(ctx: RestrictedRenderingContext): void;
     onCursorStateChanged(e: ViewCursorStateChangedEvent): boolean;
     onConfigurationChanged(e: ViewConfigurationChangedEvent): boolean;
@@ -59,7 +60,9 @@ export declare class NativeEditContext extends AbstractEditContext {
     private _getNewEditContextState;
     private _editContextStartPosition;
     private _handleTextFormatUpdate;
-    private _updateSelectionAndControlBounds;
+    private _linesVisibleRanges;
+    private _updateSelectionAndControlBoundsData;
+    private _updateSelectionAndControlBoundsAfterRender;
     private _updateCharacterBounds;
     private _ensureClipboardGetsEditorSelection;
 }

package/vscode/src/vs/editor/browser/controller/editContext/native/nativeEditContext.js

@@ -48,6 +48,7 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         this._targetWindowId = -1;
         this._scrollTop = 0;
         this._scrollLeft = 0;
+        this._linesVisibleRanges = null;
         this.domNode = ( new FastDomNode(createElement('div')));
         this.domNode.setClassName(`native-edit-context`);
         this._imeTextArea = ( new FastDomNode(createElement('textarea')));
@@ -183,7 +184,10 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
     }
     prepareRender(ctx) {
         this._screenReaderSupport.prepareRender(ctx);
-        this._updateSelectionAndControlBounds(ctx);
+        this._updateSelectionAndControlBoundsData(ctx);
+    }
+    onDidRender() {
+        this._updateSelectionAndControlBoundsAfterRender();
     }
     render(ctx) {
         this._screenReaderSupport.render(ctx);
@@ -391,24 +395,30 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         });
         this._decorations = this._context.viewModel.model.deltaDecorations(this._decorations, decorations);
     }
-    _updateSelectionAndControlBounds(ctx) {
-        if (!this._parent) {
-            return;
+    _updateSelectionAndControlBoundsData(ctx) {
+        const viewSelection = this._context.viewModel.coordinatesConverter.convertModelRangeToViewRange(this._primarySelection);
+        if (this._primarySelection.isEmpty()) {
+            const linesVisibleRanges = ctx.visibleRangeForPosition(viewSelection.getStartPosition());
+            this._linesVisibleRanges = linesVisibleRanges;
+        }
+        else {
+            this._linesVisibleRanges = null;
         }
+    }
+    _updateSelectionAndControlBoundsAfterRender() {
         const options = this._context.configuration.options;
         const contentLeft = options.get(EditorOption.layoutInfo).contentLeft;
-        const parentBounds = this._parent.getBoundingClientRect();
         const viewSelection = this._context.viewModel.coordinatesConverter.convertModelRangeToViewRange(this._primarySelection);
         const verticalOffsetStart = this._context.viewLayout.getVerticalOffsetForLineNumber(viewSelection.startLineNumber);
-        const top = parentBounds.top + verticalOffsetStart - this._scrollTop;
         const verticalOffsetEnd = this._context.viewLayout.getVerticalOffsetAfterLineNumber(viewSelection.endLineNumber);
+        const parentBounds = this._parent.getBoundingClientRect();
+        const top = parentBounds.top + verticalOffsetStart - this._scrollTop;
         const height = verticalOffsetEnd - verticalOffsetStart;
         let left = parentBounds.left + contentLeft - this._scrollLeft;
         let width;
         if (this._primarySelection.isEmpty()) {
-            const linesVisibleRanges = ctx.visibleRangeForPosition(viewSelection.getStartPosition());
-            if (linesVisibleRanges) {
-                left += linesVisibleRanges.left;
+            if (this._linesVisibleRanges) {
+                left += this._linesVisibleRanges.left;
             }
             width = 0;
         }
@@ -420,9 +430,6 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         this._editContext.updateControlBounds(selectionBounds);
     }
     _updateCharacterBounds(e) {
-        if (!this._parent) {
-            return;
-        }
         const options = this._context.configuration.options;
         const typicalHalfWidthCharacterWidth = options.get(EditorOption.fontInfo).typicalHalfwidthCharacterWidth;
         const contentLeft = options.get(EditorOption.layoutInfo).contentLeft;

package/vscode/src/vs/editor/browser/controller/editContext/native/nativeEditContextUtils.d.ts

@@ -19,4 +19,4 @@ export declare class FocusTracker extends Disposable {
     refreshFocusState(): void;
     get isFocused(): boolean;
 }
-export declare function editContextAddDisposableListener<K extends keyof EditContextEventHandlersEventMap>(target: EventTarget, type: K, listener: (this: GlobalEventHandlers, ev: EditContextEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): IDisposable;
+export declare function editContextAddDisposableListener<K extends keyof EditContextEventHandlersEventMap>(target: EventTarget, type: K, listener: (this: GlobalEventHandlers, ev: EditContextEventHandlersEventMap[K]) => void, options?: boolean | AddEventListenerOptions): IDisposable;

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

@@ -142,7 +142,8 @@ class MouseHandler extends ViewEventHandler {
         if (!this.viewHelper.viewDomNode.contains(target)) {
             const shadowRoot = getShadowRoot(this.viewHelper.viewDomNode);
             if (shadowRoot) {
-                target = shadowRoot.elementsFromPoint(e.posx, e.posy).find((el) => this.viewHelper.viewDomNode.contains(el));
+                const potentialTarget = shadowRoot.elementsFromPoint(e.posx, e.posy).find((el) => this.viewHelper.viewDomNode.contains(el)) ?? null;
+                target = potentialTarget;
             }
         }
         return this.mouseTargetFactory.createMouseTarget(this.viewHelper.getLastRenderData(), e.editorPos, e.pos, e.relativePos, testEventTarget ? target : null);

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

@@ -362,7 +362,7 @@ class HitTestRequest extends BareHitTestRequest {
         return MouseTarget.createMargin(type, this.target, this._getMouseColumn(position), position, range, detail);
     }
     fulfillViewZone(type, position, detail) {
-        return MouseTarget.createViewZone(type, this.target, this._getMouseColumn(position), position, detail);
+        return MouseTarget.createViewZone(type, this.target, this._getMouseColumn(), position, detail);
     }
     fulfillContentText(position, range, detail) {
         return MouseTarget.createContentText(this.target, this._getMouseColumn(position), position, range, detail);