@codingame/monaco-vscode-view-common-service-override 4.5.0-improve-code-splitting.1

package/vscode/src/vs/platform/languagePacks/common/localizedStrings.js

@@ -0,0 +1,12 @@
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+
+const open = ( localizeWithPath('vs/platform/languagePacks/common/localizedStrings', 'open', 'open'));
+const close = ( localizeWithPath('vs/platform/languagePacks/common/localizedStrings', 'close', 'close'));
+const find = ( localizeWithPath('vs/platform/languagePacks/common/localizedStrings', 'find', 'find'));
+var localizedStrings = {
+    open: open,
+    close: close,
+    find: find
+};
+
+export { localizedStrings as default };

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

@@ -0,0 +1,24 @@
+import { Mimes, getMediaMime } from 'vscode/vscode/vs/base/common/mime';
+import { extname } from 'vscode/vscode/vs/base/common/path';
+
+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/vscode/src/vs/platform/webview/common/webviewPortMapping.js

@@ -0,0 +1,64 @@
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { extractLocalHostUriMetaDataForPortMapping } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
+
+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 tunnelOrError = await this.tunnelService.openTunnel({ getAddress: async () => remoteAuthority }, undefined, remotePort);
+        let tunnel;
+        if (typeof tunnelOrError === 'string') {
+            tunnel = undefined;
+        }
+        if (tunnel) {
+            this._tunnels.set(remotePort, tunnel);
+        }
+        return tunnel;
+    }
+}
+
+export { WebviewPortMappingManager };