@codingame/monaco-vscode-api 1.76.1 → 1.76.3-next.0

package/dist/configuration.js

@@ -1,18 +1,18 @@
-import { E as Emitter, _ as __decorate, a as __param } from './contextkey.js';
-import { I as IPolicyService, N as NullPolicyService, b as NullPolicyConfiguration, P as PolicyConfiguration, U as UserSettings, c as parseTree, d as findNodeAtLocation, e as createScanner } from './polyfill.js';
-import { c as IExtensionService, I as ILifecycleService } from './missing-services.js';
+import { J as IUserDataProfilesService, n as IFileService, E as Emitter, _ as __decorate, a as __param, o as IWorkbenchEnvironmentService } from './services2.js';
+import { o as onServicesInitialized, P as Position, I as IPolicyService, k as NullPolicyService, l as NullPolicyConfiguration, q as PolicyConfiguration, U as UserSettings } from './polyfill.js';
+import { bp as IExtensionService, bL as ILifecycleService } from './missing-services.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { DefaultConfiguration } from 'monaco-editor/esm/vs/platform/configuration/common/configurations.js';
 import { extUriBiasedIgnorePathCase } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { Configuration, ConfigurationModel, ConfigurationChangeEvent } from 'monaco-editor/esm/vs/platform/configuration/common/configurationModels.js';
 import { RunOnceScheduler, Delayer } from 'monaco-editor/esm/vs/base/common/async.js';
-import { bn as Position$2, bo as keyFromOverrideIdentifiers, bp as configurationDefaultsSchemaId } from './extHost.js';
-export { bq as ConfigurationScope } from './extHost.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.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 { r as IUserDataProfilesService, c as IFileService, l as IWorkbenchEnvironmentService } from './services2.js';
+import { d as defaultSettingsSchemaId, u as userSettingsSchemaId, p as profileSettingsSchemaId, m as machineSettingsSchemaId, w as workspaceSettingsSchemaId, f as folderSettingsSchemaId, s as setProperty } from './configuration2.js';
+import { k as keyFromOverrideIdentifiers, c as configurationDefaultsSchemaId } from './configurationRegistry.js';
+export { C as ConfigurationScope } from './configurationRegistry.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Extensions, applicationSettings, windowSettings, resourceSettings, allSettings, machineSettings, machineOverridableSettings, OVERRIDE_PROPERTY_PATTERN, resourceLanguageSettingsSchemaId } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
@@ -22,7 +22,6 @@ import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform
 import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
 import { g as getServiceOverride$2 } from './workspaceContext.js';
 import { g as getServiceOverride$1 } from './files.js';
-import { o as onServicesInitialized } from './tools.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
@@ -42,328 +41,6 @@ function isConfigurationUpdateOverrides(thing) {
         && !thing.overrideIdentifier
         && (!thing.resource || thing.resource instanceof URI);
 }
-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();
@@ -459,7 +136,7 @@ let TextResourceConfigurationService = class TextResourceConfigurationService ex
     }
     getValue(resource, arg2, arg3) {
         if (typeof arg3 === 'string') {
-            return this._getValue(resource, Position$2.isIPosition(arg2) ? arg2 : null, arg3);
+            return this._getValue(resource, Position.isIPosition(arg2) ? arg2 : null, arg3);
         }
         return this._getValue(resource, null, typeof arg2 === 'string' ? arg2 : undefined);
     }
@@ -551,20 +228,6 @@ TextResourceConfigurationService = ( (__decorate([
     ( (__param(1, IModelService))),
     ( (__param(2, ILanguageService)))
 ], TextResourceConfigurationService)));
-const FOLDER_CONFIG_FOLDER_NAME = '.vscode';
-const defaultSettingsSchemaId = 'vscode://schemas/settings/default';
-const userSettingsSchemaId = 'vscode://schemas/settings/user';
-const profileSettingsSchemaId = 'vscode://schemas/settings/profile';
-const machineSettingsSchemaId = 'vscode://schemas/settings/machine';
-const workspaceSettingsSchemaId = 'vscode://schemas/settings/workspace';
-const folderSettingsSchemaId = 'vscode://schemas/settings/folder';
-const TASKS_CONFIGURATION_KEY = 'tasks';
-const LAUNCH_CONFIGURATION_KEY = 'launch';
-const WORKSPACE_STANDALONE_CONFIGURATIONS = Object.create(null);
-WORKSPACE_STANDALONE_CONFIGURATIONS[TASKS_CONFIGURATION_KEY] = `${FOLDER_CONFIG_FOLDER_NAME}/${TASKS_CONFIGURATION_KEY}.json`;
-WORKSPACE_STANDALONE_CONFIGURATIONS[LAUNCH_CONFIGURATION_KEY] = `${FOLDER_CONFIG_FOLDER_NAME}/${LAUNCH_CONFIGURATION_KEY}.json`;
-const USER_STANDALONE_CONFIGURATIONS = Object.create(null);
-USER_STANDALONE_CONFIGURATIONS[TASKS_CONFIGURATION_KEY] = `${TASKS_CONFIGURATION_KEY}.json`;
 let RegisterConfigurationSchemasContribution = class RegisterConfigurationSchemasContribution extends Disposable {
     constructor(workspaceContextService, environmentService, workspaceTrustManagementService, extensionService, lifecycleService) {
         super();