@codingame/monaco-vscode-api 1.67.14 → 1.67.17

package/dist/monaco.js

@@ -0,0 +1,149 @@
+import { b as __decorate, c as __param } from './tslib.es6-16b40665.js';
+import { _util, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.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';
+import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { StandaloneEditor, StandaloneDiffEditor } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
+function equals(one, other) {
+    if (one === other) {
+        return true;
+    }
+    if (one === null || one === undefined || other === null || other === undefined) {
+        return false;
+    }
+    if (typeof one !== typeof other) {
+        return false;
+    }
+    if (typeof one !== 'object') {
+        return false;
+    }
+    if ((Array.isArray(one)) !== (Array.isArray(other))) {
+        return false;
+    }
+    let i;
+    let key;
+    if (Array.isArray(one)) {
+        if (one.length !== other.length) {
+            return false;
+        }
+        for (i = 0; i < one.length; i++) {
+            if (!equals(one[i], other[i])) {
+                return false;
+            }
+        }
+    }
+    else {
+        const oneKeys = [];
+        for (key in one) {
+            oneKeys.push(key);
+        }
+        oneKeys.sort();
+        const otherKeys = [];
+        for (key in other) {
+            otherKeys.push(key);
+        }
+        otherKeys.sort();
+        if (!equals(oneKeys, otherKeys)) {
+            return false;
+        }
+        for (i = 0; i < oneKeys.length; i++) {
+            if (!equals(one[oneKeys[i]], other[oneKeys[i]])) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function distinct(base, target) {
+    const result = Object.create(null);
+    if (!base || !target) {
+        return result;
+    }
+    const targetKeys = Object.keys(target);
+    targetKeys.forEach(k => {
+        const baseValue = base[k];
+        const targetValue = target[k];
+        if (!equals(baseValue, targetValue)) {
+            result[k] = targetValue;
+        }
+    });
+    return result;
+}
+function getInjectedParameters(instantiationService, ctor) {
+    return instantiationService.invokeFunction((accessor) => {
+        return _util.getServiceDependencies(ctor).sort((a, b) => a.index - b.index).map(d => accessor.get(d.id));
+    });
+}
+function createInjectedClass(ctor) {
+    const _ctor = ctor;
+    return class extends _ctor {
+        constructor(...args) {
+            super(...args.slice(1), ...getInjectedParameters(args[0], ctor));
+        }
+    };
+}
+function computeConfiguration(configuration, isDiffEditor, overrides) {
+    const editorConfiguration = isObject(configuration.editor) ? deepClone(configuration.editor) : Object.create(null);
+    if (isDiffEditor && isObject(configuration.diffEditor)) {
+        Object.assign(editorConfiguration, configuration.diffEditor);
+    }
+    if (isObject(configuration.diffEditor)) {
+        Object.assign(editorConfiguration, overrides);
+    }
+    return editorConfiguration;
+}
+let ConfiguredStandaloneEditor = class ConfiguredStandaloneEditor extends createInjectedClass(StandaloneEditor) {
+    constructor(domElement, isDiffEditor, _options, instantiationService, textResourceConfigurationService) {
+        const computedOptions = computeConfiguration(textResourceConfigurationService.getValue(_options?.model?.uri), isDiffEditor, _options);
+        super(instantiationService, domElement, computedOptions);
+        this.isDiffEditor = isDiffEditor;
+        this.textResourceConfigurationService = textResourceConfigurationService;
+        this.lastAppliedEditorOptions = computedOptions;
+        this.optionsOverrides = _options;
+        this._register(textResourceConfigurationService.onDidChangeConfiguration(() => this.updateEditorConfiguration()));
+        this._register(this.onDidChangeModelLanguage(() => this.updateEditorConfiguration()));
+        this._register(this.onDidChangeModel(() => this.updateEditorConfiguration()));
+    }
+    updateEditorConfiguration() {
+        const resource = this.getModel()?.uri;
+        if (resource == null) {
+            return;
+        }
+        const configuration = this.textResourceConfigurationService.getValue(resource);
+        if (configuration == null) {
+            return;
+        }
+        const editorConfiguration = computeConfiguration(configuration, this.isDiffEditor, this.optionsOverrides);
+        let editorSettingsToApply = editorConfiguration;
+        if (this.lastAppliedEditorOptions != null) {
+            editorSettingsToApply = distinct(this.lastAppliedEditorOptions, editorSettingsToApply);
+        }
+        if (Object.keys(editorSettingsToApply).length > 0) {
+            this.lastAppliedEditorOptions = editorConfiguration;
+            super.updateOptions(editorSettingsToApply);
+        }
+    }
+    updateOptions(newOptions) {
+        this.optionsOverrides = newOptions;
+        this.updateEditorConfiguration();
+    }
+};
+ConfiguredStandaloneEditor = __decorate([
+    __param(3, IInstantiationService),
+    __param(4, ITextResourceConfigurationService)
+], ConfiguredStandaloneEditor);
+class ConfiguredStandaloneDiffEditor extends StandaloneDiffEditor {
+    _createInnerEditor(instantiationService, container, options) {
+        return instantiationService.createInstance(ConfiguredStandaloneEditor, container, true, options);
+    }
+}
+const createConfiguredEditor = (domElement, options, override) => {
+    const instantiationService = StandaloneServices.initialize(override ?? {});
+    return instantiationService.createInstance(ConfiguredStandaloneEditor, domElement, false, options);
+};
+const createConfiguredDiffEditor = (domElement, options, override) => {
+    const instantiationService = StandaloneServices.initialize(override ?? {});
+    return instantiationService.createInstance(ConfiguredStandaloneDiffEditor, domElement, options);
+};
+export { createConfiguredDiffEditor, createConfiguredEditor };

package/dist/position-291dfe99.js

@@ -0,0 +1,3 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
+const Position = monaco.Position;
+export { Position as P };

package/dist/{services-621e567e.js → services-9299c4ca.js}

@@ -1,5 +1,6 @@
 import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { b as __decorate, c as __param } from './tslib.es6-16b40665.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { isWindows, OS } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
@@ -13,6 +14,7 @@ import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configurati
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { raceCancellation, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/map.js';
 import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
 import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
@@ -269,6 +271,60 @@ function isValidBasename(name, isWindowsOS = isWindows) {
     }
     return true;
 }
+function sortedDiff(before, after, compare) {
+    const result = [];
+    function pushSplice(start, deleteCount, toInsert) {
+        if (deleteCount === 0 && toInsert.length === 0) {
+            return;
+        }
+        const latest = result[result.length - 1];
+        if (latest && latest.start + latest.deleteCount === start) {
+            latest.deleteCount += deleteCount;
+            latest.toInsert.push(...toInsert);
+        }
+        else {
+            result.push({ start, deleteCount, toInsert });
+        }
+    }
+    let beforeIdx = 0;
+    let afterIdx = 0;
+    while (true) {
+        if (beforeIdx === before.length) {
+            pushSplice(beforeIdx, 0, after.slice(afterIdx));
+            break;
+        }
+        if (afterIdx === after.length) {
+            pushSplice(beforeIdx, before.length - beforeIdx, []);
+            break;
+        }
+        const beforeElement = before[beforeIdx];
+        const afterElement = after[afterIdx];
+        const n = compare(beforeElement, afterElement);
+        if (n === 0) {
+            beforeIdx += 1;
+            afterIdx += 1;
+        }
+        else if (n < 0) {
+            pushSplice(beforeIdx, 1, []);
+            beforeIdx += 1;
+        }
+        else if (n > 0) {
+            pushSplice(beforeIdx, 0, [afterElement]);
+            afterIdx += 1;
+        }
+    }
+    return result;
+}
+function delta(before, after, compare) {
+    const splices = sortedDiff(before, after, compare);
+    const removed = [];
+    const added = [];
+    for (const splice of splices) {
+        removed.push(...before.slice(splice.start, splice.start + splice.deleteCount));
+        added.push(...splice.toInsert);
+    }
+    return { removed, added };
+}
 function coalesceInPlace(array) {
     let to = 0;
     for (let i = 0; i < array.length; i++) {
@@ -291,6 +347,11 @@ function remove(array, element) {
     }
     return undefined;
 }
+function mapArrayOrNot(items, fn) {
+    return Array.isArray(items) ?
+        items.map(fn) :
+        fn(items);
+}
 var NeverShowAgainScope;
  (function(NeverShowAgainScope) {
     NeverShowAgainScope[NeverShowAgainScope["WORKSPACE"] = 0] = "WORKSPACE";
@@ -319,26 +380,6 @@ class NoOpProgress {
     total(value) { }
     worked(value) { }
 }
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function __param(paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-}
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
 const IFileService =  createDecorator('fileService');
 var FileType;
  (function(FileType) {
@@ -351,6 +392,24 @@ var FilePermission;
  (function(FilePermission) {
     FilePermission[FilePermission["Readonly"] = 1] = "Readonly";
 })(FilePermission || (FilePermission = {}));
+function hasReadWriteCapability(provider) {
+    return !!((provider.capabilities & 2) );
+}
+function hasFileFolderCopyCapability(provider) {
+    return !!((provider.capabilities & 8) );
+}
+function hasOpenReadWriteCloseCapability(provider) {
+    return !!((provider.capabilities & 4) );
+}
+function hasFileReadStreamCapability(provider) {
+    return !!((provider.capabilities & 16) );
+}
+function hasFileAtomicReadCapability(provider) {
+    if (!hasReadWriteCapability(provider)) {
+        return false;
+    }
+    return !!((provider.capabilities & 16384) );
+}
 var FileSystemProviderErrorCode;
  (function(FileSystemProviderErrorCode) {
     FileSystemProviderErrorCode["FileExists"] = "EntryExists";
@@ -364,10 +423,181 @@ var FileSystemProviderErrorCode;
     FileSystemProviderErrorCode["Unavailable"] = "Unavailable";
     FileSystemProviderErrorCode["Unknown"] = "Unknown";
 })(FileSystemProviderErrorCode || (FileSystemProviderErrorCode = {}));
+class FileSystemProviderError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+function createFileSystemProviderError(error, code) {
+    const providerError =  new FileSystemProviderError(error.toString(), code);
+    markAsFileSystemProviderError(providerError, code);
+    return providerError;
+}
+function ensureFileSystemProviderError(error) {
+    if (!error) {
+        return createFileSystemProviderError( localize('unknownError', "Unknown Error"), FileSystemProviderErrorCode.Unknown);
+    }
+    return error;
+}
 function markAsFileSystemProviderError(error, code) {
     error.name = code ? `${code} (FileSystemError)` : `FileSystemError`;
     return error;
 }
+function toFileSystemProviderErrorCode(error) {
+    if (!error) {
+        return FileSystemProviderErrorCode.Unknown;
+    }
+    if (error instanceof FileSystemProviderError) {
+        return error.code;
+    }
+    const match = /^(.+) \(FileSystemError\)$/.exec(error.name);
+    if (!match) {
+        return FileSystemProviderErrorCode.Unknown;
+    }
+    switch (match[1]) {
+        case FileSystemProviderErrorCode.FileExists: return FileSystemProviderErrorCode.FileExists;
+        case FileSystemProviderErrorCode.FileIsADirectory: return FileSystemProviderErrorCode.FileIsADirectory;
+        case FileSystemProviderErrorCode.FileNotADirectory: return FileSystemProviderErrorCode.FileNotADirectory;
+        case FileSystemProviderErrorCode.FileNotFound: return FileSystemProviderErrorCode.FileNotFound;
+        case FileSystemProviderErrorCode.FileExceedsMemoryLimit: return FileSystemProviderErrorCode.FileExceedsMemoryLimit;
+        case FileSystemProviderErrorCode.FileTooLarge: return FileSystemProviderErrorCode.FileTooLarge;
+        case FileSystemProviderErrorCode.FileWriteLocked: return FileSystemProviderErrorCode.FileWriteLocked;
+        case FileSystemProviderErrorCode.NoPermissions: return FileSystemProviderErrorCode.NoPermissions;
+        case FileSystemProviderErrorCode.Unavailable: return FileSystemProviderErrorCode.Unavailable;
+    }
+    return FileSystemProviderErrorCode.Unknown;
+}
+function toFileOperationResult(error) {
+    if (error instanceof FileOperationError) {
+        return error.fileOperationResult;
+    }
+    switch (toFileSystemProviderErrorCode(error)) {
+        case FileSystemProviderErrorCode.FileNotFound:
+            return 1 ;
+        case FileSystemProviderErrorCode.FileIsADirectory:
+            return 0 ;
+        case FileSystemProviderErrorCode.FileNotADirectory:
+            return 10 ;
+        case FileSystemProviderErrorCode.FileWriteLocked:
+            return 5 ;
+        case FileSystemProviderErrorCode.NoPermissions:
+            return 6 ;
+        case FileSystemProviderErrorCode.FileExists:
+            return 4 ;
+        case FileSystemProviderErrorCode.FileExceedsMemoryLimit:
+            return 9 ;
+        case FileSystemProviderErrorCode.FileTooLarge:
+            return 7 ;
+        default:
+            return 11 ;
+    }
+}
+class FileOperationEvent {
+    constructor(resource, operation, target) {
+        this.resource = resource;
+        this.operation = operation;
+        this.target = target;
+    }
+    isOperation(operation) {
+        return this.operation === operation;
+    }
+}
+class FileChangesEvent {
+    constructor(changes, ignorePathCasing) {
+        this.added = undefined;
+        this.updated = undefined;
+        this.deleted = undefined;
+        this.rawChanges = [];
+        this.rawAdded = [];
+        this.rawUpdated = [];
+        this.rawDeleted = [];
+        this.rawChanges = changes;
+        const entriesByType =  new Map();
+        for (const change of changes) {
+            const array = entriesByType.get(change.type);
+            if (array) {
+                array.push([change.resource, change]);
+            }
+            else {
+                entriesByType.set(change.type, [[change.resource, change]]);
+            }
+            switch (change.type) {
+                case 1 :
+                    this.rawAdded.push(change.resource);
+                    break;
+                case 0 :
+                    this.rawUpdated.push(change.resource);
+                    break;
+                case 2 :
+                    this.rawDeleted.push(change.resource);
+                    break;
+            }
+        }
+        for (const [key, value] of entriesByType) {
+            switch (key) {
+                case 1 :
+                    this.added = TernarySearchTree.forUris(() => ignorePathCasing);
+                    this.added.fill(value);
+                    break;
+                case 0 :
+                    this.updated = TernarySearchTree.forUris(() => ignorePathCasing);
+                    this.updated.fill(value);
+                    break;
+                case 2 :
+                    this.deleted = TernarySearchTree.forUris(() => ignorePathCasing);
+                    this.deleted.fill(value);
+                    break;
+            }
+        }
+    }
+    contains(resource, ...types) {
+        return this.doContains(resource, { includeChildren: false }, ...types);
+    }
+    affects(resource, ...types) {
+        return this.doContains(resource, { includeChildren: true }, ...types);
+    }
+    doContains(resource, options, ...types) {
+        if (!resource) {
+            return false;
+        }
+        const hasTypesFilter = types.length > 0;
+        if (!hasTypesFilter || types.includes(1 )) {
+            if (this.added?.get(resource)) {
+                return true;
+            }
+            if (options.includeChildren && this.added?.findSuperstr(resource)) {
+                return true;
+            }
+        }
+        if (!hasTypesFilter || types.includes(0 )) {
+            if (this.updated?.get(resource)) {
+                return true;
+            }
+            if (options.includeChildren && this.updated?.findSuperstr(resource)) {
+                return true;
+            }
+        }
+        if (!hasTypesFilter || types.includes(2 )) {
+            if (this.deleted?.findSubstr(resource) ) {
+                return true;
+            }
+            if (options.includeChildren && this.deleted?.findSuperstr(resource)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    gotAdded() {
+        return !!this.added;
+    }
+    gotDeleted() {
+        return !!this.deleted;
+    }
+    gotUpdated() {
+        return !!this.updated;
+    }
+}
 class FileOperationError extends ErrorNoTelemetry {
     constructor(message, fileOperationResult, options) {
         super(message);
@@ -375,6 +605,19 @@ class FileOperationError extends ErrorNoTelemetry {
         this.options = options;
     }
 }
+class NotModifiedSinceFileOperationError extends FileOperationError {
+    constructor(message, stat, options) {
+        super(message, 2 , options);
+        this.stat = stat;
+    }
+}
+const ETAG_DISABLED = '';
+function etag(stat) {
+    if (typeof stat.size !== 'number' || typeof stat.mtime !== 'number') {
+        return undefined;
+    }
+    return stat.mtime.toString(29) + stat.size.toString(31);
+}
 const IEditorGroupsService =  createDecorator('editorGroupsService');
 function isEditorGroup(obj) {
     const group = obj;
@@ -770,4 +1013,4 @@ var Services;
     }
     Services.install = install;
 })(Services || (Services = {}));
-export { ACTIVE_GROUP as A, CancellationTokenSource as C, FileSystemProviderErrorCode as F, IProgressService as I, NoOpNotification as N, SIDE_GROUP as S, __classPrivateFieldSet as _, __classPrivateFieldGet as a, __decorate as b, coalesceInPlace as c, __param as d, ITextFileService as e, IFileService as f, IWorkbenchEnvironmentService as g, IUriIdentityService as h, IWorkingCopyFileService as i, IPathService as j, disposed as k, IEditorService as l, markAsFileSystemProviderError as m, IEditorGroupsService as n, IPaneCompositePartService as o, IProductService as p, ILanguageStatusService as q, readonly as r, IHostService as s, Services as t, FileType as u, FilePermission as v, NotificationsFilter as w, refineServiceDecorator as x, NeverShowAgainScope as y, isPreferredGroup as z };
+export { ACTIVE_GROUP as A, createFileSystemProviderError as B, CancellationTokenSource as C, FileChangesEvent as D, FileOperationError as E, FileSystemProviderErrorCode as F, hasOpenReadWriteCloseCapability as G, hasReadWriteCapability as H, IProgressService as I, hasFileReadStreamCapability as J, toFileSystemProviderErrorCode as K, etag as L, FileOperationEvent as M, NoOpNotification as N, toFileOperationResult as O, ETAG_DISABLED as P, hasFileAtomicReadCapability as Q, NotModifiedSinceFileOperationError as R, SIDE_GROUP as S, hasFileFolderCopyCapability as T, mapArrayOrNot as a, ITextFileService as b, coalesceInPlace as c, delta as d, IFileService as e, IWorkbenchEnvironmentService as f, IUriIdentityService as g, IWorkingCopyFileService as h, IPathService as i, disposed as j, IEditorService as k, IEditorGroupsService as l, markAsFileSystemProviderError as m, IPaneCompositePartService as n, IProductService as o, ILanguageStatusService as p, IHostService as q, readonly as r, Services as s, FileType as t, FilePermission as u, NotificationsFilter as v, refineServiceDecorator as w, NeverShowAgainScope as x, isPreferredGroup as y, ensureFileSystemProviderError as z };