@codingame/monaco-vscode-api 1.67.5 → 1.67.8-dev.0

package/dist/services-f1f30499.js

@@ -0,0 +1,300 @@
+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 { VSBuffer as VSBuffer$1 } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
+import 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
+import 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import 'monaco-editor/esm/vs/editor/common/services/model.js';
+import 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import 'monaco-editor/esm/vs/base/common/severity.js';
+function readonly(name) {
+    return name
+        ?  new Error(`readonly property '${name} cannot be changed'`)
+        :  new Error('readonly property cannot be changed');
+}
+function disposed(what) {
+    const result =  new Error(`${what} has been disposed`);
+    result.name = 'DISPOSED';
+    return result;
+}
+class ErrorNoTelemetry extends Error {
+    constructor() {
+        super(...arguments);
+        this.logTelemetry = false;
+    }
+}
+function refineServiceDecorator(serviceIdentifier) {
+    return serviceIdentifier;
+}
+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 = {}));
+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 = {}));
+function markAsFileSystemProviderError(error, code) {
+    error.name = code ? `${code} (FileSystemError)` : `FileSystemError`;
+    return error;
+}
+class FileOperationError extends ErrorNoTelemetry {
+    constructor(message, fileOperationResult, options) {
+        super(message);
+        this.fileOperationResult = fileOperationResult;
+        this.options = options;
+    }
+}
+const hasBuffer = (typeof Buffer !== 'undefined');
+let textEncoder;
+let textDecoder;
+class VSBuffer {
+    constructor(buffer) {
+        this.buffer = buffer;
+        this.byteLength = this.buffer.byteLength;
+    }
+    static alloc(byteLength) {
+        if (hasBuffer) {
+            return (
+                 new VSBuffer(Buffer.allocUnsafe(byteLength))
+            );
+        }
+        else {
+            return (
+                 new VSBuffer( new Uint8Array(byteLength))
+            );
+        }
+    }
+    static wrap(actual) {
+        if (hasBuffer && !(Buffer.isBuffer(actual))) {
+            actual = Buffer.from(actual.buffer, actual.byteOffset, actual.byteLength);
+        }
+        return (
+             new VSBuffer(actual)
+        );
+    }
+    static fromString(source, options) {
+        const dontUseNodeBuffer = options?.dontUseNodeBuffer || false;
+        if (!dontUseNodeBuffer && hasBuffer) {
+            return (
+                 new VSBuffer(Buffer.from(source))
+            );
+        }
+        else {
+            if (!textEncoder) {
+                textEncoder =  new TextEncoder();
+            }
+            return (
+                 new VSBuffer(textEncoder.encode(source))
+            );
+        }
+    }
+    static fromByteArray(source) {
+        const result = VSBuffer.alloc(source.length);
+        for (let i = 0, len = source.length; i < len; i++) {
+            result.buffer[i] = source[i];
+        }
+        return result;
+    }
+    static concat(buffers, totalLength) {
+        if (typeof totalLength === 'undefined') {
+            totalLength = 0;
+            for (let i = 0, len = buffers.length; i < len; i++) {
+                totalLength += buffers[i].byteLength;
+            }
+        }
+        const ret = VSBuffer.alloc(totalLength);
+        let offset = 0;
+        for (let i = 0, len = buffers.length; i < len; i++) {
+            const element = buffers[i];
+            ret.set(element, offset);
+            offset += element.byteLength;
+        }
+        return ret;
+    }
+    clone() {
+        const result = VSBuffer.alloc(this.byteLength);
+        result.set(this);
+        return result;
+    }
+    toString() {
+        if (hasBuffer) {
+            return this.buffer.toString();
+        }
+        else {
+            if (!textDecoder) {
+                textDecoder =  new TextDecoder();
+            }
+            return textDecoder.decode(this.buffer);
+        }
+    }
+    slice(start, end) {
+        return (
+             new VSBuffer(this.buffer.subarray(start, end))
+        );
+    }
+    set(array, offset) {
+        if (array instanceof VSBuffer) {
+            this.buffer.set(array.buffer, offset);
+        }
+        else if (array instanceof Uint8Array) {
+            this.buffer.set(array, offset);
+        }
+        else if (array instanceof ArrayBuffer) {
+            this.buffer.set( new Uint8Array(array), offset);
+        }
+        else if (ArrayBuffer.isView(array)) {
+            this.buffer.set( new Uint8Array(array.buffer, array.byteOffset, array.byteLength), offset);
+        }
+        else {
+            throw new Error(`Unknown argument 'array'`);
+        }
+    }
+    readUInt32BE(offset) {
+        return readUInt32BE(this.buffer, offset);
+    }
+    writeUInt32BE(value, offset) {
+        writeUInt32BE(this.buffer, value, offset);
+    }
+    readUInt32LE(offset) {
+        return readUInt32LE(this.buffer, offset);
+    }
+    writeUInt32LE(value, offset) {
+        writeUInt32LE(this.buffer, value, offset);
+    }
+    readUInt8(offset) {
+        return readUInt8(this.buffer, offset);
+    }
+    writeUInt8(value, offset) {
+        writeUInt8(this.buffer, value, offset);
+    }
+}
+function readUInt32BE(source, offset) {
+    return (source[offset] * 2 ** 24
+        + source[offset + 1] * 2 ** 16
+        + source[offset + 2] * 2 ** 8
+        + source[offset + 3]);
+}
+function writeUInt32BE(destination, value, offset) {
+    destination[offset + 3] = value;
+    value = value >>> 8;
+    destination[offset + 2] = value;
+    value = value >>> 8;
+    destination[offset + 1] = value;
+    value = value >>> 8;
+    destination[offset] = value;
+}
+function readUInt32LE(source, offset) {
+    return (((source[offset + 0] << 0) >>> 0) |
+        ((source[offset + 1] << 8) >>> 0) |
+        ((source[offset + 2] << 16) >>> 0) |
+        ((source[offset + 3] << 24) >>> 0));
+}
+function writeUInt32LE(destination, value, offset) {
+    destination[offset + 0] = (value & 0b11111111);
+    value = value >>> 8;
+    destination[offset + 1] = (value & 0b11111111);
+    value = value >>> 8;
+    destination[offset + 2] = (value & 0b11111111);
+    value = value >>> 8;
+    destination[offset + 3] = (value & 0b11111111);
+}
+function readUInt8(source, offset) {
+    return source[offset];
+}
+function writeUInt8(destination, value, offset) {
+    destination[offset] = value;
+}
+function toVSCodeVSBuffer (value) {
+  if (value instanceof VSBuffer$1) {
+    return new VSBuffer(value.buffer)
+  }
+  return value
+}
+function toMonacoVSBuffer (value) {
+  if (value instanceof VSBuffer) {
+    return new VSBuffer$1(value.buffer)
+  }
+  return value
+}
+for (const key of Object.getOwnPropertyNames(VSBuffer)) {
+  if (!Object.hasOwnProperty.call(VSBuffer$1, key)) {
+    VSBuffer$1[key] = function (...args) {
+      return toMonacoVSBuffer(VSBuffer[key].call(VSBuffer$1, ...args.map(toVSCodeVSBuffer)))
+    };
+  }
+}
+for (const key of Object.getOwnPropertyNames(VSBuffer.prototype)) {
+  if (!Object.hasOwnProperty.call(VSBuffer$1.prototype, key)) {
+    VSBuffer$1.prototype[key] = function (...args) {
+      return toMonacoVSBuffer(VSBuffer.prototype[key].call(this, ...args.map(toVSCodeVSBuffer)))
+    };
+  }
+}
+const IEditorGroupsService =  createDecorator('editorGroupsService');
+const IEditorService =  createDecorator('editorService');
+const ACTIVE_GROUP = -1;
+const SIDE_GROUP = -2;
+const ITextFileService =  createDecorator('textFileService');
+const IWorkbenchEnvironmentService = refineServiceDecorator(IEnvironmentService);
+const IUriIdentityService =  createDecorator('IUriIdentityService');
+const IWorkingCopyFileService =  createDecorator('workingCopyFileService');
+const IPathService =  createDecorator('pathService');
+const IPaneCompositePartService =  createDecorator('paneCompositePartService');
+const IProductService =  createDecorator('productService');
+const ILanguageStatusService =  createDecorator('ILanguageStatusService');
+const IHostService =  createDecorator('hostService');
+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 { ACTIVE_GROUP as A, FileSystemProviderErrorCode as F, IEditorService as I, SIDE_GROUP as S, IPaneCompositePartService as a, IUriIdentityService as b, ITextFileService as c, disposed as d, IFileService as e, IEditorGroupsService as f, IWorkbenchEnvironmentService as g, IWorkingCopyFileService as h, IPathService as i, Services as j, IProductService as k, ILanguageStatusService as l, markAsFileSystemProviderError as m, IHostService as n, FileType as o, FilePermission as p, readonly as r };