VSCode 技术揭秘（一）

├── build         # gulp编译构建脚本├── extensions    # 内置插件├── gulpfile.js   # gulp task├── out           # 编译输出目录├── resources     # 平台相关静态资源，图标等├── scripts       # 工具脚本，开发/测试├── src           # 源码目录├── test          # 测试套件└── product.json  # App meta信息

├── bootstrap-amd.js    # 子进程实际入口├── bootstrap-fork.js   #├── bootstrap-window.js #├── bootstrap.js        # 子进程环境初始化├── buildfile.js        # 构建config├── cli.js              # CLI入口├── main.js             # 主进程入口├── paths.js            # AppDataPath与DefaultUserDataPath├── typings│   └── xxx.d.ts        # ts类型声明└── vs    ├── base            # 定义基础的工具方法和基础的 DOM UI 控件    │   ├── browser     # 基础UI组件，DOM操作、交互事件、DnD等    │   ├── common      # diff描述，markdown解析器，worker协议，各种工具函数    │   ├── node        # Node工具函数    │   ├── parts       # IPC协议（Electron、Node），quickopen、tree组件    │   ├── test        # base单测用例    │   └── worker      # Worker factory 和 main Worker（运行IDE Core：Monaco）    ├── code            # VSCode Electron 应用的入口，包括 Electron 的主进程脚本入口    │   ├── electron-browser # 需要 Electron 渲染器处理API的源代码（可以使用 common, browser, node）    │   ├── electron-main    # 需要Electron主进程API的源代码（可以使用 common, node）    │   ├── node        # 需要Electron主进程API的源代码（可以使用 common, node）    │   ├── test    │   └── code.main.ts    ├── editor          # Monaco Editor 代码编辑器：其中包含单独打包发布的 Monaco Editor 和只能在 VSCode 的使用的部分    │   ├── browser     # 代码编辑器核心    │   ├── common      # 代码编辑器核心    │   ├── contrib     # vscode 与独立 IDE共享的代码    │   ├── standalone  # 独立 IDE 独有的代码    │   ├── test    │   ├── editor.all.ts    │   ├── editor.api.ts    │   ├── editor.main.ts    │   └── editor.worker.ts    ├── platform        # 依赖注入的实现和 VSCode 使用的基础服务 Services    ├── workbench       # VSCode 桌面应用程序工作台的实现    ├── buildunit.json    ├── css.build.js    # 用于插件构建的CSS loader    ├── css.js          # CSS loader    ├── loader.js       # AMD loader（用于异步加载AMD模块，类似于require.js）    ├── nls.build.js    # 用于插件构建的 NLS loader    └── nls.js          # NLS（National Language Support）多语言loader

"outDir": "../out",

const app = require('electron').app;

// Load our code once readyapp.once('ready', function () {  if (args['trace']) {    // @ts-ignore    const contentTracing = require('electron').contentTracing;
    const traceOptions = {      categoryFilter: args['trace-category-filter'] || '*',      traceOptions: args['trace-options'] || 'record-until-full,enable-sampling'    };
    contentTracing.startRecording(traceOptions, () => onReady());  } else {    onReady();  }});

function onReady() {  perf.mark('main:appReady');
  Promise.all([nodeCachedDataDir.ensureExists(), userDefinedLocale]).then(([cachedDataDir, locale]) => {    if (locale && !nlsConfiguration) {      nlsConfiguration = lp.getNLSConfiguration(product.commit, userDataPath, metaDataFile, locale);    }
    if (!nlsConfiguration) {      nlsConfiguration = Promise.resolve(undefined);    }
    // First, we need to test a user defined locale. If it fails we try the app locale.    // If that fails we fall back to English.    nlsConfiguration.then(nlsConfig => {
      const startup = nlsConfig => {        nlsConfig._languagePackSupport = true;        process.env['VSCODE_NLS_CONFIG'] = JSON.stringify(nlsConfig);        process.env['VSCODE_NODE_CACHED_DATA_DIR'] = cachedDataDir || '';
        // Load main in AMD        perf.mark('willLoadMainBundle');        require('./bootstrap-amd').load('vs/code/electron-main/main', () => {          perf.mark('didLoadMainBundle');        });      };
      // We received a valid nlsConfig from a user defined locale      if (nlsConfig) {        startup(nlsConfig);      }
      // Try to use the app locale. Please note that the app locale is only      // valid after we have received the app ready event. This is why the      // code is here.      else {        let appLocale = app.getLocale();        if (!appLocale) {          startup({ locale: 'en', availableLanguages: {} });        } else {
          // See above the comment about the loader and case sensitiviness          appLocale = appLocale.toLowerCase();
          lp.getNLSConfiguration(product.commit, userDataPath, metaDataFile, appLocale).then(nlsConfig => {            if (!nlsConfig) {              nlsConfig = { locale: appLocale, availableLanguages: {} };            }
            startup(nlsConfig);          });        }      }    });  }, console.error);}

const startup = nlsConfig => {    nlsConfig._languagePackSupport = true;    process.env['VSCODE_NLS_CONFIG'] = JSON.stringify(nlsConfig);    process.env['VSCODE_NODE_CACHED_DATA_DIR'] = cachedDataDir || '';
    // Load main in AMD    perf.mark('willLoadMainBundle');    require('./bootstrap-amd').load('vs/code/electron-main/main', () => {        perf.mark('didLoadMainBundle');    });};

const loader = require('./vs/loader');

// src/vs/code/electron-main/mainclass CodeMain {  main(): void {    ...    // Launch    this.startup(args);  }
  private async startup(args: ParsedArgs): Promise<void> {
    // We need to buffer the spdlog logs until we are sure    // we are the only instance running, otherwise we'll have concurrent    // log file access on Windows (https://github.com/Microsoft/vscode/issues/41218)    const bufferLogService = new BufferLogService();
    const [instantiationService, instanceEnvironment] = this.createServices(args, bufferLogService);    try {
      // Init services      await instantiationService.invokeFunction(async accessor => {        const environmentService = accessor.get(IEnvironmentService);        const configurationService = accessor.get(IConfigurationService);        const stateService = accessor.get(IStateService);
        try {          await this.initServices(environmentService, configurationService as ConfigurationService, stateService as StateService);        } catch (error) {
          // Show a dialog for errors that can be resolved by the user          this.handleStartupDataDirError(environmentService, error);
          throw error;        }      });
      // Startup      await instantiationService.invokeFunction(async accessor => {        const environmentService = accessor.get(IEnvironmentService);        const logService = accessor.get(ILogService);        const lifecycleMainService = accessor.get(ILifecycleMainService);        const configurationService = accessor.get(IConfigurationService);
        const mainIpcServer = await this.doStartup(logService, environmentService, lifecycleMainService, instantiationService, true);
        bufferLogService.logger = new SpdLogService('main', environmentService.logsPath, bufferLogService.getLevel());        once(lifecycleMainService.onWillShutdown)(() => (configurationService as ConfigurationService).dispose());
        return instantiationService.createInstance(CodeApplication, mainIpcServer, instanceEnvironment).startup();      });    } catch (error) {      instantiationService.invokeFunction(this.quit, error);    }  }
  private createServices(args: ParsedArgs, bufferLogService: BufferLogService): [IInstantiationService, typeof process.env] {    const services = new ServiceCollection();
    const environmentService = new EnvironmentService(args, process.execPath);    const instanceEnvironment = this.patchEnvironment(environmentService); // Patch `process.env` with the instance's environment    services.set(IEnvironmentService, environmentService);
    const logService = new MultiplexLogService([new ConsoleLogMainService(getLogLevel(environmentService)), bufferLogService]);    process.once('exit', () => logService.dispose());    services.set(ILogService, logService);
    services.set(IConfigurationService, new ConfigurationService(environmentService.settingsResource));    services.set(ILifecycleMainService, new SyncDescriptor(LifecycleMainService));    services.set(IStateService, new SyncDescriptor(StateService));    services.set(IRequestService, new SyncDescriptor(RequestMainService));    services.set(IThemeMainService, new SyncDescriptor(ThemeMainService));    services.set(ISignService, new SyncDescriptor(SignService));
    return [new InstantiationService(services, true), instanceEnvironment];  }  ...}
// Main Startupconst code = new CodeMain();code.main();

private createServices(args: ParsedArgs, bufferLogService: BufferLogService): [IInstantiationService, typeof process.env] {    const services = new ServiceCollection();
    const environmentService = new EnvironmentService(args, process.execPath);    const instanceEnvironment = this.patchEnvironment(environmentService); // Patch `process.env` with the instance's environment    // environmentService 一些基本配置，包括运行目录、用户数据目录、工作区缓存目录等    services.set(IEnvironmentService, environmentService);
    const logService = new MultiplexLogService([new ConsoleLogMainService(getLogLevel(environmentService)), bufferLogService]);    process.once('exit', () => logService.dispose());    // logService 日志服务    services.set(ILogService, logService);
    // ConfigurationService 配置项    services.set(IConfigurationService, new ConfigurationService(environmentService.settingsResource));    // LifecycleService 生命周期相关的一些方法    services.set(ILifecycleMainService, new SyncDescriptor(LifecycleMainService));    // StateService 持久化数据    services.set(IStateService, new SyncDescriptor(StateService));    // RequestService 请求服务    services.set(IRequestService, new SyncDescriptor(RequestMainService));    services.set(IThemeMainService, new SyncDescriptor(ThemeMainService));    services.set(ISignService, new SyncDescriptor(SignService));
    return [new InstantiationService(services, true), instanceEnvironment];  }

return instantiationService.createInstance(CodeApplication, mainIpcServer,instanceEnvironment).startup();

//src/vs/code/electron-main/app.tsexport class CodeApplication extends Disposable {  ...  async startup(): Promise<void> {    this.logService.debug('Starting VS Code');    this.logService.debug(`from: ${this.environmentService.appRoot}`);    this.logService.debug('args:', this.environmentService.args);
    // Make sure we associate the program with the app user model id    // This will help Windows to associate the running program with    // any shortcut that is pinned to the taskbar and prevent showing    // two icons in the taskbar for the same app.    const win32AppUserModelId = product.win32AppUserModelId;    if (isWindows && win32AppUserModelId) {      app.setAppUserModelId(win32AppUserModelId);    }
    // Fix native tabs on macOS 10.13    // macOS enables a compatibility patch for any bundle ID beginning with    // "com.microsoft.", which breaks native tabs for VS Code when using this    // identifier (from the official build).    // Explicitly opt out of the patch here before creating any windows.    // See: https://github.com/Microsoft/vscode/issues/35361#issuecomment-399794085    try {      if (isMacintosh && this.configurationService.getValue<boolean>('window.nativeTabs') === true && !systemPreferences.getUserDefault('NSUseImprovedLayoutPass', 'boolean')) {        systemPreferences.setUserDefault('NSUseImprovedLayoutPass', 'boolean', true as any);      }    } catch (error) {      this.logService.error(error);    }
    // Create Electron IPC Server    const electronIpcServer = new ElectronIPCServer();
    // Resolve unique machine ID    this.logService.trace('Resolving machine identifier...');    const { machineId, trueMachineId } = await this.resolveMachineId();    this.logService.trace(`Resolved machine identifier: ${machineId} (trueMachineId: ${trueMachineId})`);
    // Spawn shared process after the first window has opened and 3s have passed    const sharedProcess = this.instantiationService.createInstance(SharedProcess, machineId, this.userEnv);    const sharedProcessClient = sharedProcess.whenReady().then(() => connect(this.environmentService.sharedIPCHandle, 'main'));    this.lifecycleMainService.when(LifecycleMainPhase.AfterWindowOpen).then(() => {      this._register(new RunOnceScheduler(async () => {        const userEnv = await getShellEnvironment(this.logService, this.environmentService);
        sharedProcess.spawn(userEnv);      }, 3000)).schedule();    });
    // Services    const appInstantiationService = await this.createServices(machineId, trueMachineId, sharedProcess, sharedProcessClient);
    // Create driver    if (this.environmentService.driverHandle) {      const server = await serveDriver(electronIpcServer, this.environmentService.driverHandle!, this.environmentService, appInstantiationService);
      this.logService.info('Driver started at:', this.environmentService.driverHandle);      this._register(server);    }
    // Setup Auth Handler    this._register(new ProxyAuthHandler());
    // Open Windows    const windows = appInstantiationService.invokeFunction(accessor => this.openFirstWindow(accessor, electronIpcServer, sharedProcessClient));
    // Post Open Windows Tasks    this.afterWindowOpen();
    // Tracing: Stop tracing after windows are ready if enabled    if (this.environmentService.args.trace) {      this.stopTracingEventually(windows);    }  }
  ...
  private openFirstWindow(accessor: ServicesAccessor, electronIpcServer: ElectronIPCServer, sharedProcessClient: Promise<Client<string>>): ICodeWindow[] {
    // Register more Main IPC services    const launchMainService = accessor.get(ILaunchMainService);    const launchChannel = createChannelReceiver(launchMainService, { disableMarshalling: true });    this.mainIpcServer.registerChannel('launch', launchChannel);
    // Register more Electron IPC services    const updateService = accessor.get(IUpdateService);    const updateChannel = new UpdateChannel(updateService);    electronIpcServer.registerChannel('update', updateChannel);
    const issueService = accessor.get(IIssueService);    const issueChannel = createChannelReceiver(issueService);    electronIpcServer.registerChannel('issue', issueChannel);
    const electronService = accessor.get(IElectronService);    const electronChannel = createChannelReceiver(electronService);    electronIpcServer.registerChannel('electron', electronChannel);    sharedProcessClient.then(client => client.registerChannel('electron', electronChannel));
    const sharedProcessMainService = accessor.get(ISharedProcessMainService);    const sharedProcessChannel = createChannelReceiver(sharedProcessMainService);    electronIpcServer.registerChannel('sharedProcess', sharedProcessChannel);
    const workspacesService = accessor.get(IWorkspacesService);    const workspacesChannel = createChannelReceiver(workspacesService);    electronIpcServer.registerChannel('workspaces', workspacesChannel);
    const menubarService = accessor.get(IMenubarService);    const menubarChannel = createChannelReceiver(menubarService);    electronIpcServer.registerChannel('menubar', menubarChannel);
    const urlService = accessor.get(IURLService);    const urlChannel = createChannelReceiver(urlService);    electronIpcServer.registerChannel('url', urlChannel);
    const storageMainService = accessor.get(IStorageMainService);    const storageChannel = this._register(new GlobalStorageDatabaseChannel(this.logService, storageMainService));    electronIpcServer.registerChannel('storage', storageChannel);
    const loggerChannel = new LoggerChannel(accessor.get(ILogService));    electronIpcServer.registerChannel('logger', loggerChannel);    sharedProcessClient.then(client => client.registerChannel('logger', loggerChannel));
    // ExtensionHost Debug broadcast service    electronIpcServer.registerChannel(ExtensionHostDebugBroadcastChannel.ChannelName, new ExtensionHostDebugBroadcastChannel());
    // Signal phase: ready (services set)    this.lifecycleMainService.phase = LifecycleMainPhase.Ready;
    // Propagate to clients    const windowsMainService = this.windowsMainService = accessor.get(IWindowsMainService);    this.dialogMainService = accessor.get(IDialogMainService);
    // Create a URL handler to open file URIs in the active window    const environmentService = accessor.get(IEnvironmentService);    urlService.registerHandler({      async handleURL(uri: URI, options?: IOpenURLOptions): Promise<boolean> {
        // Catch file URLs        if (uri.authority === Schemas.file && !!uri.path) {          const cli = assign(Object.create(null), environmentService.args);          const urisToOpen = [{ fileUri: URI.file(uri.fsPath) }];
          windowsMainService.open({ context: OpenContext.API, cli, urisToOpen, gotoLineMode: true });
          return true;        }
        return false;      }    });
    // Create a URL handler which forwards to the last active window    const activeWindowManager = new ActiveWindowManager(electronService);    const activeWindowRouter = new StaticRouter(ctx => activeWindowManager.getActiveClientId().then(id => ctx === id));    const urlHandlerRouter = new URLHandlerRouter(activeWindowRouter);    const urlHandlerChannel = electronIpcServer.getChannel('urlHandler', urlHandlerRouter);    const multiplexURLHandler = new URLHandlerChannelClient(urlHandlerChannel);
    // On Mac, Code can be running without any open windows, so we must create a window to handle urls,    // if there is none    if (isMacintosh) {      urlService.registerHandler({        async handleURL(uri: URI, options?: IOpenURLOptions): Promise<boolean> {          if (windowsMainService.getWindowCount() === 0) {            const cli = { ...environmentService.args };            const [window] = windowsMainService.open({ context: OpenContext.API, cli, forceEmpty: true, gotoLineMode: true });
            await window.ready();
            return urlService.open(uri);          }
          return false;        }      });    }
    // Register the multiple URL handler    urlService.registerHandler(multiplexURLHandler);
    // Watch Electron URLs and forward them to the UrlService    const args = this.environmentService.args;    const urls = args['open-url'] ? args._urls : [];    const urlListener = new ElectronURLListener(urls || [], urlService, windowsMainService);    this._register(urlListener);
    // Open our first window    const macOpenFiles: string[] = (<any>global).macOpenFiles;    const context = !!process.env['VSCODE_CLI'] ? OpenContext.CLI : OpenContext.DESKTOP;    const hasCliArgs = args._.length;    const hasFolderURIs = !!args['folder-uri'];    const hasFileURIs = !!args['file-uri'];    const noRecentEntry = args['skip-add-to-recently-opened'] === true;    const waitMarkerFileURI = args.wait && args.waitMarkerFilePath ? URI.file(args.waitMarkerFilePath) : undefined;
    // new window if "-n" was used without paths    if (args['new-window'] && !hasCliArgs && !hasFolderURIs && !hasFileURIs) {      return windowsMainService.open({        context,        cli: args,        forceNewWindow: true,        forceEmpty: true,        noRecentEntry,        waitMarkerFileURI,        initialStartup: true      });    }
    // mac: open-file event received on startup    if (macOpenFiles && macOpenFiles.length && !hasCliArgs && !hasFolderURIs && !hasFileURIs) {      return windowsMainService.open({        context: OpenContext.DOCK,        cli: args,        urisToOpen: macOpenFiles.map(file => this.getWindowOpenableFromPathSync(file)),        noRecentEntry,        waitMarkerFileURI,        gotoLineMode: false,        initialStartup: true      });    }
    // default: read paths from cli    return windowsMainService.open({      context,      cli: args,      forceNewWindow: args['new-window'] || (!hasCliArgs && args['unity-launch']),      diffMode: args.diff,      noRecentEntry,      waitMarkerFileURI,      gotoLineMode: args.goto,      initialStartup: true    });  }  ...}

open(openConfig: IOpenConfiguration): ICodeWindow[] {    ...
    // Open based on config    const usedWindows = this.doOpen(openConfig, workspacesToOpen, foldersToOpen,     ...  }

private doOpen(    openConfig: IOpenConfiguration,    workspacesToOpen: IWorkspacePathToOpen[],    foldersToOpen: IFolderPathToOpen[],    emptyToRestore: IEmptyWindowBackupInfo[],    emptyToOpen: number,    fileInputs: IFileInputs | undefined,    foldersToAdd: IFolderPathToOpen[]  ) {    const usedWindows: ICodeWindow[] = [];
    ...
    // Handle empty to open (only if no other window opened)    if (usedWindows.length === 0 || fileInputs) {      if (fileInputs && !emptyToOpen) {        emptyToOpen++;      }
      const remoteAuthority = fileInputs ? fileInputs.remoteAuthority : (openConfig.cli && openConfig.cli.remote || undefined);
      for (let i = 0; i < emptyToOpen; i++) {        usedWindows.push(this.openInBrowserWindow({          userEnv: openConfig.userEnv,          cli: openConfig.cli,          initialStartup: openConfig.initialStartup,          remoteAuthority,          forceNewWindow: openFolderInNewWindow,          forceNewTabbedWindow: openConfig.forceNewTabbedWindow,          fileInputs        }));
        // Reset these because we handled them        fileInputs = undefined;        openFolderInNewWindow = true; // any other window to open must open in new window then      }    }
    return arrays.distinct(usedWindows);  }

private openInBrowserWindow(options: IOpenBrowserWindowOptions): ICodeWindow {
    ...
    // Create the window    window = this.instantiationService.createInstance(CodeWindow, {      state,      extensionDevelopmentPath: configuration.extensionDevelopmentPath,      isExtensionTestHost: !!configuration.extensionTestsPath    });    ...
    // If the window was already loaded, make sure to unload it    // first and only load the new configuration if that was    // not vetoed    if (window.isReady) {      this.lifecycleMainService.unload(window, UnloadReason.LOAD).then(veto => {        if (!veto) {          this.doOpenInBrowserWindow(window!, configuration, options);        }      });    } else {      this.doOpenInBrowserWindow(window, configuration, options);    }
    return window;  }

//src/vs/code/electron-main/window.tsexport class CodeWindow extends Disposable implements ICodeWindow {
  ...
  constructor(    config: IWindowCreationOptions,    @ILogService private readonly logService: ILogService,    @IEnvironmentService private readonly environmentService: IEnvironmentService,    @IFileService private readonly fileService: IFileService,    @IConfigurationService private readonly configurationService: IConfigurationService,    @IThemeMainService private readonly themeMainService: IThemeMainService,    @IWorkspacesMainService private readonly workspacesMainService: IWorkspacesMainService,    @IBackupMainService private readonly backupMainService: IBackupMainService,  ) {    super();
    this.touchBarGroups = [];    this._lastFocusTime = -1;    this._readyState = ReadyState.NONE;    this.whenReadyCallbacks = [];
    // create browser window    this.createBrowserWindow(config);
    // respect configured menu bar visibility    this.onConfigurationUpdated();
    // macOS: touch bar support    this.createTouchBar();
    // Request handling    this.handleMarketplaceRequests();
    // Eventing    this.registerListeners();  }
  private createBrowserWindow(config: IWindowCreationOptions): void {
    ...    // Create the browser window.    this._win = new BrowserWindow(options);    ...  }}

private doOpenInBrowserWindow(window: ICodeWindow, configuration: IWindowConfiguration, options: IOpenBrowserWindowOptions): void {    ...    // Load it    window.load(configuration);    ...  }

load(config: IWindowConfiguration, isReload?: boolean, disableExtensions?: boolean): void {  ...  // Load URL  perf.mark('main:loadWindow');  this._win.loadURL(this.getUrl(configuration));  ...}

private getUrl(windowConfiguration: IWindowConfiguration): string {
    ...    let configUrl = this.doGetUrl(config);    ...
    return configUrl;  }

private doGetUrl(config: object): string {  return `${require.toUrl('vs/code/electron-browser/workbench/workbench.html')}?config=${encodeURIComponent(JSON.stringify(config))}`;}

//src/vs/code/electron-browser/workbench/workbench.html<!-- Copyright (C) Microsoft Corporation. All rights reserved. --><!DOCTYPE html><html>  <head>    <meta charset="utf-8" />    <meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src 'self' https: data: blob: vscode-remote-resource:; media-src 'none'; frame-src 'self' https://*.vscode-webview-test.com; object-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self' https:; font-src 'self' https: vscode-remote-resource:;">  </head>  <body class="vs-dark" aria-label="">  </body>
  <!-- Startup via workbench.js -->  <script src="workbench.js"></script></html>

// src/vs/code/electron-browser/workbench/workbench.jsconst bootstrapWindow = require('../../../../bootstrap-window');
// Setup shell environmentprocess['lazyEnv'] = getLazyEnv();
// Load workbench main JS, CSS and NLS all in parallel. This is an// optimization to prevent a waterfall of loading to happen, because// we know for a fact that workbench.desktop.main will depend on// the related CSS and NLS counterparts.bootstrapWindow.load([  'vs/workbench/workbench.desktop.main',  'vs/nls!vs/workbench/workbench.desktop.main',  'vs/css!vs/workbench/workbench.desktop.main'],  function (workbench, configuration) {    perf.mark('didLoadWorkbenchMain');
    return process['lazyEnv'].then(function () {      perf.mark('main/startup');
      // @ts-ignore      //加载 Workbench 并初始化主界面      return require('vs/workbench/electron-browser/desktop.main').main(configuration);    });  }, {    removeDeveloperKeybindingsAfterLoad: true,    canModifyDOM: function (windowConfig) {      showPartsSplash(windowConfig);    },    beforeLoaderConfig: function (windowConfig, loaderConfig) {      loaderConfig.recordStats = true;    },    beforeRequire: function () {      perf.mark('willLoadWorkbenchMain');    }  });

class DesktopMain extends Disposable {
  async open(): Promise<void> {    ...
    // Create Workbench    const workbench = new Workbench(document.body, services.serviceCollection, services.logService);
    // Listeners    this.registerListeners(workbench, services.storageService);
    // Startup    const instantiationService = workbench.startup();    ...  }  ...}
export function main(configuration: IWindowConfiguration): Promise<void> {  const renderer = new DesktopMain(configuration);  return renderer.open();}

export class Workbench extends Layout {
  ...  startup(): IInstantiationService {    try {
      // Configure emitter leak warning threshold      setGlobalLeakWarningThreshold(175);
      // ARIA      setARIAContainer(document.body);
      // Services      const instantiationService = this.initServices(this.serviceCollection);
      instantiationService.invokeFunction(async accessor => {        const lifecycleService = accessor.get(ILifecycleService);        const storageService = accessor.get(IStorageService);        const configurationService = accessor.get(IConfigurationService);
        // Layout        this.initLayout(accessor);
        // Registries        this.startRegistries(accessor);
        // Context Keys        this._register(instantiationService.createInstance(WorkbenchContextKeysHandler));
        // Register Listeners        this.registerListeners(lifecycleService, storageService, configurationService);
        // Render Workbench        this.renderWorkbench(instantiationService, accessor.get(INotificationService) as NotificationService, storageService, configurationService);
        // Workbench Layout        this.createWorkbenchLayout(instantiationService);
        // Layout        this.layout();
        // Restore        try {          await this.restoreWorkbench(accessor.get(IEditorService), accessor.get(IEditorGroupsService), accessor.get(IViewletService), accessor.get(IPanelService), accessor.get(ILogService), lifecycleService);        } catch (error) {          onUnexpectedError(error);        }      });
      return instantiationService;    } catch (error) {      onUnexpectedError(error);
      throw error; // rethrow because this is a critical issue we cannot handle properly here    }  }  ...}

{  "nameShort": "Code - OSS",  "nameLong": "Code - OSS",  "applicationName": "code-oss",  "dataFolderName": ".vscode-oss",  "win32MutexName": "vscodeoss",  "licenseName": "MIT",  "licenseUrl": "https://github.com/Microsoft/vscode/blob/master/LICENSE.txt",  "win32DirName": "Microsoft Code OSS",  "win32NameVersion": "Microsoft Code OSS",  "win32RegValueName": "CodeOSS",  "win32AppId": "{{E34003BB-9E10-4501-8C11-BE3FAA83F23F}",  "win32x64AppId": "{{D77B7E06-80BA-4137-BCF4-654B95CCEBC5}",  "win32UserAppId": "{{C6065F05-9603-4FC4-8101-B9781A25D88E}",  "win32x64UserAppId": "{{C6065F05-9603-4FC4-8101-B9781A25D88E}",  "win32AppUserModelId": "Microsoft.CodeOSS",  "win32ShellNameShort": "C&ode - OSS",  "darwinBundleIdentifier": "com.visualstudio.code.oss",  "linuxIconName": "com.visualstudio.code.oss",  "licenseFileName": "LICENSE.txt",  "reportIssueUrl": "https://github.com/Microsoft/vscode/issues/new",  "urlProtocol": "code-oss",  "extensionAllowedProposedApi": [    "ms-vscode.references-view"  ]}

...function code() {  cd "$ROOT"  if [[ "$OSTYPE" == "darwin"* ]]; then    NAME=`node -p "require('./product.json').nameLong"`    CODE="./.build/electron/$NAME.app/Contents/MacOS/Electron"  else    NAME=`node -p "require('./product.json').applicationName"`    CODE=".build/electron/$NAME"  fi  ...  # Launch Code  exec "$CODE" . "$@"}...