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

package/dist/services.js

@@ -1,4 +1,4 @@
-import './vscode-services/extHost.js';
+import './extHost.js';
 export { default as Severity } from 'monaco-editor/esm/vs/base/common/severity.js';
 export { StorageScope, StorageTarget } from './vscode/vs/platform/storage/common/storage.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';

package/dist/standaloneServices.d.ts

@@ -1,4 +1,4 @@
-import { S as ServiceIdentifier, I as IInstantiationService } from './instantiation.js';
+import { S as ServiceIdentifier, a as IInstantiationService } from './instantiation.js';
 import * as monaco from 'monaco-editor';
 
 type IEditorOverrideServices = monaco.editor.IEditorOverrideServices

package/dist/views.d.ts

@@ -1,10 +1,10 @@
-import { S as ServiceIdentifier, b as SyncDescriptor } from './instantiation.js';
+import { S as ServiceIdentifier, c as SyncDescriptor } from './instantiation.js';
 import { U as URI } from './uri.js';
 import { E as Event } from './event.js';
 import { T as ThemeIcon } from './themables.js';
 import { C as ContextKeyExpression } from './contextkey.js';
-import { c as ILocalizedString, E as ExtensionIdentifier } from './extensions.d2.ts';
-import { I as IComposite, a as IProgressIndicator } from './composite.js';
+import { h as ILocalizedString, E as ExtensionIdentifier } from './extensions.d2.ts';
+import { I as IComposite, b as IProgressIndicator } from './composite.js';
 
 interface IKeybindings {
     primary?: number;
@@ -267,4 +267,4 @@ interface IViewPaneContainer {
     toggleViewVisibility(viewId: string): void;
 }
 
-export { IView as I, ViewContainerLocation as V, IViewDescriptorService as a, IViewPaneContainer as b, ViewContainer as c, IViewContainerModel as d, IViewDescriptor as e, IAddedViewDescriptorRef as f, IPaneComposite as g, IViewsService as h };
+export { IView as I, ViewContainer as V, IViewDescriptorService as a, IViewPaneContainer as b, IViewContainerModel as c, IViewDescriptor as d, IAddedViewDescriptorRef as e, IPaneComposite as f, ViewContainerLocation as g, IViewsService as h };

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

@@ -0,0 +1,79 @@
+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/tunnel/common/tunnel.js

@@ -20,6 +20,19 @@ var ProvidedOnAutoForward;
     ProvidedOnAutoForward[ProvidedOnAutoForward["Ignore"] = 5] = "Ignore";
     ProvidedOnAutoForward[ProvidedOnAutoForward["OpenBrowserOnce"] = 6] = "OpenBrowserOnce";
 })(ProvidedOnAutoForward || (ProvidedOnAutoForward = {})));
+function extractLocalHostUriMetaDataForPortMapping(uri) {
+    if (uri.scheme !== 'http' && uri.scheme !== 'https') {
+        return undefined;
+    }
+    const localhostMatch = /^(localhost|127\.0\.0\.1|0\.0\.0\.0):(\d+)$/.exec(uri.authority);
+    if (!localhostMatch) {
+        return undefined;
+    }
+    return {
+        address: localhostMatch[1],
+        port: +localhostMatch[2],
+    };
+}
 const LOCALHOST_ADDRESSES = ['localhost', '127.0.0.1', '0:0:0:0:0:0:0:1', '::1'];
 function isLocalhost(host) {
     return LOCALHOST_ADDRESSES.indexOf(host) >= 0;
@@ -28,4 +41,4 @@ const ALL_INTERFACES_ADDRESSES = ['0.0.0.0', '0:0:0:0:0:0:0:0', '::'];
 function isAllInterfaces(host) {
     return ALL_INTERFACES_ADDRESSES.indexOf(host) >= 0;
 }
-export { ALL_INTERFACES_ADDRESSES, ITunnelService, LOCALHOST_ADDRESSES, ProvidedOnAutoForward, TunnelPrivacyId, TunnelProtocol, isAllInterfaces, isLocalhost };
+export { ALL_INTERFACES_ADDRESSES, ITunnelService, LOCALHOST_ADDRESSES, ProvidedOnAutoForward, TunnelPrivacyId, TunnelProtocol, extractLocalHostUriMetaDataForPortMapping, isAllInterfaces, isLocalhost };

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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,58 @@
+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 };