@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/service-override/modelEditor.d.ts

@@ -1,560 +1,12 @@
-import * as monaco from 'monaco-editor';
-import * as vscode from 'vscode';
-
-/**
- * An object that performs a cleanup operation when `.dispose()` is called.
- *
- * Some examples of how disposables are used:
- *
- * - An event listener that removes itself when `.dispose()` is called.
- * - A resource such as a file system watcher that cleans up the resource when `.dispose()` is called.
- * - The return value from registering a provider. When `.dispose()` is called, the provider is unregistered.
- */
-interface IDisposable {
-    dispose(): void;
-}
-/**
- * Manages a collection of disposable values.
- *
- * This is the preferred way to manage multiple disposables. A `DisposableStore` is safer to work with than an
- * `IDisposable[]` as it considers edge cases, such as registering the same value multiple times or adding an item to a
- * store that has already been disposed of.
- */
-declare class DisposableStore implements IDisposable {
-    static DISABLE_DISPOSED_WARNING: boolean;
-    private readonly _toDispose;
-    private _isDisposed;
-    constructor();
-    /**
-     * Dispose of all registered disposables and mark this object as disposed.
-     *
-     * Any future disposables added to this object will be disposed of on `add`.
-     */
-    dispose(): void;
-    /**
-     * @return `true` if this object has been disposed of.
-     */
-    get isDisposed(): boolean;
-    /**
-     * Dispose of all registered disposables but do not mark this object as disposed.
-     */
-    clear(): void;
-    /**
-     * Add a new {@link IDisposable disposable} to the collection.
-     */
-    add<T extends IDisposable>(o: T): T;
-}
-interface IReference<T> extends IDisposable {
-    readonly object: T;
-}
-
-interface IObservable<T, TChange = void> {
-    readonly TChange: TChange;
-    /**
-     * Reads the current value.
-     *
-     * Must not be called from {@link IObserver.handleChange}.
-     */
-    get(): T;
-    /**
-     * Adds an observer.
-     */
-    addObserver(observer: IObserver): void;
-    removeObserver(observer: IObserver): void;
-    /**
-     * Subscribes the reader to this observable and returns the current value of this observable.
-     */
-    read(reader: IReader): T;
-    map<TNew>(fn: (value: T) => TNew): IObservable<TNew>;
-    readonly debugName: string;
-}
-interface IReader {
-    /**
-     * Reports an observable that was read.
-     *
-     * Is called by {@link IObservable.read}.
-     */
-    subscribeTo<T>(observable: IObservable<T, any>): void;
-}
-interface IObserver {
-    /**
-     * Indicates that an update operation is about to begin.
-     *
-     * During an update, invariants might not hold for subscribed observables and
-     * change events might be delayed.
-     * However, all changes must be reported before all update operations are over.
-     */
-    beginUpdate<T>(observable: IObservable<T>): void;
-    /**
-     * Is called by a subscribed observable immediately after it notices a change.
-     *
-     * When {@link IObservable.get} returns and no change has been reported,
-     * there has been no change for that observable.
-     *
-     * Implementations must not call into other observables!
-     * The change should be processed when {@link IObserver.endUpdate} is called.
-     */
-    handleChange<T, TChange>(observable: IObservable<T, TChange>, change: TChange): void;
-    /**
-     * Indicates that an update operation has completed.
-     */
-    endUpdate<T>(observable: IObservable<T>): void;
-}
-
-/**
- * Can be passed into the Delayed to defer using a microtask
- * */
-declare const MicrotaskDelay: unique symbol;
-
-/**
- * An event with zero or one parameters that can be subscribed to. The event is a function itself.
- */
-type Event<T> = vscode.Event<T>
-declare namespace Event {
-    const None: Event<any>;
-    /**
-     * Given an event, returns another event which debounces calls and defers the listeners to a later task via a shared
-     * `setTimeout`. The event is converted into a signal (`Event<void>`) to avoid additional object creation as a
-     * result of merging events and to try prevent race conditions that could arise when using related deferred and
-     * non-deferred events.
-     *
-     * This is useful for deferring non-critical work (eg. general UI updates) to ensure it does not block critical work
-     * (eg. latency of keypress to text rendered).
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @param event The event source for the new event.
-     * @param disposable A disposable store to add the new EventEmitter to.
-     */
-    function defer(event: Event<unknown>, disposable?: DisposableStore): Event<void>;
-    /**
-     * Given an event, returns another event which only fires once.
-     *
-     * @param event The event source for the new event.
-     */
-    function once<T>(event: Event<T>): Event<T>;
-    /**
-     * Maps an event of one type into an event of another type using a mapping function, similar to how
-     * `Array.prototype.map` works.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @param event The event source for the new event.
-     * @param map The mapping function.
-     * @param disposable A disposable store to add the new EventEmitter to.
-     */
-    function map<I, O>(event: Event<I>, map: (i: I) => O, disposable?: DisposableStore): Event<O>;
-    /**
-     * Wraps an event in another event that performs some function on the event object before firing.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @param event The event source for the new event.
-     * @param each The function to perform on the event object.
-     * @param disposable A disposable store to add the new EventEmitter to.
-     */
-    function forEach<I>(event: Event<I>, each: (i: I) => void, disposable?: DisposableStore): Event<I>;
-    /**
-     * Wraps an event in another event that fires only when some condition is met.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @param event The event source for the new event.
-     * @param filter The filter function that defines the condition. The event will fire for the object if this function
-     * returns true.
-     * @param disposable A disposable store to add the new EventEmitter to.
-     */
-    function filter<T, U>(event: Event<T | U>, filter: (e: T | U) => e is T, disposable?: DisposableStore): Event<T>;
-    function filter<T>(event: Event<T>, filter: (e: T) => boolean, disposable?: DisposableStore): Event<T>;
-    function filter<T, R>(event: Event<T | R>, filter: (e: T | R) => e is R, disposable?: DisposableStore): Event<R>;
-    /**
-     * Given an event, returns the same event but typed as `Event<void>`.
-     */
-    function signal<T>(event: Event<T>): Event<void>;
-    /**
-     * Given a collection of events, returns a single event which emits whenever any of the provided events emit.
-     */
-    function any<T>(...events: Event<T>[]): Event<T>;
-    function any(...events: Event<any>[]): Event<void>;
-    /**
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     */
-    function reduce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, initial?: O, disposable?: DisposableStore): Event<O>;
-    /**
-     * Given an event, creates a new emitter that event that will debounce events based on {@link delay} and give an
-     * array event object of all events that fired.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @param event The original event to debounce.
-     * @param merge A function that reduces all events into a single event.
-     * @param delay The number of milliseconds to debounce.
-     * @param leading Whether to fire a leading event without debouncing.
-     * @param flushOnListenerRemove Whether to fire all debounced events when a listener is removed. If this is not
-     * specified, some events could go missing. Use this if it's important that all events are processed, even if the
-     * listener gets disposed before the debounced event fires.
-     * @param leakWarningThreshold See {@link EmitterOptions.leakWarningThreshold}.
-     * @param disposable A disposable store to register the debounce emitter to.
-     */
-    function debounce<T>(event: Event<T>, merge: (last: T | undefined, event: T) => T, delay?: number | typeof MicrotaskDelay, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<T>;
-    function debounce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay?: number | typeof MicrotaskDelay, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<O>;
-    /**
-     * Debounces an event, firing after some delay (default=0) with an array of all event original objects.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     */
-    function accumulate<T>(event: Event<T>, delay?: number, disposable?: DisposableStore): Event<T[]>;
-    /**
-     * Filters an event such that some condition is _not_ met more than once in a row, effectively ensuring duplicate
-     * event objects from different sources do not fire the same event object.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @param event The event source for the new event.
-     * @param equals The equality condition.
-     * @param disposable A disposable store to add the new EventEmitter to.
-     *
-     * @example
-     * ```
-     * // Fire only one time when a single window is opened or focused
-     * Event.latch(Event.any(onDidOpenWindow, onDidFocusWindow))
-     * ```
-     */
-    function latch<T>(event: Event<T>, equals?: (a: T, b: T) => boolean, disposable?: DisposableStore): Event<T>;
-    /**
-     * Splits an event whose parameter is a union type into 2 separate events for each type in the union.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @example
-     * ```
-     * const event = new EventEmitter<number | undefined>().event;
-     * const [numberEvent, undefinedEvent] = Event.split(event, isUndefined);
-     * ```
-     *
-     * @param event The event source for the new event.
-     * @param isT A function that determines what event is of the first type.
-     * @param disposable A disposable store to add the new EventEmitter to.
-     */
-    function split<T, U>(event: Event<T | U>, isT: (e: T | U) => e is T, disposable?: DisposableStore): [Event<T>, Event<U>];
-    /**
-     * Buffers an event until it has a listener attached.
-     *
-     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
-     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
-     * returned event causes this utility to leak a listener on the original event.
-     *
-     * @param event The event source for the new event.
-     * @param flushAfterTimeout Determines whether to flush the buffer after a timeout immediately or after a
-     * `setTimeout` when the first event listener is added.
-     * @param _buffer Internal: A source event array used for tests.
-     *
-     * @example
-     * ```
-     * // Start accumulating events, when the first listener is attached, flush
-     * // the event after a timeout such that multiple listeners attached before
-     * // the timeout would receive the event
-     * this.onInstallExtension = Event.buffer(service.onInstallExtension, true);
-     * ```
-     */
-    function buffer<T>(event: Event<T>, flushAfterTimeout?: boolean, _buffer?: T[]): Event<T>;
-    interface IChainableEvent<T> extends IDisposable {
-        event: Event<T>;
-        map<O>(fn: (i: T) => O): IChainableEvent<O>;
-        forEach(fn: (i: T) => void): IChainableEvent<T>;
-        filter(fn: (e: T) => boolean): IChainableEvent<T>;
-        filter<R>(fn: (e: T | R) => e is R): IChainableEvent<R>;
-        reduce<R>(merge: (last: R | undefined, event: T) => R, initial?: R): IChainableEvent<R>;
-        latch(): IChainableEvent<T>;
-        debounce(merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number): IChainableEvent<T>;
-        debounce<R>(merge: (last: R | undefined, event: T) => R, delay?: number, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number): IChainableEvent<R>;
-        on(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[] | DisposableStore): IDisposable;
-        once(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[]): IDisposable;
-    }
-    /**
-     * Wraps the event in an {@link IChainableEvent}, allowing a more functional programming style.
-     *
-     * @example
-     * ```
-     * // Normal
-     * const onEnterPressNormal = Event.filter(
-     *   Event.map(onKeyPress.event, e => new StandardKeyboardEvent(e)),
-     *   e.keyCode === KeyCode.Enter
-     * ).event;
-     *
-     * // Using chain
-     * const onEnterPressChain = Event.chain(onKeyPress.event)
-     *   .map(e => new StandardKeyboardEvent(e))
-     *   .filter(e => e.keyCode === KeyCode.Enter)
-     *   .event;
-     * ```
-     */
-    function chain<T>(event: Event<T>): IChainableEvent<T>;
-    interface NodeEventEmitter {
-        on(event: string | symbol, listener: Function): unknown;
-        removeListener(event: string | symbol, listener: Function): unknown;
-    }
-    /**
-     * Creates an {@link Event} from a node event emitter.
-     */
-    function fromNodeEventEmitter<T>(emitter: NodeEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
-    interface DOMEventEmitter {
-        addEventListener(event: string | symbol, listener: Function): void;
-        removeEventListener(event: string | symbol, listener: Function): void;
-    }
-    /**
-     * Creates an {@link Event} from a DOM event emitter.
-     */
-    function fromDOMEventEmitter<T>(emitter: DOMEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
-    /**
-     * Creates a promise out of an event, using the {@link Event.once} helper.
-     */
-    function toPromise<T>(event: Event<T>): Promise<T>;
-    /**
-     * Adds a listener to an event and calls the listener immediately with undefined as the event object.
-     *
-     * @example
-     * ```
-     * // Initialize the UI and update it when dataChangeEvent fires
-     * runAndSubscribe(dataChangeEvent, () => this._updateUI());
-     * ```
-     */
-    function runAndSubscribe<T>(event: Event<T>, handler: (e: T | undefined) => any): IDisposable;
-    /**
-     * Adds a listener to an event and calls the listener immediately with undefined as the event object. A new
-     * {@link DisposableStore} is passed to the listener which is disposed when the returned disposable is disposed.
-     */
-    function runAndSubscribeWithStore<T>(event: Event<T>, handler: (e: T | undefined, disposableStore: DisposableStore) => any): IDisposable;
-    function fromObservable<T>(obs: IObservable<T, any>, store?: DisposableStore): Event<T>;
-}
-
-/**
- * Text snapshot that works like an iterator.
- * Will try to return chunks of roughly ~64KB size.
- * Will return null when finished.
- */
-interface ITextSnapshot {
-    read(): string | null;
-}
-/**
- * A model.
- */
-type ITextModel = monaco.editor.ITextModel
-
-/**
- * A rich code editor.
- */
-type ICodeEditor = monaco.editor.ICodeEditor
-
-interface IEditorModel {
-    /**
-     * Emitted when the model is about to be disposed.
-     */
-    readonly onWillDispose: Event<void>;
-    /**
-     * Resolves the model.
-     */
-    resolve(): Promise<void>;
-    /**
-     * Find out if the editor model was resolved or not.
-     */
-    isResolved(): boolean;
-    /**
-     * Find out if this model has been disposed.
-     */
-    isDisposed(): boolean;
-    /**
-     * Dispose associated resources
-     */
-    dispose(): void;
-}
-declare enum EditorActivation {
-    /**
-     * Activate the editor after it opened. This will automatically restore
-     * the editor if it is minimized.
-     */
-    ACTIVATE = 1,
-    /**
-     * Only restore the editor if it is minimized but do not activate it.
-     *
-     * Note: will only work in combination with the `preserveFocus: true` option.
-     * Otherwise, if focus moves into the editor, it will activate and restore
-     * automatically.
-     */
-    RESTORE = 2,
-    /**
-     * Preserve the current active editor.
-     *
-     * Note: will only work in combination with the `preserveFocus: true` option.
-     * Otherwise, if focus moves into the editor, it will activate and restore
-     * automatically.
-     */
-    PRESERVE = 3
-}
-declare enum EditorResolution {
-    /**
-     * Displays a picker and allows the user to decide which editor to use.
-     */
-    PICK = 0,
-    /**
-     * Only exclusive editors are considered.
-     */
-    EXCLUSIVE_ONLY = 1
-}
-declare enum EditorOpenSource {
-    /**
-     * Default: the editor is opening via a programmatic call
-     * to the editor service API.
-     */
-    API = 0,
-    /**
-     * Indicates that a user action triggered the opening, e.g.
-     * via mouse or keyboard use.
-     */
-    USER = 1
-}
-interface IEditorOptions {
-    /**
-     * Tells the editor to not receive keyboard focus when the editor is being opened.
-     *
-     * Will also not activate the group the editor opens in unless the group is already
-     * the active one. This behaviour can be overridden via the `activation` option.
-     */
-    preserveFocus?: boolean;
-    /**
-     * This option is only relevant if an editor is opened into a group that is not active
-     * already and allows to control if the inactive group should become active, restored
-     * or preserved.
-     *
-     * By default, the editor group will become active unless `preserveFocus` or `inactive`
-     * is specified.
-     */
-    activation?: EditorActivation;
-    /**
-     * Tells the editor to reload the editor input in the editor even if it is identical to the one
-     * already showing. By default, the editor will not reload the input if it is identical to the
-     * one showing.
-     */
-    forceReload?: boolean;
-    /**
-     * Will reveal the editor if it is already opened and visible in any of the opened editor groups.
-     *
-     * Note that this option is just a hint that might be ignored if the user wants to open an editor explicitly
-     * to the side of another one or into a specific editor group.
-     */
-    revealIfVisible?: boolean;
-    /**
-     * Will reveal the editor if it is already opened (even when not visible) in any of the opened editor groups.
-     *
-     * Note that this option is just a hint that might be ignored if the user wants to open an editor explicitly
-     * to the side of another one or into a specific editor group.
-     */
-    revealIfOpened?: boolean;
-    /**
-     * An editor that is pinned remains in the editor stack even when another editor is being opened.
-     * An editor that is not pinned will always get replaced by another editor that is not pinned.
-     */
-    pinned?: boolean;
-    /**
-     * An editor that is sticky moves to the beginning of the editors list within the group and will remain
-     * there unless explicitly closed. Operations such as "Close All" will not close sticky editors.
-     */
-    sticky?: boolean;
-    /**
-     * The index in the document stack where to insert the editor into when opening.
-     */
-    index?: number;
-    /**
-     * An active editor that is opened will show its contents directly. Set to true to open an editor
-     * in the background without loading its contents.
-     *
-     * Will also not activate the group the editor opens in unless the group is already
-     * the active one. This behaviour can be overridden via the `activation` option.
-     */
-    inactive?: boolean;
-    /**
-     * Will not show an error in case opening the editor fails and thus allows to show a custom error
-     * message as needed. By default, an error will be presented as notification if opening was not possible.
-     */
-    /**
-     * In case of an error opening the editor, will not present this error to the user (e.g. by showing
-     * a generic placeholder in the editor area). So it is up to the caller to provide error information
-     * in that case.
-     *
-     * By default, an error when opening an editor will result in a placeholder editor that shows the error.
-     * In certain cases a modal dialog may be presented to ask the user for further action.
-     */
-    ignoreError?: boolean;
-    /**
-     * Allows to override the editor that should be used to display the input:
-     * - `undefined`: let the editor decide for itself
-     * - `string`: specific override by id
-     * - `EditorResolution`: specific override handling
-     */
-    override?: string | EditorResolution;
-    /**
-     * A optional hint to signal in which context the editor opens.
-     *
-     * If configured to be `EditorOpenSource.USER`, this hint can be
-     * used in various places to control the experience. For example,
-     * if the editor to open fails with an error, a notification could
-     * inform about this in a modal dialog. If the editor opened through
-     * some background task, the notification would show in the background,
-     * not as a modal dialog.
-     */
-    source?: EditorOpenSource;
-    /**
-     * An optional property to signal that certain view state should be
-     * applied when opening the editor.
-     */
-    viewState?: object;
-}
-
-type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
-
-interface ITextEditorModel extends IEditorModel {
-    /**
-     * Provides access to the underlying `ITextModel`.
-     */
-    readonly textEditorModel: ITextModel | null;
-    /**
-     * Creates a snapshot of the model's contents.
-     */
-    createSnapshot(this: IResolvedTextEditorModel): ITextSnapshot;
-    createSnapshot(this: ITextEditorModel): ITextSnapshot | null;
-    /**
-     * Signals if this model is readonly or not.
-     */
-    isReadonly(): boolean;
-    /**
-     * The language id of the text model if known.
-     */
-    getLanguageId(): string | undefined;
-}
-interface IResolvedTextEditorModel extends ITextEditorModel {
-    /**
-     * Same as ITextEditorModel#textEditorModel, but never null.
-     */
-    readonly textEditorModel: ITextModel;
-}
+import { I as IEditorOverrideServices } from '../standaloneServices.js';
+import { p as IResolvedTextEditorModel, j as ICodeEditor } from '../editorBrowser.js';
+import { c as IEditorOptions } from '../editor.js';
+import { a as IReference } from '../event.js';
+import '../instantiation.js';
+import 'monaco-editor';
+import '../uri.js';
+import '../themables.js';
+import 'vscode';
 
 type OpenEditor = (modelRef: IReference<IResolvedTextEditorModel>, options: IEditorOptions | undefined, sideBySide?: boolean) => Promise<ICodeEditor | undefined>;
 declare function getServiceOverride(openEditor: OpenEditor): IEditorOverrideServices;

package/dist/service-override/modelEditor.js

@@ -63,8 +63,8 @@ let EditorService = class EditorService extends Disposable {
         this.isOpened = () => false;
         this.isVisible = () => false;
         this.findEditors = () => [];
-        this.save = async () => true;
-        this.saveAll = async () => true;
+        this.save = async () => ({ success: true, editors: [] });
+        this.saveAll = async () => ({ success: true, editors: [] });
         this.revert = unsupported;
         this.revertAll = unsupported;
         this.closeEditor = unsupported;
@@ -110,7 +110,9 @@ let EditorService = class EditorService extends Disposable {
         if (options != null) {
             applyTextEditorOptions(options, modelEditor, 1 );
         }
-        modelEditor.focus();
+        if (!(options?.preserveFocus ?? false)) {
+            modelEditor.focus();
+        }
         return new SimpleEditorPane(modelEditor);
     }
 };

package/dist/service-override/notifications.d.ts

@@ -1,6 +1,6 @@
-import * as monaco from 'monaco-editor';
-
-type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
+import { I as IEditorOverrideServices } from '../standaloneServices.js';
+import '../instantiation.js';
+import 'monaco-editor';
 
 declare function getServiceOverride(container?: HTMLElement): IEditorOverrideServices;
 

package/dist/service-override/preferences.d.ts

@@ -1,6 +1,6 @@
-import * as monaco from 'monaco-editor';
-
-type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
+import { I as IEditorOverrideServices } from '../standaloneServices.js';
+import '../instantiation.js';
+import 'monaco-editor';
 
 declare function getServiceOverride(): IEditorOverrideServices;
 

package/dist/service-override/snippets.d.ts

@@ -1,6 +1,6 @@
-import * as monaco from 'monaco-editor';
-
-type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
+import { I as IEditorOverrideServices } from '../standaloneServices.js';
+import '../instantiation.js';
+import 'monaco-editor';
 
 interface ISnippetsExtensionPoint {
     language: string;

package/dist/service-override/textmate.d.ts

@@ -1,15 +1,7 @@
-import * as monaco from 'monaco-editor';
+import { I as IEditorOverrideServices } from '../standaloneServices.js';
+import { S as ServiceIdentifier } from '../instantiation.js';
 import { IGrammar } from 'vscode-textmate';
-
-/**
- * Identifies a service of type `T`.
- */
-interface ServiceIdentifier<T> {
-    (...args: any[]): void;
-    type: T;
-}
-
-type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
+import 'monaco-editor';
 
 declare const ITextMateTokenizationService: ServiceIdentifier<ITextMateTokenizationService>;
 interface ITextMateTokenizationService {

package/dist/service-override/theme.d.ts

@@ -1,19 +1,7 @@
-import * as monaco from 'monaco-editor';
-
-declare const VS_LIGHT_THEME = "vs";
-declare const VS_DARK_THEME = "vs-dark";
-declare const VS_HC_THEME = "hc-black";
-declare const VS_HC_LIGHT_THEME = "hc-light";
-interface IThemeExtensionPoint {
-    id: string;
-    label?: string;
-    description?: string;
-    path: string;
-    uiTheme?: typeof VS_LIGHT_THEME | typeof VS_DARK_THEME | typeof VS_HC_THEME | typeof VS_HC_LIGHT_THEME;
-    _watch: boolean;
-}
-
-type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
+import { b as IThemeExtensionPoint } from '../workbenchThemeService.js';
+import { I as IEditorOverrideServices } from '../standaloneServices.js';
+import '../instantiation.js';
+import 'monaco-editor';
 
 type PartialIThemeExtensionPoint = Partial<IThemeExtensionPoint> & Pick<IThemeExtensionPoint, 'id' | 'path'>;
 declare function getServiceOverride(): IEditorOverrideServices;