@vscode/test-web 0.0.56 → 0.0.58

package/out/browser/esm/main.js

@@ -0,0 +1,204 @@
+import { create, URI, Emitter } from './workbench.api';
+class WorkspaceProvider {
+    workspace;
+    payload;
+    static QUERY_PARAM_EMPTY_WINDOW = 'ew';
+    static QUERY_PARAM_FOLDER = 'folder';
+    static QUERY_PARAM_WORKSPACE = 'workspace';
+    static QUERY_PARAM_PAYLOAD = 'payload';
+    static create(config) {
+        let foundWorkspace = false;
+        let workspace;
+        let payload = Object.create(null);
+        const query = new URL(document.location.href).searchParams;
+        query.forEach((value, key) => {
+            switch (key) {
+                case WorkspaceProvider.QUERY_PARAM_FOLDER:
+                    workspace = { folderUri: URI.parse(value) };
+                    foundWorkspace = true;
+                    break;
+                case WorkspaceProvider.QUERY_PARAM_WORKSPACE:
+                    workspace = { workspaceUri: URI.parse(value) };
+                    foundWorkspace = true;
+                    break;
+                case WorkspaceProvider.QUERY_PARAM_EMPTY_WINDOW:
+                    workspace = undefined;
+                    foundWorkspace = true;
+                    break;
+                case WorkspaceProvider.QUERY_PARAM_PAYLOAD:
+                    try {
+                        payload = JSON.parse(value);
+                    }
+                    catch (error) {
+                        console.error(error);
+                    }
+                    break;
+            }
+        });
+        if (!foundWorkspace) {
+            if (config.folderUri) {
+                workspace = { folderUri: URI.revive(config.folderUri) };
+            }
+            else if (config.workspaceUri) {
+                workspace = { workspaceUri: URI.revive(config.workspaceUri) };
+            }
+        }
+        return new WorkspaceProvider(workspace, payload);
+    }
+    trusted = true;
+    constructor(workspace, payload) {
+        this.workspace = workspace;
+        this.payload = payload;
+    }
+    async open(workspace, options) {
+        if (options?.reuse && !options.payload && this.isSame(this.workspace, workspace)) {
+            return true;
+        }
+        const targetHref = this.createTargetUrl(workspace, options);
+        if (targetHref) {
+            if (options?.reuse) {
+                window.location.href = targetHref;
+                return true;
+            }
+            else {
+                return !!window.open(targetHref);
+            }
+        }
+        return false;
+    }
+    createTargetUrl(workspace, options) {
+        let targetHref = undefined;
+        if (!workspace) {
+            targetHref = `${document.location.origin}${document.location.pathname}?${WorkspaceProvider.QUERY_PARAM_EMPTY_WINDOW}=true`;
+        }
+        else if ('folderUri' in workspace) {
+            const queryParamFolder = encodeURIComponent(workspace.folderUri.toString(true));
+            targetHref = `${document.location.origin}${document.location.pathname}?${WorkspaceProvider.QUERY_PARAM_FOLDER}=${queryParamFolder}`;
+        }
+        else if ('workspaceUri' in workspace) {
+            const queryParamWorkspace = encodeURIComponent(workspace.workspaceUri.toString(true));
+            targetHref = `${document.location.origin}${document.location.pathname}?${WorkspaceProvider.QUERY_PARAM_WORKSPACE}=${queryParamWorkspace}`;
+        }
+        if (options?.payload) {
+            targetHref += `&${WorkspaceProvider.QUERY_PARAM_PAYLOAD}=${encodeURIComponent(JSON.stringify(options.payload))}`;
+        }
+        return targetHref;
+    }
+    isSame(workspaceA, workspaceB) {
+        if (!workspaceA || !workspaceB) {
+            return workspaceA === workspaceB;
+        }
+        if ('folderUri' in workspaceA && 'folderUri' in workspaceB) {
+            return this.isEqualURI(workspaceA.folderUri, workspaceB.folderUri);
+        }
+        if ('workspaceUri' in workspaceA && 'workspaceUri' in workspaceB) {
+            return this.isEqualURI(workspaceA.workspaceUri, workspaceB.workspaceUri);
+        }
+        return false;
+    }
+    isEqualURI(a, b) {
+        return a.scheme === b.scheme && a.authority === b.authority && a.path === b.path;
+    }
+}
+class LocalStorageURLCallbackProvider {
+    _callbackRoute;
+    static REQUEST_ID = 0;
+    static QUERY_KEYS = [
+        'scheme',
+        'authority',
+        'path',
+        'query',
+        'fragment'
+    ];
+    _onCallback = new Emitter();
+    onCallback = this._onCallback.event;
+    pendingCallbacks = new Set();
+    lastTimeChecked = Date.now();
+    checkCallbacksTimeout = undefined;
+    onDidChangeLocalStorageDisposable;
+    constructor(_callbackRoute) {
+        this._callbackRoute = _callbackRoute;
+    }
+    create(options = {}) {
+        const id = ++LocalStorageURLCallbackProvider.REQUEST_ID;
+        const queryParams = [`vscode-reqid=${id}`];
+        for (const key of LocalStorageURLCallbackProvider.QUERY_KEYS) {
+            const value = options[key];
+            if (value) {
+                queryParams.push(`vscode-${key}=${encodeURIComponent(value)}`);
+            }
+        }
+        if (!(options.authority === 'vscode.github-authentication' && options.path === '/dummy')) {
+            const key = `vscode-web.url-callbacks[${id}]`;
+            localStorage.removeItem(key);
+            this.pendingCallbacks.add(id);
+            this.startListening();
+        }
+        return URI.parse(window.location.href).with({ path: this._callbackRoute, query: queryParams.join('&') });
+    }
+    startListening() {
+        if (this.onDidChangeLocalStorageDisposable) {
+            return;
+        }
+        const fn = () => this.onDidChangeLocalStorage();
+        window.addEventListener('storage', fn);
+        this.onDidChangeLocalStorageDisposable = { dispose: () => window.removeEventListener('storage', fn) };
+    }
+    stopListening() {
+        this.onDidChangeLocalStorageDisposable?.dispose();
+        this.onDidChangeLocalStorageDisposable = undefined;
+    }
+    async onDidChangeLocalStorage() {
+        const ellapsed = Date.now() - this.lastTimeChecked;
+        if (ellapsed > 1000) {
+            this.checkCallbacks();
+        }
+        else if (this.checkCallbacksTimeout === undefined) {
+            this.checkCallbacksTimeout = setTimeout(() => {
+                this.checkCallbacksTimeout = undefined;
+                this.checkCallbacks();
+            }, 1000 - ellapsed);
+        }
+    }
+    checkCallbacks() {
+        let pendingCallbacks;
+        for (const id of this.pendingCallbacks) {
+            const key = `vscode-web.url-callbacks[${id}]`;
+            const result = localStorage.getItem(key);
+            if (result !== null) {
+                try {
+                    this._onCallback.fire(URI.revive(JSON.parse(result)));
+                }
+                catch (error) {
+                    console.error(error);
+                }
+                pendingCallbacks = pendingCallbacks ?? new Set(this.pendingCallbacks);
+                pendingCallbacks.delete(id);
+                localStorage.removeItem(key);
+            }
+        }
+        if (pendingCallbacks) {
+            this.pendingCallbacks = pendingCallbacks;
+            if (this.pendingCallbacks.size === 0) {
+                this.stopListening();
+            }
+        }
+        this.lastTimeChecked = Date.now();
+    }
+    dispose() {
+        this._onCallback.dispose();
+    }
+}
+(function () {
+    const configElement = window.document.getElementById('vscode-workbench-web-configuration');
+    const configElementAttribute = configElement ? configElement.getAttribute('data-settings') : undefined;
+    if (!configElement || !configElementAttribute) {
+        throw new Error('Missing web configuration element');
+    }
+    const config = JSON.parse(configElementAttribute);
+    create(window.document.body, {
+        ...config,
+        workspaceProvider: WorkspaceProvider.create(config),
+        urlCallbackProvider: new LocalStorageURLCallbackProvider(config.callbackRoute)
+    });
+})();

package/out/server/app.js

@@ -4,6 +4,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createApp;
 const fs_1 = require("fs");
 const Koa = require("koa");
 const morgan = require("koa-morgan");
@@ -95,4 +96,3 @@ async function createApp(config) {
     app.use((0, workbench_1.default)(config));
     return app;
 }
-exports.default = createApp;

package/out/server/download.js

@@ -4,7 +4,13 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fileExists = exports.directoryExists = exports.fetchJSON = exports.fetch = exports.downloadAndUnzipVSCode = void 0;
+exports.getDownloadURL = getDownloadURL;
+exports.downloadAndUnzipVSCode = downloadAndUnzipVSCode;
+exports.fetch = fetch;
+exports.fetchJSON = fetchJSON;
+exports.directoryExists = directoryExists;
+exports.fileExists = fileExists;
+exports.readFileInRepo = readFileInRepo;
 const fs_1 = require("fs");
 const path = require("path");
 const https = require("https");
@@ -12,9 +18,23 @@ const http = require("http");
 const https_proxy_agent_1 = require("https-proxy-agent");
 const http_proxy_agent_1 = require("http-proxy-agent");
 const url_1 = require("url");
-async function getLatestVersion(quality) {
-    const update = await fetchJSON(`https://update.code.visualstudio.com/api/update/web-standalone/${quality}/latest`);
-    return update;
+async function getLatestBuild(quality) {
+    return await fetchJSON(`https://update.code.visualstudio.com/api/update/web-standalone/${quality}/latest`);
+}
+async function getDownloadURL(quality, commit) {
+    return new Promise((resolve, reject) => {
+        const url = `https://update.code.visualstudio.com/commit:${commit}/web-standalone/${quality}`;
+        const httpLibrary = url.startsWith('https') ? https : http;
+        httpLibrary.get(url, { method: 'HEAD', ...getAgent(url) }, res => {
+            console.log(res.statusCode, res.headers.location);
+            if ((res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307) && res.headers.location) {
+                resolve(res.headers.location);
+            }
+            else {
+                resolve(undefined);
+            }
+        });
+    });
 }
 const reset = '\x1b[G\x1b[0K';
 async function downloadAndUntar(downloadUrl, destination, message) {
@@ -54,29 +74,39 @@ async function downloadAndUntar(downloadUrl, destination, message) {
         });
     });
 }
-async function downloadAndUnzipVSCode(quality, vscodeTestDir) {
-    const info = await getLatestVersion(quality);
-    const folderName = `vscode-web-${quality}-${info.version}`;
+async function downloadAndUnzipVSCode(vscodeTestDir, quality, commit) {
+    let downloadURL;
+    if (!commit) {
+        const info = await getLatestBuild(quality);
+        commit = info.version;
+        downloadURL = info.url;
+    }
+    const folderName = `vscode-web-${quality}-${commit}`;
     const downloadedPath = path.resolve(vscodeTestDir, folderName);
     if ((0, fs_1.existsSync)(downloadedPath) && (0, fs_1.existsSync)(path.join(downloadedPath, 'version'))) {
-        return { type: 'static', location: downloadedPath, quality, version: info.version };
+        return { type: 'static', location: downloadedPath, quality, version: commit };
+    }
+    if (!downloadURL) {
+        downloadURL = await getDownloadURL(quality, commit);
+        if (!downloadURL) {
+            throw Error(`Failed to find a download for ${quality} and ${commit}`);
+        }
     }
     if ((0, fs_1.existsSync)(vscodeTestDir)) {
-        await fs_1.promises.rmdir(vscodeTestDir, { recursive: true, maxRetries: 5 });
+        await fs_1.promises.rm(vscodeTestDir, { recursive: true, maxRetries: 5 });
     }
     await fs_1.promises.mkdir(vscodeTestDir, { recursive: true });
     const productName = `VS Code ${quality === 'stable' ? 'Stable' : 'Insiders'}`;
     try {
-        await downloadAndUntar(info.url, downloadedPath, `Downloading ${productName}`);
+        await downloadAndUntar(downloadURL, downloadedPath, `Downloading ${productName}`);
         await fs_1.promises.writeFile(path.join(downloadedPath, 'version'), folderName);
     }
     catch (err) {
         console.error(err);
-        throw Error(`Failed to download and unpack ${productName}`);
+        throw Error(`Failed to download and unpack ${productName}.${commit ? ' Did you specify a valid commit?' : ''}`);
     }
-    return { type: 'static', location: downloadedPath, quality, version: info.version };
+    return { type: 'static', location: downloadedPath, quality, version: commit };
 }
-exports.downloadAndUnzipVSCode = downloadAndUnzipVSCode;
 async function fetch(api) {
     return new Promise((resolve, reject) => {
         const httpLibrary = api.startsWith('https') ? https : http;
@@ -97,7 +127,6 @@ async function fetch(api) {
         });
     });
 }
-exports.fetch = fetch;
 async function fetchJSON(api) {
     const data = await fetch(api);
     try {
@@ -107,7 +136,6 @@ async function fetchJSON(api) {
         throw new Error(`Failed to parse response from ${api}`);
     }
 }
-exports.fetchJSON = fetchJSON;
 let PROXY_AGENT = undefined;
 let HTTPS_PROXY_AGENT = undefined;
 if (process.env.npm_config_proxy) {
@@ -137,7 +165,6 @@ async function directoryExists(path) {
         return false;
     }
 }
-exports.directoryExists = directoryExists;
 async function fileExists(path) {
     try {
         const stats = await fs_1.promises.stat(path);
@@ -147,4 +174,6 @@ async function fileExists(path) {
         return false;
     }
 }
-exports.fileExists = fileExists;
+async function readFileInRepo(pathInRepo) {
+    return (await fs_1.promises.readFile(path.resolve(__dirname, '../..', pathInRepo))).toString();
+}

package/out/server/extensions.js

@@ -4,7 +4,9 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getScannedBuiltinExtensions = exports.prebuiltExtensionsLocation = exports.scanForExtensions = void 0;
+exports.prebuiltExtensionsLocation = void 0;
+exports.scanForExtensions = scanForExtensions;
+exports.getScannedBuiltinExtensions = getScannedBuiltinExtensions;
 const fs_1 = require("fs");
 const path = require("path");
 const download_1 = require("./download");
@@ -43,7 +45,6 @@ async function scanForExtensions(rootPath, serverURI) {
     await processFolder('');
     return result;
 }
-exports.scanForExtensions = scanForExtensions;
 exports.prebuiltExtensionsLocation = '.build/builtInExtensions';
 async function getScannedBuiltinExtensions(vsCodeDevLocation) {
     // use the build utility as to not duplicate the code
@@ -64,4 +65,3 @@ async function getScannedBuiltinExtensions(vsCodeDevLocation) {
     }
     return localExtensions.concat(prebuiltExtensions);
 }
-exports.getScannedBuiltinExtensions = getScannedBuiltinExtensions;

package/out/{index.js → server/index.js}

@@ -2,13 +2,14 @@
 "use strict";
 /* eslint-disable header/header */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.open = exports.runTests = void 0;
+exports.runTests = runTests;
+exports.open = open;
 /*---------------------------------------------------------------------------------------------
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-const main_1 = require("./server/main");
-const download_1 = require("./server/download");
+const main_1 = require("./main");
+const download_1 = require("./download");
 const playwright = require("playwright");
 const minimist = require("minimist");
 const path = require("path");
@@ -71,7 +72,6 @@ async function runTests(options) {
         }
     });
 }
-exports.runTests = runTests;
 async function getBuild(options) {
     if (options.vsCodeDevPath) {
         return {
@@ -80,8 +80,9 @@ async function getBuild(options) {
         };
     }
     const quality = options.quality || options.version;
+    const commit = options.commit;
     const testRunnerDataDir = options.testRunnerDataDir ?? path.resolve(process.cwd(), '.vscode-test-web');
-    return await (0, download_1.downloadAndUnzipVSCode)(quality === 'stable' ? 'stable' : 'insider', testRunnerDataDir);
+    return await (0, download_1.downloadAndUnzipVSCode)(testRunnerDataDir, quality === 'stable' ? 'stable' : 'insider', commit);
 }
 async function open(options) {
     const config = {
@@ -109,7 +110,6 @@ async function open(options) {
         },
     };
 }
-exports.open = open;
 async function openBrowser(endpoint, options, configPage) {
     if (options.browserType === 'none') {
         return undefined;
@@ -336,6 +336,20 @@ function validateQuality(quality, version, vsCodeDevPath) {
     showHelp();
     process.exit(-1);
 }
+function validateCommit(commit, vsCodeDevPath) {
+    if (vsCodeDevPath && commit) {
+        console.log(`Sources folder is provided as input, commit is ignored.`);
+        return undefined;
+    }
+    if (commit === undefined || (typeof commit === 'string' && commit.match(/^[0-9a-f]{40}$/))) {
+        return commit;
+    }
+    else {
+        console.log(`Invalid format for commit. Expected a 40 character long SHA1 hash.`);
+    }
+    showHelp();
+    process.exit(-1);
+}
 function validatePortNumber(port) {
     if (typeof port === 'string') {
         const number = Number.parseInt(port);
@@ -352,6 +366,7 @@ function showHelp() {
     console.log(`  --extensionDevelopmentPath path: A path pointing to an extension under development to include. [Optional]`);
     console.log(`  --extensionTestsPath path: A path to a test module to run. [Optional]`);
     console.log(`  --quality 'insiders' | 'stable' [Optional, default 'insiders', ignored when running from sources]`);
+    console.log(`  --commit commitHash [Optional, defaults to latest build version of the given quality, ignored when running from sources]`);
     console.log(`  --sourcesPath path: If provided, running from VS Code sources at the given location. [Optional]`);
     console.log(`  --open-devtools: If set, opens the dev tools. [Optional]`);
     console.log(`  --headless: Whether to hide the browser. Defaults to true when an extensionTestsPath is provided, otherwise false. [Optional]`);
@@ -376,11 +391,12 @@ async function cliMain() {
     process.on('uncaughtException', (e) => {
         console.error('uncaughtException', e);
     });
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const manifest = require('../package.json');
+    /* eslint-disable @typescript-eslint/no-var-requires */
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const manifest = JSON.parse(await (0, download_1.readFileInRepo)('package.json'));
     console.log(`${manifest.name}: ${manifest.version}`);
     const options = {
-        string: ['extensionDevelopmentPath', 'extensionTestsPath', 'browser', 'browserOption', 'browserType', 'quality', 'version', 'waitForDebugger', 'folder-uri', 'permission', 'extensionPath', 'extensionId', 'sourcesPath', 'host', 'port', 'testRunnerDataDir'],
+        string: ['extensionDevelopmentPath', 'extensionTestsPath', 'browser', 'browserOption', 'browserType', 'quality', 'version', 'commit', 'waitForDebugger', 'folder-uri', 'permission', 'extensionPath', 'extensionId', 'sourcesPath', 'host', 'port', 'testRunnerDataDir'],
         boolean: ['open-devtools', 'headless', 'hideServerLog', 'printServerLog', 'help', 'verbose', 'coi', 'esm'],
         unknown: arg => {
             if (arg.startsWith('-')) {
@@ -404,6 +420,7 @@ async function cliMain() {
     const extensionIds = await validateExtensionIds(args.extensionId);
     const vsCodeDevPath = await validatePathOrUndefined(args, 'sourcesPath');
     const quality = validateQuality(args.quality, args.version, vsCodeDevPath);
+    const commit = validateCommit(args.commit, vsCodeDevPath);
     const devTools = validateBooleanOrUndefined(args, 'open-devtools');
     const headless = validateBooleanOrUndefined(args, 'headless');
     const permissions = validatePermissions(args.permission);
@@ -435,6 +452,7 @@ async function cliMain() {
             browserOptions,
             browserType,
             quality,
+            commit,
             devTools,
             waitForDebugger,
             folderUri,
@@ -462,6 +480,7 @@ async function cliMain() {
             browserOptions,
             browserType,
             quality,
+            commit,
             devTools,
             waitForDebugger,
             folderUri,

package/out/server/main.js

@@ -4,7 +4,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runServer = void 0;
+exports.runServer = runServer;
 const app_1 = require("./app");
 async function runServer(host, port, config) {
     const app = await (0, app_1.default)(config);
@@ -18,4 +18,3 @@ async function runServer(host, port, config) {
         throw e;
     }
 }
-exports.runServer = runServer;

package/out/server/mounts.js

@@ -4,7 +4,8 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configureMounts = exports.fsProviderFolderUri = exports.fsProviderExtensionPrefix = void 0;
+exports.fsProviderFolderUri = exports.fsProviderExtensionPrefix = void 0;
+exports.configureMounts = configureMounts;
 const kstatic = require("koa-static");
 const kmount = require("koa-mount");
 const Router = require("@koa/router");
@@ -22,7 +23,6 @@ function configureMounts(config, app) {
         app.use(kmount(exports.fsProviderExtensionPrefix, kstatic(path.join(__dirname, '../../fs-provider'), { hidden: true })));
     }
 }
-exports.configureMounts = configureMounts;
 function fileOps(mountPrefix, folderMountPath) {
     const router = new Router();
     router.get(`${mountPrefix}(/.*)?`, async (ctx, next) => {

package/out/server/workbench.js

@@ -4,17 +4,24 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
 const path = require("path");
 const fs_1 = require("fs");
 const vscode_uri_1 = require("vscode-uri");
 const Router = require("@koa/router");
 const extensions_1 = require("./extensions");
-const download_1 = require("./download");
 const mounts_1 = require("./mounts");
+const download_1 = require("./download");
 function asJSON(value) {
     return JSON.stringify(value).replace(/"/g, '"');
 }
 class Workbench {
+    baseUrl;
+    dev;
+    esm;
+    devCSSModules;
+    builtInExtensions;
+    productOverrides;
     constructor(baseUrl, dev, esm, devCSSModules, builtInExtensions = [], productOverrides) {
         this.baseUrl = baseUrl;
         this.dev = dev;
@@ -29,34 +36,51 @@ class Workbench {
         }
         const values = {
             WORKBENCH_WEB_CONFIGURATION: asJSON(workbenchWebConfiguration),
-            WORKBENCH_AUTH_SESSION: '',
             WORKBENCH_WEB_BASE_URL: this.baseUrl,
             WORKBENCH_BUILTIN_EXTENSIONS: asJSON(this.builtInExtensions),
-            WORKBENCH_MAIN: this.getMain(),
-            WORKBENCH_DEV_CSS_MODULES: JSON.stringify(this.devCSSModules)
+            WORKBENCH_MAIN: await this.getMain()
         };
         try {
-            const workbenchTemplate = (await fs_1.promises.readFile(path.resolve(__dirname, `../../views/workbench${this.esm ? '-esm' : ''}.html`))).toString();
+            const workbenchTemplate = await (0, download_1.readFileInRepo)(`views/workbench${this.esm ? '-esm' : ''}.html`);
             return workbenchTemplate.replace(/\{\{([^}]+)\}\}/g, (_, key) => values[key] ?? 'undefined');
         }
         catch (e) {
             return String(e);
         }
     }
-    getMain() {
+    async getMain() {
+        const lines = [];
         if (this.esm) {
-            return `<script type="module" src="${this.baseUrl}/out/vs/code/browser/workbench/workbench.js"></script>`;
+            let workbenchMain = await (0, download_1.readFileInRepo)(`out/browser/esm/main.js`);
+            if (this.dev) {
+                lines.push("<script>", `globalThis._VSCODE_CSS_MODULES = ${JSON.stringify(this.devCSSModules)};`, "</script>", "<script>", "const sheet = document.getElementById('vscode-css-modules').sheet;", "globalThis._VSCODE_CSS_LOAD = function (url) { sheet.insertRule(`@import url(${url});`); };", "", "const importMap = { imports: {} };", "for (const cssModule of globalThis._VSCODE_CSS_MODULES) {", "  const cssUrl = new URL(cssModule, globalThis._VSCODE_FILE_ROOT).href;", "  const jsSrc = `globalThis._VSCODE_CSS_LOAD('${cssUrl}');\\n`;", "  const blob = new Blob([jsSrc], { type: 'application/javascript' });", "  importMap.imports[cssUrl] = URL.createObjectURL(blob);", "}", "const importMapElement = document.createElement('script');", "importMapElement.type = 'importmap';", "importMapElement.setAttribute('nonce', '1nline-m4p');", "importMapElement.textContent = JSON.stringify(importMap, undefined, 2);", "document.head.appendChild(importMapElement);", "</script>");
+                workbenchMain = workbenchMain.replace('./workbench.api', `${this.baseUrl}/out/vs/workbench/workbench.web.main.js`);
+                lines.push(`<script type="module">${workbenchMain}</script>`);
+            }
+            else {
+                workbenchMain = workbenchMain.replace('./workbench.api', `${this.baseUrl}/out/vs/workbench/workbench.web.main.internal.js`);
+                lines.push(`<script src="${this.baseUrl}/out/nls.messages.js"></script>`);
+                lines.push(`<script type="module">${workbenchMain}</script>`);
+            }
+            return lines.join('\n');
         }
-        if (this.dev) {
-            return `<script> require(['vs/code/browser/workbench/workbench'], function() {}); </script>`;
+        else {
+            let workbenchMain = await (0, download_1.readFileInRepo)(`out/browser/amd/main.js`); // defines a AMD module `vscode-web-browser-main`
+            workbenchMain = workbenchMain.replace('./workbench.api', `vs/workbench/workbench.web.main`);
+            workbenchMain = workbenchMain + '\nrequire(["vscode-web-browser-main"], function() { });';
+            if (this.dev) {
+            }
+            else {
+                lines.push(`<script src="${this.baseUrl}/out/nls.messages.js"></script>`);
+                lines.push(`<script src="${this.baseUrl}/out/vs/workbench/workbench.web.main.nls.js"></script>`);
+                lines.push(`<script src="${this.baseUrl}/out/vs/workbench/workbench.web.main.js"></script>`);
+            }
+            lines.push(`<script>${workbenchMain}</script>`);
         }
-        return `<script src="${this.baseUrl}/out/nls.messages.js"></script>`
-            + `<script src="${this.baseUrl}/out/vs/workbench/workbench.web.main.nls.js"></script>`
-            + `<script src="${this.baseUrl}/out/vs/workbench/workbench.web.main.js"></script>`
-            + `<script src="${this.baseUrl}/out/vs/code/browser/workbench/workbench.js"></script>`;
+        return lines.join('\n');
     }
     async renderCallback() {
-        return await (0, download_1.fetch)(`${this.baseUrl}/out/vs/code/browser/workbench/callback.html`);
+        return await (0, download_1.readFileInRepo)(`views/callback.html`);
     }
 }
 async function getWorkbenchOptions(ctx, config) {
@@ -114,8 +138,10 @@ function default_1(config) {
         if (config.build.type === 'sources') {
             const builtInExtensions = await (0, extensions_1.getScannedBuiltinExtensions)(config.build.location);
             const productOverrides = await getProductOverrides(config.build.location);
-            const devCSSModules = config.esm ? await getDevCssModules(config.build.location) : [];
-            ctx.state.workbench = new Workbench(`${ctx.protocol}://${ctx.host}/static/sources`, true, config.esm, devCSSModules, builtInExtensions, {
+            const esm = config.esm || await isESM(config.build.location);
+            console.log('Using ESM loader:', esm);
+            const devCSSModules = esm ? await getDevCssModules(config.build.location) : [];
+            ctx.state.workbench = new Workbench(`${ctx.protocol}://${ctx.host}/static/sources`, true, esm, devCSSModules, builtInExtensions, {
                 ...productOverrides,
                 webEndpointUrlTemplate: `${ctx.protocol}://{{uuid}}.${ctx.host}/static/sources`,
                 webviewContentExternalBaseUrlTemplate: `${ctx.protocol}://{{uuid}}.${ctx.host}/static/sources/out/vs/workbench/contrib/webview/browser/pre/`
@@ -146,7 +172,6 @@ function default_1(config) {
     });
     return router.routes();
 }
-exports.default = default_1;
 async function getProductOverrides(vsCodeDevLocation) {
     try {
         return JSON.parse((await fs_1.promises.readFile(path.join(vsCodeDevLocation, 'product.overrides.json'))).toString());
@@ -159,3 +184,12 @@ async function getDevCssModules(vsCodeDevLocation) {
     const glob = await Promise.resolve().then(() => require('glob'));
     return glob.glob('**/*.css', { cwd: path.join(vsCodeDevLocation, 'out') });
 }
+async function isESM(vsCodeDevLocation) {
+    try {
+        const packageJSON = await fs_1.promises.readFile(path.join(vsCodeDevLocation, 'out', 'package.json'));
+        return JSON.parse(packageJSON.toString()).type === 'module';
+    }
+    catch (e) {
+        return false;
+    }
+}