@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/workbench/services/suggest/browser/simpleSuggestWidgetRenderer.js

@@ -0,0 +1,83 @@
+import { append, $, show } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IconLabel } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabel.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+function getAriaId(index) {
+    return `simple-suggest-aria-id:${index}`;
+}
+class SimpleSuggestWidgetItemRenderer {
+    constructor() {
+        this._onDidToggleDetails = ( new Emitter());
+        this.onDidToggleDetails = this._onDidToggleDetails.event;
+        this.templateId = 'suggestion';
+    }
+    dispose() {
+        this._onDidToggleDetails.dispose();
+    }
+    renderTemplate(container) {
+        const disposables = ( new DisposableStore());
+        const root = container;
+        root.classList.add('show-file-icons');
+        const icon = append(container, $('.icon'));
+        const colorspan = append(icon, $('span.colorspan'));
+        const text = append(container, $('.contents'));
+        const main = append(text, $('.main'));
+        const iconContainer = append(main, $('.icon-label.codicon'));
+        const left = append(main, $('span.left'));
+        const right = append(main, $('span.right'));
+        const iconLabel = ( new IconLabel(left, { supportHighlights: true, supportIcons: true }));
+        disposables.add(iconLabel);
+        const parametersLabel = append(left, $('span.signature-label'));
+        const qualifierLabel = append(left, $('span.qualifier-label'));
+        const detailsLabel = append(right, $('span.details-label'));
+        const configureFont = () => {
+            const fontFamily = 'Hack';
+            const fontFeatureSettings = '';
+            const fontSize = '12';
+            const lineHeight = '20';
+            const fontWeight = 'normal';
+            const letterSpacing = '0';
+            const fontSizePx = `${fontSize}px`;
+            const lineHeightPx = `${lineHeight}px`;
+            const letterSpacingPx = `${letterSpacing}px`;
+            root.style.fontSize = fontSizePx;
+            root.style.fontWeight = fontWeight;
+            root.style.letterSpacing = letterSpacingPx;
+            main.style.fontFamily = fontFamily;
+            main.style.fontFeatureSettings = fontFeatureSettings;
+            main.style.lineHeight = lineHeightPx;
+            icon.style.height = lineHeightPx;
+            icon.style.width = lineHeightPx;
+        };
+        configureFont();
+        return { root, left, right, icon, colorspan, iconLabel, iconContainer, parametersLabel, qualifierLabel, detailsLabel, disposables };
+    }
+    renderElement(element, index, data) {
+        const { completion } = element;
+        data.root.id = getAriaId(index);
+        data.colorspan.style.backgroundColor = '';
+        const labelOptions = {
+            labelEscapeNewLines: true,
+            matches: createMatches(element.score)
+        };
+        data.icon.className = 'icon hide';
+        data.iconContainer.className = '';
+        data.iconContainer.classList.add('suggest-icon', ...ThemeIcon.asClassNameArray(completion.icon || Codicon.symbolText));
+        data.iconLabel.setLabel(completion.label, undefined, labelOptions);
+        data.parametersLabel.textContent = '';
+        data.detailsLabel.textContent = stripNewLines(completion.detail || '');
+        data.root.classList.add('string-label');
+        show(data.detailsLabel);
+        data.right.classList.remove('can-expand-details');
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+}
+function stripNewLines(str) {
+    return str.replace(/\r\n|\r|\n/g, '');
+}
+export { SimpleSuggestWidgetItemRenderer, getAriaId };

package/dist/vscode/vs/workbench/services/terminal/common/embedderTerminalService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IEmbedderTerminalService = ( createDecorator('embedderTerminalService'));
+export { IEmbedderTerminalService };

package/dist/vscode/vs/workbench/services/textMate/browser/worker/textMate.worker.js

@@ -0,0 +1,90 @@
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { TMGrammarFactory } from '../../common/TMGrammarFactory.js';
+import { TextMateWorkerModel } from './textMateWorkerModel.js';
+class TextMateTokenizationWorker {
+    constructor(ctx, createData) {
+        this.createData = createData;
+        this._models = Object.create(null);
+        this._grammarCache = [];
+        this._host = ctx.host;
+        const grammarDefinitions = ( createData.grammarDefinitions.map((def) => {
+            return {
+                location: URI.revive(def.location),
+                language: def.language,
+                scopeName: def.scopeName,
+                embeddedLanguages: def.embeddedLanguages,
+                tokenTypes: def.tokenTypes,
+                injectTo: def.injectTo,
+                balancedBracketSelectors: def.balancedBracketSelectors,
+                unbalancedBracketSelectors: def.unbalancedBracketSelectors,
+            };
+        }));
+        this._grammarFactory = this._loadTMGrammarFactory(grammarDefinitions);
+    }
+    async _loadTMGrammarFactory(grammarDefinitions) {
+        const vscodeTextmate = await import('vscode-textmate').then(module => module.default ?? module);
+        const vscodeOniguruma = await import('vscode-oniguruma').then(module => module.default ?? module);
+        const response = await fetch(this.createData.onigurumaWASMUri);
+        const bytes = await response.arrayBuffer();
+        await vscodeOniguruma.loadWASM(bytes);
+        const onigLib = Promise.resolve({
+            createOnigScanner: (sources) => vscodeOniguruma.createOnigScanner(sources),
+            createOnigString: (str) => vscodeOniguruma.createOnigString(str)
+        });
+        return ( new TMGrammarFactory({
+            logTrace: (msg) => { },
+            logError: (msg, err) => console.error(msg, err),
+            readFile: (resource) => this._host.readFile(resource)
+        }, grammarDefinitions, vscodeTextmate, onigLib));
+    }
+    acceptNewModel(data) {
+        const uri = URI.revive(data.uri);
+        const key = ( uri.toString());
+        this._models[key] = ( new TextMateWorkerModel(
+            uri,
+            data.lines,
+            data.EOL,
+            data.versionId,
+            this,
+            data.languageId,
+            data.encodedLanguageId,
+            data.maxTokenizationLineLength
+        ));
+    }
+    acceptModelChanged(strURL, e) {
+        this._models[strURL].onEvents(e);
+    }
+    retokenize(strURL, startLineNumber, endLineNumberExclusive) {
+        this._models[strURL].retokenize(startLineNumber, endLineNumberExclusive);
+    }
+    acceptModelLanguageChanged(strURL, newLanguageId, newEncodedLanguageId) {
+        this._models[strURL].onLanguageId(newLanguageId, newEncodedLanguageId);
+    }
+    acceptRemovedModel(strURL) {
+        if (this._models[strURL]) {
+            this._models[strURL].dispose();
+            delete this._models[strURL];
+        }
+    }
+    async acceptTheme(theme, colorMap) {
+        const grammarFactory = await this._grammarFactory;
+        grammarFactory?.setTheme(theme, colorMap);
+    }
+    acceptMaxTokenizationLineLength(strURL, value) {
+        this._models[strURL].acceptMaxTokenizationLineLength(value);
+    }
+    async getOrCreateGrammar(languageId, encodedLanguageId) {
+        const grammarFactory = await this._grammarFactory;
+        if (!grammarFactory) {
+            return Promise.resolve(null);
+        }
+        if (!this._grammarCache[encodedLanguageId]) {
+            this._grammarCache[encodedLanguageId] = grammarFactory.createGrammar(languageId, encodedLanguageId);
+        }
+        return this._grammarCache[encodedLanguageId];
+    }
+    setTokensAndStates(resource, versionId, tokens, stateDeltas) {
+        this._host.setTokensAndStates(resource, versionId, tokens, stateDeltas);
+    }
+}
+export { TextMateTokenizationWorker };

package/dist/vscode/vs/workbench/services/textMate/browser/worker/textMateWorkerModel.js

@@ -0,0 +1,133 @@
+import { MirrorTextModel } from 'monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js';
+import { TokenizerWithStateStore } from 'monaco-editor/esm/vs/editor/common/model/textModelTokens.js';
+import { diffStateStacksRefEq } from 'vscode-textmate';
+import { ContiguousMultilineTokensBuilder } from 'monaco-editor/esm/vs/editor/common/tokens/contiguousMultilineTokensBuilder.js';
+import { LineTokens } from 'monaco-editor/esm/vs/editor/common/tokens/lineTokens.js';
+import { TextMateTokenizationSupport } from '../tokenizationSupport/textMateTokenizationSupport.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { observableValue } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { TokenizationSupportWithLineLimit } from '../tokenizationSupport/tokenizationSupportWithLineLimit.js';
+import { LineRange } from 'monaco-editor/esm/vs/editor/common/core/lineRange.js';
+class TextMateWorkerModel extends MirrorTextModel {
+    constructor(uri, lines, eol, versionId, _worker, _languageId, _encodedLanguageId, maxTokenizationLineLength) {
+        super(uri, lines, eol, versionId);
+        this._worker = _worker;
+        this._languageId = _languageId;
+        this._encodedLanguageId = _encodedLanguageId;
+        this._tokenizationStateStore = null;
+        this._isDisposed = false;
+        this._maxTokenizationLineLength = observableValue('_maxTokenizationLineLength', -1);
+        this.tokenizeDebouncer = ( new RunOnceScheduler(() => this._tokenize(), 10));
+        this._maxTokenizationLineLength.set(maxTokenizationLineLength, undefined);
+        this._resetTokenization();
+    }
+    dispose() {
+        this._isDisposed = true;
+        super.dispose();
+    }
+    onLanguageId(languageId, encodedLanguageId) {
+        this._languageId = languageId;
+        this._encodedLanguageId = encodedLanguageId;
+        this._resetTokenization();
+    }
+    onEvents(e) {
+        super.onEvents(e);
+        if (this._tokenizationStateStore) {
+            this._tokenizationStateStore.store.acceptChanges(e.changes);
+        }
+        this.tokenizeDebouncer.schedule();
+    }
+    acceptMaxTokenizationLineLength(maxTokenizationLineLength) {
+        this._maxTokenizationLineLength.set(maxTokenizationLineLength, undefined);
+    }
+    retokenize(startLineNumber, endLineNumberExclusive) {
+        if (this._tokenizationStateStore) {
+            this._tokenizationStateStore.store.invalidateEndStateRange(( new LineRange(startLineNumber, endLineNumberExclusive)));
+            this.tokenizeDebouncer.schedule();
+        }
+    }
+    _resetTokenization() {
+        this._tokenizationStateStore = null;
+        const languageId = this._languageId;
+        const encodedLanguageId = this._encodedLanguageId;
+        this._worker.getOrCreateGrammar(languageId, encodedLanguageId).then((r) => {
+            if (this._isDisposed ||
+                languageId !== this._languageId ||
+                encodedLanguageId !== this._encodedLanguageId ||
+                !r) {
+                return;
+            }
+            if (r.grammar) {
+                const tokenizationSupport = ( new TokenizationSupportWithLineLimit(this._encodedLanguageId, ( new TextMateTokenizationSupport(r.grammar, r.initialState, false)), this._maxTokenizationLineLength));
+                this._tokenizationStateStore = ( new TokenizerWithStateStore(this._lines.length, tokenizationSupport));
+            }
+            else {
+                this._tokenizationStateStore = null;
+            }
+            this._tokenize();
+        });
+    }
+    _tokenize() {
+        if (this._isDisposed || !this._tokenizationStateStore) {
+            return;
+        }
+        const startTime = ( new Date()).getTime();
+        while (true) {
+            let tokenizedLines = 0;
+            const tokenBuilder = ( new ContiguousMultilineTokensBuilder());
+            const stateDeltaBuilder = ( new StateDeltaBuilder());
+            while (true) {
+                const lineNumberToTokenize = this._tokenizationStateStore.store.getFirstInvalidEndStateLineNumber();
+                if (lineNumberToTokenize === null || tokenizedLines > 200) {
+                    break;
+                }
+                tokenizedLines++;
+                const text = this._lines[lineNumberToTokenize - 1];
+                const lineStartState = this._tokenizationStateStore.getStartState(lineNumberToTokenize);
+                const r = this._tokenizationStateStore.tokenizationSupport.tokenizeEncoded(text, true, lineStartState);
+                if (this._tokenizationStateStore.store.setEndState(lineNumberToTokenize, r.endState)) {
+                    const delta = diffStateStacksRefEq(lineStartState, r.endState);
+                    stateDeltaBuilder.setState(lineNumberToTokenize, delta);
+                }
+                else {
+                    stateDeltaBuilder.setState(lineNumberToTokenize, null);
+                }
+                LineTokens.convertToEndOffset(r.tokens, text.length);
+                tokenBuilder.add(lineNumberToTokenize, r.tokens);
+                const deltaMs = ( new Date()).getTime() - startTime;
+                if (deltaMs > 20) {
+                    break;
+                }
+            }
+            if (tokenizedLines === 0) {
+                break;
+            }
+            const stateDeltas = stateDeltaBuilder.getStateDeltas();
+            this._worker.setTokensAndStates(this._uri, this._versionId, tokenBuilder.serialize(), stateDeltas);
+            const deltaMs = ( new Date()).getTime() - startTime;
+            if (deltaMs > 20) {
+                setTimeout(() => this._tokenize(), 3);
+                return;
+            }
+        }
+    }
+}
+class StateDeltaBuilder {
+    constructor() {
+        this._lastStartLineNumber = -1;
+        this._stateDeltas = [];
+    }
+    setState(lineNumber, stackDiff) {
+        if (lineNumber === this._lastStartLineNumber + 1) {
+            this._stateDeltas[this._stateDeltas.length - 1].stateDeltas.push(stackDiff);
+        }
+        else {
+            this._stateDeltas.push({ startLineNumber: lineNumber, stateDeltas: [stackDiff] });
+        }
+        this._lastStartLineNumber = lineNumber;
+    }
+    getStateDeltas() {
+        return this._stateDeltas;
+    }
+}
+export { TextMateWorkerModel };

package/dist/vscode/vs/workbench/services/textfile/browser/textFileService.js

@@ -323,7 +323,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         let sourceTextModel = undefined;
         if (sourceModel instanceof BaseTextEditorModel) {
             if (sourceModel.isResolved()) {
-                sourceTextModel = sourceModel.textEditorModel;
+                sourceTextModel = withNullAsUndefined(sourceModel.textEditorModel);
             }
         }
         else {

package/dist/vscode/vs/workbench/services/textfile/common/textFileEditorModel.js

@@ -80,6 +80,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
     registerListeners() {
         this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
         this._register(this.filesConfigurationService.onFilesAssociationChange(() => this.onFilesAssociationChange()));
+        this._register(this.filesConfigurationService.onReadonlyChange(() => this._onDidChangeReadonly.fire()));
     }
     async onDidFilesChange(e) {
         let fileEventImpactsModel = false;
@@ -228,7 +229,8 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
             etag,
             value: buffer,
             encoding: preferredEncoding.encoding,
-            readonly: false
+            readonly: false,
+            locked: false
         }, true , options);
     }
     async resolveFromBackup(options) {
@@ -259,7 +261,8 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
             etag: backup.meta ? backup.meta.etag : ETAG_DISABLED,
             value: await createTextBufferFactoryFromStream(await this.textFileService.getDecodedStream(this.resource, backup.value, { encoding: UTF8 })),
             encoding,
-            readonly: false
+            readonly: false,
+            locked: false
         }, true , options);
         if (backup.meta?.orphaned) {
             this.setOrphaned(true);
@@ -319,6 +322,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
             size: content.size,
             etag: content.etag,
             readonly: content.readonly,
+            locked: content.locked,
             isFile: true,
             isDirectory: false,
             isSymbolicLink: false,
@@ -408,6 +412,9 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
     isDirty() {
         return this.dirty;
     }
+    isModified() {
+        return this.isDirty();
+    }
     setDirty(dirty) {
         if (!this.isResolved()) {
             return;
@@ -681,7 +688,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
         return !!this.textEditorModel;
     }
     isReadonly() {
-        return this.lastResolvedFileStat?.readonly || this.fileService.hasCapability(this.resource, 2048 );
+        return this.filesConfigurationService.isReadonly(this.resource, this.lastResolvedFileStat);
     }
     dispose() {
         this.trace('dispose()');

package/dist/vscode/vs/workbench/services/themes/browser/fileIconThemeData.js

@@ -1,7 +1,7 @@
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import * as path from 'monaco-editor/esm/vs/base/common/path.js';
 import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
-import * as Json from 'monaco-editor/esm/vs/base/common/json.js';
+import * as json from 'monaco-editor/esm/vs/base/common/json.js';
 import { ExtensionData } from '../common/workbenchThemeService.js';
 import { getParseErrorMessage } from '../../../../base/common/jsonErrorMessages.js';
 import { asCSSUrl } from 'monaco-editor/esm/vs/base/browser/dom.js';
@@ -133,7 +133,7 @@ class FileIconThemeLoader {
     loadIconThemeDocument(location) {
         return this.fileService.readExtensionResource(location).then((content) => {
             const errors = [];
-            const contentValue = Json.parse(content, errors);
+            const contentValue = json.parse(content, errors);
             if (errors.length > 0) {
                 return Promise.reject(( new Error(( nls.localize(
                     'error.cannotparseicontheme',
@@ -141,7 +141,7 @@ class FileIconThemeLoader {
                     ( errors.map(e => getParseErrorMessage(e.error))).join(', ')
                 )))));
             }
-            else if (Json.getNodeType(contentValue) !== 'object') {
+            else if (json.getNodeType(contentValue) !== 'object') {
                 return Promise.reject(( new Error(( nls.localize(
                     'error.invalidformat',
                     "Invalid format for file icons theme file: Object expected."

package/dist/vscode/vs/workbench/services/themes/browser/productIconThemeData.js

@@ -1,7 +1,7 @@
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import * as path from 'monaco-editor/esm/vs/base/common/path.js';
 import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
-import * as Json from 'monaco-editor/esm/vs/base/common/json.js';
+import * as json from 'monaco-editor/esm/vs/base/common/json.js';
 import { ThemeSettingDefaults, ExtensionData } from '../common/workbenchThemeService.js';
 import { getParseErrorMessage } from '../../../../base/common/jsonErrorMessages.js';
 import { fontIdRegex, fontWeightRegex, fontStyleRegex, fontFormatRegex } from '../common/productIconThemeSchema.js';
@@ -152,7 +152,7 @@ ProductIconThemeData._defaultProductIconTheme = null;
 function _loadProductIconThemeDocument(fileService, location, warnings) {
     return fileService.readExtensionResource(location).then((content) => {
         const parseErrors = [];
-        const contentValue = Json.parse(content, parseErrors);
+        const contentValue = json.parse(content, parseErrors);
         if (parseErrors.length > 0) {
             return Promise.reject(( new Error(( nls.localize(
                 'error.cannotparseicontheme',
@@ -160,7 +160,7 @@ function _loadProductIconThemeDocument(fileService, location, warnings) {
                 ( parseErrors.map(e => getParseErrorMessage(e.error))).join(', ')
             )))));
         }
-        else if (Json.getNodeType(contentValue) !== 'object') {
+        else if (json.getNodeType(contentValue) !== 'object') {
             return Promise.reject(( new Error(( nls.localize(
                 'error.invalidformat',
                 "Invalid format for product icons theme file: Object expected."

package/dist/vscode/vs/workbench/services/themes/common/colorThemeData.js

@@ -1,5 +1,5 @@
 import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
-import * as Json from 'monaco-editor/esm/vs/base/common/json.js';
+import * as json from 'monaco-editor/esm/vs/base/common/json.js';
 import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
 import { THEME_SCOPE_OPEN_PAREN, THEME_SCOPE_CLOSE_PAREN, THEME_SCOPE_WILDCARD, themeScopeRegex, ExtensionData, VS_HC_LIGHT_THEME, VS_HC_THEME, VS_LIGHT_THEME } from './workbenchThemeService.js';
 import { convertSettings } from './themeCompatibility.js';
@@ -580,7 +580,7 @@ async function _loadColorTheme(extensionResourceLoaderService, themeLocation, re
     if (resources.extname(themeLocation) === '.json') {
         const content = await extensionResourceLoaderService.readExtensionResource(themeLocation);
         const errors = [];
-        const contentValue = Json.parse(content, errors);
+        const contentValue = json.parse(content, errors);
         if (errors.length > 0) {
             return Promise.reject(( new Error(( nls.localize(
                 'error.cannotparsejson',
@@ -588,7 +588,7 @@ async function _loadColorTheme(extensionResourceLoaderService, themeLocation, re
                 ( errors.map(e => getParseErrorMessage(e.error))).join(', ')
             )))));
         }
-        else if (Json.getNodeType(contentValue) !== 'object') {
+        else if (json.getNodeType(contentValue) !== 'object') {
             return Promise.reject(( new Error(( nls.localize(
                 'error.invalidformat',
                 "Invalid format for JSON theme file: Object expected."

package/dist/vscode/vs/workbench/services/untitled/common/untitledTextEditorInput.js

@@ -8,6 +8,7 @@ import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.j
 import { toLocalResource, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
 import { IPathService } from '../../path/common/pathService.js';
+import { IFilesConfigurationService } from '../../filesConfiguration/common/filesConfigurationService.js';
 let UntitledTextEditorInput = class UntitledTextEditorInput extends AbstractTextResourceEditorInput {
     get typeId() {
         return UntitledTextEditorInput.ID;
@@ -15,8 +16,8 @@ let UntitledTextEditorInput = class UntitledTextEditorInput extends AbstractText
     get editorId() {
         return DEFAULT_EDITOR_ASSOCIATION.id;
     }
-    constructor(model, textFileService, labelService, editorService, fileService, environmentService, pathService) {
-        super(model.resource, undefined, editorService, textFileService, labelService, fileService);
+    constructor(model, textFileService, labelService, editorService, fileService, environmentService, pathService, filesConfigurationService) {
+        super(model.resource, undefined, editorService, textFileService, labelService, fileService, filesConfigurationService);
         this.model = model;
         this.environmentService = environmentService;
         this.pathService = pathService;
@@ -85,7 +86,7 @@ let UntitledTextEditorInput = class UntitledTextEditorInput extends AbstractText
         if (typeof options?.preserveViewState === 'number') {
             untypedInput.encoding = this.getEncoding();
             untypedInput.languageId = this.getLanguageId();
-            untypedInput.contents = this.model.isDirty() ? this.model.textEditorModel?.getValue() : undefined;
+            untypedInput.contents = this.model.isModified() ? this.model.textEditorModel?.getValue() : undefined;
             untypedInput.options.viewState = findViewStateForEditor(this, options.preserveViewState, this.editorService);
             if (typeof untypedInput.contents === 'string' && !this.model.hasAssociatedFilePath) {
                 untypedInput.resource = undefined;
@@ -117,6 +118,7 @@ UntitledTextEditorInput = ( __decorate([
     ( __param(3, IEditorService)),
     ( __param(4, IFileService)),
     ( __param(5, IWorkbenchEnvironmentService)),
-    ( __param(6, IPathService))
+    ( __param(6, IPathService)),
+    ( __param(7, IFilesConfigurationService))
 ], UntitledTextEditorInput));
 export { UntitledTextEditorInput };

package/dist/vscode/vs/workbench/services/untitled/common/untitledTextEditorModel.js

@@ -113,6 +113,9 @@ let UntitledTextEditorModel = class UntitledTextEditorModel extends BaseTextEdit
     isDirty() {
         return this.dirty;
     }
+    isModified() {
+        return this.isDirty();
+    }
     setDirty(dirty) {
         if (this.dirty === dirty) {
             return;

package/dist/vscode/vs/workbench/services/untitled/common/untitledTextEditorService.js

@@ -1,3 +1,114 @@
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-const IUntitledTextEditorService = ( createDecorator('untitledTextEditorService'));
-export { IUntitledTextEditorService };
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { UntitledTextEditorModel } from './untitledTextEditorModel.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+const IUntitledTextEditorService = ( (createDecorator('untitledTextEditorService')));
+let UntitledTextEditorService = class UntitledTextEditorService extends Disposable {
+    constructor(instantiationService, configurationService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this._onDidChangeDirty = this._register(( (new Emitter())));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._onDidChangeEncoding = this._register(( (new Emitter())));
+        this.onDidChangeEncoding = this._onDidChangeEncoding.event;
+        this._onWillDispose = this._register(( (new Emitter())));
+        this.onWillDispose = this._onWillDispose.event;
+        this._onDidChangeLabel = this._register(( (new Emitter())));
+        this.onDidChangeLabel = this._onDidChangeLabel.event;
+        this.mapResourceToModel = ( (new ResourceMap()));
+    }
+    get(resource) {
+        return this.mapResourceToModel.get(resource);
+    }
+    getValue(resource) {
+        return this.get(resource)?.textEditorModel?.getValue();
+    }
+    async resolve(options) {
+        const model = this.doCreateOrGet(options);
+        await model.resolve();
+        return model;
+    }
+    create(options) {
+        return this.doCreateOrGet(options);
+    }
+    doCreateOrGet(options = Object.create(null)) {
+        const massagedOptions = this.massageOptions(options);
+        if (massagedOptions.untitledResource && ( (this.mapResourceToModel.has(massagedOptions.untitledResource)))) {
+            return this.mapResourceToModel.get(massagedOptions.untitledResource);
+        }
+        return this.doCreate(massagedOptions);
+    }
+    massageOptions(options) {
+        const massagedOptions = Object.create(null);
+        if (options.associatedResource) {
+            massagedOptions.untitledResource = ( (URI.from({
+                scheme: Schemas.untitled,
+                authority: options.associatedResource.authority,
+                fragment: options.associatedResource.fragment,
+                path: options.associatedResource.path,
+                query: options.associatedResource.query
+            })));
+            massagedOptions.associatedResource = options.associatedResource;
+        }
+        else {
+            if (options.untitledResource?.scheme === Schemas.untitled) {
+                massagedOptions.untitledResource = options.untitledResource;
+            }
+        }
+        if (options.languageId) {
+            massagedOptions.languageId = options.languageId;
+        }
+        else if (!massagedOptions.associatedResource) {
+            const configuration = this.configurationService.getValue();
+            if (configuration.files?.defaultLanguage) {
+                massagedOptions.languageId = configuration.files.defaultLanguage;
+            }
+        }
+        massagedOptions.encoding = options.encoding;
+        massagedOptions.initialValue = options.initialValue;
+        return massagedOptions;
+    }
+    doCreate(options) {
+        let untitledResource = options.untitledResource;
+        if (!untitledResource) {
+            let counter = 1;
+            do {
+                untitledResource = ( ( URI.from({ scheme: Schemas.untitled, path: `Untitled-${counter}` })));
+                counter++;
+            } while (( (this.mapResourceToModel.has(untitledResource))));
+        }
+        const model = this._register(this.instantiationService.createInstance(UntitledTextEditorModel, untitledResource, !!options.associatedResource, options.initialValue, options.languageId, options.encoding));
+        this.registerModel(model);
+        return model;
+    }
+    registerModel(model) {
+        const modelListeners = ( (new DisposableStore()));
+        modelListeners.add(model.onDidChangeDirty(() => this._onDidChangeDirty.fire(model)));
+        modelListeners.add(model.onDidChangeName(() => this._onDidChangeLabel.fire(model)));
+        modelListeners.add(model.onDidChangeEncoding(() => this._onDidChangeEncoding.fire(model)));
+        modelListeners.add(model.onWillDispose(() => this._onWillDispose.fire(model)));
+        Event.once(model.onWillDispose)(() => {
+            this.mapResourceToModel.delete(model.resource);
+            modelListeners.dispose();
+        });
+        this.mapResourceToModel.set(model.resource, model);
+        if (model.isDirty()) {
+            this._onDidChangeDirty.fire(model);
+        }
+    }
+    isUntitledWithAssociatedResource(resource) {
+        return resource.scheme === Schemas.untitled && resource.path.length > 1 && !UntitledTextEditorService.UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX.test(resource.path);
+    }
+};
+UntitledTextEditorService.UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX = /Untitled-\d+/;
+UntitledTextEditorService = ( (__decorate([
+    ( (__param(0, IInstantiationService))),
+    ( (__param(1, IConfigurationService)))
+], UntitledTextEditorService)));
+export { IUntitledTextEditorService, UntitledTextEditorService };

package/dist/vscode/vs/workbench/services/userActivity/common/userActivityRegistry.js

@@ -0,0 +1,15 @@
+class UserActivityRegistry {
+    constructor() {
+        this.todo = [];
+        this.add = (ctor) => {
+            this.todo.push(ctor);
+        };
+    }
+    take(userActivityService, instantiation) {
+        this.add = ctor => instantiation.createInstance(ctor, userActivityService);
+        this.todo.forEach(this.add);
+        this.todo = [];
+    }
+}
+const userActivityRegistry = ( new UserActivityRegistry());
+export { userActivityRegistry };