@codingame/monaco-vscode-api 1.79.7-next.2 → 1.79.8

package/dist/extHost.js

@@ -1,271 +0,0 @@
-import { ExtHostExtensionService } from './vscode/vs/workbench/api/worker/extHostExtensionService.js';
-import { IExtHostManagedSockets } from './vscode/vs/workbench/api/common/extHostManagedSockets.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IExtHostInitDataService } from './vscode/vs/workbench/api/common/extHostInitDataService.js';
-import { UIKind } from './vscode/vs/workbench/services/extensions/common/extensionHostProtocol.js';
-import { ExtHostVariableResolverProviderService, IExtHostVariableResolverProvider } from './vscode/vs/workbench/api/common/extHostVariableResolverService.js';
-import { IHostUtils, IExtHostExtensionService } from './vscode/vs/workbench/api/common/extHostExtensionService.js';
-import { ExtensionStoragePaths, IExtensionStoragePaths } from './vscode/vs/workbench/api/common/extHostStoragePaths.js';
-import { ExtHostTunnelService, IExtHostTunnelService } from './vscode/vs/workbench/api/common/extHostTunnelService.js';
-import { ExtHostRpcService, IExtHostRpcService } from './vscode/vs/workbench/api/common/extHostRpcService.js';
-import { ILogService, ILoggerService, LogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { ExtHostCustomersRegistry } from './vscode/vs/workbench/services/extensions/common/extHostCustomers.js';
-import { ExtHostApiDeprecationService, IExtHostApiDeprecationService } from './vscode/vs/workbench/api/common/extHostApiDeprecationService.js';
-import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { ExtHostContext } from './vscode/vs/workbench/api/common/extHost.protocol.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { BufferedEmitter } from './vscode/vs/base/parts/ipc/common/ipc.net.js';
-import { RPCProtocol } from './vscode/vs/workbench/services/extensions/common/rpcProtocol.js';
-import * as errors from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Barrier } from 'monaco-editor/esm/vs/base/common/async.js';
-import { IExtensionService } from './vscode/vs/workbench/services/extensions/common/extensions.js';
-import { array } from './node_modules/toposort/index.js';
-import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
-import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-import { InstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiationService.js';
-import { ExtHostLogService } from './vscode/vs/workbench/api/common/extHostLogService.js';
-import { ExtHostLoggerService } from './vscode/vs/workbench/api/common/extHostLoggerService.js';
-import { IURITransformerService, URITransformerService } from './vscode/vs/workbench/api/common/extHostUriTransformerService.js';
-import { unsupported } from './tools.js';
-import './vscode/vs/workbench/api/browser/mainThreadConsole.js';
-import './vscode/vs/workbench/api/browser/mainThreadExtensionService.js';
-import './vscode/vs/workbench/api/browser/mainThreadLogService.js';
-const serviceCollection = new ServiceCollection();
-function registerExtHostSingleton(id, ctorOrDescriptor, supportsDelayedInstantiation) {
-    if (!(ctorOrDescriptor instanceof SyncDescriptor)) {
-        ctorOrDescriptor = new SyncDescriptor(ctorOrDescriptor, [], Boolean(supportsDelayedInstantiation));
-    }
-    serviceCollection.set(id, ctorOrDescriptor);
-}
-serviceCollection.set(IURITransformerService, new URITransformerService(null));
-const extHostInstantiationService = new InstantiationService(serviceCollection, false);
-serviceCollection.set(IInstantiationService, extHostInstantiationService);
-class SimpleMessagePassingProtocol {
-    constructor() {
-        this._onMessage = new BufferedEmitter();
-        this.onMessage = this._onMessage.event;
-    }
-    send(buffer) {
-        setTimeout(() => {
-            this._onMessage.fire(buffer);
-        });
-    }
-}
-const imessagePassingProtocol = new SimpleMessagePassingProtocol();
-const rpcProtocol = new RPCProtocol(imessagePassingProtocol);
-const environment = {
-    isExtensionDevelopmentDebug: false,
-    appName: 'Monaco',
-    appHost: 'web',
-    appLanguage: window.navigator.language ?? 'en-US',
-    extensionTelemetryLogResource: ( URI.from({ scheme: 'user', path: '/extensionTelemetryLogResource.log' })),
-    isExtensionTelemetryLoggingOnly: false,
-    get appUriScheme() { return unsupported(); },
-    get globalStorageHome() { return unsupported(); },
-    get workspaceStorageHome() { return unsupported(); }
-};
-registerExtHostSingleton(ILogService, new SyncDescriptor(ExtHostLogService, [true], true));
-registerExtHostSingleton(ILoggerService, ExtHostLoggerService, 1 );
-class ExtHostInitDataService {
-    constructor(_telemetryService) {
-        this._telemetryService = _telemetryService;
-        this.quality = undefined;
-        this.version = '1.0.0';
-        this.parentPid = 0;
-        this.environment = environment;
-        this.allExtensions = [];
-        this.myExtensions = [];
-        this.consoleForward = {
-            includeStack: false,
-            logNative: false
-        };
-        this.logLevel = LogLevel.Off;
-        this.logsLocation = ( URI.from({ scheme: 'logs', path: '/' }));
-        this.logFile = ( URI.from({ scheme: 'logs', path: '/logs.log' }));
-        this.autoStart = true;
-        this.remote = {
-            isRemote: false,
-            authority: undefined,
-            connectionData: null
-        };
-        this.uiKind = UIKind.Web;
-        this.loggers = [];
-        this.logName = 'browser';
-        this.activationEvents = {};
-    }
-    get telemetryInfo() {
-        return this._telemetryService;
-    }
-}
-registerExtHostSingleton(IHostUtils, class HostUtils {
-    constructor() {
-        this.pid = undefined;
-    }
-    exit() {
-        window.close();
-    }
-    async exists() {
-        return true;
-    }
-    async realpath(path) {
-        return path;
-    }
-}, 1 );
-registerExtHostSingleton(IExtHostRpcService, new SyncDescriptor(ExtHostRpcService, [rpcProtocol], true));
-registerExtHostSingleton(IExtensionStoragePaths, ExtensionStoragePaths, 1 );
-class _ExtHostExtensionService extends ExtHostExtensionService {
-    getExtensionRegistries() {
-        return { mine: this._myRegistry, all: this._globalRegistry };
-    }
-}
-registerExtHostSingleton(IExtHostExtensionService, _ExtHostExtensionService, 1 );
-registerExtHostSingleton(IExtHostTunnelService, ExtHostTunnelService, 1 );
-registerExtHostSingleton(IExtHostApiDeprecationService, ExtHostApiDeprecationService, 1 );
-registerExtHostSingleton(IExtHostVariableResolverProvider, ExtHostVariableResolverProviderService, 1 );
-registerExtHostSingleton(IExtHostManagedSockets, class ExtHostManagedSockets {
-    constructor() {
-        this.setFactory = () => {
-        };
-        this.$openRemoteSocket = unsupported;
-        this.$remoteSocketWrite = unsupported;
-        this.$remoteSocketEnd = unsupported;
-        this.$remoteSocketDrain = unsupported;
-    }
-}, 1 );
-const mainContext = {
-    remoteAuthority: null,
-    extensionHostKind: 1 ,
-    internalExtensionService: {
-        _activateById() {
-            return Promise.resolve();
-        },
-        _onWillActivateExtension() {
-        },
-        _onDidActivateExtension() {
-        },
-        _onDidActivateExtensionError() {
-        },
-        _onExtensionRuntimeError() {
-        }
-    },
-    getProxy: function (identifier) {
-        return ( rpcProtocol.getProxy(identifier));
-    },
-    set: function (identifier, instance) {
-        return rpcProtocol.set(identifier, instance);
-    },
-    assertRegistered: function (identifiers) {
-        rpcProtocol.assertRegistered(identifiers);
-    },
-    drain: function () {
-        return rpcProtocol.drain();
-    },
-    dispose() {
-        rpcProtocol.dispose();
-    },
-    _setExtensionHostProxy(proxy) {
-        StandaloneServices.get(IExtensionService).setExtensionHostProxy(proxy);
-    },
-    _setAllMainProxyIdentifiers() { }
-};
-const extHostProviders = new Map();
-function registerExtHostProvider(name, provider) {
-    extHostProviders.set(name, provider);
-}
-function createExtHostServices(accessor) {
-    registerExtHostSingleton(IExtHostInitDataService, new SyncDescriptor(ExtHostInitDataService, [StandaloneServices.get(ITelemetryService)], true));
-    const rpcProtocol = accessor.get(IExtHostRpcService);
-    const logService = accessor.get(ILogService);
-    const extHostApiDeprecationService = accessor.get(IExtHostApiDeprecationService);
-    const extHostTunnelService = accessor.get(IExtHostTunnelService);
-    const extHostInitData = accessor.get(IExtHostInitDataService);
-    rpcProtocol.set(ExtHostContext.ExtHostTunnelService, extHostTunnelService);
-    const extHostExtensionService = rpcProtocol.set(ExtHostContext.ExtHostExtensionService, accessor.get(IExtHostExtensionService));
-    const extHostServices = {
-        extHostInitData,
-        extHostLogService: logService,
-        extHostApiDeprecationService,
-        extHostExtensionService
-    };
-    const sortedProviders = array(Array.from(( extHostProviders.values())), Array.from(extHostProviders.entries()).flatMap(([name, provider]) => provider.dependencies?.map(dependency => {
-        const dependencyImpl = extHostProviders.get(dependency);
-        if (dependencyImpl == null) {
-            logService.warn(`ExtHost ${name} depends on not registered ${dependency}`);
-            return null;
-        }
-        return [dependencyImpl, provider];
-    }).filter((a) => a != null) ?? []));
-    for (const extHostProvider of sortedProviders) {
-        Object.assign(extHostServices, extHostProvider.provide(accessor, mainContext, extHostServices));
-    }
-    return extHostServices;
-}
-function runExtHostCustomers(accessor) {
-    const instantiationService = accessor.get(IInstantiationService);
-    const logService = accessor.get(ILogService);
-    const namedCustomers = ExtHostCustomersRegistry.getNamedCustomers();
-    for (const [id, ctor] of namedCustomers) {
-        try {
-            const instance = instantiationService.createInstance(ctor, mainContext);
-            rpcProtocol.set(id, instance);
-        }
-        catch (err) {
-            logService.error(`Cannot instantiate named customer: '${id.sid}'`);
-            logService.error(err);
-            errors.onUnexpectedError(err);
-        }
-    }
-    const customers = ExtHostCustomersRegistry.getCustomers();
-    for (const ctor of customers) {
-        try {
-            instantiationService.createInstance(ctor, mainContext);
-        }
-        catch (err) {
-            logService.error(err);
-            errors.onUnexpectedError(err);
-        }
-    }
-}
-let extHostServices;
-let configProvider;
-const extHostInitializedBarrier = new Barrier();
-function onExtHostInitialized(fct) {
-    void extHostInitializedBarrier.wait().then(fct);
-}
-async function _initialize() {
-    const partialExtHostServices = extHostInstantiationService.invokeFunction(createExtHostServices);
-    StandaloneServices.get(IInstantiationService).invokeFunction(runExtHostCustomers);
-    configProvider = await partialExtHostServices.extHostConfiguration?.getConfigProvider();
-    await partialExtHostServices.extHostExtensionService.initialize();
-    extHostServices = new Proxy(partialExtHostServices, {
-        get(target, p) {
-            const v = target[p];
-            if (v == null) {
-                StandaloneServices.get(ILogService).warn(`ExtHost ${p} not registered`);
-            }
-            return v;
-        }
-    });
-    extHostInitializedBarrier.open();
-}
-let initializePromise;
-async function initialize() {
-    if (initializePromise == null) {
-        initializePromise = _initialize();
-    }
-    await initializePromise;
-}
-function getExtHostServices() {
-    if (extHostServices == null) {
-        throw new Error('Extension api not initialized');
-    }
-    return extHostServices;
-}
-function getConfigProvider() {
-    if (configProvider == null) {
-        throw new Error('Config provider not available');
-    }
-    return configProvider;
-}
-export { extHostInstantiationService, getConfigProvider, getExtHostServices, initialize, onExtHostInitialized, registerExtHostProvider, registerExtHostSingleton };

package/dist/extensionWorker.js

@@ -1,80 +0,0 @@
-async function getRealUrl(url) {
-    if (url.startsWith('extension:')) {
-        const { workspace, Uri } = require('vscode');
-        const value = await workspace.fs.readFile(Uri.parse(url));
-        const source = new TextDecoder().decode(value);
-        const sourceURL = `${url}#vscode-extension-worker`;
-        const fullSource = `${source}\n//# sourceURL=${sourceURL}`;
-        const blob = new Blob([fullSource]);
-        return URL.createObjectURL(blob);
-    }
-    return url;
-}
-class ExtensionWorker {
-    constructor(scriptURL, options) {
-        this._onmessage = null;
-        this._onmessageerror = null;
-        this._onerror = null;
-        this.workerPromise = getRealUrl(scriptURL instanceof URL ? scriptURL.toString() : scriptURL).then(url => {
-            return new Worker(url, options);
-        });
-    }
-    set onmessage(cb) {
-        this._onmessage = cb;
-        this.workerPromise.then(worker => {
-            worker.onmessage = cb;
-        }, console.error);
-    }
-    get onmessage() {
-        return this._onmessage;
-    }
-    set onmessageerror(cb) {
-        this._onmessageerror = cb;
-        this.workerPromise.then(worker => {
-            worker.onmessageerror = cb;
-        }, console.error);
-    }
-    get onmessageerror() {
-        return this._onmessageerror;
-    }
-    set onerror(cb) {
-        this._onerror = cb;
-        this.workerPromise.then(worker => {
-            worker.onerror = cb;
-        }, console.error);
-    }
-    get onerror() {
-        return this._onerror;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    postMessage(message, options) {
-        this.workerPromise.then(worker => {
-            worker.postMessage(message, options);
-        }, console.error);
-    }
-    terminate() {
-        this.workerPromise.then(worker => {
-            worker.terminate();
-        }, console.error);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    addEventListener(type, listener, options) {
-        this.workerPromise.then(worker => {
-            worker.addEventListener(type, listener, options);
-        }, console.error);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    removeEventListener(type, listener, options) {
-        this.workerPromise.then(worker => {
-            worker.removeEventListener(type, listener, options);
-        }, console.error);
-    }
-    dispatchEvent(event) {
-        this.workerPromise.then(worker => {
-            worker.dispatchEvent(event);
-        }, console.error);
-        return false;
-    }
-}
-
-export { ExtensionWorker as default };

package/dist/node_modules/toposort/index.js

@@ -1,76 +0,0 @@
-import { __module as toposort$1 } from '../../_virtual/index.js';
-toposort$1.exports = function(edges) {
-  return toposort(uniqueNodes(edges), edges)
-};
-var array = toposort$1.exports.array = toposort;
-function toposort(nodes, edges) {
-  var cursor = nodes.length
-    , sorted = new Array(cursor)
-    , visited = {}
-    , i = cursor
-    , outgoingEdges = makeOutgoingEdges(edges)
-    , nodesHash = makeNodesHash(nodes);
-  edges.forEach(function(edge) {
-    if (!( nodesHash.has(edge[0])) || !( nodesHash.has(edge[1]))) {
-      throw new Error('Unknown node. There is an unknown node in the supplied edges.')
-    }
-  });
-  while (i--) {
-    if (!visited[i]) visit(nodes[i], i, new Set());
-  }
-  return sorted
-  function visit(node, i, predecessors) {
-    if(( predecessors.has(node))) {
-      var nodeRep;
-      try {
-        nodeRep = ", node was:" + JSON.stringify(node);
-      } catch(e) {
-        nodeRep = "";
-      }
-      throw new Error('Cyclic dependency' + nodeRep)
-    }
-    if (!( nodesHash.has(node))) {
-      throw new Error('Found unknown node. Make sure to provided all involved nodes. Unknown node: '+JSON.stringify(node))
-    }
-    if (visited[i]) return;
-    visited[i] = true;
-    var outgoing = outgoingEdges.get(node) || new Set();
-    outgoing = Array.from(outgoing);
-    if (i = outgoing.length) {
-      predecessors.add(node);
-      do {
-        var child = outgoing[--i];
-        visit(child, nodesHash.get(child), predecessors);
-      } while (i)
-      predecessors.delete(node);
-    }
-    sorted[--cursor] = node;
-  }
-}
-function uniqueNodes(arr){
-  var res = new Set();
-  for (var i = 0, len = arr.length; i < len; i++) {
-    var edge = arr[i];
-    res.add(edge[0]);
-    res.add(edge[1]);
-  }
-  return Array.from(res)
-}
-function makeOutgoingEdges(arr){
-  var edges = new Map();
-  for (var i = 0, len = arr.length; i < len; i++) {
-    var edge = arr[i];
-    if (!( edges.has(edge[0]))) edges.set(edge[0], new Set());
-    if (!( edges.has(edge[1]))) edges.set(edge[1], new Set());
-    edges.get(edge[0]).add(edge[1]);
-  }
-  return edges
-}
-function makeNodesHash(arr){
-  var res = new Map();
-  for (var i = 0, len = arr.length; i < len; i++) {
-    res.set(arr[i], i);
-  }
-  return res
-}
-export { array };

package/dist/vscode/vs/platform/extensions/common/extensionValidator.js

@@ -1,79 +0,0 @@
-const VERSION_REGEXP = /^(\^|>=)?((\d+)|x)\.((\d+)|x)\.((\d+)|x)(\-.*)?$/;
-const NOT_BEFORE_REGEXP = /^-(\d{4})(\d{2})(\d{2})$/;
-function isValidVersionStr(version) {
-    version = version.trim();
-    return (version === '*' || VERSION_REGEXP.test(version));
-}
-function parseVersion(version) {
-    if (!isValidVersionStr(version)) {
-        return null;
-    }
-    version = version.trim();
-    if (version === '*') {
-        return {
-            hasCaret: false,
-            hasGreaterEquals: false,
-            majorBase: 0,
-            majorMustEqual: false,
-            minorBase: 0,
-            minorMustEqual: false,
-            patchBase: 0,
-            patchMustEqual: false,
-            preRelease: null
-        };
-    }
-    const m = version.match(VERSION_REGEXP);
-    if (!m) {
-        return null;
-    }
-    return {
-        hasCaret: m[1] === '^',
-        hasGreaterEquals: m[1] === '>=',
-        majorBase: m[2] === 'x' ? 0 : parseInt(m[2], 10),
-        majorMustEqual: (m[2] === 'x' ? false : true),
-        minorBase: m[4] === 'x' ? 0 : parseInt(m[4], 10),
-        minorMustEqual: (m[4] === 'x' ? false : true),
-        patchBase: m[6] === 'x' ? 0 : parseInt(m[6], 10),
-        patchMustEqual: (m[6] === 'x' ? false : true),
-        preRelease: m[8] || null
-    };
-}
-function normalizeVersion(version) {
-    if (!version) {
-        return null;
-    }
-    const majorBase = version.majorBase;
-    const majorMustEqual = version.majorMustEqual;
-    const minorBase = version.minorBase;
-    let minorMustEqual = version.minorMustEqual;
-    const patchBase = version.patchBase;
-    let patchMustEqual = version.patchMustEqual;
-    if (version.hasCaret) {
-        if (majorBase === 0) {
-            patchMustEqual = false;
-        }
-        else {
-            minorMustEqual = false;
-            patchMustEqual = false;
-        }
-    }
-    let notBefore = 0;
-    if (version.preRelease) {
-        const match = NOT_BEFORE_REGEXP.exec(version.preRelease);
-        if (match) {
-            const [, year, month, day] = match;
-            notBefore = Date.UTC(Number(year), Number(month) - 1, Number(day));
-        }
-    }
-    return {
-        majorBase: majorBase,
-        majorMustEqual: majorMustEqual,
-        minorBase: minorBase,
-        minorMustEqual: minorMustEqual,
-        patchBase: patchBase,
-        patchMustEqual: patchMustEqual,
-        isMinimum: version.hasGreaterEquals,
-        notBefore,
-    };
-}
-export { isValidVersionStr, normalizeVersion, parseVersion };

package/dist/vscode/vs/platform/webview/common/mimeTypes.js

@@ -1,22 +0,0 @@
-import { getMediaMime, Mimes } from 'monaco-editor/esm/vs/base/common/mime.js';
-import { extname } from 'monaco-editor/esm/vs/base/common/path.js';
-const webviewMimeTypes = ( new Map([
-    ['.svg', 'image/svg+xml'],
-    ['.txt', Mimes.text],
-    ['.css', 'text/css'],
-    ['.js', 'application/javascript'],
-    ['.cjs', 'application/javascript'],
-    ['.mjs', 'application/javascript'],
-    ['.json', 'application/json'],
-    ['.html', 'text/html'],
-    ['.htm', 'text/html'],
-    ['.xhtml', 'application/xhtml+xml'],
-    ['.oft', 'font/otf'],
-    ['.xml', 'application/xml'],
-    ['.wasm', 'application/wasm'],
-]));
-function getWebviewContentMimeType(resource) {
-    const ext = extname(resource.fsPath).toLowerCase();
-    return webviewMimeTypes.get(ext) || getMediaMime(resource.fsPath) || Mimes.unknown;
-}
-export { getWebviewContentMimeType };

package/dist/vscode/vs/platform/webview/common/webviewPortMapping.js

@@ -1,58 +0,0 @@
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { extractLocalHostUriMetaDataForPortMapping } from '../../tunnel/common/tunnel.js';
-class WebviewPortMappingManager {
-    constructor(_getExtensionLocation, _getMappings, tunnelService) {
-        this._getExtensionLocation = _getExtensionLocation;
-        this._getMappings = _getMappings;
-        this.tunnelService = tunnelService;
-        this._tunnels = ( new Map());
-    }
-    async getRedirect(resolveAuthority, url) {
-        const uri = ( URI.parse(url));
-        const requestLocalHostInfo = extractLocalHostUriMetaDataForPortMapping(uri);
-        if (!requestLocalHostInfo) {
-            return undefined;
-        }
-        for (const mapping of this._getMappings()) {
-            if (mapping.webviewPort === requestLocalHostInfo.port) {
-                const extensionLocation = this._getExtensionLocation();
-                if (extensionLocation && extensionLocation.scheme === Schemas.vscodeRemote) {
-                    const tunnel = resolveAuthority && (await this.getOrCreateTunnel(resolveAuthority, mapping.extensionHostPort));
-                    if (tunnel) {
-                        if (tunnel.tunnelLocalPort === mapping.webviewPort) {
-                            return undefined;
-                        }
-                        return encodeURI(( uri.with({
-                            authority: `127.0.0.1:${tunnel.tunnelLocalPort}`,
-                        }).toString(true)));
-                    }
-                }
-                if (mapping.webviewPort !== mapping.extensionHostPort) {
-                    return encodeURI(( uri.with({
-                        authority: `${requestLocalHostInfo.address}:${mapping.extensionHostPort}`
-                    }).toString(true)));
-                }
-            }
-        }
-        return undefined;
-    }
-    async dispose() {
-        for (const tunnel of ( this._tunnels.values())) {
-            await tunnel.dispose();
-        }
-        this._tunnels.clear();
-    }
-    async getOrCreateTunnel(remoteAuthority, remotePort) {
-        const existing = this._tunnels.get(remotePort);
-        if (existing) {
-            return existing;
-        }
-        const tunnel = await this.tunnelService.openTunnel({ getAddress: async () => remoteAuthority }, undefined, remotePort);
-        if (tunnel) {
-            this._tunnels.set(remotePort, tunnel);
-        }
-        return tunnel;
-    }
-}
-export { WebviewPortMappingManager };