diff --git a/build/lib/standalone.js b/build/lib/standalone.js
index cf0e452aff3..78030842569 100644
--- a/build/lib/standalone.js
+++ b/build/lib/standalone.js
@@ -131,7 +131,7 @@ function createESMSourcesAndResources2(options) {
         }
         if (file === 'tsconfig.json') {
             const tsConfig = JSON.parse(fs.readFileSync(path.join(SRC_FOLDER, file)).toString());
-            tsConfig.compilerOptions.module = 'es6';
+            tsConfig.compilerOptions.module = 'es2022';
             tsConfig.compilerOptions.outDir = path.join(path.relative(OUT_FOLDER, OUT_RESOURCES_FOLDER), 'vs').replace(/\\/g, '/');
             write(getDestAbsoluteFilePath(file), JSON.stringify(tsConfig, null, '\t'));
             continue;
diff --git a/build/lib/standalone.ts b/build/lib/standalone.ts
index 9a65bfa7444..e1b9db65e12 100644
--- a/build/lib/standalone.ts
+++ b/build/lib/standalone.ts
@@ -157,7 +157,7 @@ export function createESMSourcesAndResources2(options: IOptions2): void {
 
 		if (file === 'tsconfig.json') {
 			const tsConfig = JSON.parse(fs.readFileSync(path.join(SRC_FOLDER, file)).toString());
-			tsConfig.compilerOptions.module = 'es6';
+			tsConfig.compilerOptions.module = 'es2022';
 			tsConfig.compilerOptions.outDir = path.join(path.relative(OUT_FOLDER, OUT_RESOURCES_FOLDER), 'vs').replace(/\\/g, '/');
 			write(getDestAbsoluteFilePath(file), JSON.stringify(tsConfig, null, '\t'));
 			continue;
diff --git a/src/bootstrap-amd.js b/src/bootstrap-amd.js
index c228faccfed..b8cc7a8bb50 100644
--- a/src/bootstrap-amd.js
+++ b/src/bootstrap-amd.js
@@ -11,20 +11,16 @@
  * @import { IProductConfiguration } from './vs/base/common/product'
  */
 
-// ESM-comment-begin
-const isESM = false;
-// ESM-comment-end
 // ESM-uncomment-begin
 // import * as path from 'path';
 // import * as fs from 'fs';
 // import { fileURLToPath } from 'url';
 // import { createRequire, register } from 'node:module';
 // import { product, pkg } from './bootstrap-meta.js';
-// import * as bootstrapNode from './bootstrap-node.js';
+// import './bootstrap-node.js';
 // import * as performance from './vs/base/common/performance.js';
 //
 // const require = createRequire(import.meta.url);
-// const isESM = true;
 // const module = { exports: {} };
 // const __dirname = path.dirname(fileURLToPath(import.meta.url));
 //
@@ -171,77 +167,77 @@ async function doSetupNLS() {
 
 //#region Loader Config
 
-if (isESM) {
+// ESM-uncomment-begin
+// /**
+//  * @param {string=} entrypoint
+//  * @param {(value: any) => void} [onLoad]
+//  * @param {(err: Error) => void} [onError]
+//  */
+// module.exports.load = function (entrypoint, onLoad, onError) {
+// 	if (!entrypoint) {
+// 		return;
+// 	}
 
-	/**
-	 * @param {string=} entrypoint
-	 * @param {(value: any) => void} [onLoad]
-	 * @param {(err: Error) => void} [onError]
-	 */
-	module.exports.load = function (entrypoint, onLoad, onError) {
-		if (!entrypoint) {
-			return;
-		}
+// 	entrypoint = `./${entrypoint}.js`;
 
-		entrypoint = `./${entrypoint}.js`;
+// 	onLoad = onLoad || function () { };
+// 	onError = onError || function (err) { console.error(err); };
 
-		onLoad = onLoad || function () { };
-		onError = onError || function (err) { console.error(err); };
+// 	setupNLS().then(() => {
+// 		performance.mark(`code/fork/willLoadCode`);
+// 		import(entrypoint).then(onLoad, onError);
+// 	});
+// };
+// ESM-uncomment-end
 
-		setupNLS().then(() => {
-			performance.mark(`code/fork/willLoadCode`);
-			import(entrypoint).then(onLoad, onError);
-		});
-	};
-} else {
+// ESM-comment-begin
+// @ts-ignore
+const loader = require('./vs/loader');
 
-	// @ts-ignore
-	const loader = require('./vs/loader');
+loader.config({
+	baseUrl: bootstrapNode.fileUriFromPath(__dirname, { isWindows: process.platform === 'win32' }),
+	catchError: true,
+	nodeRequire,
+	amdModulesPattern: /^vs\//,
+	recordStats: true
+});
 
-	loader.config({
-		baseUrl: bootstrapNode.fileUriFromPath(__dirname, { isWindows: process.platform === 'win32' }),
-		catchError: true,
-		nodeRequire,
-		amdModulesPattern: /^vs\//,
-		recordStats: true
+// Running in Electron
+if (process.env['ELECTRON_RUN_AS_NODE'] || process.versions['electron']) {
+	loader.define('fs', ['original-fs'], function (/** @type {import('fs')} */originalFS) {
+		return originalFS;  // replace the patched electron fs with the original node fs for all AMD code
 	});
+}
 
-	// Running in Electron
-	if (process.env['ELECTRON_RUN_AS_NODE'] || process.versions['electron']) {
-		loader.define('fs', ['original-fs'], function (/** @type {import('fs')} */originalFS) {
-			return originalFS;  // replace the patched electron fs with the original node fs for all AMD code
+/**
+ * @param {string=} entrypoint
+ * @param {(value: any) => void} [onLoad]
+ * @param {(err: Error) => void} [onError]
+ */
+module.exports.load = function (entrypoint, onLoad, onError) {
+	if (!entrypoint) {
+		return;
+	}
+
+	// code cache config
+	if (process.env['VSCODE_CODE_CACHE_PATH']) {
+		loader.config({
+			nodeCachedData: {
+				path: process.env['VSCODE_CODE_CACHE_PATH'],
+				seed: entrypoint
+			}
 		});
 	}
 
-	/**
-	 * @param {string=} entrypoint
-	 * @param {(value: any) => void} [onLoad]
-	 * @param {(err: Error) => void} [onError]
-	 */
-	module.exports.load = function (entrypoint, onLoad, onError) {
-		if (!entrypoint) {
-			return;
-		}
+	onLoad = onLoad || function () { };
+	onError = onError || function (err) { console.error(err); };
 
-		// code cache config
-		if (process.env['VSCODE_CODE_CACHE_PATH']) {
-			loader.config({
-				nodeCachedData: {
-					path: process.env['VSCODE_CODE_CACHE_PATH'],
-					seed: entrypoint
-				}
-			});
-		}
-
-		onLoad = onLoad || function () { };
-		onError = onError || function (err) { console.error(err); };
-
-		setupNLS().then(() => {
-			performance.mark('code/fork/willLoadCode');
-			loader([entrypoint], onLoad, onError);
-		});
-	};
-}
+	setupNLS().then(() => {
+		performance.mark('code/fork/willLoadCode');
+		loader([entrypoint], onLoad, onError);
+	});
+};
+// ESM-comment-end
 
 //#endregion
 
diff --git a/src/bootstrap-node.js b/src/bootstrap-node.js
index 1484cbb8bed..b375c69b9b3 100644
--- a/src/bootstrap-node.js
+++ b/src/bootstrap-node.js
@@ -10,18 +10,12 @@
 const path = require('path');
 const fs = require('fs');
 const Module = require('module');
-
-const isESM = false;
 // ESM-comment-end
 // ESM-uncomment-begin
 // import * as path from 'path';
 // import * as fs from 'fs';
 // import { fileURLToPath } from 'url';
-// import { createRequire } from 'node:module';
 //
-// const require = createRequire(import.meta.url);
-// const Module = require('module');
-// const isESM = true;
 // const module = { exports: {} };
 // const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // ESM-uncomment-end
@@ -86,32 +80,31 @@ module.exports.devInjectNodeModuleLookupPath = function (injectPath) {
 	}
 
 	const Module = require('node:module');
-	if (isESM) {
-		// register a loader hook
-		// ESM-uncomment-begin
-		// Module.register('./bootstrap-import.js', { parentURL: import.meta.url, data: injectPath });
-		// ESM-uncomment-end
-	} else {
-		const nodeModulesPath = path.join(__dirname, '../node_modules');
+	// ESM-uncomment-begin
+	// // register a loader hook
+	// Module.register('./bootstrap-import.js', { parentURL: import.meta.url, data: injectPath });
+	// ESM-uncomment-end
+	// ESM-comment-begin
+	const nodeModulesPath = path.join(__dirname, '../node_modules');
 
-		// @ts-ignore
-		const originalResolveLookupPaths = Module._resolveLookupPaths;
+	// @ts-ignore
+	const originalResolveLookupPaths = Module._resolveLookupPaths;
 
-		// @ts-ignore
-		Module._resolveLookupPaths = function (moduleName, parent) {
-			const paths = originalResolveLookupPaths(moduleName, parent);
-			if (Array.isArray(paths)) {
-				for (let i = 0, len = paths.length; i < len; i++) {
-					if (paths[i] === nodeModulesPath) {
-						paths.splice(i, 0, injectPath);
-						break;
-					}
+	// @ts-ignore
+	Module._resolveLookupPaths = function (moduleName, parent) {
+		const paths = originalResolveLookupPaths(moduleName, parent);
+		if (Array.isArray(paths)) {
+			for (let i = 0, len = paths.length; i < len; i++) {
+				if (paths[i] === nodeModulesPath) {
+					paths.splice(i, 0, injectPath);
+					break;
 				}
 			}
+		}
 
-			return paths;
-		};
-	}
+		return paths;
+	};
+	// ESM-comment-end
 };
 
 module.exports.removeGlobalNodeModuleLookupPaths = function () {
@@ -207,30 +200,28 @@ module.exports.configurePortable = function (product) {
  * Helper to enable ASAR support.
  */
 module.exports.enableASARSupport = function () {
-	if (isESM) {
-		return; // TODO@esm ASAR support is disabled in ESM
-	} else {
-		const NODE_MODULES_PATH = path.join(__dirname, '../node_modules');
-		const NODE_MODULES_ASAR_PATH = `${NODE_MODULES_PATH}.asar`;
+	// ESM-comment-begin
+	const NODE_MODULES_PATH = path.join(__dirname, '../node_modules');
+	const NODE_MODULES_ASAR_PATH = `${NODE_MODULES_PATH}.asar`;
 
-		// @ts-ignore
-		const originalResolveLookupPaths = Module._resolveLookupPaths;
+	// @ts-ignore
+	const originalResolveLookupPaths = Module._resolveLookupPaths;
 
-		// @ts-ignore
-		Module._resolveLookupPaths = function (request, parent) {
-			const paths = originalResolveLookupPaths(request, parent);
-			if (Array.isArray(paths)) {
-				for (let i = 0, len = paths.length; i < len; i++) {
-					if (paths[i] === NODE_MODULES_PATH) {
-						paths.splice(i, 0, NODE_MODULES_ASAR_PATH);
-						break;
-					}
+	// @ts-ignore
+	Module._resolveLookupPaths = function (request, parent) {
+		const paths = originalResolveLookupPaths(request, parent);
+		if (Array.isArray(paths)) {
+			for (let i = 0, len = paths.length; i < len; i++) {
+				if (paths[i] === NODE_MODULES_PATH) {
+					paths.splice(i, 0, NODE_MODULES_ASAR_PATH);
+					break;
 				}
 			}
+		}
 
-			return paths;
-		};
-	}
+		return paths;
+	};
+	// ESM-comment-end
 };
 
 /**
diff --git a/src/bootstrap-window.js b/src/bootstrap-window.js
index b3216ac0f2e..25a4a216ba2 100644
--- a/src/bootstrap-window.js
+++ b/src/bootstrap-window.js
@@ -15,13 +15,6 @@
 
 /* eslint-disable no-restricted-globals */
 
-// ESM-comment-begin
-const isESM = false;
-// ESM-comment-end
-// ESM-uncomment-begin
-// const isESM = true;
-// ESM-uncomment-end
-
 (function (factory) {
 	// @ts-ignore
 	globalThis.MonacoBootstrapWindow = factory();
@@ -95,133 +88,133 @@ const isESM = false;
 
 		window['MonacoEnvironment'] = {};
 
-		if (isESM) {
+		// ESM-uncomment-begin
+		// // Signal before require()
+		// if (typeof options?.beforeRequire === 'function') {
+		// 	options.beforeRequire(configuration);
+		// }
 
-			// Signal before require()
-			if (typeof options?.beforeRequire === 'function') {
-				options.beforeRequire(configuration);
-			}
+		// const baseUrl = new URL(`${fileUriFromPath(configuration.appRoot, { isWindows: safeProcess.platform === 'win32', scheme: 'vscode-file', fallbackAuthority: 'vscode-app' })}/out/`);
+		// globalThis._VSCODE_FILE_ROOT = baseUrl.toString();
 
-			const baseUrl = new URL(`${fileUriFromPath(configuration.appRoot, { isWindows: safeProcess.platform === 'win32', scheme: 'vscode-file', fallbackAuthority: 'vscode-app' })}/out/`);
-			globalThis._VSCODE_FILE_ROOT = baseUrl.toString();
+		// // DEV ---------------------------------------------------------------------------------------
+		// // DEV: This is for development and enables loading CSS via import-statements via import-maps.
+		// // DEV: For each CSS modules that we have we defined an entry in the import map that maps to
+		// // DEV: a blob URL that loads the CSS via a dynamic @import-rule.
+		// // DEV ---------------------------------------------------------------------------------------
+		// if (Array.isArray(configuration.cssModules) && configuration.cssModules.length > 0) {
+		// 	performance.mark('code/willAddCssLoader');
 
-			// DEV ---------------------------------------------------------------------------------------
-			// DEV: This is for development and enables loading CSS via import-statements via import-maps.
-			// DEV: For each CSS modules that we have we defined an entry in the import map that maps to
-			// DEV: a blob URL that loads the CSS via a dynamic @import-rule.
-			// DEV ---------------------------------------------------------------------------------------
-			if (Array.isArray(configuration.cssModules) && configuration.cssModules.length > 0) {
-				performance.mark('code/willAddCssLoader');
+		// 	const style = document.createElement('style');
+		// 	style.type = 'text/css';
+		// 	style.media = 'screen';
+		// 	style.id = 'vscode-css-loading';
+		// 	document.head.appendChild(style);
 
-				const style = document.createElement('style');
-				style.type = 'text/css';
-				style.media = 'screen';
-				style.id = 'vscode-css-loading';
-				document.head.appendChild(style);
+		// 	globalThis._VSCODE_CSS_LOAD = function (url) {
+		// 		style.textContent += `@import url(${url});\n`;
+		// 	};
 
-				globalThis._VSCODE_CSS_LOAD = function (url) {
-					style.textContent += `@import url(${url});\n`;
-				};
+		// 	/**
+		// 	 * @type { { imports: Record<string, string> }}
+		// 	 */
+		// 	const importMap = { imports: {} };
+		// 	for (const cssModule of configuration.cssModules) {
+		// 		const cssUrl = new URL(cssModule, baseUrl).href;
+		// 		const jsSrc = `globalThis._VSCODE_CSS_LOAD('${cssUrl}');\n`;
+		// 		const blob = new Blob([jsSrc], { type: 'application/javascript' });
+		// 		importMap.imports[cssUrl] = URL.createObjectURL(blob);
+		// 	}
 
-				/**
-				 * @type { { imports: Record<string, string> }}
-				 */
-				const importMap = { imports: {} };
-				for (const cssModule of configuration.cssModules) {
-					const cssUrl = new URL(cssModule, baseUrl).href;
-					const jsSrc = `globalThis._VSCODE_CSS_LOAD('${cssUrl}');\n`;
-					const blob = new Blob([jsSrc], { type: 'application/javascript' });
-					importMap.imports[cssUrl] = URL.createObjectURL(blob);
+		// 	const ttp = window.trustedTypes?.createPolicy('vscode-bootstrapImportMap', { createScript(value) { return value; }, });
+		// 	const importMapSrc = JSON.stringify(importMap, undefined, 2);
+		// 	const importMapScript = document.createElement('script');
+		// 	importMapScript.type = 'importmap';
+		// 	importMapScript.setAttribute('nonce', '0c6a828f1297');
+		// 	// @ts-ignore
+		// 	importMapScript.textContent = ttp?.createScript(importMapSrc) ?? importMapSrc;
+		// 	document.head.appendChild(importMapScript);
+
+		// 	performance.mark('code/didAddCssLoader');
+		// }
+
+		// const result = Promise.all(modulePaths.map(modulePath => {
+		// 	if (modulePath.includes('vs/css!')) {
+		// 		// ESM/CSS when seeing the old `vs/css!` prefix we use that as a signal to
+		// 		// load CSS via a <link> tag
+		// 		const cssModule = modulePath.replace('vs/css!', '');
+		// 		const link = document.createElement('link');
+		// 		link.rel = 'stylesheet';
+		// 		link.href = new URL(`${cssModule}.css`, baseUrl).href;
+		// 		document.head.appendChild(link);
+		// 		return Promise.resolve();
+
+		// 	} else {
+		// 		// ESM/JS module loading
+		// 		return import(new URL(`${modulePath}.js`, baseUrl).href);
+		// 	}
+		// }));
+
+		// result.then((res) => invokeResult(res[0]), onUnexpectedError);
+		// ESM-uncomment-end
+
+		// ESM-comment-begin
+		/** @type {LoaderConfig} */
+		const loaderConfig = {
+			baseUrl: `${fileUriFromPath(configuration.appRoot, { isWindows: safeProcess.platform === 'win32', scheme: 'vscode-file', fallbackAuthority: 'vscode-app' })}/out`,
+			preferScriptTags: true
+		};
+
+		// use a trusted types policy when loading via script tags
+		loaderConfig.trustedTypesPolicy = window.trustedTypes?.createPolicy('amdLoader', {
+			createScriptURL(value) {
+				if (value.startsWith(window.location.origin)) {
+					return value;
 				}
-
-				const ttp = window.trustedTypes?.createPolicy('vscode-bootstrapImportMap', { createScript(value) { return value; }, });
-				const importMapSrc = JSON.stringify(importMap, undefined, 2);
-				const importMapScript = document.createElement('script');
-				importMapScript.type = 'importmap';
-				importMapScript.setAttribute('nonce', '0c6a828f1297');
-				// @ts-ignore
-				importMapScript.textContent = ttp?.createScript(importMapSrc) ?? importMapSrc;
-				document.head.appendChild(importMapScript);
-
-				performance.mark('code/didAddCssLoader');
+				throw new Error(`Invalid script url: ${value}`);
 			}
+		});
 
-			const result = Promise.all(modulePaths.map(modulePath => {
-				if (modulePath.includes('vs/css!')) {
-					// ESM/CSS when seeing the old `vs/css!` prefix we use that as a signal to
-					// load CSS via a <link> tag
-					const cssModule = modulePath.replace('vs/css!', '');
-					const link = document.createElement('link');
-					link.rel = 'stylesheet';
-					link.href = new URL(`${cssModule}.css`, baseUrl).href;
-					document.head.appendChild(link);
-					return Promise.resolve();
+		// Teach the loader the location of the node modules we use in renderers
+		// This will enable to load these modules via <script> tags instead of
+		// using a fallback such as node.js require which does not exist in sandbox
+		const baseNodeModulesPath = isDev ? '../node_modules' : '../node_modules.asar';
+		loaderConfig.paths = {
+			'@vscode/tree-sitter-wasm': `${baseNodeModulesPath}/@vscode/tree-sitter-wasm/wasm/tree-sitter.js`,
+			'vscode-textmate': `${baseNodeModulesPath}/vscode-textmate/release/main.js`,
+			'vscode-oniguruma': `${baseNodeModulesPath}/vscode-oniguruma/release/main.js`,
+			'vsda': `${baseNodeModulesPath}/vsda/index.js`,
+			'@xterm/xterm': `${baseNodeModulesPath}/@xterm/xterm/lib/xterm.js`,
+			'@xterm/addon-clipboard': `${baseNodeModulesPath}/@xterm/addon-clipboard/lib/addon-clipboard.js`,
+			'@xterm/addon-image': `${baseNodeModulesPath}/@xterm/addon-image/lib/addon-image.js`,
+			'@xterm/addon-search': `${baseNodeModulesPath}/@xterm/addon-search/lib/addon-search.js`,
+			'@xterm/addon-serialize': `${baseNodeModulesPath}/@xterm/addon-serialize/lib/addon-serialize.js`,
+			'@xterm/addon-unicode11': `${baseNodeModulesPath}/@xterm/addon-unicode11/lib/addon-unicode11.js`,
+			'@xterm/addon-webgl': `${baseNodeModulesPath}/@xterm/addon-webgl/lib/addon-webgl.js`,
+			'@vscode/iconv-lite-umd': `${baseNodeModulesPath}/@vscode/iconv-lite-umd/lib/iconv-lite-umd.js`,
+			'jschardet': `${baseNodeModulesPath}/jschardet/dist/jschardet.min.js`,
+			'@vscode/vscode-languagedetection': `${baseNodeModulesPath}/@vscode/vscode-languagedetection/dist/lib/index.js`,
+			'vscode-regexp-languagedetection': `${baseNodeModulesPath}/vscode-regexp-languagedetection/dist/index.js`,
+			'tas-client-umd': `${baseNodeModulesPath}/tas-client-umd/lib/tas-client-umd.js`
+		};
 
-				} else {
-					// ESM/JS module loading
-					return import(new URL(`${modulePath}.js`, baseUrl).href);
-				}
-			}));
-
-			result.then((res) => invokeResult(res[0]), onUnexpectedError);
-		} else {
-
-			/** @type {LoaderConfig} */
-			const loaderConfig = {
-				baseUrl: `${fileUriFromPath(configuration.appRoot, { isWindows: safeProcess.platform === 'win32', scheme: 'vscode-file', fallbackAuthority: 'vscode-app' })}/out`,
-				preferScriptTags: true
-			};
-
-			// use a trusted types policy when loading via script tags
-			loaderConfig.trustedTypesPolicy = window.trustedTypes?.createPolicy('amdLoader', {
-				createScriptURL(value) {
-					if (value.startsWith(window.location.origin)) {
-						return value;
-					}
-					throw new Error(`Invalid script url: ${value}`);
-				}
-			});
-
-			// Teach the loader the location of the node modules we use in renderers
-			// This will enable to load these modules via <script> tags instead of
-			// using a fallback such as node.js require which does not exist in sandbox
-			const baseNodeModulesPath = isDev ? '../node_modules' : '../node_modules.asar';
-			loaderConfig.paths = {
-				'@vscode/tree-sitter-wasm': `${baseNodeModulesPath}/@vscode/tree-sitter-wasm/wasm/tree-sitter.js`,
-				'vscode-textmate': `${baseNodeModulesPath}/vscode-textmate/release/main.js`,
-				'vscode-oniguruma': `${baseNodeModulesPath}/vscode-oniguruma/release/main.js`,
-				'vsda': `${baseNodeModulesPath}/vsda/index.js`,
-				'@xterm/xterm': `${baseNodeModulesPath}/@xterm/xterm/lib/xterm.js`,
-				'@xterm/addon-clipboard': `${baseNodeModulesPath}/@xterm/addon-clipboard/lib/addon-clipboard.js`,
-				'@xterm/addon-image': `${baseNodeModulesPath}/@xterm/addon-image/lib/addon-image.js`,
-				'@xterm/addon-search': `${baseNodeModulesPath}/@xterm/addon-search/lib/addon-search.js`,
-				'@xterm/addon-serialize': `${baseNodeModulesPath}/@xterm/addon-serialize/lib/addon-serialize.js`,
-				'@xterm/addon-unicode11': `${baseNodeModulesPath}/@xterm/addon-unicode11/lib/addon-unicode11.js`,
-				'@xterm/addon-webgl': `${baseNodeModulesPath}/@xterm/addon-webgl/lib/addon-webgl.js`,
-				'@vscode/iconv-lite-umd': `${baseNodeModulesPath}/@vscode/iconv-lite-umd/lib/iconv-lite-umd.js`,
-				'jschardet': `${baseNodeModulesPath}/jschardet/dist/jschardet.min.js`,
-				'@vscode/vscode-languagedetection': `${baseNodeModulesPath}/@vscode/vscode-languagedetection/dist/lib/index.js`,
-				'vscode-regexp-languagedetection': `${baseNodeModulesPath}/vscode-regexp-languagedetection/dist/index.js`,
-				'tas-client-umd': `${baseNodeModulesPath}/tas-client-umd/lib/tas-client-umd.js`
-			};
-
-			// Signal before require.config()
-			if (typeof options?.beforeLoaderConfig === 'function') {
-				options.beforeLoaderConfig(loaderConfig);
-			}
-
-			// Configure loader
-			require.config(loaderConfig);
-
-			// Signal before require()
-			if (typeof options?.beforeRequire === 'function') {
-				options.beforeRequire(configuration);
-			}
-
-			// Actually require the main module as specified
-			require(modulePaths, invokeResult, onUnexpectedError);
+		// Signal before require.config()
+		if (typeof options?.beforeLoaderConfig === 'function') {
+			options.beforeLoaderConfig(loaderConfig);
 		}
 
+		// Configure loader
+		require.config(loaderConfig);
+
+		// Signal before require()
+		if (typeof options?.beforeRequire === 'function') {
+			options.beforeRequire(configuration);
+		}
+
+		// Actually require the main module as specified
+		require(modulePaths, invokeResult, onUnexpectedError);
+		// ESM-comment-end
+
 		/**
 		 * @param {any} firstModule
 		 */
diff --git a/src/vs/base/browser/defaultWorkerFactory.ts b/src/vs/base/browser/defaultWorkerFactory.ts
index 0861a3cb751..3b9bed26884 100644
--- a/src/vs/base/browser/defaultWorkerFactory.ts
+++ b/src/vs/base/browser/defaultWorkerFactory.ts
@@ -5,9 +5,18 @@
 
 import { createTrustedTypesPolicy } from 'vs/base/browser/trustedTypes';
 import { onUnexpectedError } from 'vs/base/common/errors';
-import { COI } from 'vs/base/common/network';
+import { AppResourcePath, COI, FileAccess } from 'vs/base/common/network';
+import { URI } from 'vs/base/common/uri';
 import { IWorker, IWorkerCallback, IWorkerFactory, logOnceWebWorkerWarning } from 'vs/base/common/worker/simpleWorker';
 import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { coalesce } from 'vs/base/common/arrays';
+
+// ESM-comment-begin
+const isESM = false;
+// ESM-comment-end
+// ESM-uncomment-begin
+// const isESM = true;
+// ESM-uncomment-end
 
 // Reuse the trusted types policy defined from worker bootstrap
 // when available.
@@ -23,10 +32,10 @@ export function createBlobWorker(blobUrl: string, options?: WorkerOptions): Work
 	if (!blobUrl.startsWith('blob:')) {
 		throw new URIError('Not a blob-url: ' + blobUrl);
 	}
-	return new Worker(ttPolicy ? ttPolicy.createScriptURL(blobUrl) as unknown as string : blobUrl, options);
+	return new Worker(ttPolicy ? ttPolicy.createScriptURL(blobUrl) as unknown as string : blobUrl, { ...options, type: isESM ? 'module' : undefined });
 }
 
-function getWorker(label: string): Worker | Promise<Worker> {
+function getWorker(workerMainLocation: URI | undefined, label: string): Worker | Promise<Worker> {
 	// Option for hosts to overwrite the worker script (used in the standalone editor)
 	interface IMonacoEnvironment {
 		getWorker?(moduleId: string, label: string): Worker | Promise<Worker>;
@@ -39,56 +48,76 @@ function getWorker(label: string): Worker | Promise<Worker> {
 		}
 		if (typeof monacoEnvironment.getWorkerUrl === 'function') {
 			const workerUrl = monacoEnvironment.getWorkerUrl('workerMain.js', label);
-			return new Worker(ttPolicy ? ttPolicy.createScriptURL(workerUrl) as unknown as string : workerUrl, { name: label });
+			return new Worker(ttPolicy ? ttPolicy.createScriptURL(workerUrl) as unknown as string : workerUrl, { name: label, type: isESM ? 'module' : undefined });
 		}
 	}
 	// ESM-comment-begin
 	if (typeof require === 'function') {
-		// check if the JS lives on a different origin
-		const workerMain = require.toUrl('vs/base/worker/workerMain.js'); // explicitly using require.toUrl(), see https://github.com/microsoft/vscode/issues/107440#issuecomment-698982321
-		const workerUrl = getWorkerBootstrapUrl(workerMain, label);
-		return new Worker(ttPolicy ? ttPolicy.createScriptURL(workerUrl) as unknown as string : workerUrl, { name: label });
+		const workerMainLocation = require.toUrl('vs/base/worker/workerMain.js'); // explicitly using require.toUrl(), see https://github.com/microsoft/vscode/issues/107440#issuecomment-698982321
+		const factoryModuleId = 'vs/base/worker/defaultWorkerFactory.js';
+		const workerBaseUrl = require.toUrl(factoryModuleId).slice(0, -factoryModuleId.length); // explicitly using require.toUrl(), see https://github.com/microsoft/vscode/issues/107440#issuecomment-698982321
+		const workerUrl = getWorkerBootstrapUrl(label, workerMainLocation, workerBaseUrl);
+		return new Worker(ttPolicy ? ttPolicy.createScriptURL(workerUrl) as unknown as string : workerUrl, { name: label, type: isESM ? 'module' : undefined });
 	}
 	// ESM-comment-end
+	if (workerMainLocation) {
+		const workerUrl = getWorkerBootstrapUrl(label, workerMainLocation.toString(true));
+		const worker = new Worker(ttPolicy ? ttPolicy.createScriptURL(workerUrl) as unknown as string : workerUrl, { name: label, type: isESM ? 'module' : undefined });
+		if (isESM) {
+			return whenESMWorkerReady(worker);
+		} else {
+			return worker;
+		}
+	}
 	throw new Error(`You must define a function MonacoEnvironment.getWorkerUrl or MonacoEnvironment.getWorker`);
 }
 
-// ESM-comment-begin
-export function getWorkerBootstrapUrl(scriptPath: string, label: string): string {
-	if (/^((http:)|(https:)|(file:))/.test(scriptPath) && scriptPath.substring(0, globalThis.origin.length) !== globalThis.origin) {
+function getWorkerBootstrapUrl(label: string, workerScriptUrl: string, workerBaseUrl?: string): string {
+	if (/^((http:)|(https:)|(file:))/.test(workerScriptUrl) && workerScriptUrl.substring(0, globalThis.origin.length) !== globalThis.origin) {
 		// this is the cross-origin case
 		// i.e. the webpage is running at a different origin than where the scripts are loaded from
 	} else {
-		const start = scriptPath.lastIndexOf('?');
-		const end = scriptPath.lastIndexOf('#', start);
+		const start = workerScriptUrl.lastIndexOf('?');
+		const end = workerScriptUrl.lastIndexOf('#', start);
 		const params = start > 0
-			? new URLSearchParams(scriptPath.substring(start + 1, ~end ? end : undefined))
+			? new URLSearchParams(workerScriptUrl.substring(start + 1, ~end ? end : undefined))
 			: new URLSearchParams();
 
 		COI.addSearchParam(params, true, true);
 		const search = params.toString();
 		if (!search) {
-			scriptPath = `${scriptPath}#${label}`;
+			workerScriptUrl = `${workerScriptUrl}#${label}`;
 		} else {
-			scriptPath = `${scriptPath}?${params.toString()}#${label}`;
+			workerScriptUrl = `${workerScriptUrl}?${params.toString()}#${label}`;
 		}
 	}
 
-	const factoryModuleId = 'vs/base/worker/defaultWorkerFactory.js';
-	const workerBaseUrl = require.toUrl(factoryModuleId).slice(0, -factoryModuleId.length); // explicitly using require.toUrl(), see https://github.com/microsoft/vscode/issues/107440#issuecomment-698982321
-	const blob = new Blob([[
+	const blob = new Blob([coalesce([
 		`/*${label}*/`,
-		`globalThis.MonacoEnvironment = { baseUrl: '${workerBaseUrl}' };`,
+		workerBaseUrl ? `globalThis.MonacoEnvironment = { baseUrl: '${workerBaseUrl}' };` : undefined,
 		`globalThis._VSCODE_NLS_MESSAGES = ${JSON.stringify(globalThis._VSCODE_NLS_MESSAGES)};`,
 		`globalThis._VSCODE_NLS_LANGUAGE = ${JSON.stringify(globalThis._VSCODE_NLS_LANGUAGE)};`,
+		`globalThis._VSCODE_FILE_ROOT = '${globalThis._VSCODE_FILE_ROOT}';`,
 		`const ttPolicy = globalThis.trustedTypes?.createPolicy('defaultWorkerFactory', { createScriptURL: value => value });`,
 		`globalThis.workerttPolicy = ttPolicy;`,
-		`importScripts(ttPolicy?.createScriptURL('${scriptPath}') ?? '${scriptPath}');`,
+		isESM ? `await import(ttPolicy?.createScriptURL('${workerScriptUrl}') ?? '${workerScriptUrl}');` : `importScripts(ttPolicy?.createScriptURL('${workerScriptUrl}') ?? '${workerScriptUrl}');`, //
+		isESM ? `globalThis.postMessage({ type: 'vscode-worker-ready' });` : undefined, // in ESM signal we are ready after the async import
 		`/*${label}*/`
-	].join('')], { type: 'application/javascript' });
+	]).join('')], { type: 'application/javascript' });
 	return URL.createObjectURL(blob);
 }
-// ESM-comment-end
+
+function whenESMWorkerReady(worker: Worker): Promise<Worker> {
+	return new Promise<Worker>((resolve, reject) => {
+		worker.onmessage = function (e) {
+			if (e.data.type === 'vscode-worker-ready') {
+				worker.onmessage = null;
+				resolve(worker);
+			}
+		};
+		worker.onerror = reject;
+	});
+}
 
 function isPromiseLike<T>(obj: any): obj is PromiseLike<T> {
 	if (typeof obj.then === 'function') {
@@ -107,11 +136,11 @@ class WebWorker extends Disposable implements IWorker {
 	private readonly label: string;
 	private worker: Promise<Worker> | null;
 
-	constructor(moduleId: string, id: number, label: string, onMessageCallback: IWorkerCallback, onErrorCallback: (err: any) => void) {
+	constructor(workerMainLocation: URI | undefined, moduleId: string, id: number, label: string, onMessageCallback: IWorkerCallback, onErrorCallback: (err: any) => void) {
 		super();
 		this.id = id;
 		this.label = label;
-		const workerOrPromise = getWorker(label);
+		const workerOrPromise = getWorker(workerMainLocation, label);
 		if (isPromiseLike(workerOrPromise)) {
 			this.worker = workerOrPromise;
 		} else {
@@ -161,19 +190,26 @@ export class DefaultWorkerFactory implements IWorkerFactory {
 	private _label: string | undefined;
 	private _webWorkerFailedBeforeError: any;
 
-	constructor(label: string | undefined) {
+	constructor(private readonly workerMainLocation: URI | undefined, label: string | undefined) {
 		this._label = label;
 		this._webWorkerFailedBeforeError = false;
 	}
 
-	public create(moduleId: string, onMessageCallback: IWorkerCallback, onErrorCallback: (err: any) => void): IWorker {
+	public create(modules: { moduleId: string; esmModuleId: string }, onMessageCallback: IWorkerCallback, onErrorCallback: (err: any) => void): IWorker {
 		const workerId = (++DefaultWorkerFactory.LAST_WORKER_ID);
 
 		if (this._webWorkerFailedBeforeError) {
 			throw this._webWorkerFailedBeforeError;
 		}
 
-		return new WebWorker(moduleId, workerId, this._label || 'anonymous' + workerId, onMessageCallback, (err) => {
+		let workerMainLocation = this.workerMainLocation;
+		const moduleId = modules.moduleId;
+
+		if (isESM) {
+			workerMainLocation = FileAccess.asBrowserUri(`${modules.esmModuleId}.esm.js` as AppResourcePath);
+		}
+
+		return new WebWorker(workerMainLocation, moduleId, workerId, this._label || 'anonymous' + workerId, onMessageCallback, (err) => {
 			logOnceWebWorkerWarning(err);
 			this._webWorkerFailedBeforeError = err;
 			onErrorCallback(err);
diff --git a/src/vs/base/common/network.ts b/src/vs/base/common/network.ts
index 1d782b2804d..4e59843a163 100644
--- a/src/vs/base/common/network.ts
+++ b/src/vs/base/common/network.ts
@@ -253,7 +253,12 @@ class FileAccessImpl {
 	 * **Note:** use `dom.ts#asCSSUrl` whenever the URL is to be used in CSS context.
 	 */
 	asBrowserUri(resourcePath: AppResourcePath | ''): URI {
+		// ESM-comment-begin
 		const uri = this.toUri(resourcePath, require);
+		// ESM-comment-end
+		// ESM-uncomment-begin
+		// const uri = this.toUri(resourcePath);
+		// ESM-uncomment-end
 		return this.uriToBrowserUri(uri);
 	}
 
@@ -300,7 +305,12 @@ class FileAccessImpl {
 	 * is responsible for loading.
 	 */
 	asFileUri(resourcePath: AppResourcePath | ''): URI {
+		// ESM-comment-begin
 		const uri = this.toUri(resourcePath, require);
+		// ESM-comment-end
+		// ESM-uncomment-begin
+		// const uri = this.toUri(resourcePath);
+		// ESM-uncomment-end
 		return this.uriToFileUri(uri);
 	}
 
@@ -325,12 +335,25 @@ class FileAccessImpl {
 		return uri;
 	}
 
-	private toUri(uriOrModule: URI | string, moduleIdToUrl: { toUrl(moduleId: string): string }): URI {
+	private toUri(uriOrModule: URI | string, moduleIdToUrl?: { toUrl(moduleId: string): string }): URI {
 		if (URI.isUri(uriOrModule)) {
 			return uriOrModule;
 		}
 
-		return URI.parse(moduleIdToUrl.toUrl(uriOrModule));
+		if (globalThis._VSCODE_FILE_ROOT) {
+			const rootUriOrPath = globalThis._VSCODE_FILE_ROOT;
+
+			// File URL (with scheme)
+			if (/^\w[\w\d+.-]*:\/\//.test(rootUriOrPath)) {
+				return URI.joinPath(URI.parse(rootUriOrPath, true), uriOrModule);
+			}
+
+			// File Path (no scheme)
+			const modulePath = paths.join(rootUriOrPath, uriOrModule);
+			return URI.file(modulePath);
+		}
+
+		return URI.parse(moduleIdToUrl!.toUrl(uriOrModule));
 	}
 }
 
diff --git a/src/vs/base/common/worker/simpleWorker.ts b/src/vs/base/common/worker/simpleWorker.ts
index 57cc59ee770..81d4e55e6d5 100644
--- a/src/vs/base/common/worker/simpleWorker.ts
+++ b/src/vs/base/common/worker/simpleWorker.ts
@@ -6,10 +6,18 @@
 import { transformErrorForSerialization } from 'vs/base/common/errors';
 import { Emitter, Event } from 'vs/base/common/event';
 import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
+import { AppResourcePath, FileAccess } from 'vs/base/common/network';
 import { getAllMethodNames } from 'vs/base/common/objects';
 import { isWeb } from 'vs/base/common/platform';
 import * as strings from 'vs/base/common/strings';
 
+// ESM-comment-begin
+const isESM = false;
+// ESM-comment-end
+// ESM-uncomment-begin
+// const isESM = true;
+// ESM-uncomment-end
+
 const INITIALIZE = '$initialize';
 
 export interface IWorker extends IDisposable {
@@ -22,7 +30,7 @@ export interface IWorkerCallback {
 }
 
 export interface IWorkerFactory {
-	create(moduleId: string, callback: IWorkerCallback, onErrorCallback: (err: any) => void): IWorker;
+	create(modules: { moduleId: string; esmModuleId: string }, callback: IWorkerCallback, onErrorCallback: (err: any) => void): IWorker;
 }
 
 let webWorkerWarningLogged = false;
@@ -276,7 +284,7 @@ export class SimpleWorkerClient<W extends object, H extends object> extends Disp
 		let lazyProxyReject: ((err: any) => void) | null = null;
 
 		this._worker = this._register(workerFactory.create(
-			'vs/base/common/worker/simpleWorker',
+			{ moduleId: 'vs/base/common/worker/simpleWorker', esmModuleId: moduleId },
 			(msg: Message) => {
 				this._protocol.handleMessage(msg);
 			},
@@ -532,6 +540,19 @@ export class SimpleWorkerServer<H extends object> {
 			globalThis.require.config(loaderConfig);
 		}
 
+		if (isESM) {
+			const url = FileAccess.asBrowserUri(`${moduleId}.js` as AppResourcePath).toString(true);
+			return import(`${url}`).then((module: { create: IRequestHandlerFactory<H> }) => {
+				this._requestHandler = module.create(hostProxy);
+
+				if (!this._requestHandler) {
+					throw new Error(`No RequestHandler!`);
+				}
+
+				return getAllMethodNames(this._requestHandler);
+			});
+		}
+
 		return new Promise<string[]>((resolve, reject) => {
 			// Use the global require to be sure to get the global config
 
diff --git a/src/vs/base/common/worker/simpleWorkerBootstrap.ts b/src/vs/base/common/worker/simpleWorkerBootstrap.ts
new file mode 100644
index 00000000000..01e71dc4f2f
--- /dev/null
+++ b/src/vs/base/common/worker/simpleWorkerBootstrap.ts
@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IRequestHandlerFactory, SimpleWorkerServer } from 'vs/base/common/worker/simpleWorker';
+
+type MessageEvent = {
+	data: any;
+};
+
+declare const globalThis: {
+	postMessage: (message: any) => void;
+	onmessage: (event: MessageEvent) => void;
+};
+
+let initialized = false;
+
+function initialize<H extends object>(factory: IRequestHandlerFactory<H>) {
+	if (initialized) {
+		return;
+	}
+	initialized = true;
+
+	const simpleWorker = new SimpleWorkerServer<H>(
+		msg => globalThis.postMessage(msg),
+		host => factory(host)
+	);
+
+	globalThis.onmessage = (e: MessageEvent) => {
+		simpleWorker.onmessage(e.data);
+	};
+}
+
+export function bootstrapSimpleWorker<H extends object>(factory: IRequestHandlerFactory<H>) {
+	globalThis.onmessage = (_e: MessageEvent) => {
+		// Ignore first message in this case and initialize if not yet initialized
+		if (!initialized) {
+			initialize(factory);
+		}
+	};
+}
diff --git a/src/vs/base/worker/workerMain.ts b/src/vs/base/worker/workerMain.ts
index 35c685ff771..a0d011da879 100644
--- a/src/vs/base/worker/workerMain.ts
+++ b/src/vs/base/worker/workerMain.ts
@@ -13,6 +13,7 @@
 		): undefined | Pick<TrustedTypePolicy<Options>, 'name' | Extract<keyof Options, keyof TrustedTypePolicyOptions>>;
 	}
 	const monacoEnvironment: IMonacoEnvironment | undefined = (globalThis as any).MonacoEnvironment;
+
 	const monacoBaseUrl = monacoEnvironment && monacoEnvironment.baseUrl ? monacoEnvironment.baseUrl : '../../../';
 
 	function createTrustedTypesPolicy<Options extends TrustedTypePolicyOptions>(
@@ -111,23 +112,42 @@
 		});
 	}
 
-	function loadCode(moduleId: string) {
-		loadAMDLoader().then(() => {
-			configureAMDLoader();
-			require([moduleId], function (ws) {
-				setTimeout(function () {
-					const messageHandler = ws.create((msg: any, transfer?: Transferable[]) => {
-						(<any>globalThis).postMessage(msg, transfer);
-					}, null);
+	function loadCode(moduleId: string): Promise<SimpleWorkerModule> {
+		// ESM-uncomment-begin
+		// const moduleUrl = new URL(`${moduleId}.js`, globalThis._VSCODE_FILE_ROOT);
+		// return import(moduleUrl.href);
+		// ESM-uncomment-end
 
-					globalThis.onmessage = (e: MessageEvent) => messageHandler.onmessage(e.data, e.ports);
-					while (beforeReadyMessages.length > 0) {
-						const e = beforeReadyMessages.shift()!;
-						messageHandler.onmessage(e.data, e.ports);
-					}
-				}, 0);
+		// ESM-comment-begin
+		return loadAMDLoader().then(() => {
+			configureAMDLoader();
+			return new Promise<SimpleWorkerModule>((resolve, reject) => {
+				require([moduleId], resolve, reject);
 			});
 		});
+		// ESM-comment-end
+	}
+
+	interface MessageHandler {
+		onmessage(msg: any, ports: readonly MessagePort[]): void;
+	}
+
+	// shape of vs/base/common/worker/simpleWorker.ts
+	interface SimpleWorkerModule {
+		create(postMessage: (msg: any, transfer?: Transferable[]) => void): MessageHandler;
+	}
+
+	function setupWorkerServer(ws: SimpleWorkerModule) {
+		setTimeout(function () {
+			const messageHandler = ws.create((msg: any, transfer?: Transferable[]) => {
+				(<any>globalThis).postMessage(msg, transfer);
+			});
+
+			self.onmessage = (e: MessageEvent) => messageHandler.onmessage(e.data, e.ports);
+			while (beforeReadyMessages.length > 0) {
+				self.onmessage(beforeReadyMessages.shift()!);
+			}
+		}, 0);
 	}
 
 	// If the loader is already defined, configure it immediately
@@ -146,6 +166,10 @@
 		}
 
 		isFirstMessage = false;
-		loadCode(message.data);
+		loadCode(message.data).then((ws) => {
+			setupWorkerServer(ws);
+		}, (err) => {
+			console.error(err);
+		});
 	};
 })();
diff --git a/src/vs/editor/browser/services/editorWorkerService.ts b/src/vs/editor/browser/services/editorWorkerService.ts
index aa1e41c8985..6a950ada9e1 100644
--- a/src/vs/editor/browser/services/editorWorkerService.ts
+++ b/src/vs/editor/browser/services/editorWorkerService.ts
@@ -63,6 +63,7 @@ export class EditorWorkerService extends Disposable implements IEditorWorkerServ
 	private readonly _logService: ILogService;
 
 	constructor(
+		workerMainLocation: URI | undefined,
 		@IModelService modelService: IModelService,
 		@ITextResourceConfigurationService configurationService: ITextResourceConfigurationService,
 		@ILogService logService: ILogService,
@@ -71,7 +72,7 @@ export class EditorWorkerService extends Disposable implements IEditorWorkerServ
 	) {
 		super();
 		this._modelService = modelService;
-		this._workerManager = this._register(new WorkerManager(this._modelService, languageConfigurationService));
+		this._workerManager = this._register(new WorkerManager(workerMainLocation, this._modelService, languageConfigurationService));
 		this._logService = logService;
 
 		// register default link-provider and default completions-provider
@@ -281,7 +282,7 @@ class WorkerManager extends Disposable {
 	private _editorWorkerClient: EditorWorkerClient | null;
 	private _lastWorkerUsedTime: number;
 
-	constructor(modelService: IModelService, private readonly languageConfigurationService: ILanguageConfigurationService) {
+	constructor(private readonly workerMainLocation: URI | undefined, modelService: IModelService, private readonly languageConfigurationService: ILanguageConfigurationService) {
 		super();
 		this._modelService = modelService;
 		this._editorWorkerClient = null;
@@ -335,7 +336,7 @@ class WorkerManager extends Disposable {
 	public withWorker(): Promise<EditorWorkerClient> {
 		this._lastWorkerUsedTime = (new Date()).getTime();
 		if (!this._editorWorkerClient) {
-			this._editorWorkerClient = new EditorWorkerClient(this._modelService, false, 'editorWorkerService', this.languageConfigurationService);
+			this._editorWorkerClient = new EditorWorkerClient(this.workerMainLocation, this._modelService, false, 'editorWorkerService', this.languageConfigurationService);
 		}
 		return Promise.resolve(this._editorWorkerClient);
 	}
@@ -484,6 +485,7 @@ export class EditorWorkerClient extends Disposable implements IEditorWorkerClien
 	private _disposed = false;
 
 	constructor(
+		workerMainLocation: URI | undefined,
 		modelService: IModelService,
 		keepIdleModels: boolean,
 		label: string | undefined,
@@ -492,7 +494,7 @@ export class EditorWorkerClient extends Disposable implements IEditorWorkerClien
 		super();
 		this._modelService = modelService;
 		this._keepIdleModels = keepIdleModels;
-		this._workerFactory = new DefaultWorkerFactory(label);
+		this._workerFactory = new DefaultWorkerFactory(workerMainLocation, label);
 		this._worker = null;
 		this._modelManager = null;
 	}
diff --git a/src/vs/editor/browser/services/webWorker.ts b/src/vs/editor/browser/services/webWorker.ts
index b5757c58865..8ca8af228ed 100644
--- a/src/vs/editor/browser/services/webWorker.ts
+++ b/src/vs/editor/browser/services/webWorker.ts
@@ -3,6 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { FileAccess } from 'vs/base/common/network';
 import { getAllMethodNames } from 'vs/base/common/objects';
 import { URI } from 'vs/base/common/uri';
 import { EditorWorkerClient } from 'vs/editor/browser/services/editorWorkerService';
@@ -14,7 +15,14 @@ import { IModelService } from 'vs/editor/common/services/model';
  * Specify an AMD module to load that will `create` an object that will be proxied.
  */
 export function createWebWorker<T extends object>(modelService: IModelService, languageConfigurationService: ILanguageConfigurationService, opts: IWebWorkerOptions): MonacoWebWorker<T> {
-	return new MonacoWebWorkerImpl<T>(modelService, languageConfigurationService, opts);
+	return new MonacoWebWorkerImpl<T>(undefined, modelService, languageConfigurationService, opts);
+}
+
+/**
+ * @internal
+ */
+export function createWorkbenchWebWorker<T extends object>(modelService: IModelService, languageConfigurationService: ILanguageConfigurationService, opts: IWebWorkerOptions): MonacoWebWorker<T> {
+	return new MonacoWebWorkerImpl<T>(FileAccess.asBrowserUri('vs/base/worker/workerMain.js'), modelService, languageConfigurationService, opts);
 }
 
 /**
@@ -68,8 +76,8 @@ class MonacoWebWorkerImpl<T extends object> extends EditorWorkerClient implement
 	private _foreignModuleCreateData: any | null;
 	private _foreignProxy: Promise<T> | null;
 
-	constructor(modelService: IModelService, languageConfigurationService: ILanguageConfigurationService, opts: IWebWorkerOptions) {
-		super(modelService, opts.keepIdleModels || false, opts.label, languageConfigurationService);
+	constructor(workerMainLocation: URI | undefined, modelService: IModelService, languageConfigurationService: ILanguageConfigurationService, opts: IWebWorkerOptions) {
+		super(workerMainLocation, modelService, opts.keepIdleModels || false, opts.label, languageConfigurationService);
 		this._foreignModuleId = opts.moduleId;
 		this._foreignModuleCreateData = opts.createData || null;
 		this._foreignModuleHost = opts.host || null;
diff --git a/src/vs/editor/common/services/editorSimpleWorker.esm.ts b/src/vs/editor/common/services/editorSimpleWorker.esm.ts
new file mode 100644
index 00000000000..5f659c76f8e
--- /dev/null
+++ b/src/vs/editor/common/services/editorSimpleWorker.esm.ts
@@ -0,0 +1,9 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { create } from 'vs/editor/common/services/editorSimpleWorker';
+import { bootstrapSimpleEditorWorker } from './editorWorkerBootstrap';
+
+bootstrapSimpleEditorWorker(create);
diff --git a/src/vs/editor/common/services/editorSimpleWorker.ts b/src/vs/editor/common/services/editorSimpleWorker.ts
index 195a870b0af..42c128690c0 100644
--- a/src/vs/editor/common/services/editorSimpleWorker.ts
+++ b/src/vs/editor/common/services/editorSimpleWorker.ts
@@ -26,10 +26,18 @@ import { DetailedLineRangeMapping } from '../diff/rangeMapping';
 import { linesDiffComputers } from 'vs/editor/common/diff/linesDiffComputers';
 import { createProxyObject, getAllMethodNames } from 'vs/base/common/objects';
 import { IDocumentDiffProviderOptions } from 'vs/editor/common/diff/documentDiffProvider';
+import { AppResourcePath, FileAccess } from 'vs/base/common/network';
 import { BugIndicatingError } from 'vs/base/common/errors';
 import { IDocumentColorComputerTarget, computeDefaultDocumentColors } from 'vs/editor/common/languages/defaultDocumentColorsComputer';
 import { FindSectionHeaderOptions, SectionHeader, findSectionHeaders } from 'vs/editor/common/services/findSectionHeaders';
 
+// ESM-comment-begin
+const isESM = false;
+// ESM-comment-end
+// ESM-uncomment-begin
+// const isESM = true;
+// ESM-uncomment-end
+
 export interface IMirrorModel extends IMirrorTextModel {
 	readonly uri: URI;
 	readonly version: number;
@@ -818,20 +826,21 @@ export class EditorSimpleWorker implements IRequestHandler, IDisposable {
 			// static foreing module
 			return Promise.resolve(getAllMethodNames(this._foreignModule));
 		}
-		// ESM-comment-begin
+
 		return new Promise<any>((resolve, reject) => {
-			require([moduleId], (foreignModule: { create: IForeignModuleFactory }) => {
+
+			const onModuleCallback = (foreignModule: { create: IForeignModuleFactory }) => {
 				this._foreignModule = foreignModule.create(ctx, createData);
-
 				resolve(getAllMethodNames(this._foreignModule));
+			};
 
-			}, reject);
+			if (!isESM) {
+				require([`${moduleId}`], onModuleCallback, reject);
+			} else {
+				const url = FileAccess.asBrowserUri(`${moduleId}.js` as AppResourcePath).toString(true);
+				import(`${url}`).then(onModuleCallback).catch(reject);
+			}
 		});
-		// ESM-comment-end
-
-		// ESM-uncomment-begin
-		// return Promise.reject(new Error(`Unexpected usage`));
-		// ESM-uncomment-end
 	}
 
 	// foreign method request
diff --git a/src/vs/editor/common/services/editorWorkerBootstrap.ts b/src/vs/editor/common/services/editorWorkerBootstrap.ts
new file mode 100644
index 00000000000..4902f7d48ff
--- /dev/null
+++ b/src/vs/editor/common/services/editorWorkerBootstrap.ts
@@ -0,0 +1,51 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { SimpleWorkerServer } from 'vs/base/common/worker/simpleWorker';
+import { EditorSimpleWorker } from 'vs/editor/common/services/editorSimpleWorker';
+import { IEditorWorkerHost } from 'vs/editor/common/services/editorWorkerHost';
+
+type MessageEvent = {
+	data: any;
+};
+
+declare const globalThis: {
+	postMessage: (message: any) => void;
+	onmessage: (event: MessageEvent) => void;
+};
+
+let initialized = false;
+
+export function initialize(factory: any) {
+	if (initialized) {
+		return;
+	}
+	initialized = true;
+
+	const simpleWorker = new SimpleWorkerServer((msg) => {
+		globalThis.postMessage(msg);
+	}, (host: IEditorWorkerHost) => new EditorSimpleWorker(host, null));
+
+	globalThis.onmessage = (e: MessageEvent) => {
+		simpleWorker.onmessage(e.data);
+	};
+}
+
+globalThis.onmessage = (e: MessageEvent) => {
+	// Ignore first message in this case and initialize if not yet initialized
+	if (!initialized) {
+		initialize(null);
+	}
+};
+
+type CreateFunction<C, D, R = any> = (ctx: C, data: D) => R;
+
+export function bootstrapSimpleEditorWorker<C, D, R>(createFn: CreateFunction<C, D, R>) {
+	globalThis.onmessage = () => {
+		initialize((ctx: C, createData: D) => {
+			return createFn.call(self, ctx, createData);
+		});
+	};
+}
diff --git a/src/vs/editor/contrib/colorPicker/browser/defaultDocumentColorProvider.ts b/src/vs/editor/contrib/colorPicker/browser/defaultDocumentColorProvider.ts
index 8bb5e3ad56a..6e3c6f235d2 100644
--- a/src/vs/editor/contrib/colorPicker/browser/defaultDocumentColorProvider.ts
+++ b/src/vs/editor/contrib/colorPicker/browser/defaultDocumentColorProvider.ts
@@ -13,6 +13,7 @@ import { ILanguageConfigurationService } from 'vs/editor/common/languages/langua
 import { Disposable } from 'vs/base/common/lifecycle';
 import { ILanguageFeaturesService } from 'vs/editor/common/services/languageFeatures';
 import { registerEditorFeature } from 'vs/editor/common/editorFeatures';
+import { FileAccess } from 'vs/base/common/network';
 
 export class DefaultDocumentColorProvider implements DocumentColorProvider {
 
@@ -22,7 +23,7 @@ export class DefaultDocumentColorProvider implements DocumentColorProvider {
 		modelService: IModelService,
 		languageConfigurationService: ILanguageConfigurationService,
 	) {
-		this._editorWorkerClient = new EditorWorkerClient(modelService, false, 'editorWorkerService', languageConfigurationService);
+		this._editorWorkerClient = new EditorWorkerClient(FileAccess.asBrowserUri('vs/base/worker/workerMain.js'), modelService, false, 'editorWorkerService', languageConfigurationService);
 	}
 
 	async provideDocumentColors(model: ITextModel, _token: CancellationToken): Promise<IColorInformation[] | null> {
diff --git a/src/vs/editor/contrib/suggest/test/browser/wordDistance.test.ts b/src/vs/editor/contrib/suggest/test/browser/wordDistance.test.ts
index 15f238b1627..65e3b8a4594 100644
--- a/src/vs/editor/contrib/suggest/test/browser/wordDistance.test.ts
+++ b/src/vs/editor/contrib/suggest/test/browser/wordDistance.test.ts
@@ -66,7 +66,7 @@ suite('suggest, word distance', function () {
 			private _worker = new EditorSimpleWorker(new class extends mock<IEditorWorkerHost>() { }, null);
 
 			constructor() {
-				super(modelService, new class extends mock<ITextResourceConfigurationService>() { }, new NullLogService(), new TestLanguageConfigurationService(), new LanguageFeaturesService());
+				super(undefined, modelService, new class extends mock<ITextResourceConfigurationService>() { }, new NullLogService(), new TestLanguageConfigurationService(), new LanguageFeaturesService());
 				this._worker.acceptNewModel({
 					url: model.uri.toString(),
 					lines: model.getLinesContent(),
diff --git a/src/vs/editor/editor.worker.ts b/src/vs/editor/editor.worker.ts
index 7c53a6094b2..a50ddd14bad 100644
--- a/src/vs/editor/editor.worker.ts
+++ b/src/vs/editor/editor.worker.ts
@@ -3,30 +3,4 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { SimpleWorkerServer } from 'vs/base/common/worker/simpleWorker';
-import { EditorSimpleWorker } from 'vs/editor/common/services/editorSimpleWorker';
-import { IEditorWorkerHost } from 'vs/editor/common/services/editorWorkerHost';
-
-let initialized = false;
-
-export function initialize(foreignModule: any) {
-	if (initialized) {
-		return;
-	}
-	initialized = true;
-
-	const simpleWorker = new SimpleWorkerServer((msg) => {
-		globalThis.postMessage(msg);
-	}, (host: IEditorWorkerHost) => new EditorSimpleWorker(host, foreignModule));
-
-	globalThis.onmessage = (e: MessageEvent) => {
-		simpleWorker.onmessage(e.data);
-	};
-}
-
-globalThis.onmessage = (e: MessageEvent) => {
-	// Ignore first message in this case and initialize if not yet initialized
-	if (!initialized) {
-		initialize(null);
-	}
-};
+export * from 'vs/editor/common/services/editorWorkerBootstrap';
diff --git a/src/vs/editor/standalone/browser/standaloneServices.ts b/src/vs/editor/standalone/browser/standaloneServices.ts
index 9682a3cfb0f..ca773a2b41d 100644
--- a/src/vs/editor/standalone/browser/standaloneServices.ts
+++ b/src/vs/editor/standalone/browser/standaloneServices.ts
@@ -3,7 +3,6 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import 'vs/editor/common/languages/languageConfigurationRegistry';
 import 'vs/editor/standalone/browser/standaloneCodeEditorService';
 import 'vs/editor/standalone/browser/standaloneLayoutService';
 import 'vs/platform/undoRedo/common/undoRedoService';
@@ -89,6 +88,8 @@ import { IStorageService, InMemoryStorageService } from 'vs/platform/storage/com
 import { DefaultConfiguration } from 'vs/platform/configuration/common/configurations';
 import { WorkspaceEdit } from 'vs/editor/common/languages';
 import { AccessibilitySignal, AccessibilityModality, IAccessibilitySignalService, Sound } from 'vs/platform/accessibilitySignal/browser/accessibilitySignalService';
+import { ILanguageFeaturesService } from 'vs/editor/common/services/languageFeatures';
+import { ILanguageConfigurationService } from 'vs/editor/common/languages/languageConfigurationRegistry';
 import { LogService } from 'vs/platform/log/common/logService';
 import { getEditorFeatures } from 'vs/editor/common/editorFeatures';
 import { onUnexpectedError } from 'vs/base/common/errors';
@@ -1072,6 +1073,18 @@ class StandaloneContextMenuService extends ContextMenuService {
 	}
 }
 
+class StandaloneEditorWorkerService extends EditorWorkerService {
+	constructor(
+		@IModelService modelService: IModelService,
+		@ITextResourceConfigurationService configurationService: ITextResourceConfigurationService,
+		@ILogService logService: ILogService,
+		@ILanguageConfigurationService languageConfigurationService: ILanguageConfigurationService,
+		@ILanguageFeaturesService languageFeaturesService: ILanguageFeaturesService,
+	) {
+		super(undefined, modelService, configurationService, logService, languageConfigurationService, languageFeaturesService);
+	}
+}
+
 class StandaloneAccessbilitySignalService implements IAccessibilitySignalService {
 	_serviceBrand: undefined;
 	async playSignal(cue: AccessibilitySignal, options: {}): Promise<void> {
@@ -1130,7 +1143,7 @@ registerSingleton(IContextKeyService, ContextKeyService, InstantiationType.Eager
 registerSingleton(IProgressService, StandaloneProgressService, InstantiationType.Eager);
 registerSingleton(IEditorProgressService, StandaloneEditorProgressService, InstantiationType.Eager);
 registerSingleton(IStorageService, InMemoryStorageService, InstantiationType.Eager);
-registerSingleton(IEditorWorkerService, EditorWorkerService, InstantiationType.Eager);
+registerSingleton(IEditorWorkerService, StandaloneEditorWorkerService, InstantiationType.Eager);
 registerSingleton(IBulkEditService, StandaloneBulkEditService, InstantiationType.Eager);
 registerSingleton(IWorkspaceTrustManagementService, StandaloneWorkspaceTrustManagementService, InstantiationType.Eager);
 registerSingleton(ITextModelService, StandaloneTextModelService, InstantiationType.Eager);
diff --git a/src/vs/platform/profiling/electron-sandbox/profileAnalysisWorker.esm.ts b/src/vs/platform/profiling/electron-sandbox/profileAnalysisWorker.esm.ts
new file mode 100644
index 00000000000..4329929cd9c
--- /dev/null
+++ b/src/vs/platform/profiling/electron-sandbox/profileAnalysisWorker.esm.ts
@@ -0,0 +1,9 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { create } from './profileAnalysisWorker';
+import { bootstrapSimpleWorker } from 'vs/base/common/worker/simpleWorkerBootstrap';
+
+bootstrapSimpleWorker(create);
diff --git a/src/vs/platform/profiling/electron-sandbox/profileAnalysisWorkerService.ts b/src/vs/platform/profiling/electron-sandbox/profileAnalysisWorkerService.ts
index ad6a25cd679..f862cc5944a 100644
--- a/src/vs/platform/profiling/electron-sandbox/profileAnalysisWorkerService.ts
+++ b/src/vs/platform/profiling/electron-sandbox/profileAnalysisWorkerService.ts
@@ -5,6 +5,7 @@
 
 
 import { DefaultWorkerFactory } from 'vs/base/browser/defaultWorkerFactory';
+import { FileAccess } from 'vs/base/common/network';
 import { URI } from 'vs/base/common/uri';
 import { SimpleWorkerClient } from 'vs/base/common/worker/simpleWorker';
 import { InstantiationType, registerSingleton } from 'vs/platform/instantiation/common/extensions';
@@ -41,7 +42,7 @@ class ProfileAnalysisWorkerService implements IProfileAnalysisWorkerService {
 
 	declare _serviceBrand: undefined;
 
-	private readonly _workerFactory = new DefaultWorkerFactory('CpuProfileAnalysis');
+	private readonly _workerFactory = new DefaultWorkerFactory(FileAccess.asBrowserUri('vs/base/worker/workerMain.js'), 'CpuProfileAnalysis');
 
 	constructor(
 		@ITelemetryService private readonly _telemetryService: ITelemetryService,
diff --git a/src/vs/workbench/api/worker/extensionHostWorker.esm.ts b/src/vs/workbench/api/worker/extensionHostWorker.esm.ts
new file mode 100644
index 00000000000..10a4278a7e5
--- /dev/null
+++ b/src/vs/workbench/api/worker/extensionHostWorker.esm.ts
@@ -0,0 +1,9 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { create } from './extensionHostWorker';
+
+const data = create();
+self.onmessage = (e) => data.onmessage(e.data);
diff --git a/src/vs/workbench/contrib/codeEditor/browser/workbenchEditorWorkerService.ts b/src/vs/workbench/contrib/codeEditor/browser/workbenchEditorWorkerService.ts
new file mode 100644
index 00000000000..5eb837a9509
--- /dev/null
+++ b/src/vs/workbench/contrib/codeEditor/browser/workbenchEditorWorkerService.ts
@@ -0,0 +1,24 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { FileAccess } from 'vs/base/common/network';
+import { EditorWorkerService } from 'vs/editor/browser/services/editorWorkerService';
+import { ILanguageConfigurationService } from 'vs/editor/common/languages/languageConfigurationRegistry';
+import { ILanguageFeaturesService } from 'vs/editor/common/services/languageFeatures';
+import { IModelService } from 'vs/editor/common/services/model';
+import { ITextResourceConfigurationService } from 'vs/editor/common/services/textResourceConfiguration';
+import { ILogService } from 'vs/platform/log/common/log';
+
+export class WorkbenchEditorWorkerService extends EditorWorkerService {
+	constructor(
+		@IModelService modelService: IModelService,
+		@ITextResourceConfigurationService configurationService: ITextResourceConfigurationService,
+		@ILogService logService: ILogService,
+		@ILanguageConfigurationService languageConfigurationService: ILanguageConfigurationService,
+		@ILanguageFeaturesService languageFeaturesService: ILanguageFeaturesService,
+	) {
+		super(FileAccess.asBrowserUri('vs/base/worker/workerMain.js'), modelService, configurationService, logService, languageConfigurationService, languageFeaturesService);
+	}
+}
diff --git a/src/vs/workbench/contrib/notebook/browser/services/notebookWorkerServiceImpl.ts b/src/vs/workbench/contrib/notebook/browser/services/notebookWorkerServiceImpl.ts
index 65980c57a9c..e643b5f0534 100644
--- a/src/vs/workbench/contrib/notebook/browser/services/notebookWorkerServiceImpl.ts
+++ b/src/vs/workbench/contrib/notebook/browser/services/notebookWorkerServiceImpl.ts
@@ -13,6 +13,7 @@ import { INotebookService } from 'vs/workbench/contrib/notebook/common/notebookS
 import { NotebookEditorSimpleWorker } from 'vs/workbench/contrib/notebook/common/services/notebookSimpleWorker';
 import { INotebookWorkerHost } from 'vs/workbench/contrib/notebook/common/services/notebookWorkerHost';
 import { INotebookEditorWorkerService } from 'vs/workbench/contrib/notebook/common/services/notebookWorkerService';
+import { FileAccess } from 'vs/base/common/network';
 
 export class NotebookEditorWorkerServiceImpl extends Disposable implements INotebookEditorWorkerService {
 	declare readonly _serviceBrand: undefined;
@@ -207,7 +208,7 @@ class NotebookWorkerClient extends Disposable {
 
 	constructor(private readonly _notebookService: INotebookService, label: string) {
 		super();
-		this._workerFactory = new DefaultWorkerFactory(label);
+		this._workerFactory = new DefaultWorkerFactory(FileAccess.asBrowserUri('vs/base/worker/workerMain.js'), label);
 		this._worker = null;
 		this._modelManager = null;
 
diff --git a/src/vs/workbench/contrib/notebook/common/services/notebookSimpleWorker.esm.ts b/src/vs/workbench/contrib/notebook/common/services/notebookSimpleWorker.esm.ts
new file mode 100644
index 00000000000..d288a2ebd9d
--- /dev/null
+++ b/src/vs/workbench/contrib/notebook/common/services/notebookSimpleWorker.esm.ts
@@ -0,0 +1,9 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { bootstrapSimpleWorker } from 'vs/base/common/worker/simpleWorkerBootstrap';
+import { create } from './notebookSimpleWorker';
+
+bootstrapSimpleWorker(create);
diff --git a/src/vs/workbench/contrib/output/browser/outputLinkProvider.ts b/src/vs/workbench/contrib/output/browser/outputLinkProvider.ts
index 3b82ad1889e..b9a82cf5584 100644
--- a/src/vs/workbench/contrib/output/browser/outputLinkProvider.ts
+++ b/src/vs/workbench/contrib/output/browser/outputLinkProvider.ts
@@ -9,7 +9,7 @@ import { IModelService } from 'vs/editor/common/services/model';
 import { ILink } from 'vs/editor/common/languages';
 import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
 import { OUTPUT_MODE_ID, LOG_MODE_ID } from 'vs/workbench/services/output/common/output';
-import { MonacoWebWorker, createWebWorker } from 'vs/editor/browser/services/webWorker';
+import { MonacoWebWorker, createWorkbenchWebWorker } from 'vs/editor/browser/services/webWorker';
 import { ICreateData, OutputLinkComputer } from 'vs/workbench/contrib/output/common/outputLinkComputer';
 import { IDisposable, dispose, Disposable } from 'vs/base/common/lifecycle';
 import { ILanguageConfigurationService } from 'vs/editor/common/languages/languageConfigurationRegistry';
@@ -73,7 +73,7 @@ export class OutputLinkProvider extends Disposable {
 				workspaceFolders: this.contextService.getWorkspace().folders.map(folder => folder.uri.toString())
 			};
 
-			this.worker = createWebWorker<OutputLinkComputer>(this.modelService, this.languageConfigurationService, {
+			this.worker = createWorkbenchWebWorker<OutputLinkComputer>(this.modelService, this.languageConfigurationService, {
 				moduleId: 'vs/workbench/contrib/output/common/outputLinkComputer',
 				createData,
 				label: 'outputLinkComputer'
diff --git a/src/vs/workbench/services/extensions/browser/webWorkerExtensionHost.ts b/src/vs/workbench/services/extensions/browser/webWorkerExtensionHost.ts
index 95e972cd752..02a4d6d344d 100644
--- a/src/vs/workbench/services/extensions/browser/webWorkerExtensionHost.ts
+++ b/src/vs/workbench/services/extensions/browser/webWorkerExtensionHost.ts
@@ -189,7 +189,7 @@ export class WebWorkerExtensionHost extends Disposable implements IExtensionHost
 					type: event.data.type,
 					data: {
 						baseUrl,
-						workerUrl: isESM ? FileAccess.asBrowserUri(factoryModuleId).toString(true) : require.toUrl(factoryModuleId),
+						workerUrl: isESM ? FileAccess.asBrowserUri('vs/workbench/api/worker/extensionHostWorker.esm.js').toString(true) : require.toUrl(factoryModuleId),
 						fileRoot: globalThis._VSCODE_FILE_ROOT,
 						nls: {
 							messages: globalThis._VSCODE_NLS_MESSAGES,
diff --git a/src/vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker.esm.ts b/src/vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker.esm.ts
new file mode 100644
index 00000000000..46e5fb85eba
--- /dev/null
+++ b/src/vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker.esm.ts
@@ -0,0 +1,10 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { LanguageDetectionSimpleWorker } from './languageDetectionSimpleWorker';
+import { bootstrapSimpleWorker } from 'vs/base/common/worker/simpleWorkerBootstrap';
+import { IEditorWorkerHost } from 'vs/editor/common/services/editorWorkerHost';
+
+bootstrapSimpleWorker<IEditorWorkerHost>(host => new LanguageDetectionSimpleWorker(host, () => { return {}; }));
diff --git a/src/vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker.ts b/src/vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker.ts
index f967fc38127..ad75f10f039 100644
--- a/src/vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker.ts
+++ b/src/vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker.ts
@@ -4,6 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import type { ModelOperations, ModelResult } from '@vscode/vscode-languagedetection';
+import { importAMDNodeModule } from 'vs/amdX';
 import { StopWatch } from 'vs/base/common/stopwatch';
 import { IRequestHandler } from 'vs/base/common/worker/simpleWorker';
 import { EditorSimpleWorker } from 'vs/editor/common/services/editorSimpleWorker';
@@ -103,7 +104,7 @@ export class LanguageDetectionSimpleWorker extends EditorSimpleWorker {
 		}
 		const uri: string = await this._host.fhr('getRegexpModelUri', []);
 		try {
-			this._regexpModel = await import(uri) as RegexpModel;
+			this._regexpModel = await importAMDNodeModule(uri, '') as RegexpModel;
 			return this._regexpModel;
 		} catch (e) {
 			this._regexpLoadFailed = true;
@@ -137,7 +138,7 @@ export class LanguageDetectionSimpleWorker extends EditorSimpleWorker {
 		}
 
 		const uri: string = await this._host.fhr('getIndexJsUri', []);
-		const { ModelOperations } = await import(uri) as typeof import('@vscode/vscode-languagedetection');
+		const { ModelOperations } = await importAMDNodeModule(uri, '') as typeof import('@vscode/vscode-languagedetection');
 		this._modelOperations = new ModelOperations({
 			modelJsonLoaderFunc: async () => {
 				const response = await fetch(await this._host.fhr('getModelJsonUri', []));
diff --git a/src/vs/workbench/services/languageDetection/browser/languageDetectionWorkerServiceImpl.ts b/src/vs/workbench/services/languageDetection/browser/languageDetectionWorkerServiceImpl.ts
index 1577e10f794..29256414c6c 100644
--- a/src/vs/workbench/services/languageDetection/browser/languageDetectionWorkerServiceImpl.ts
+++ b/src/vs/workbench/services/languageDetection/browser/languageDetectionWorkerServiceImpl.ts
@@ -24,6 +24,7 @@ import { IEditorService } from 'vs/workbench/services/editor/common/editorServic
 import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';
 import { LRUCache } from 'vs/base/common/map';
 import { ILogService } from 'vs/platform/log/common/log';
+import { canASAR } from 'vs/base/common/amd';
 
 const TOP_LANG_COUNTS = 12;
 
@@ -66,21 +67,22 @@ export class LanguageDetectionService extends Disposable implements ILanguageDet
 	) {
 		super();
 
+		const useAsar = canASAR && this._environmentService.isBuilt && !isWeb;
 		this._languageDetectionWorkerClient = this._register(new LanguageDetectionWorkerClient(
 			modelService,
 			languageService,
 			telemetryService,
-			// TODO: See if it's possible to bundle vscode-languagedetection
-			this._environmentService.isBuilt && !isWeb
+			// TODO@esm: See if it's possible to bundle vscode-languagedetection
+			useAsar
 				? FileAccess.asBrowserUri(`${moduleLocationAsar}/dist/lib/index.js`).toString(true)
 				: FileAccess.asBrowserUri(`${moduleLocation}/dist/lib/index.js`).toString(true),
-			this._environmentService.isBuilt && !isWeb
+			useAsar
 				? FileAccess.asBrowserUri(`${moduleLocationAsar}/model/model.json`).toString(true)
 				: FileAccess.asBrowserUri(`${moduleLocation}/model/model.json`).toString(true),
-			this._environmentService.isBuilt && !isWeb
+			useAsar
 				? FileAccess.asBrowserUri(`${moduleLocationAsar}/model/group1-shard1of1.bin`).toString(true)
 				: FileAccess.asBrowserUri(`${moduleLocation}/model/group1-shard1of1.bin`).toString(true),
-			this._environmentService.isBuilt && !isWeb
+			useAsar
 				? FileAccess.asBrowserUri(`${regexpModuleLocationAsar}/dist/index.js`).toString(true)
 				: FileAccess.asBrowserUri(`${regexpModuleLocation}/dist/index.js`).toString(true),
 			languageConfigurationService
@@ -234,7 +236,7 @@ export class LanguageDetectionWorkerClient extends EditorWorkerClient {
 		private readonly _regexpModelUri: string,
 		languageConfigurationService: ILanguageConfigurationService,
 	) {
-		super(modelService, true, 'languageDetectionWorkerService', languageConfigurationService);
+		super(FileAccess.asBrowserUri('vs/base/worker/workerMain.js'), modelService, true, 'languageDetectionWorkerService', languageConfigurationService);
 	}
 
 	private _getOrCreateLanguageDetectionWorker(): Promise<IWorkerClient<LanguageDetectionSimpleWorker>> {
diff --git a/src/vs/workbench/services/search/browser/searchService.ts b/src/vs/workbench/services/search/browser/searchService.ts
index f9aea8ee65a..7c8570a4622 100644
--- a/src/vs/workbench/services/search/browser/searchService.ts
+++ b/src/vs/workbench/services/search/browser/searchService.ts
@@ -21,7 +21,7 @@ import { InstantiationType, registerSingleton } from 'vs/platform/instantiation/
 import { ILocalFileSearchSimpleWorker, ILocalFileSearchSimpleWorkerHost } from 'vs/workbench/services/search/common/localFileSearchWorkerTypes';
 import { memoize } from 'vs/base/common/decorators';
 import { HTMLFileSystemProvider } from 'vs/platform/files/browser/htmlFileSystemProvider';
-import { Schemas } from 'vs/base/common/network';
+import { FileAccess, Schemas } from 'vs/base/common/network';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { Emitter, Event } from 'vs/base/common/event';
 import { localize } from 'vs/nls';
@@ -64,7 +64,7 @@ export class LocalFileSearchWorkerClient extends Disposable implements ISearchRe
 	) {
 		super();
 		this._worker = null;
-		this._workerFactory = new DefaultWorkerFactory('localFileSearchWorker');
+		this._workerFactory = new DefaultWorkerFactory(FileAccess.asBrowserUri('vs/base/worker/workerMain.js'), 'localFileSearchWorker');
 	}
 
 	sendTextSearchMatch(match: IFileMatch<UriComponents>, queryId: number): void {
diff --git a/src/vs/workbench/services/search/worker/localFileSearch.esm.ts b/src/vs/workbench/services/search/worker/localFileSearch.esm.ts
new file mode 100644
index 00000000000..fadd727c58f
--- /dev/null
+++ b/src/vs/workbench/services/search/worker/localFileSearch.esm.ts
@@ -0,0 +1,9 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { bootstrapSimpleWorker } from 'vs/base/common/worker/simpleWorkerBootstrap';
+import { create } from 'vs/workbench/services/search/worker/localFileSearch';
+
+bootstrapSimpleWorker(create);
diff --git a/src/vs/workbench/services/textMate/browser/backgroundTokenization/threadedBackgroundTokenizerFactory.ts b/src/vs/workbench/services/textMate/browser/backgroundTokenization/threadedBackgroundTokenizerFactory.ts
index ee9f5a9f1ca..1a54e0d1bb6 100644
--- a/src/vs/workbench/services/textMate/browser/backgroundTokenization/threadedBackgroundTokenizerFactory.ts
+++ b/src/vs/workbench/services/textMate/browser/backgroundTokenization/threadedBackgroundTokenizerFactory.ts
@@ -128,23 +128,15 @@ export class ThreadedBackgroundTokenizerFactory implements IDisposable {
 	}
 
 	private async _createWorkerProxy(): Promise<TextMateTokenizationWorker | null> {
-		const textmateModuleLocation: AppResourcePath = `${nodeModulesPath}/vscode-textmate`;
-		const textmateModuleLocationAsar: AppResourcePath = `${nodeModulesAsarPath}/vscode-textmate`;
 		const onigurumaModuleLocation: AppResourcePath = `${nodeModulesPath}/vscode-oniguruma`;
 		const onigurumaModuleLocationAsar: AppResourcePath = `${nodeModulesAsarPath}/vscode-oniguruma`;
 
 		const useAsar = canASAR && this._environmentService.isBuilt && !isWeb;
-		const textmateLocation: AppResourcePath = useAsar ? textmateModuleLocationAsar : textmateModuleLocation;
 		const onigurumaLocation: AppResourcePath = useAsar ? onigurumaModuleLocationAsar : onigurumaModuleLocation;
-		const textmateMain: AppResourcePath = `${textmateLocation}/release/main.js`;
-		const onigurumaMain: AppResourcePath = `${onigurumaLocation}/release/main.js`;
 		const onigurumaWASM: AppResourcePath = `${onigurumaLocation}/release/onig.wasm`;
-		const uri = FileAccess.asBrowserUri(textmateMain).toString(true);
 
 		const createData: ICreateData = {
 			grammarDefinitions: this._grammarDefinitions,
-			textmateMainUri: uri,
-			onigurumaMainUri: FileAccess.asBrowserUri(onigurumaMain).toString(true),
 			onigurumaWASMUri: FileAccess.asBrowserUri(onigurumaWASM).toString(true),
 		};
 		const host: ITextMateWorkerHost = {
diff --git a/src/vs/workbench/services/textMate/browser/backgroundTokenization/worker/textMateTokenizationWorker.worker.ts b/src/vs/workbench/services/textMate/browser/backgroundTokenization/worker/textMateTokenizationWorker.worker.ts
index 3974d642732..28a58f6837d 100644
--- a/src/vs/workbench/services/textMate/browser/backgroundTokenization/worker/textMateTokenizationWorker.worker.ts
+++ b/src/vs/workbench/services/textMate/browser/backgroundTokenization/worker/textMateTokenizationWorker.worker.ts
@@ -11,6 +11,7 @@ import { ICreateGrammarResult, TMGrammarFactory } from 'vs/workbench/services/te
 import { IValidEmbeddedLanguagesMap, IValidGrammarDefinition, IValidTokenTypeMap } from 'vs/workbench/services/textMate/common/TMScopeRegistry';
 import type { IOnigLib, IRawTheme, StackDiff } from 'vscode-textmate';
 import { TextMateWorkerTokenizer } from './textMateWorkerTokenizer';
+import { importAMDNodeModule } from 'vs/amdX';
 
 /**
  * Defines the worker entry point. Must be exported and named `create`.
@@ -27,8 +28,6 @@ export interface ITextMateWorkerHost {
 
 export interface ICreateData {
 	grammarDefinitions: IValidGrammarDefinitionDTO[];
-	textmateMainUri: string;
-	onigurumaMainUri: string;
 	onigurumaWASMUri: string;
 }
 
@@ -78,9 +77,8 @@ export class TextMateTokenizationWorker {
 	}
 
 	private async _loadTMGrammarFactory(grammarDefinitions: IValidGrammarDefinition[]): Promise<TMGrammarFactory> {
-		const uri = this._createData.textmateMainUri;
-		const vscodeTextmate = await import(uri);
-		const vscodeOniguruma = await import(this._createData.onigurumaMainUri);
+		const vscodeTextmate = await importAMDNodeModule<typeof import('vscode-textmate')>('vscode-textmate', 'release/main.js');
+		const vscodeOniguruma = await importAMDNodeModule<typeof import('vscode-oniguruma')>('vscode-oniguruma', 'release/main.js');
 		const response = await fetch(this._createData.onigurumaWASMUri);
 
 		// Using the response directly only works if the server sets the MIME type 'application/wasm'.
diff --git a/src/vs/workbench/workbench.common.main.ts b/src/vs/workbench/workbench.common.main.ts
index f8d24e3f5fd..9e2c97b4a68 100644
--- a/src/vs/workbench/workbench.common.main.ts
+++ b/src/vs/workbench/workbench.common.main.ts
@@ -129,7 +129,7 @@ import { ContextViewService } from 'vs/platform/contextview/browser/contextViewS
 import { IContextViewService } from 'vs/platform/contextview/browser/contextView';
 import { IListService, ListService } from 'vs/platform/list/browser/listService';
 import { IEditorWorkerService } from 'vs/editor/common/services/editorWorker';
-import { EditorWorkerService } from 'vs/editor/browser/services/editorWorkerService';
+import { WorkbenchEditorWorkerService } from 'vs/workbench/contrib/codeEditor/browser/workbenchEditorWorkerService';
 import { MarkerDecorationsService } from 'vs/editor/common/services/markerDecorationsService';
 import { IMarkerDecorationsService } from 'vs/editor/common/services/markerDecorations';
 import { IMarkerService } from 'vs/platform/markers/common/markers';
@@ -154,7 +154,7 @@ registerSingleton(IExtensionStorageService, ExtensionStorageService, Instantiati
 registerSingleton(IExtensionGalleryService, ExtensionGalleryService, InstantiationType.Delayed);
 registerSingleton(IContextViewService, ContextViewService, InstantiationType.Delayed);
 registerSingleton(IListService, ListService, InstantiationType.Delayed);
-registerSingleton(IEditorWorkerService, EditorWorkerService, InstantiationType.Eager /* registers link detection and word based suggestions for any document */);
+registerSingleton(IEditorWorkerService, WorkbenchEditorWorkerService, InstantiationType.Eager /* registers link detection and word based suggestions for any document */);
 registerSingleton(IMarkerDecorationsService, MarkerDecorationsService, InstantiationType.Delayed);
 registerSingleton(IMarkerService, MarkerService, InstantiationType.Delayed);
 registerSingleton(IContextKeyService, ContextKeyService, InstantiationType.Delayed);
diff --git a/test/monaco/dist/core.html b/test/monaco/dist/core.html
index 35f656becf1..13a208944b1 100644
--- a/test/monaco/dist/core.html
+++ b/test/monaco/dist/core.html
@@ -5,6 +5,9 @@
 </head>
 <body>
 	<div id="container" style="width:800px;height:600px;border:1px solid #ccc"></div>
+	<script>
+		globalThis._VSCODE_FILE_ROOT = 'http://127.0.0.1:8563/dist/';
+	</script>
 	<script src="./core.bundle.js"></script>
 </body>
 </html>