@codingame/monaco-vscode-api 1.69.19 → 1.69.21

package/README.md

@@ -33,15 +33,15 @@ Services.install({
 Also, monaco-editor use `standalone` versions or the vscode services, which are much simpler.
 
 You may want to provide your custom implementations of them, especially for: `textModelService`, `codeEditorService` and `notificationService`. To do so, you can provide them as the third parameter while creating your first editor.
-This library allows you to use a more convenient way using `StandaloneService.initialize`.
+This library allows you to use a more convenient way using `StandaloneServices.initialize`.
 Also, monaco-editor doesn't provide good type for them, so this library does it.
 
 Example:
 ```typescript
-import { StandaloneService, INotificationService } from 'vscode/services'
+import { StandaloneServices, INotificationService } from 'vscode/services'
 
 class MyCustomNotificationService implements INotificationService { ... }
-StandaloneService.initialize({
+StandaloneServices.initialize({
   get [INotificationService.toString()] () {
     return new MyCustomNotificationService(...)
   }
@@ -63,7 +63,7 @@ Additionally, this library exposes 10 modules that include the vscode version of
 
 Usage:
 ```typescript
-import { StandaloneService } from 'vscode/services'
+import { StandaloneServices } from 'vscode/services'
 import getModelEditorServiceOverride from 'vscode/service-override/modelEditor'
 import getMessageServiceOverride from 'vscode/service-override/messages'
 import getConfigurationServiceOverride, { updateUserConfiguration, configurationRegistry } from 'vscode/service-override/configuration'

package/dist/api.js

@@ -1,7 +1,7 @@
 import './polyfill.js';
-import { B as Breakpoint$1, C as CallHierarchyIncomingCall$1, a as CallHierarchyItem$1, b as CallHierarchyOutgoingCall$1, c as CodeAction$1, d as CodeActionKind$1, e as CodeActionTriggerKind$1, f as CodeLens$1, g as Color$1, h as ColorInformation$1, i as ColorPresentation$1, j as CommentMode$1, k as CommentThreadCollapsibleState$1, l as CompletionItem$1, m as CompletionItemKind$1, n as CompletionItemTag$1, o as CompletionList$1, p as CompletionTriggerKind$1, q as ConfigurationTarget$1, r as CustomExecution$1, D as DebugAdapterExecutable$1, s as DebugAdapterInlineImplementation$1, t as DebugAdapterNamedPipeServer$1, u as DebugAdapterServer$1, v as DebugConsoleMode$1, w as DecorationRangeBehavior$1, x as Diagnostic$1, y as DiagnosticRelatedInformation$1, z as DiagnosticSeverity$1, A as DiagnosticTag$1, E as Disposable$1, F as DocumentHighlight$1, G as DocumentHighlightKind$1, H as DocumentLink$1, I as DocumentSymbol$1, J as EndOfLine$1, K as EnvironmentVariableMutatorType$1, L as EvaluatableExpression$1, M as InlineValueText$1, N as InlineValueVariableLookup$1, O as InlineValueEvaluatableExpression$1, P as ExtensionKind$1, Q as ExtensionMode$1, R as FileChangeType$1, S as FileDecoration$1, T as FileSystemError$1, U as FoldingRange$1, V as FoldingRangeKind$1, W as FunctionBreakpoint$1, X as Hover$1, Y as Location$1, Z as MarkdownString$1, _ as ParameterInformation$1, $ as Position$1, a0 as ProcessExecution$1, a1 as ProgressLocation$1, a2 as QuickInputButtons$1, a3 as Range$1, a4 as RelativePattern$1, a5 as Selection$2, a6 as SelectionRange$1, a7 as SemanticTokens$1, a8 as SemanticTokensBuilder$1, a9 as SemanticTokensEdit$1, aa as SemanticTokensEdits$1, ab as SemanticTokensLegend$1, ac as ShellExecution$1, ad as ShellQuoting$1, ae as SignatureHelp$1, af as SignatureHelpTriggerKind$1, ag as SignatureInformation$1, ah as SnippetString$1, ai as SourceBreakpoint$1, aj as StatusBarAlignment$1, ak as SymbolInformation$1, al as SymbolKind$1, am as SymbolTag$1, an as Task$1, ao as TaskGroup$1, ap as TaskPanelKind$1, aq as TaskRevealKind$1, ar as TaskScope$1, as as TerminalLink$1, at as TerminalLocation$1, au as TerminalProfile$1, av as TextDocumentSaveReason$1, aw as TextEdit$1, ax as TextEditorLineNumbersStyle$1, ay as TextEditorRevealType$1, az as TextEditorSelectionChangeKind$1, aA as TextDocumentChangeReason$1, aB as ThemeColor$1, aC as ThemeIcon$1, aD as TreeItem$1, aE as TreeItemCollapsibleState$1, aF as TypeHierarchyItem$1, aG as UIKind$1, aH as ViewColumn$1, aI as WorkspaceEdit$1, aJ as InlayHint$1, aK as InlayHintLabelPart$1, aL as InlayHintKind$1, aM as NotebookRange$1, aN as NotebookCellKind$1, aO as NotebookCellData$1, aP as NotebookData$1, aQ as NotebookCellStatusBarAlignment$1, aR as NotebookCellOutput$1, aS as NotebookCellOutputItem$1, aT as NotebookCellStatusBarItem$1, aU as NotebookControllerAffinity$1, aV as LinkedEditingRanges$1, aW as TestRunRequest$1, aX as TestMessage$1, aY as TestTag$1, aZ as TestRunProfileKind$1, a_ as LanguageStatusSeverity$1, a$ as QuickPickItemKind$1, b0 as TextDiffTabInput, b1 as CustomEditorTabInput, b2 as NotebookEditorTabInput, b3 as NotebookDiffEditorTabInput, b4 as WebviewEditorTabInput, b5 as TerminalEditorTabInput, b6 as InputBoxValidationSeverity$1, b7 as InlineSuggestionList, b8 as InlineCompletionTriggerKind$1, b9 as InlineSuggestion, ba as DocumentDropEdit$1, bb as NotebookEditorRevealType$1, bc as getExtHostServices, bd as DEFAULT_EXTENSION, be as LanguageSelector } from './extHost.js';
-import { C as CancellationTokenSource$1, F as FileType$1, a as FilePermission$1, S as Services } from './services2.js';
+import { B as Breakpoint$1, C as CallHierarchyIncomingCall$1, a as CallHierarchyItem$1, b as CallHierarchyOutgoingCall$1, c as CancellationTokenSource$1, d as CodeAction$1, e as CodeActionKind$1, f as CodeActionTriggerKind$1, g as CodeLens$1, h as Color$1, i as ColorInformation$1, j as ColorPresentation$1, k as CommentMode$1, l as CommentThreadCollapsibleState$1, m as CompletionItem$1, n as CompletionItemKind$1, o as CompletionItemTag$1, p as CompletionList$1, q as CompletionTriggerKind$1, r as ConfigurationTarget$1, s as CustomExecution$1, D as DebugAdapterExecutable$1, t as DebugAdapterInlineImplementation$1, u as DebugAdapterNamedPipeServer$1, v as DebugAdapterServer$1, w as DebugConsoleMode$1, x as DecorationRangeBehavior$1, y as Diagnostic$1, z as DiagnosticRelatedInformation$1, A as DiagnosticSeverity$1, E as DiagnosticTag$1, F as Disposable$1, G as DocumentHighlight$1, H as DocumentHighlightKind$1, I as DocumentLink$1, J as DocumentSymbol$1, K as EndOfLine$1, L as EnvironmentVariableMutatorType$1, M as EvaluatableExpression$1, N as InlineValueText$1, O as InlineValueVariableLookup$1, P as InlineValueEvaluatableExpression$1, Q as ExtensionKind$1, R as ExtensionMode$1, S as FileChangeType$1, T as FileDecoration$1, U as FileSystemError$1, V as FoldingRange$1, W as FoldingRangeKind$1, X as FunctionBreakpoint$1, Y as Hover$1, Z as Location$1, _ as MarkdownString$1, $ as ParameterInformation$1, a0 as Position$1, a1 as ProcessExecution$1, a2 as ProgressLocation$1, a3 as QuickInputButtons$1, a4 as Range$1, a5 as RelativePattern$1, a6 as Selection$2, a7 as SelectionRange$1, a8 as SemanticTokens$1, a9 as SemanticTokensBuilder$1, aa as SemanticTokensEdit$1, ab as SemanticTokensEdits$1, ac as SemanticTokensLegend$1, ad as ShellExecution$1, ae as ShellQuoting$1, af as SignatureHelp$1, ag as SignatureHelpTriggerKind$1, ah as SignatureInformation$1, ai as SnippetString$1, aj as SourceBreakpoint$1, ak as StatusBarAlignment$1, al as SymbolInformation$1, am as SymbolKind$1, an as SymbolTag$1, ao as Task$1, ap as TaskGroup$1, aq as TaskPanelKind$1, ar as TaskRevealKind$1, as as TaskScope$1, at as TerminalLink$1, au as TerminalLocation$1, av as TerminalProfile$1, aw as TextDocumentSaveReason$1, ax as TextEdit$1, ay as TextEditorLineNumbersStyle$1, az as TextEditorRevealType$1, aA as TextEditorSelectionChangeKind$1, aB as TextDocumentChangeReason$1, aC as ThemeColor$1, aD as ThemeIcon$1, aE as TreeItem$1, aF as TreeItemCollapsibleState$1, aG as TypeHierarchyItem$1, aH as UIKind$1, aI as ViewColumn$1, aJ as WorkspaceEdit$1, aK as InlayHint$1, aL as InlayHintLabelPart$1, aM as InlayHintKind$1, aN as NotebookRange$1, aO as NotebookCellKind$1, aP as NotebookCellData$1, aQ as NotebookData$1, aR as NotebookCellStatusBarAlignment$1, aS as NotebookCellOutput$1, aT as NotebookCellOutputItem$1, aU as NotebookCellStatusBarItem$1, aV as NotebookControllerAffinity$1, aW as LinkedEditingRanges$1, aX as TestRunRequest$1, aY as TestMessage$1, aZ as TestTag$1, a_ as TestRunProfileKind$1, a$ as LanguageStatusSeverity$1, b0 as QuickPickItemKind$1, b1 as TextDiffTabInput, b2 as CustomEditorTabInput, b3 as NotebookEditorTabInput, b4 as NotebookDiffEditorTabInput, b5 as WebviewEditorTabInput, b6 as TerminalEditorTabInput, b7 as InputBoxValidationSeverity$1, b8 as InlineSuggestionList, b9 as InlineCompletionTriggerKind$1, ba as InlineSuggestion, bb as DocumentDropEdit$1, bc as NotebookEditorRevealType$1, bd as getExtHostServices, be as DEFAULT_EXTENSION, bf as LanguageSelector } from './extHost.js';
 import { E as Emitter } from './workspace.js';
+import { F as FileType$1, a as FilePermission$1, S as Services } from './services2.js';
 import { score } from 'monaco-editor/esm/vs/editor/common/languageSelector.js';
 import { u as unsupported$1 } from './missing-services.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';

package/dist/async.js

@@ -0,0 +1,196 @@
+import { E as Emitter } from './workspace.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { extUri } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { CancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+function raceCancellationError(promise, token) {
+    return ( new Promise((resolve, reject) => {
+        const ref = token.onCancellationRequested(() => {
+            ref.dispose();
+            reject(( new CancellationError()));
+        });
+        promise.then(resolve, reject).finally(() => ref.dispose());
+    }));
+}
+class Sequencer {
+    constructor() {
+        this.current = Promise.resolve(null);
+    }
+    queue(promiseTask) {
+        return this.current = this.current.then(() => promiseTask(), () => promiseTask());
+    }
+}
+class Barrier {
+    constructor() {
+        this._isOpen = false;
+        this._promise = ( new Promise((c, e) => {
+            this._completePromise = c;
+        }));
+    }
+    isOpen() {
+        return this._isOpen;
+    }
+    open() {
+        this._isOpen = true;
+        this._completePromise(true);
+    }
+    wait() {
+        return this._promise;
+    }
+}
+class Limiter {
+    constructor(maxDegreeOfParalellism) {
+        this._size = 0;
+        this.maxDegreeOfParalellism = maxDegreeOfParalellism;
+        this.outstandingPromises = [];
+        this.runningPromises = 0;
+        this._onDrained = ( new Emitter());
+    }
+    get onDrained() {
+        return this._onDrained.event;
+    }
+    get size() {
+        return this._size;
+    }
+    queue(factory) {
+        this._size++;
+        return ( new Promise((c, e) => {
+            this.outstandingPromises.push({ factory, c, e });
+            this.consume();
+        }));
+    }
+    consume() {
+        while (this.outstandingPromises.length && this.runningPromises < this.maxDegreeOfParalellism) {
+            const iLimitedTask = this.outstandingPromises.shift();
+            this.runningPromises++;
+            const promise = iLimitedTask.factory();
+            promise.then(iLimitedTask.c, iLimitedTask.e);
+            promise.then(() => this.consumed(), () => this.consumed());
+        }
+    }
+    consumed() {
+        this._size--;
+        this.runningPromises--;
+        if (this.outstandingPromises.length > 0) {
+            this.consume();
+        }
+        else {
+            this._onDrained.fire();
+        }
+    }
+    dispose() {
+        this._onDrained.dispose();
+    }
+}
+class Queue extends Limiter {
+    constructor() {
+        super(1);
+    }
+}
+class ResourceQueue {
+    constructor() {
+        this.queues = ( new Map());
+        this.drainers = ( new Set());
+    }
+    async whenDrained() {
+        if (this.isDrained()) {
+            return;
+        }
+        const promise = ( new DeferredPromise());
+        this.drainers.add(promise);
+        return promise.p;
+    }
+    isDrained() {
+        for (const [, queue] of this.queues) {
+            if (queue.size > 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    queueFor(resource, extUri$1 = extUri) {
+        const key = extUri$1.getComparisonKey(resource);
+        let queue = this.queues.get(key);
+        if (!queue) {
+            queue = ( new Queue());
+            Event.once(queue.onDrained)(() => {
+                queue?.dispose();
+                this.queues.delete(key);
+                this.onDidQueueDrain();
+            });
+            this.queues.set(key, queue);
+        }
+        return queue;
+    }
+    onDidQueueDrain() {
+        if (!this.isDrained()) {
+            return;
+        }
+        this.releaseDrainers();
+    }
+    releaseDrainers() {
+        for (const drainer of this.drainers) {
+            drainer.complete();
+        }
+        this.drainers.clear();
+    }
+    dispose() {
+        for (const [, queue] of this.queues) {
+            queue.dispose();
+        }
+        this.queues.clear();
+        this.releaseDrainers();
+    }
+}
+class IntervalCounter {
+    constructor(interval, nowFn = () => Date.now()) {
+        this.interval = interval;
+        this.nowFn = nowFn;
+        this.lastIncrementTime = 0;
+        this.value = 0;
+    }
+    increment() {
+        const now = this.nowFn();
+        if (now - this.lastIncrementTime > this.interval) {
+            this.lastIncrementTime = now;
+            this.value = 0;
+        }
+        this.value++;
+        return this.value;
+    }
+}
+class DeferredPromise {
+    constructor() {
+        this.rejected = false;
+        this.resolved = false;
+        this.p = ( new Promise((c, e) => {
+            this.completeCallback = c;
+            this.errorCallback = e;
+        }));
+    }
+    get isRejected() {
+        return this.rejected;
+    }
+    get isResolved() {
+        return this.resolved;
+    }
+    get isSettled() {
+        return this.rejected || this.resolved;
+    }
+    complete(value) {
+        return ( new Promise(resolve => {
+            this.completeCallback(value);
+            this.resolved = true;
+            resolve();
+        }));
+    }
+    error(err) {
+        return ( new Promise(resolve => {
+            this.errorCallback(err);
+            this.rejected = true;
+            resolve();
+        }));
+    }
+    cancel() {
+    }
+}
+export { Barrier as B, IntervalCounter as I, ResourceQueue as R, Sequencer as S, raceCancellationError as r };

package/dist/configuration.d.ts

@@ -1,5 +1,5 @@
-import * as monaco from 'monaco-editor';
 import * as vscode from 'vscode';
+import * as monaco from 'monaco-editor';
 
 interface IDisposable {
     dispose(): void;
@@ -483,7 +483,8 @@ interface IColorCustomizations {
 
 declare function updateUserConfiguration(configurationJson: string): Promise<void>;
 declare function getUserConfiguration(): Promise<string>;
+declare function onUserConfigurationChange(callback: () => void): vscode.Disposable;
 declare const configurationRegistry: IConfigurationRegistry;
 declare function getServiceOverride(): IEditorOverrideServices;
 
-export { ConfigurationScope, IColorCustomizations, IConfigurationDefaults, IConfigurationNode, IThemeScopedColorCustomizations, configurationRegistry, getServiceOverride as default, getUserConfiguration, updateUserConfiguration };
+export { ConfigurationScope, IColorCustomizations, IConfigurationDefaults, IConfigurationNode, IThemeScopedColorCustomizations, configurationRegistry, getServiceOverride as default, getUserConfiguration, onUserConfigurationChange, updateUserConfiguration };

package/dist/configuration.js

@@ -1,7 +1,7 @@
 import { E as Emitter, _ as __decorate, a as __param } from './workspace.js';
-import { U as UserSettings } from './polyfill.js';
-import { e as IPolicyService, N as NullPolicyService, s as setProperty } from './missing-services.js';
-import { b as isEmptyObject } from './types.js';
+import { U as UserSettings, p as parseTree, f as findNodeAtLocation, c as createScanner } from './polyfill.js';
+import { b as IPolicyService, N as NullPolicyService } from './missing-services.js';
+import { i as isEmptyObject } from './types.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Extensions, machineOverridableSettings, windowSettings, resourceSettings, allSettings, OVERRIDE_PROPERTY_PATTERN, resourceLanguageSettingsSchemaId, OVERRIDE_PROPERTY_REGEX, overrideIdentifiersFromKey, applicationSettings, machineSettings } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
@@ -15,11 +15,11 @@ import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { isArray } from 'monaco-editor/esm/vs/base/common/types.js';
 import { extUriBiasedIgnorePathCase } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
-import { bf as Position$2, bg as keyFromOverrideIdentifiers, bh as configurationDefaultsSchemaId } from './extHost.js';
-export { bi as ConfigurationScope } from './extHost.js';
+import { bg as Position$2, bh as keyFromOverrideIdentifiers, bi as configurationDefaultsSchemaId } from './extHost.js';
+export { bj as ConfigurationScope } from './extHost.js';
 import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
 import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { q as IUserDataProfilesService, i as IFileService, j as IWorkbenchEnvironmentService } from './services2.js';
+import { r as IUserDataProfilesService, c as IFileService, l as IWorkbenchEnvironmentService } from './services2.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
 import { IWorkspaceTrustManagementService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
@@ -192,6 +192,328 @@ PolicyConfiguration = ( (__decorate([
     ( (__param(1, IPolicyService))),
     ( (__param(2, ILogService)))
 ], PolicyConfiguration)));
+function format(documentText, range, options) {
+    let initialIndentLevel;
+    let formatText;
+    let formatTextStart;
+    let rangeStart;
+    let rangeEnd;
+    if (range) {
+        rangeStart = range.offset;
+        rangeEnd = rangeStart + range.length;
+        formatTextStart = rangeStart;
+        while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+            formatTextStart--;
+        }
+        let endOffset = rangeEnd;
+        while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+            endOffset++;
+        }
+        formatText = documentText.substring(formatTextStart, endOffset);
+        initialIndentLevel = computeIndentLevel(formatText, options);
+    }
+    else {
+        formatText = documentText;
+        initialIndentLevel = 0;
+        formatTextStart = 0;
+        rangeStart = 0;
+        rangeEnd = documentText.length;
+    }
+    const eol = getEOL(options, documentText);
+    let lineBreak = false;
+    let indentLevel = 0;
+    let indentValue;
+    if (options.insertSpaces) {
+        indentValue = repeat(' ', options.tabSize || 4);
+    }
+    else {
+        indentValue = '\t';
+    }
+    const scanner = createScanner(formatText, false);
+    let hasError = false;
+    function newLineAndIndent() {
+        return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    function scanNext() {
+        let token = scanner.scan();
+        lineBreak = false;
+        while (token === 15  || token === 14 ) {
+            lineBreak = lineBreak || ((token === 14) );
+            token = scanner.scan();
+        }
+        hasError = token === 16  || scanner.getTokenError() !== 0 ;
+        return token;
+    }
+    const editOperations = [];
+    function addEdit(text, startOffset, endOffset) {
+        if (!hasError && startOffset < rangeEnd && endOffset > rangeStart && documentText.substring(startOffset, endOffset) !== text) {
+            editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+        }
+    }
+    let firstToken = scanNext();
+    if (firstToken !== 17 ) {
+        const firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+        const initialIndent = repeat(indentValue, initialIndentLevel);
+        addEdit(initialIndent, formatTextStart, firstTokenStart);
+    }
+    while (firstToken !== 17 ) {
+        let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+        let secondToken = scanNext();
+        let replaceContent = '';
+        while (!lineBreak && ((secondToken === 12  || secondToken === 13) )) {
+            const commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+            addEdit(' ', firstTokenEnd, commentTokenStart);
+            firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+            replaceContent = secondToken === 12  ? newLineAndIndent() : '';
+            secondToken = scanNext();
+        }
+        if (secondToken === 2 ) {
+            if (firstToken !== 1 ) {
+                indentLevel--;
+                replaceContent = newLineAndIndent();
+            }
+        }
+        else if (secondToken === 4 ) {
+            if (firstToken !== 3 ) {
+                indentLevel--;
+                replaceContent = newLineAndIndent();
+            }
+        }
+        else {
+            switch (firstToken) {
+                case 3 :
+                case 1 :
+                    indentLevel++;
+                    replaceContent = newLineAndIndent();
+                    break;
+                case 5 :
+                case 12 :
+                    replaceContent = newLineAndIndent();
+                    break;
+                case 13 :
+                    if (lineBreak) {
+                        replaceContent = newLineAndIndent();
+                    }
+                    else {
+                        replaceContent = ' ';
+                    }
+                    break;
+                case 6 :
+                    replaceContent = ' ';
+                    break;
+                case 10 :
+                    if (secondToken === 6 ) {
+                        replaceContent = '';
+                        break;
+                    }
+                case 7 :
+                case 8 :
+                case 9 :
+                case 11 :
+                case 2 :
+                case 4 :
+                    if (secondToken === 12  || secondToken === 13 ) {
+                        replaceContent = ' ';
+                    }
+                    else if (secondToken !== 5  && secondToken !== 17 ) {
+                        hasError = true;
+                    }
+                    break;
+                case 16 :
+                    hasError = true;
+                    break;
+            }
+            if (lineBreak && ((secondToken === 12  || secondToken === 13) )) {
+                replaceContent = newLineAndIndent();
+            }
+        }
+        const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+        addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+        firstToken = secondToken;
+    }
+    return editOperations;
+}
+function repeat(s, count) {
+    let result = '';
+    for (let i = 0; i < count; i++) {
+        result += s;
+    }
+    return result;
+}
+function computeIndentLevel(content, options) {
+    let i = 0;
+    let nChars = 0;
+    const tabSize = options.tabSize || 4;
+    while (i < content.length) {
+        const ch = content.charAt(i);
+        if (ch === ' ') {
+            nChars++;
+        }
+        else if (ch === '\t') {
+            nChars += tabSize;
+        }
+        else {
+            break;
+        }
+        i++;
+    }
+    return Math.floor(nChars / tabSize);
+}
+function getEOL(options, text) {
+    for (let i = 0; i < text.length; i++) {
+        const ch = text.charAt(i);
+        if (ch === '\r') {
+            if (i + 1 < text.length && text.charAt(i + 1) === '\n') {
+                return '\r\n';
+            }
+            return '\r';
+        }
+        else if (ch === '\n') {
+            return '\n';
+        }
+    }
+    return (options && options.eol) || '\n';
+}
+function isEOL(text, offset) {
+    return '\r\n'.indexOf(text.charAt(offset)) !== -1;
+}
+function setProperty(text, originalPath, value, formattingOptions, getInsertionIndex) {
+    const path = originalPath.slice();
+    const errors = [];
+    const root = parseTree(text, errors);
+    let parent = undefined;
+    let lastSegment = undefined;
+    while (path.length > 0) {
+        lastSegment = path.pop();
+        parent = findNodeAtLocation(root, path);
+        if (parent === undefined && value !== undefined) {
+            if (typeof lastSegment === 'string') {
+                value = { [lastSegment]: value };
+            }
+            else {
+                value = [value];
+            }
+        }
+        else {
+            break;
+        }
+    }
+    if (!parent) {
+        if (value === undefined) {
+            throw new Error('Can not delete in empty document');
+        }
+        return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, formattingOptions);
+    }
+    else if (parent.type === 'object' && typeof lastSegment === 'string' && Array.isArray(parent.children)) {
+        const existing = findNodeAtLocation(parent, [lastSegment]);
+        if (existing !== undefined) {
+            if (value === undefined) {
+                if (!existing.parent) {
+                    throw new Error('Malformed AST');
+                }
+                const propertyIndex = parent.children.indexOf(existing.parent);
+                let removeBegin;
+                let removeEnd = existing.parent.offset + existing.parent.length;
+                if (propertyIndex > 0) {
+                    const previous = parent.children[propertyIndex - 1];
+                    removeBegin = previous.offset + previous.length;
+                }
+                else {
+                    removeBegin = parent.offset + 1;
+                    if (parent.children.length > 1) {
+                        const next = parent.children[1];
+                        removeEnd = next.offset;
+                    }
+                }
+                return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: '' }, formattingOptions);
+            }
+            else {
+                return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, formattingOptions);
+            }
+        }
+        else {
+            if (value === undefined) {
+                return [];
+            }
+            const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+            const index = getInsertionIndex ? getInsertionIndex(parent.children.map(p => p.children[0].value)) : parent.children.length;
+            let edit;
+            if (index > 0) {
+                const previous = parent.children[index - 1];
+                edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
+            }
+            else if (parent.children.length === 0) {
+                edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+            }
+            else {
+                edit = { offset: parent.offset + 1, length: 0, content: newProperty + ',' };
+            }
+            return withFormatting(text, edit, formattingOptions);
+        }
+    }
+    else if (parent.type === 'array' && typeof lastSegment === 'number' && Array.isArray(parent.children)) {
+        if (value !== undefined) {
+            const newProperty = `${JSON.stringify(value)}`;
+            let edit;
+            if (parent.children.length === 0 || lastSegment === 0) {
+                edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + ',' };
+            }
+            else {
+                const index = lastSegment === -1 || lastSegment > parent.children.length ? parent.children.length : lastSegment;
+                const previous = parent.children[index - 1];
+                edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
+            }
+            return withFormatting(text, edit, formattingOptions);
+        }
+        else {
+            const removalIndex = lastSegment;
+            const toRemove = parent.children[removalIndex];
+            let edit;
+            if (parent.children.length === 1) {
+                edit = { offset: parent.offset + 1, length: parent.length - 2, content: '' };
+            }
+            else if (parent.children.length - 1 === removalIndex) {
+                const previous = parent.children[removalIndex - 1];
+                const offset = previous.offset + previous.length;
+                const parentEndOffset = parent.offset + parent.length;
+                edit = { offset, length: parentEndOffset - 2 - offset, content: '' };
+            }
+            else {
+                edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: '' };
+            }
+            return withFormatting(text, edit, formattingOptions);
+        }
+    }
+    else {
+        throw new Error(`Can not add ${typeof lastSegment !== 'number' ? 'index' : 'property'} to parent of type ${parent.type}`);
+    }
+}
+function withFormatting(text, edit, formattingOptions) {
+    let newText = applyEdit(text, edit);
+    let begin = edit.offset;
+    let end = edit.offset + edit.content.length;
+    if (edit.length === 0 || edit.content.length === 0) {
+        while (begin > 0 && !isEOL(newText, begin - 1)) {
+            begin--;
+        }
+        while (end < newText.length && !isEOL(newText, end)) {
+            end++;
+        }
+    }
+    const edits = format(newText, { offset: begin, length: end - begin }, formattingOptions);
+    for (let i = edits.length - 1; i >= 0; i--) {
+        const curr = edits[i];
+        newText = applyEdit(newText, curr);
+        begin = Math.min(begin, curr.offset);
+        end = Math.max(end, curr.offset + curr.length);
+        end += curr.content.length - curr.length;
+    }
+    const editLength = text.length - (newText.length - end) - begin;
+    return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+}
+function applyEdit(text, edit) {
+    return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
 class ConfigurationService extends Disposable {
     constructor(settingsResource, fileService, policyService, logService) {
         super();
@@ -549,6 +871,14 @@ async function getUserConfiguration() {
     const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
     return ( (await StandaloneServices.get(IFileService).readFile(userDataProfilesService.defaultProfile.settingsResource)).value.toString());
 }
+function onUserConfigurationChange(callback) {
+    const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
+    return StandaloneServices.get(IFileService).onDidFilesChange(e => {
+        if (e.affects(userDataProfilesService.defaultProfile.settingsResource)) {
+            callback();
+        }
+    });
+}
 const configurationRegistry = ( Registry.as(Extensions.Configuration));
 function updateJsonValue(jsonValue, jsonPath, value, configFileUrl) {
     const creationOptions = StandaloneServices.get(IModelService).getCreationOptions('json', configFileUrl, true);
@@ -598,6 +928,7 @@ InjectedConfigurationService = ( __decorate([
 ], InjectedConfigurationService));
 function initialize(instantiationService) {
     instantiationService.createInstance(RegisterConfigurationSchemasContribution);
+    void updateUserConfiguration('{}');
 }
 function getServiceOverride() {
     onServicesInitialized(initialize);
@@ -608,4 +939,4 @@ function getServiceOverride() {
         [( ITextResourceConfigurationService.toString())]: new SyncDescriptor(TextResourceConfigurationService)
     };
 }
-export { configurationRegistry, getServiceOverride as default, getUserConfiguration, updateUserConfiguration };
+export { configurationRegistry, getServiceOverride as default, getUserConfiguration, onUserConfigurationChange, updateUserConfiguration };

package/dist/dialogs.js

@@ -4,7 +4,7 @@ import { g as getServiceOverride$1, D as DialogHandlerContribution } from './lay
 import { _ as __decorate, a as __param, E as Emitter } from './workspace.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
-import { j as IWorkbenchEnvironmentService } from './services2.js';
+import { l as IWorkbenchEnvironmentService } from './services2.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { o as onServicesInitialized } from './tools.js';
 import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';