@codingame/monaco-vscode-api 1.68.7 → 1.69.2

package/dist/services.js

@@ -1,26 +1,23 @@
+export { f as IEditorGroupsService, c as IEditorService, I as IFileService, l as IHostService, k as ILanguageStatusService, d as IPaneCompositePartService, i as IPathService, j as IProductService, m as ISnippetsService, e as ITextFileService, b as IUriIdentityService, g as IWorkbenchEnvironmentService, h as IWorkingCopyFileService, w as NotificationsFilter, S as Services } from './services2.js';
+export { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+export { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+export { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+export { IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+export { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+export { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+export { ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
+export { IEditorWorkerService } from 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
+export { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+export { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+export { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+export { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+export { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+export { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+export { IMarkerService } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+export { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+export { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+export { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+export { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+export { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+export { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
 export { default as Severity } from 'monaco-editor/esm/vs/base/common/severity.js';
-let services;
-var Services;
-(function (Services) {
-    Services.get = () => {
-        if (services == null) {
-            throw new Error('Services has not been installed');
-        }
-        return services;
-    };
-    function install(_services) {
-        if (services != null) {
-            console.warn('Services have been overridden');
-        }
-        services = _services;
-        return {
-            dispose: () => {
-                if (services === _services) {
-                    services = undefined;
-                }
-            }
-        };
-    }
-    Services.install = install;
-})(Services || (Services = {}));
-export { Services };

package/dist/services2.js

@@ -0,0 +1,423 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/map.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+function refineServiceDecorator(serviceIdentifier) {
+    return serviceIdentifier;
+}
+const CancellationTokenSource = monaco.CancellationTokenSource;
+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++) {
+        if (!!array[i]) {
+            array[to] = array[i];
+            to += 1;
+        }
+    }
+    array.length = to;
+}
+function flatten(arr) {
+    return [].concat(...arr);
+}
+function index(array, indexer, mapper) {
+    return array.reduce((r, t) => {
+        r[indexer(t)] = mapper ? mapper(t) : t;
+        return r;
+    }, Object.create(null));
+}
+function shuffle(array, _seed) {
+    let rand;
+    if (typeof _seed === 'number') {
+        let seed = _seed;
+        rand = () => {
+            const x = Math.sin(seed++) * 179426549;
+            return x - Math.floor(x);
+        };
+    }
+    else {
+        rand = Math.random;
+    }
+    for (let i = array.length - 1; i > 0; i -= 1) {
+        const j = Math.floor(rand() * (i + 1));
+        const temp = array[i];
+        array[i] = array[j];
+        array[j] = temp;
+    }
+}
+function mapArrayOrNot(items, fn) {
+    return Array.isArray(items) ?
+        items.map(fn) :
+        fn(items);
+}
+var NeverShowAgainScope;
+( ((function(NeverShowAgainScope) {
+    NeverShowAgainScope[NeverShowAgainScope["WORKSPACE"] = 0] = "WORKSPACE";
+    NeverShowAgainScope[NeverShowAgainScope["PROFILE"] = 1] = "PROFILE";
+    NeverShowAgainScope[NeverShowAgainScope["APPLICATION"] = 2] = "APPLICATION";
+})(NeverShowAgainScope || (NeverShowAgainScope = {}))));
+var NotificationsFilter;
+( ((function(NotificationsFilter) {
+    NotificationsFilter[NotificationsFilter["OFF"] = 0] = "OFF";
+    NotificationsFilter[NotificationsFilter["SILENT"] = 1] = "SILENT";
+    NotificationsFilter[NotificationsFilter["ERROR"] = 2] = "ERROR";
+})(NotificationsFilter || (NotificationsFilter = {}))));
+class NoOpNotification {
+    constructor() {
+        this.progress = ( (new NoOpProgress()));
+        this.onDidClose = Event.None;
+        this.onDidChangeVisibility = Event.None;
+    }
+    updateSeverity(severity) { }
+    updateMessage(message) { }
+    updateActions(actions) { }
+    close() { }
+}
+class NoOpProgress {
+    infinite() { }
+    done() { }
+    total(value) { }
+    worked(value) { }
+}
+const IFileService = ( (createDecorator('fileService')));
+var FileType;
+( ((function(FileType) {
+    FileType[FileType["Unknown"] = 0] = "Unknown";
+    FileType[FileType["File"] = 1] = "File";
+    FileType[FileType["Directory"] = 2] = "Directory";
+    FileType[FileType["SymbolicLink"] = 64] = "SymbolicLink";
+})(FileType || (FileType = {}))));
+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 hasFileCloneCapability(provider) {
+    return !!((provider.capabilities & 32768) );
+}
+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";
+    FileSystemProviderErrorCode["FileNotFound"] = "EntryNotFound";
+    FileSystemProviderErrorCode["FileNotADirectory"] = "EntryNotADirectory";
+    FileSystemProviderErrorCode["FileIsADirectory"] = "EntryIsADirectory";
+    FileSystemProviderErrorCode["FileExceedsMemoryLimit"] = "EntryExceedsMemoryLimit";
+    FileSystemProviderErrorCode["FileTooLarge"] = "EntryTooLarge";
+    FileSystemProviderErrorCode["FileWriteLocked"] = "EntryWriteLocked";
+    FileSystemProviderErrorCode["NoPermissions"] = "NoPermissions";
+    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 Error {
+    constructor(message, fileOperationResult, options) {
+        super(message);
+        this.fileOperationResult = fileOperationResult;
+        this.options = options;
+    }
+}
+class NotModifiedSinceFileOperationError extends FileOperationError {
+    constructor(message, stat, options) {
+        super(message, 2 , options);
+        this.stat = stat;
+    }
+}
+const FILES_ASSOCIATIONS_CONFIG = 'files.associations';
+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 IUriIdentityService = ( (createDecorator('IUriIdentityService')));
+const IEditorGroupsService = ( (createDecorator('editorGroupsService')));
+function isEditorGroup(obj) {
+    const group = obj;
+    return !!group && typeof group.id === 'number' && Array.isArray(group.editors);
+}
+const IEditorService = ( (createDecorator('editorService')));
+const ACTIVE_GROUP = -1;
+const SIDE_GROUP = -2;
+function isPreferredGroup(obj) {
+    const candidate = obj;
+    return typeof obj === 'number' || isEditorGroup(candidate);
+}
+const ITextFileService = ( (createDecorator('textFileService')));
+const IWorkbenchEnvironmentService = refineServiceDecorator(IEnvironmentService);
+const IWorkingCopyFileService = ( (createDecorator('workingCopyFileService')));
+const IPathService = ( (createDecorator('pathService')));
+const IPaneCompositePartService = ( (createDecorator('paneCompositePartService')));
+const IProductService = ( (createDecorator('productService')));
+const productSchemaId = 'vscode://schemas/vscode-product';
+const ILanguageStatusService = ( (createDecorator('ILanguageStatusService')));
+const IHostService = ( (createDecorator('hostService')));
+const ISnippetsService = ( (createDecorator('snippetService')));
+let services;
+var Services;
+( (function(Services) {
+    Services.get = () => {
+        return services ?? {};
+    };
+    function install(_services) {
+        if (services != null) {
+            console.warn('Services have been overridden');
+        }
+        services = _services;
+        return {
+            dispose: () => {
+                if (services === _services) {
+                    services = undefined;
+                }
+            }
+        };
+    }
+    Services.install = install;
+})(Services || (Services = {})));
+export { ACTIVE_GROUP as A, FileChangesEvent as B, CancellationTokenSource as C, FileOperationError as D, hasOpenReadWriteCloseCapability as E, FileType as F, hasReadWriteCapability as G, hasFileReadStreamCapability as H, IFileService as I, toFileSystemProviderErrorCode as J, ensureFileSystemProviderError as K, etag as L, FileOperationEvent as M, NoOpNotification as N, toFileOperationResult as O, ETAG_DISABLED as P, hasFileAtomicReadCapability as Q, NotModifiedSinceFileOperationError as R, Services as S, hasFileFolderCopyCapability as T, hasFileCloneCapability as U, createFileSystemProviderError as V, index as W, flatten as X, FILES_ASSOCIATIONS_CONFIG as Y, FilePermission as a, IUriIdentityService as b, IEditorService as c, IPaneCompositePartService as d, ITextFileService as e, IEditorGroupsService as f, IWorkbenchEnvironmentService as g, IWorkingCopyFileService as h, IPathService as i, IProductService as j, ILanguageStatusService as k, IHostService as l, ISnippetsService as m, coalesceInPlace as n, markAsFileSystemProviderError as o, productSchemaId as p, FileSystemProviderErrorCode as q, refineServiceDecorator as r, shuffle as s, mapArrayOrNot as t, SIDE_GROUP as u, delta as v, NotificationsFilter as w, NeverShowAgainScope as x, isPreferredGroup as y, FileSystemProviderError as z };