Bump v9.0.0-beta.17

This reverts commit 27367fb553.

.eslintrc.json

@@ -6,9 +6,11 @@
     "browser": true
   },
   "rules": {
+    "semi": ["error", "always"],
     "no-var": "error",
     "no-unused-vars": 0,
     "no-global-assign": 0,
+    "guard-for-in": 2,
     "@typescript-eslint/no-unused-vars": ["error", {
       "vars": "all",
       "args": "after-used",

.gitattributes

@@ -1,3 +1,4 @@
 # `git apply` and friends don't understand CRLF, even on windows. Force those
 # files to be checked out with LF endings even if core.autocrlf is true.
 *.patch text eol=lf
+patches/**/.patches merge=union

BUILD.gn

@@ -224,7 +224,6 @@ grit("resources") {
   ]
 
   # Mojo manifest overlays are generated.
-  source_is_generated = true
   grit_flags = [
     "-E",
     "target_gen_dir=" + rebase_path(target_gen_dir, root_build_dir),
@@ -494,15 +493,21 @@ source_set("electron_lib") {
     deps += [
       ":libnotify_loader",
       "//build/config/linux/gtk",
-      "//chrome/browser/ui/gtk",
       "//dbus",
       "//device/bluetooth",
       "//third_party/breakpad:client",
       "//ui/events/devices/x11",
       "//ui/events/platform/x11",
+      "//ui/gtk",
       "//ui/views/controls/webview",
       "//ui/wm",
     ]
+    if (use_x11) {
+      deps += [
+        "//ui/gfx/x",
+        "//ui/gtk:x",
+      ]
+    }
     configs += [ ":gio_unix" ]
     include_dirs += [ "//third_party/breakpad" ]
     configs += [ "//build/config/linux:x11" ]
@@ -629,8 +634,6 @@ source_set("electron_lib") {
     deps += [ "//components/printing/common:mojo_interfaces" ]
   }
 
-  deps += [ "shell/common/extensions/api:extensions_features" ]
-  deps += [ "shell/common/extensions/api" ]
   deps += [
     "//components/pref_registry",
     "//components/user_prefs",
@@ -642,12 +645,22 @@ source_set("electron_lib") {
   ]
   if (enable_electron_extensions) {
     sources += filenames.lib_sources_extensions
+    deps += [
+      "shell/browser/extensions/api:api_registration",
+      "shell/common/extensions/api",
+      "shell/common/extensions/api:extensions_features",
+      "//chrome/browser/resources:component_extension_resources",
+      "//components/zoom",
+    ]
   }
 
   if (enable_pdf) {
     # Printing depends on some //pdf code, so it needs to be built even if the
     # pdf viewer isn't enabled.
-    deps += [ "//pdf" ]
+    deps += [
+      "//pdf",
+      "//pdf:features",
+    ]
   }
   if (enable_pdf_viewer) {
     deps += [
@@ -728,9 +741,14 @@ if (is_mac) {
       sources = [
         "$root_out_dir/egl_intermediates/libswiftshader_libEGL.dylib",
         "$root_out_dir/egl_intermediates/libswiftshader_libGLESv2.dylib",
+        "$root_out_dir/vk_intermediates/libvk_swiftshader.dylib",
+        "$root_out_dir/vk_intermediates/vk_swiftshader_icd.json",
       ]
       outputs = [ "{{bundle_contents_dir}}/Libraries/{{source_file_part}}" ]
-      public_deps = [ "//ui/gl:swiftshader_library_copy" ]
+      public_deps = [
+        "//ui/gl:swiftshader_egl_library_copy",
+        "//ui/gl:swiftshader_vk_library_copy",
+      ]
     }
   }
   group("electron_angle_library") {
@@ -783,6 +801,7 @@ if (is_mac) {
 
     include_dirs = [ "." ]
     sources = filenames.framework_sources
+    libs = []
 
     if (enable_osr) {
       libs += [ "IOSurface.framework" ]

DEPS

@@ -12,7 +12,7 @@ gclient_gn_args = [
 
 vars = {
   'chromium_version':
-    '2102ff0fb03469ca5ff317a168e6ad99ca0f23f1',
+    '83.0.4103.14',
   'node_version':
     'v12.14.1',
   'nan_version':
@@ -155,3 +155,5 @@ hooks = [
 recursedeps = [
   'src',
 ]
+
+# Touch DEPS again to bust cache

ELECTRON_VERSION

@@ -1 +1 @@
-9.0.0-nightly.20200205
+9.0.0-beta.17

appveyor.yml

@@ -118,19 +118,29 @@ build_script:
         }
       }
   - ps: >-
-      if (Test-Path 'env:RAW_GOMA_AUTH') {
-        $env:GOMA_OAUTH2_CONFIG_FILE = "$pwd\.goma_oauth2_config"
-        $env:RAW_GOMA_AUTH | Set-Content $env:GOMA_OAUTH2_CONFIG_FILE
-        .\src\electron\script\start-goma.ps1 -gomaDir "$pwd\src\electron\external_binaries\goma"
+      if ($env:GN_CONFIG -ne 'release') {
+        if (Test-Path 'env:RAW_GOMA_AUTH') {
+          $env:GOMA_OAUTH2_CONFIG_FILE = "$pwd\.goma_oauth2_config"
+          $env:RAW_GOMA_AUTH | Set-Content $env:GOMA_OAUTH2_CONFIG_FILE      
+        }
+        git clone https://github.com/electron/build-tools.git
+        cd build-tools
+        npm install
+        mkdir third_party
+        node -e "require('./src/utils/goma.js').downloadAndPrepare()"
+        $env:GN_GOMA_FILE = node -e "console.log(require('./src/utils/goma.js').gnFilePath)"
+        $env:LOCAL_GOMA_DIR = node -e "console.log(require('./src/utils/goma.js').dir)"
+        cd ..
+        .\src\electron\script\start-goma.ps1 -gomaDir $env:LOCAL_GOMA_DIR
       }
   - cd src
   - set BUILD_CONFIG_PATH=//electron/build/args/%GN_CONFIG%.gn 
-  - if DEFINED RAW_GOMA_AUTH (gn gen out/Default "--args=import(\"%BUILD_CONFIG_PATH%\") import(\"//electron/build/args/goma.gn\") %GN_EXTRA_ARGS% ") else (gn gen out/Default "--args=import(\"%BUILD_CONFIG_PATH%\") %GN_EXTRA_ARGS% cc_wrapper=\"%SCCACHE_PATH%\"")
+  - if DEFINED GN_GOMA_FILE (gn gen out/Default "--args=import(\"%BUILD_CONFIG_PATH%\") import(\"%GN_GOMA_FILE%\") %GN_EXTRA_ARGS% ") else (gn gen out/Default "--args=import(\"%BUILD_CONFIG_PATH%\") %GN_EXTRA_ARGS% cc_wrapper=\"%SCCACHE_PATH%\"")
   - gn check out/Default //electron:electron_lib
   - gn check out/Default //electron:electron_app
   - gn check out/Default //electron:manifests
   - gn check out/Default //electron/shell/common/api:mojo
-  - if DEFINED RAW_GOMA_AUTH (ninja -j 300 -C out/Default electron:electron_app) else (ninja -C out/Default electron:electron_app)
+  - if DEFINED GN_GOMA_FILE (ninja -j 300 -C out/Default electron:electron_app) else (ninja -C out/Default electron:electron_app)
   - if "%GN_CONFIG%"=="testing" ( python C:\depot_tools\post_build_ninja_summary.py -C out\Default )
   - gn gen out/ffmpeg "--args=import(\"//electron/build/args/ffmpeg.gn\") %GN_EXTRA_ARGS%"
   - ninja -C out/ffmpeg electron:electron_ffmpeg_zip
@@ -140,7 +150,7 @@ build_script:
   - ninja -C out/Default electron:hunspell_dictionaries_zip
   - ninja -C out/Default electron:electron_chromedriver_zip
   - ninja -C out/Default third_party/electron_node:headers
-  - if DEFINED RAW_GOMA_AUTH (python electron\external_binaries\goma\goma_ctl.py stat)
+  - if "%GN_CONFIG%"=="testing" ( python %LOCAL_GOMA_DIR%\goma_ctl.py stat )
   - python electron/build/profile_toolchain.py --output-json=out/Default/windows_toolchain_profile.json
   - appveyor PushArtifact out/Default/windows_toolchain_profile.json
   - appveyor PushArtifact out/Default/dist.zip

build/args/all.gn

@@ -2,7 +2,7 @@ is_electron_build = true
 root_extra_deps = [ "//electron" ]
 
 # Registry of NMVs --> https://github.com/nodejs/node/blob/master/doc/abi_version_registry.json
-node_module_version = 76
+node_module_version = 80
 
 v8_promise_internal_field_count = 1
 v8_typed_array_max_size_in_heap = 0
@@ -21,7 +21,6 @@ dawn_enable_vulkan_validation_layers = false
 
 is_cfi = false
 
-# TODO: disabled due to crashes. re-enable.
-enable_osr = false
+enable_osr = true
 
 enable_electron_extensions = true

buildflags/buildflags.gni

@@ -14,7 +14,7 @@ declare_args() {
 
   enable_view_api = false
 
-  enable_pdf_viewer = false
+  enable_pdf_viewer = true
 
   enable_tts = true
 

chromium_src/BUILD.gn

@@ -51,8 +51,8 @@ static_library("chrome") {
     "//chrome/browser/ssl/security_state_tab_helper.cc",
     "//chrome/browser/ssl/security_state_tab_helper.h",
     "//chrome/browser/ssl/tls_deprecation_config.cc",
-    "//chrome/browser/ui/autofill/popup_view_common.cc",
-    "//chrome/browser/ui/autofill/popup_view_common.h",
+    "//chrome/browser/ui/views/autofill/autofill_popup_view_utils.cc",
+    "//chrome/browser/ui/views/autofill/autofill_popup_view_utils.h",
     "//chrome/browser/win/chrome_process_finder.cc",
     "//chrome/browser/win/chrome_process_finder.h",
     "//extensions/browser/app_window/size_constraints.cc",
@@ -68,8 +68,8 @@ static_library("chrome") {
   ]
   deps = [
     "//chrome/browser:resource_prefetch_predictor_proto",
-    "//chrome/browser/ssl:proto",
     "//components/feature_engagement:buildflags",
+    "//components/optimization_guide/proto:optimization_guide_proto",
   ]
 
   if (is_linux) {
@@ -110,11 +110,15 @@ static_library("chrome") {
     ]
 
     if (use_aura) {
-      sources += [
-        "//chrome/browser/platform_util_aura.cc",
-        "//chrome/browser/ui/views/color_chooser_aura.cc",
-        "//chrome/browser/ui/views/color_chooser_aura.h",
-      ]
+      sources += [ "//chrome/browser/platform_util_aura.cc" ]
+
+      if (!is_win) {
+        sources += [
+          "//chrome/browser/ui/views/color_chooser_aura.cc",
+          "//chrome/browser/ui/views/color_chooser_aura.h",
+        ]
+      }
+
       deps += [ "//components/feature_engagement" ]
     }
 
@@ -233,6 +237,12 @@ static_library("chrome") {
 
   if (enable_electron_extensions) {
     sources += [
+      "//chrome/browser/extensions/chrome_url_request_util.cc",
+      "//chrome/browser/extensions/chrome_url_request_util.h",
+      "//chrome/browser/pdf/pdf_extension_util.cc",
+      "//chrome/browser/pdf/pdf_extension_util.h",
+      "//chrome/browser/plugins/plugin_response_interceptor_url_loader_throttle.cc",
+      "//chrome/browser/plugins/plugin_response_interceptor_url_loader_throttle.h",
       "//chrome/renderer/extensions/extension_hooks_delegate.cc",
       "//chrome/renderer/extensions/extension_hooks_delegate.h",
       "//chrome/renderer/extensions/tabs_hooks_delegate.cc",
@@ -256,6 +266,7 @@ source_set("plugins") {
     "//chrome/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.h",
   ]
   deps += [
+    "//components/pdf/browser",
     "//media:media_buildflags",
     "//ppapi/buildflags",
     "//ppapi/proxy:ipc",
@@ -293,8 +304,6 @@ source_set("plugins") {
     sources += [
       "//chrome/renderer/pepper/pepper_flash_drm_renderer_host.cc",
       "//chrome/renderer/pepper/pepper_flash_drm_renderer_host.h",
-      "//chrome/renderer/pepper/pepper_flash_font_file_host.cc",
-      "//chrome/renderer/pepper/pepper_flash_font_file_host.h",
       "//chrome/renderer/pepper/pepper_flash_fullscreen_host.cc",
       "//chrome/renderer/pepper/pepper_flash_fullscreen_host.h",
       "//chrome/renderer/pepper/pepper_flash_menu_host.cc",
@@ -303,7 +312,14 @@ source_set("plugins") {
       "//chrome/renderer/pepper/pepper_flash_renderer_host.h",
     ]
   }
+  if (enable_pepper_flash || enable_pdf_viewer) {
+    sources += [
+      "//chrome/renderer/pepper/pepper_flash_font_file_host.cc",
+      "//chrome/renderer/pepper/pepper_flash_font_file_host.h",
+    ]
+  }
   deps += [
+    "//components/pdf/renderer",
     "//components/strings",
     "//media:media_buildflags",
     "//ppapi/host",

default_app/default_app.ts

@@ -1,48 +1,48 @@
-import { app, dialog, BrowserWindow, shell, ipcMain } from 'electron'
-import * as path from 'path'
+import { app, dialog, BrowserWindow, shell, ipcMain } from 'electron';
+import * as path from 'path';
 
-let mainWindow: BrowserWindow | null = null
+let mainWindow: BrowserWindow | null = null;
 
 // Quit when all windows are closed.
 app.on('window-all-closed', () => {
-  app.quit()
-})
+  app.quit();
+});
 
 function decorateURL (url: string) {
   // safely add `?utm_source=default_app
-  const parsedUrl = new URL(url)
-  parsedUrl.searchParams.append('utm_source', 'default_app')
-  return parsedUrl.toString()
+  const parsedUrl = new URL(url);
+  parsedUrl.searchParams.append('utm_source', 'default_app');
+  return parsedUrl.toString();
 }
 
 // Find the shortest path to the electron binary
-const absoluteElectronPath = process.execPath
-const relativeElectronPath = path.relative(process.cwd(), absoluteElectronPath)
+const absoluteElectronPath = process.execPath;
+const relativeElectronPath = path.relative(process.cwd(), absoluteElectronPath);
 const electronPath = absoluteElectronPath.length < relativeElectronPath.length
   ? absoluteElectronPath
-  : relativeElectronPath
+  : relativeElectronPath;
 
-const indexPath = path.resolve(app.getAppPath(), 'index.html')
+const indexPath = path.resolve(app.getAppPath(), 'index.html');
 
 function isTrustedSender (webContents: Electron.WebContents) {
   if (webContents !== (mainWindow && mainWindow.webContents)) {
-    return false
+    return false;
   }
 
-  const parsedUrl = new URL(webContents.getURL())
+  const parsedUrl = new URL(webContents.getURL());
   const urlPath = process.platform === 'win32'
     // Strip the prefixed "/" that occurs on windows
     ? path.resolve(parsedUrl.pathname.substr(1))
-    : parsedUrl.pathname
-  return parsedUrl.protocol === 'file:' && urlPath === indexPath
+    : parsedUrl.pathname;
+  return parsedUrl.protocol === 'file:' && urlPath === indexPath;
 }
 
 ipcMain.handle('bootstrap', (event) => {
-  return isTrustedSender(event.sender) ? electronPath : null
-})
+  return isTrustedSender(event.sender) ? electronPath : null;
+});
 
 async function createWindow () {
-  await app.whenReady()
+  await app.whenReady();
 
   const options: Electron.BrowserWindowConstructorOptions = {
     width: 900,
@@ -57,46 +57,46 @@ async function createWindow () {
     },
     useContentSize: true,
     show: false
-  }
+  };
 
   if (process.platform === 'linux') {
-    options.icon = path.join(__dirname, 'icon.png')
+    options.icon = path.join(__dirname, 'icon.png');
   }
 
-  mainWindow = new BrowserWindow(options)
-  mainWindow.on('ready-to-show', () => mainWindow!.show())
+  mainWindow = new BrowserWindow(options);
+  mainWindow.on('ready-to-show', () => mainWindow!.show());
 
   mainWindow.webContents.on('new-window', (event, url) => {
-    event.preventDefault()
-    shell.openExternal(decorateURL(url))
-  })
+    event.preventDefault();
+    shell.openExternal(decorateURL(url));
+  });
 
   mainWindow.webContents.session.setPermissionRequestHandler((webContents, permission, done) => {
-    const parsedUrl = new URL(webContents.getURL())
+    const parsedUrl = new URL(webContents.getURL());
 
     const options: Electron.MessageBoxOptions = {
       title: 'Permission Request',
       message: `Allow '${parsedUrl.origin}' to access '${permission}'?`,
       buttons: ['OK', 'Cancel'],
       cancelId: 1
-    }
+    };
 
     dialog.showMessageBox(mainWindow!, options).then(({ response }) => {
-      done(response === 0)
-    })
-  })
+      done(response === 0);
+    });
+  });
 
-  return mainWindow
+  return mainWindow;
 }
 
 export const loadURL = async (appUrl: string) => {
-  mainWindow = await createWindow()
-  mainWindow.loadURL(appUrl)
-  mainWindow.focus()
-}
+  mainWindow = await createWindow();
+  mainWindow.loadURL(appUrl);
+  mainWindow.focus();
+};
 
 export const loadFile = async (appPath: string) => {
-  mainWindow = await createWindow()
-  mainWindow.loadFile(appPath)
-  mainWindow.focus()
-}
+  mainWindow = await createWindow();
+  mainWindow.loadFile(appPath);
+  mainWindow.focus();
+};

default_app/main.ts

@@ -1,8 +1,8 @@
-import { app, dialog } from 'electron'
+import { app, dialog } from 'electron';
 
-import * as fs from 'fs'
-import * as path from 'path'
-import * as url from 'url'
+import * as fs from 'fs';
+import * as path from 'path';
+import * as url from 'url';
 
 type DefaultAppOptions = {
   file: null | string;
@@ -14,10 +14,10 @@ type DefaultAppOptions = {
   modules: string[];
 }
 
-const Module = require('module')
+const Module = require('module');
 
 // Parse command line options.
-const argv = process.argv.slice(1)
+const argv = process.argv.slice(1);
 
 const option: DefaultAppOptions = {
   file: null,
@@ -27,50 +27,50 @@ const option: DefaultAppOptions = {
   interactive: false,
   abi: false,
   modules: []
-}
+};
 
-let nextArgIsRequire = false
+let nextArgIsRequire = false;
 
 for (const arg of argv) {
   if (nextArgIsRequire) {
-    option.modules.push(arg)
-    nextArgIsRequire = false
-    continue
+    option.modules.push(arg);
+    nextArgIsRequire = false;
+    continue;
   } else if (arg === '--version' || arg === '-v') {
-    option.version = true
-    break
+    option.version = true;
+    break;
   } else if (arg.match(/^--app=/)) {
-    option.file = arg.split('=')[1]
-    break
+    option.file = arg.split('=')[1];
+    break;
   } else if (arg === '--interactive' || arg === '-i' || arg === '-repl') {
-    option.interactive = true
+    option.interactive = true;
   } else if (arg === '--test-type=webdriver') {
-    option.webdriver = true
+    option.webdriver = true;
   } else if (arg === '--require' || arg === '-r') {
-    nextArgIsRequire = true
-    continue
+    nextArgIsRequire = true;
+    continue;
   } else if (arg === '--abi' || arg === '-a') {
-    option.abi = true
-    continue
+    option.abi = true;
+    continue;
   } else if (arg === '--no-help') {
-    option.noHelp = true
-    continue
+    option.noHelp = true;
+    continue;
   } else if (arg[0] === '-') {
-    continue
+    continue;
   } else {
-    option.file = arg
-    break
+    option.file = arg;
+    break;
   }
 }
 
 if (nextArgIsRequire) {
-  console.error('Invalid Usage: --require [file]\n\n"file" is required')
-  process.exit(1)
+  console.error('Invalid Usage: --require [file]\n\n"file" is required');
+  process.exit(1);
 }
 
 // Set up preload modules
 if (option.modules.length > 0) {
-  Module._preloadModules(option.modules)
+  Module._preloadModules(option.modules);
 }
 
 function loadApplicationPackage (packagePath: string) {
@@ -79,102 +79,102 @@ function loadApplicationPackage (packagePath: string) {
     configurable: false,
     enumerable: true,
     value: true
-  })
+  });
 
   try {
     // Override app name and version.
-    packagePath = path.resolve(packagePath)
-    const packageJsonPath = path.join(packagePath, 'package.json')
-    let appPath
+    packagePath = path.resolve(packagePath);
+    const packageJsonPath = path.join(packagePath, 'package.json');
+    let appPath;
     if (fs.existsSync(packageJsonPath)) {
-      let packageJson
+      let packageJson;
       try {
-        packageJson = require(packageJsonPath)
+        packageJson = require(packageJsonPath);
       } catch (e) {
-        showErrorMessage(`Unable to parse ${packageJsonPath}\n\n${e.message}`)
-        return
+        showErrorMessage(`Unable to parse ${packageJsonPath}\n\n${e.message}`);
+        return;
       }
 
       if (packageJson.version) {
-        app.setVersion(packageJson.version)
+        app.setVersion(packageJson.version);
       }
       if (packageJson.productName) {
-        app.name = packageJson.productName
+        app.name = packageJson.productName;
       } else if (packageJson.name) {
-        app.name = packageJson.name
+        app.name = packageJson.name;
       }
-      appPath = packagePath
+      appPath = packagePath;
     }
 
     try {
-      const filePath = Module._resolveFilename(packagePath, module, true)
-      app._setDefaultAppPaths(appPath || path.dirname(filePath))
+      const filePath = Module._resolveFilename(packagePath, module, true);
+      app._setDefaultAppPaths(appPath || path.dirname(filePath));
     } catch (e) {
-      showErrorMessage(`Unable to find Electron app at ${packagePath}\n\n${e.message}`)
-      return
+      showErrorMessage(`Unable to find Electron app at ${packagePath}\n\n${e.message}`);
+      return;
     }
 
     // Run the app.
-    Module._load(packagePath, module, true)
+    Module._load(packagePath, module, true);
   } catch (e) {
-    console.error('App threw an error during load')
-    console.error(e.stack || e)
-    throw e
+    console.error('App threw an error during load');
+    console.error(e.stack || e);
+    throw e;
   }
 }
 
 function showErrorMessage (message: string) {
-  app.focus()
-  dialog.showErrorBox('Error launching app', message)
-  process.exit(1)
+  app.focus();
+  dialog.showErrorBox('Error launching app', message);
+  process.exit(1);
 }
 
 async function loadApplicationByURL (appUrl: string) {
-  const { loadURL } = await import('./default_app')
-  loadURL(appUrl)
+  const { loadURL } = await import('./default_app');
+  loadURL(appUrl);
 }
 
 async function loadApplicationByFile (appPath: string) {
-  const { loadFile } = await import('./default_app')
-  loadFile(appPath)
+  const { loadFile } = await import('./default_app');
+  loadFile(appPath);
 }
 
 function startRepl () {
   if (process.platform === 'win32') {
-    console.error('Electron REPL not currently supported on Windows')
-    process.exit(1)
+    console.error('Electron REPL not currently supported on Windows');
+    process.exit(1);
   }
 
   // prevent quitting
-  app.on('window-all-closed', () => {})
+  app.on('window-all-closed', () => {});
 
-  const repl = require('repl')
+  const repl = require('repl');
   repl.start('> ').on('exit', () => {
-    process.exit(0)
-  })
+    process.exit(0);
+  });
 }
 
 // Start the specified app if there is one specified in command line, otherwise
 // start the default app.
 if (option.file && !option.webdriver) {
-  const file = option.file
-  const protocol = url.parse(file).protocol
-  const extension = path.extname(file)
+  const file = option.file;
+  const protocol = url.parse(file).protocol;
+  const extension = path.extname(file);
   if (protocol === 'http:' || protocol === 'https:' || protocol === 'file:' || protocol === 'chrome:') {
-    loadApplicationByURL(file)
+    loadApplicationByURL(file);
   } else if (extension === '.html' || extension === '.htm') {
-    loadApplicationByFile(path.resolve(file))
+    loadApplicationByFile(path.resolve(file));
   } else {
-    loadApplicationPackage(file)
+    loadApplicationPackage(file);
   }
 } else if (option.version) {
-  console.log('v' + process.versions.electron)
-  process.exit(0)
+  console.log('v' + process.versions.electron);
+  process.exit(0);
 } else if (option.abi) {
-  console.log(process.versions.modules)
-  process.exit(0)
+  console.log(process.versions.modules);
+  process.exit(0);
 } else if (option.interactive) {
-  startRepl()
+  startRepl();
 } else {
   if (!option.noHelp) {
     const welcomeMessage = `
@@ -192,10 +192,10 @@ Options:
   -i, --interactive     Open a REPL to the main process.
   -r, --require         Module to preload (option can be repeated).
   -v, --version         Print the version.
-  -a, --abi             Print the Node ABI version.`
+  -a, --abi             Print the Node ABI version.`;
 
-    console.log(welcomeMessage)
+    console.log(welcomeMessage);
   }
 
-  loadApplicationByFile('index.html')
+  loadApplicationByFile('index.html');
 }

default_app/preload.ts

@@ -1,53 +1,53 @@
-import { ipcRenderer, contextBridge } from 'electron'
+import { ipcRenderer, contextBridge } from 'electron';
 
 async function getOcticonSvg (name: string) {
   try {
-    const response = await fetch(`octicon/${name}.svg`)
-    const div = document.createElement('div')
-    div.innerHTML = await response.text()
-    return div
+    const response = await fetch(`octicon/${name}.svg`);
+    const div = document.createElement('div');
+    div.innerHTML = await response.text();
+    return div;
   } catch {
-    return null
+    return null;
   }
 }
 
 async function loadSVG (element: HTMLSpanElement) {
   for (const cssClass of element.classList) {
     if (cssClass.startsWith('octicon-')) {
-      const icon = await getOcticonSvg(cssClass.substr(8))
+      const icon = await getOcticonSvg(cssClass.substr(8));
       if (icon) {
         for (const elemClass of element.classList) {
-          icon.classList.add(elemClass)
+          icon.classList.add(elemClass);
         }
-        element.before(icon)
-        element.remove()
-        break
+        element.before(icon);
+        element.remove();
+        break;
       }
     }
   }
 }
 
 async function initialize () {
-  const electronPath = await ipcRenderer.invoke('bootstrap')
+  const electronPath = await ipcRenderer.invoke('bootstrap');
 
   function replaceText (selector: string, text: string) {
-    const element = document.querySelector<HTMLElement>(selector)
+    const element = document.querySelector<HTMLElement>(selector);
     if (element) {
-      element.innerText = text
+      element.innerText = text;
     }
   }
 
-  replaceText('.electron-version', `Electron v${process.versions.electron}`)
-  replaceText('.chrome-version', `Chromium v${process.versions.chrome}`)
-  replaceText('.node-version', `Node v${process.versions.node}`)
-  replaceText('.v8-version', `v8 v${process.versions.v8}`)
-  replaceText('.command-example', `${electronPath} path-to-app`)
+  replaceText('.electron-version', `Electron v${process.versions.electron}`);
+  replaceText('.chrome-version', `Chromium v${process.versions.chrome}`);
+  replaceText('.node-version', `Node v${process.versions.node}`);
+  replaceText('.v8-version', `v8 v${process.versions.v8}`);
+  replaceText('.command-example', `${electronPath} path-to-app`);
 
   for (const element of document.querySelectorAll<HTMLSpanElement>('.octicon')) {
-    loadSVG(element)
+    loadSVG(element);
   }
 }
 
 contextBridge.exposeInMainWorld('electronDefaultApp', {
   initialize
-})
+});

docs/api/app.md

@@ -659,8 +659,6 @@ to the npm modules spec. You should usually also specify a `productName`
 field, which is your application's full capitalized name, and which will be
 preferred over `name` by Electron.
 
-**[Deprecated](modernization/property-updates.md)**
-
 ### `app.setName(name)`
 
 * `name` String
@@ -669,8 +667,6 @@ Overrides the current application's name.
 
 **Note:** This function overrides the name used internally by Electron; it does not affect the name that the OS uses.
 
-**[Deprecated](modernization/property-updates.md)**
-
 ### `app.getLocale()`
 
 Returns `String` - The current application locale. Possible return values are documented [here](locales.md).
@@ -703,34 +699,34 @@ Clears the recent documents list.
 
 ### `app.setAsDefaultProtocolClient(protocol[, path, args])`
 
-* `protocol` String - The name of your protocol, without `://`. If you want your
-  app to handle `electron://` links, call this method with `electron` as the
-  parameter.
-* `path` String (optional) _Windows_ - Defaults to `process.execPath`
-* `args` String[] (optional) _Windows_ - Defaults to an empty array
+* `protocol` String - The name of your protocol, without `://`. For example,
+  if you want your app to handle `electron://` links, call this method with
+  `electron` as the parameter.
+* `path` String (optional) _Windows_ - The path to the Electron executable.
+  Defaults to `process.execPath`
+* `args` String[] (optional) _Windows_ - Arguments passed to the executable.
+  Defaults to an empty array
 
 Returns `Boolean` - Whether the call succeeded.
 
-This method sets the current executable as the default handler for a protocol
-(aka URI scheme). It allows you to integrate your app deeper into the operating
-system. Once registered, all links with `your-protocol://` will be opened with
-the current executable. The whole link, including protocol, will be passed to
-your application as a parameter.
-
-On Windows, you can provide optional parameters path, the path to your executable,
-and args, an array of arguments to be passed to your executable when it launches.
+Sets the current executable as the default handler for a protocol (aka URI
+scheme). It allows you to integrate your app deeper into the operating system.
+Once registered, all links with `your-protocol://` will be opened with the
+current executable. The whole link, including protocol, will be passed to your
+application as a parameter.
 
 **Note:** On macOS, you can only register protocols that have been added to
-your app's `info.plist`, which can not be modified at runtime. You can however
-change the file with a simple text editor or script during build time.
-Please refer to [Apple's documentation][CFBundleURLTypes] for details.
+your app's `info.plist`, which cannot be modified at runtime. However, you can
+change the file during build time via [Electron Forge][electron-forge],
+[Electron Packager][electron-packager], or by editing `info.plist` with a text
+editor. Please refer to [Apple's documentation][CFBundleURLTypes] for details.
 
 **Note:** In a Windows Store environment (when packaged as an `appx`) this API
 will return `true` for all calls but the registry key it sets won't be accessible
 by other applications.  In order to register your Windows Store application
 as a default protocol handler you must [declare the protocol in your manifest](https://docs.microsoft.com/en-us/uwp/schemas/appxpackage/uapmanifestschema/element-uap-protocol).
 
-The API uses the Windows Registry and LSSetDefaultHandlerForURLScheme internally.
+The API uses the Windows Registry and `LSSetDefaultHandlerForURLScheme` internally.
 
 ### `app.removeAsDefaultProtocolClient(protocol[, path, args])` _macOS_ _Windows_
 
@@ -749,10 +745,8 @@ protocol (aka URI scheme). If so, it will remove the app as the default handler.
 * `path` String (optional) _Windows_ - Defaults to `process.execPath`
 * `args` String[] (optional) _Windows_ - Defaults to an empty array
 
-Returns `Boolean`
-
-This method checks if the current executable is the default handler for a protocol
-(aka URI scheme). If so, it will return true. Otherwise, it will return false.
+Returns `Boolean` - Whether the current executable is the default handler for a
+protocol (aka URI scheme).
 
 **Note:** On macOS, you can use this method to check if the app has been
 registered as the default protocol handler for a protocol. You can also verify
@@ -760,7 +754,7 @@ this by checking `~/Library/Preferences/com.apple.LaunchServices.plist` on the
 macOS machine. Please refer to
 [Apple's documentation][LSCopyDefaultHandlerForURLScheme] for details.
 
-The API uses the Windows Registry and LSCopyDefaultHandlerForURLScheme internally.
+The API uses the Windows Registry and `LSCopyDefaultHandlerForURLScheme` internally.
 
 ### `app.getApplicationNameForProtocol(url)`
 
@@ -1091,14 +1085,10 @@ On macOS, it shows on the dock icon. On Linux, it only works for Unity launcher.
 **Note:** Unity launcher requires the existence of a `.desktop` file to work,
 for more information please read [Desktop Environment Integration][unity-requirement].
 
-**[Deprecated](modernization/property-updates.md)**
-
 ### `app.getBadgeCount()` _Linux_ _macOS_
 
 Returns `Integer` - The current value displayed in the counter badge.
 
-**[Deprecated](modernization/property-updates.md)**
-
 ### `app.isUnityRunning()` _Linux_
 
 Returns `Boolean` - Whether the current desktop environment is Unity launcher.
@@ -1173,8 +1163,6 @@ technologies, such as screen readers, has been detected. See
 https://www.chromium.org/developers/design-documents/accessibility for more
 details.
 
-**[Deprecated](modernization/property-updates.md)**
-
 ### `app.setAccessibilitySupportEnabled(enabled)` _macOS_ _Windows_
 
 * `enabled` Boolean - Enable or disable [accessibility tree](https://developers.google.com/web/fundamentals/accessibility/semantics-builtin/the-accessibility-tree) rendering
@@ -1186,8 +1174,6 @@ This API must be called after the `ready` event is emitted.
 
 **Note:** Rendering accessibility tree can significantly affect the performance of your app. It should not be enabled by default.
 
-**[Deprecated](modernization/property-updates.md)**
-
 ### `app.showAboutPanel()`
 
 Show the app's about panel options. These options can be overridden with `app.setAboutPanelOptions(options)`.
@@ -1327,6 +1313,8 @@ A `Boolean` property that returns  `true` if the app is packaged, `false` otherw
 [dock-menu]:https://developer.apple.com/macos/human-interface-guidelines/menus/dock-menus/
 [tasks]:https://msdn.microsoft.com/en-us/library/windows/desktop/dd378460(v=vs.85).aspx#tasks
 [app-user-model-id]: https://msdn.microsoft.com/en-us/library/windows/desktop/dd378459(v=vs.85).aspx
+[electron-forge]: https://www.electronforge.io/
+[electron-packager]: https://github.com/electron/electron-packager
 [CFBundleURLTypes]: https://developer.apple.com/library/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html#//apple_ref/doc/uid/TP40009249-102207-TPXREF115
 [LSCopyDefaultHandlerForURLScheme]: https://developer.apple.com/library/mac/documentation/Carbon/Reference/LaunchServicesReference/#//apple_ref/c/func/LSCopyDefaultHandlerForURLScheme
 [handoff]: https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/Handoff/HandoffFundamentals/HandoffFundamentals.html

docs/api/browser-window.md

@@ -289,7 +289,7 @@ It creates a new `BrowserWindow` with native properties as set by the `options`.
       between the web pages even when you specified different values for them,
       including but not limited to `preload`, `sandbox` and `nodeIntegration`.
       So it is suggested to use exact same `webPreferences` for web pages with
-      the same `affinity`. _This property is experimental_
+      the same `affinity`. _Deprecated_
     * `zoomFactor` Number (optional) - The default zoom factor of the page, `3.0` represents
       `300%`. Default is `1.0`.
     * `javascript` Boolean (optional) - Enables JavaScript support. Default is `true`.
@@ -369,6 +369,8 @@ It creates a new `BrowserWindow` with native properties as set by the `options`.
       consecutive dialog protection is triggered. If not defined the default
       message would be used, note that currently the default message is in
       English and not localized.
+    * `disableDialogs` Boolean (optional) - Whether to disable dialogs
+      completely. Overrides `safeDialogs`. Default is `false`.
     * `navigateOnDragDrop` Boolean (optional) - Whether dragging and dropping a
       file or link onto the page causes a navigation. Default is `false`.
     * `autoplayPolicy` String (optional) - Autoplay policy to apply to
@@ -621,6 +623,12 @@ Returns:
 
 Emitted on 3-finger swipe. Possible directions are `up`, `right`, `down`, `left`.
 
+The method underlying this event is built to handle older macOS-style trackpad swiping,
+where the content on the screen doesn't move with the swipe. Most macOS trackpads are not
+configured to allow this kind of swiping anymore, so in order for it to emit properly the
+'Swipe between pages' preference in `System Preferences > Trackpad > More Gestures` must be
+set to 'Swipe with two or three fingers'.
+
 #### Event: 'rotate-gesture' _macOS_
 
 Returns:
@@ -1113,15 +1121,11 @@ Returns `Integer[]` - Contains the window's maximum width and height.
 
 * `resizable` Boolean
 
-Sets whether the window can be manually resized by user.
-
-**[Deprecated](modernization/property-updates.md)**
+Sets whether the window can be manually resized by the user.
 
 #### `win.isResizable()`
 
-Returns `Boolean` - Whether the window can be manually resized by user.
-
-**[Deprecated](modernization/property-updates.md)**
+Returns `Boolean` - Whether the window can be manually resized by the user.
 
 #### `win.setMovable(movable)` _macOS_ _Windows_
 
@@ -1129,41 +1133,29 @@ Returns `Boolean` - Whether the window can be manually resized by user.
 
 Sets whether the window can be moved by user. On Linux does nothing.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `win.isMovable()` _macOS_ _Windows_
 
 Returns `Boolean` - Whether the window can be moved by user.
 
 On Linux always returns `true`.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `win.setMinimizable(minimizable)` _macOS_ _Windows_
 
 * `minimizable` Boolean
 
-Sets whether the window can be manually minimized by user. On Linux does
-nothing.
-
-**[Deprecated](modernization/property-updates.md)**
+Sets whether the window can be manually minimized by user. On Linux does nothing.
 
 #### `win.isMinimizable()` _macOS_ _Windows_
 
-Returns `Boolean` - Whether the window can be manually minimized by user
+Returns `Boolean` - Whether the window can be manually minimized by the user.
 
 On Linux always returns `true`.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `win.setMaximizable(maximizable)` _macOS_ _Windows_
 
 * `maximizable` Boolean
 
-Sets whether the window can be manually maximized by user. On Linux does
-nothing.
-
-**[Deprecated](modernization/property-updates.md)**
+Sets whether the window can be manually maximized by user. On Linux does nothing.
 
 #### `win.isMaximizable()` _macOS_ _Windows_
 
@@ -1171,23 +1163,15 @@ Returns `Boolean` - Whether the window can be manually maximized by user.
 
 On Linux always returns `true`.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `win.setFullScreenable(fullscreenable)`
 
 * `fullscreenable` Boolean
 
-Sets whether the maximize/zoom window button toggles fullscreen mode or
-maximizes the window.
-
-**[Deprecated](modernization/property-updates.md)**
+Sets whether the maximize/zoom window button toggles fullscreen mode or maximizes the window.
 
 #### `win.isFullScreenable()`
 
-Returns `Boolean` - Whether the maximize/zoom window button toggles fullscreen mode or
-maximizes the window.
-
-**[Deprecated](modernization/property-updates.md)**
+Returns `Boolean` - Whether the maximize/zoom window button toggles fullscreen mode or maximizes the window.
 
 #### `win.setClosable(closable)` _macOS_ _Windows_
 
@@ -1195,16 +1179,12 @@ maximizes the window.
 
 Sets whether the window can be manually closed by user. On Linux does nothing.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `win.isClosable()` _macOS_ _Windows_
 
 Returns `Boolean` - Whether the window can be manually closed by user.
 
 On Linux always returns `true`.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `win.setAlwaysOnTop(flag[, level][, relativeLevel])`
 
 * `flag` Boolean
@@ -1616,23 +1596,17 @@ This cannot be called when `titleBarStyle` is set to `customButtonsOnHover`.
 Sets whether the window menu bar should hide itself automatically. Once set the
 menu bar will only show when users press the single `Alt` key.
 
-If the menu bar is already visible, calling `setAutoHideMenuBar(true)` won't
-hide it immediately.
-
-**[Deprecated](modernization/property-updates.md)**
+If the menu bar is already visible, calling `setAutoHideMenuBar(true)` won't hide it immediately.
 
 #### `win.isMenuBarAutoHide()`
 
 Returns `Boolean` - Whether menu bar automatically hides itself.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `win.setMenuBarVisibility(visible)` _Windows_ _Linux_
 
 * `visible` Boolean
 
-Sets whether the menu bar should be visible. If the menu bar is auto-hide, users
-can still bring up the menu bar by pressing the single `Alt` key.
+Sets whether the menu bar should be visible. If the menu bar is auto-hide, users can still bring up the menu bar by pressing the single `Alt` key.
 
 #### `win.isMenuBarVisible()`
 
@@ -1748,6 +1722,17 @@ will remove the vibrancy effect on the window.
 Note that `appearance-based`, `light`, `dark`, `medium-light`, and `ultra-dark` have been
 deprecated and will be removed in an upcoming version of macOS.
 
+#### `win.setTrafficLightPosition(position)` _macOS_
+
+* `position` [Point](structures/point.md)
+
+Set a custom position for the traffic light buttons. Can only be used with `titleBarStyle` set to `hidden`.
+
+#### `win.getTrafficLightPosition()` _macOS_
+
+Returns `Point` - The current position for the traffic light buttons. Can only be used with `titleBarStyle`
+set to `hidden`.
+
 #### `win.setTouchBar(touchBar)` _macOS_ _Experimental_
 
 * `touchBar` TouchBar | null

docs/api/client-request.md

@@ -22,6 +22,9 @@ which the request is associated.
   with which the request is associated. Defaults to the empty string. The
 `session` option prevails on `partition`. Thus if a `session` is explicitly
 specified, `partition` is ignored.
+  * `useSessionCookies` Boolean (optional) - Whether to send cookies with this
+    request from the provided session.  This will make the `net` request's
+    cookie behavior match a `fetch` request. Default is `false`.
   * `protocol` String (optional) - The protocol scheme in the form 'scheme:'.
 Currently supported values are 'http:' or 'https:'. Defaults to 'http:'.
   * `host` String (optional) - The server host provided as a concatenation of

docs/api/download-item.md

@@ -82,16 +82,12 @@ The API is only available in session's `will-download` callback function.
 If user doesn't set the save path via the API, Electron will use the original
 routine to determine the save path; this usually prompts a save dialog.
 
-**[Deprecated](modernization/property-updates.md): use the `savePath` property instead.**
-
 #### `downloadItem.getSavePath()`
 
 Returns `String` - The save path of the download item. This will be either the path
 set via `downloadItem.setSavePath(path)` or the path selected from the shown
 save dialog.
 
-**[Deprecated](modernization/property-updates.md): use the `savePath` property instead.**
-
 #### `downloadItem.setSaveDialogOptions(options)`
 
 * `options` SaveDialogOptions - Set the save file dialog options. This object has the same

docs/api/environment-variables.md

@@ -53,16 +53,23 @@ Unsupported options are:
 
 ### `GOOGLE_API_KEY`
 
-You can provide an API key for making requests to Google's geocoding webservice. To do this, place the following code in your main process
-file, before opening any browser windows that will make geocoding requests:
+Geolocation support in Electron requires the use of Google Cloud Platform's
+geolocation webservice. To enable this feature, acquire a
+[Google API key](https://developers.google.com/maps/documentation/geolocation/get-api-key)
+and place the following code in your main process file, before opening any
+browser windows that will make geolocation requests:
 
 ```javascript
 process.env.GOOGLE_API_KEY = 'YOUR_KEY_HERE'
 ```
 
-For instructions on how to acquire a Google API key, visit [this page](https://developers.google.com/maps/documentation/javascript/get-api-key).
-By default, a newly generated Google API key may not be allowed to make
-geocoding requests. To enable geocoding requests, visit [this page](https://developers.google.com/maps/documentation/geocoding/get-api-key).
+By default, a newly generated Google API key may not be allowed to make geolocation requests.
+To enable the geolocation webservice for your project, enable it through the
+[API library](https://console.cloud.google.com/apis/library).
+
+N.B. You will need to add a
+[Billing Account](https://cloud.google.com/billing/docs/how-to/payment-methods#add_a_payment_method)
+to the project associated to the API key for the geolocation webservice to work.
 
 ### `ELECTRON_NO_ASAR`
 

docs/api/modernization/property-updates.md

@@ -45,9 +45,3 @@ The Electron team is currently undergoing an initiative to convert separate gett
   * `isMacTemplateImage`
 * `SystemPreferences` module
   * `appLevelAppearance`
-* `webContents` module
-  * `audioMuted`
-  * `frameRate`
-  * `userAgent`
-  * `zoomFactor`
-  * `zoomLevel`

docs/api/native-image.md

@@ -276,14 +276,10 @@ Returns [`Size`](structures/size.md)
 
 Marks the image as a template image.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `image.isTemplateImage()`
 
 Returns `Boolean` - Whether the image is a template image.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `image.crop(rect)`
 
 * `rect` [Rectangle](structures/rectangle.md) - The area of the image to crop.

docs/api/service-workers.md

@@ -0,0 +1,62 @@
+## Class: ServiceWorkers
+
+> Query and receive events from a sessions active service workers.
+
+Process: [Main](../glossary.md#main-process)
+
+Instances of the `ServiceWorkers` class are accessed by using `serviceWorkers` property of
+a `Session`.
+
+For example:
+
+```javascript
+const { session } = require('electron')
+
+// Get all service workers.
+console.log(session.defaultSession.serviceWorkers.getAllRunning())
+
+// Handle logs and get service worker info
+session.defaultSession.serviceWorkers.on('console-message', (event, messageDetails) => {
+  console.log(
+    'Got service worker message',
+    messageDetails,
+    'from',
+    session.defaultSession.serviceWorkers.getFromVersionID(messageDetails.versionId)
+  )
+})
+```
+
+### Instance Events
+
+The following events are available on instances of `ServiceWorkers`:
+
+#### Event: 'console-message'
+
+Returns:
+
+* `event` Event
+* `messageDetails` Object - Information about the console message
+  * `message` String - The actual console message
+  * `versionId` Number - The version ID of the service worker that sent the log message
+  * `source` String - The type of source for this message.  Can be `javascript`, `xml`, `network`, `console-api`, `storage`, `app-cache`, `rendering`, `security`, `deprecation`, `worker`, `violation`, `intervention`, `recommendation` or `other`.
+  * `level` Number - The log level, from 0 to 3.  In order it matches `verbose`, `info`, `warning` and `error`.
+  * `sourceUrl` String - The URL the message came from
+  * `lineNumber` Number - The line number of the source that triggered this console message
+
+Emitted when a service worker logs something to the console.
+
+### Instance Methods
+
+The following methods are available on instances of `ServiceWorkers`:
+
+#### `serviceWorkers.getAllRunning()`
+
+Returns `Record<Number, ServiceWorkerInfo>` - A [ServiceWorkerInfo](structures/service-worker-info.md) object where the keys are the service worker version ID and the values are the information about that service worker.
+
+#### `serviceWorkers.getFromVersionID(versionId)`
+
+* `versionId` Number
+
+Returns [`ServiceWorkerInfo`](structures/service-worker-info.md) - Information about this service worker
+
+If the service worker does not exist or is not running this method will throw an exception.

docs/api/session.md

@@ -105,6 +105,45 @@ Returns:
 Emitted when a render process requests preconnection to a URL, generally due to
 a [resource hint](https://w3c.github.io/resource-hints/).
 
+#### Event: 'spellcheck-dictionary-initialized'
+
+Returns:
+
+* `event` Event
+* `languageCode` String - The language code of the dictionary file
+
+Emitted when a hunspell dictionary file has been successfully initialized. This
+occurs after the file has been downloaded.
+
+#### Event: 'spellcheck-dictionary-download-begin'
+
+Returns:
+
+* `event` Event
+* `languageCode` String - The language code of the dictionary file
+
+Emitted when a hunspell dictionary file starts downloading
+
+#### Event: 'spellcheck-dictionary-download-success'
+
+Returns:
+
+* `event` Event
+* `languageCode` String - The language code of the dictionary file
+
+Emitted when a hunspell dictionary file has been successfully downloaded
+
+#### Event: 'spellcheck-dictionary-download-failure'
+
+Returns:
+
+* `event` Event
+* `languageCode` String - The language code of the dictionary file
+
+Emitted when a hunspell dictionary file download fails.  For details
+on the failure you should collect a netlog and inspect the download
+request.
+
 ### Instance Methods
 
 The following methods are available on instances of `Session`:
@@ -483,18 +522,38 @@ setting with the current OS locale.  This setting is persisted across restarts.
 By default Electron will download hunspell dictionaries from the Chromium CDN.  If you want to override this
 behavior you can use this API to point the dictionary downloader at your own hosted version of the hunspell
 dictionaries.  We publish a `hunspell_dictionaries.zip` file with each release which contains the files you need
-to host here.
+to host here, the file server must be **case insensitive** you must upload each file twice, once with the case it
+has in the ZIP file and once with the filename as all lower case.
+
+If the files present in `hunspell_dictionaries.zip` are available at `https://example.com/dictionaries/language-code.bdic`
+then you should call this api with `ses.setSpellCheckerDictionaryDownloadURL('https://example.com/dictionaries/')`.  Please
+note the trailing slash.  The URL to the dictionaries is formed as `${url}${filename}`.
 
 **Note:** On macOS the OS spellchecker is used and therefore we do not download any dictionary files.  This API is a no-op on macOS.
 
+#### `ses.listWordsInSpellCheckerDictionary()`
+
+Returns `Promise<String[]>` - An array of all words in app's custom dictionary.
+Resolves when the full dictionary is loaded from disk.
+
 #### `ses.addWordToSpellCheckerDictionary(word)`
 
 * `word` String - The word you want to add to the dictionary
 
-Returns `Boolean` - Whether the word was successfully written to the custom dictionary.
+Returns `Boolean` - Whether the word was successfully written to the custom dictionary. This API
+will not work on non-persistent (in-memory) sessions.
 
 **Note:** On macOS and Windows 10 this word will be written to the OS custom dictionary as well
 
+#### `ses.removeWordFromSpellCheckerDictionary(word)`
+
+* `word` String - The word you want to remove from the dictionary
+
+Returns `Boolean` - Whether the word was successfully removed from the custom dictionary. This API
+will not work on non-persistent (in-memory) sessions.
+
+**Note:** On macOS and Windows 10 this word will be removed from the OS custom dictionary as well
+
 #### `ses.loadExtension(path)`
 
 * `path` String - Path to a directory containing an unpacked Chrome extension
@@ -567,6 +626,10 @@ code to the `setSpellCheckerLanaguages` API that isn't in this array will result
 
 A [`Cookies`](cookies.md) object for this session.
 
+#### `ses.serviceWorkers` _Readonly_
+
+A [`ServiceWorkers`](service-workers.md) object for this session.
+
 #### `ses.webRequest` _Readonly_
 
 A [`WebRequest`](web-request.md) object for this session.

docs/api/structures/extension.md

@@ -1,5 +1,8 @@
 # Extension Object
 
 * `id` String
+* `manifest` any - Copy of the [extension's manifest data](https://developer.chrome.com/extensions/manifest).
 * `name` String
+* `path` String - The extension's file path.
 * `version` String
+* `url` String - The extension's `chrome-extension://` URL.

docs/api/structures/service-worker-info.md

@@ -0,0 +1,5 @@
+# ServiceWorkerInfo Object
+
+* `scriptUrl` String - The full URL to the script that this service worker runs
+* `scope` String - The base URL that this service worker is active for.
+* `renderProcessId` Number - The virtual ID of the process that this service worker is running in.  This is not an OS level PID.  This aligns with the ID set used for `webContents.getProcessId()`.

docs/api/system-preferences.md

@@ -360,7 +360,7 @@ Returns `Boolean` - `true` if an inverted color scheme (a high contrast color sc
 
 Returns `Boolean` - `true` if a high contrast theme is active, `false` otherwise.
 
-**Depreacted:** Should use the new [`nativeTheme.shouldUseHighContrastColors`](native-theme.md#nativethemeshouldusehighcontrastcolors-macos-windows-readonly) API.
+**Deprecated:** Should use the new [`nativeTheme.shouldUseHighContrastColors`](native-theme.md#nativethemeshouldusehighcontrastcolors-macos-windows-readonly) API.
 
 ### `systemPreferences.getEffectiveAppearance()` _macOS_
 
@@ -369,16 +369,6 @@ Returns `String` - Can be `dark`, `light` or `unknown`.
 Gets the macOS appearance setting that is currently applied to your application,
 maps to [NSApplication.effectiveAppearance](https://developer.apple.com/documentation/appkit/nsapplication/2967171-effectiveappearance?language=objc)
 
-Please note that until Electron is built targeting the 10.14 SDK, your application's
-`effectiveAppearance` will default to 'light' and won't inherit the OS preference. In
-the interim in order for your application to inherit the OS preference you must set the
-`NSRequiresAquaSystemAppearance` key in your apps `Info.plist` to `false`.  If you are
-using `electron-packager` or `electron-forge` just set the `enableDarwinDarkMode`
-packager option to `true`.  See the [Electron Packager API](https://github.com/electron/electron-packager/blob/master/docs/api.md#darwindarkmodesupport)
-for more details.
-
-**[Deprecated](modernization/property-updates.md)**
-
 ### `systemPreferences.getAppLevelAppearance()` _macOS_ _Deprecated_
 
 Returns `String` | `null` - Can be `dark`, `light` or `unknown`.
@@ -387,8 +377,6 @@ Gets the macOS appearance setting that you have declared you want for
 your application, maps to [NSApplication.appearance](https://developer.apple.com/documentation/appkit/nsapplication/2967170-appearance?language=objc).
 You can use the `setAppLevelAppearance` API to set this value.
 
-**[Deprecated](modernization/property-updates.md)**
-
 ### `systemPreferences.setAppLevelAppearance(appearance)` _macOS_ _Deprecated_
 
 * `appearance` String | null - Can be `dark` or `light`
@@ -396,16 +384,12 @@ You can use the `setAppLevelAppearance` API to set this value.
 Sets the appearance setting for your application, this should override the
 system default and override the value of `getEffectiveAppearance`.
 
-**[Deprecated](modernization/property-updates.md)**
-
 ### `systemPreferences.canPromptTouchID()` _macOS_
 
 Returns `Boolean` - whether or not this device has the ability to use Touch ID.
 
 **NOTE:** This API will return `false` on macOS systems older than Sierra 10.12.2.
 
-**[Deprecated](modernization/property-updates.md)**
-
 ### `systemPreferences.promptTouchID(reason)` _macOS_
 
 * `reason` String - The reason you are asking for Touch ID authentication
@@ -480,11 +464,3 @@ A `String` property that can be `dark`, `light` or `unknown`.
 
 Returns the macOS appearance setting that is currently applied to your application,
 maps to [NSApplication.effectiveAppearance](https://developer.apple.com/documentation/appkit/nsapplication/2967171-effectiveappearance?language=objc)
-
-Please note that until Electron is built targeting the 10.14 SDK, your application's
-`effectiveAppearance` will default to 'light' and won't inherit the OS preference. In
-the interim in order for your application to inherit the OS preference you must set the
-`NSRequiresAquaSystemAppearance` key in your apps `Info.plist` to `false`.  If you are
-using `electron-packager` or `electron-forge` just set the `enableDarwinDarkMode`
-packager option to `true`.  See the [Electron Packager API](https://github.com/electron/electron-packager/blob/master/docs/api.md#darwindarkmodesupport)
-for more details.

docs/api/web-contents.md

@@ -967,14 +967,10 @@ Returns `Boolean` - Whether the renderer process has crashed.
 
 Overrides the user agent for this web page.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `contents.getUserAgent()`
 
 Returns `String` - The user agent for this web page.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `contents.insertCSS(css[, options])`
 
 * `css` String
@@ -1054,33 +1050,27 @@ Ignore application menu shortcuts while this web contents is focused.
 
 Mute the audio on the current web page.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `contents.isAudioMuted()`
 
 Returns `Boolean` - Whether this page has been muted.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `contents.isCurrentlyAudible()`
 
 Returns `Boolean` - Whether audio is currently playing.
 
 #### `contents.setZoomFactor(factor)`
 
-* `factor` Number - Zoom factor.
+* `factor` Double - Zoom factor; default is 1.0.
 
 Changes the zoom factor to the specified factor. Zoom factor is
 zoom percent divided by 100, so 300% = 3.0.
 
-**[Deprecated](modernization/property-updates.md)**
+The factor must be greater than 0.0.
 
 #### `contents.getZoomFactor()`
 
 Returns `Number` - the current zoom factor.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `contents.setZoomLevel(level)`
 
 * `level` Number - Zoom level.
@@ -1090,14 +1080,10 @@ increment above or below represents zooming 20% larger or smaller to default
 limits of 300% and 50% of original size, respectively. The formula for this is
 `scale := 1.2 ^ level`.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `contents.getZoomLevel()`
 
 Returns `Number` - the current zoom level.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `contents.setVisualZoomLevelLimits(minimumLevel, maximumLevel)`
 
 * `minimumLevel` Number
@@ -1286,7 +1272,7 @@ Returns [`PrinterInfo[]`](structures/printer-info.md)
   `A4`, `A5`, `Legal`, `Letter`, `Tabloid` or an Object containing `height`.
 * `callback` Function (optional)
   * `success` Boolean - Indicates success of the print call.
-  * `failureReason` String - Called back if the print fails; can be `cancelled` or `failed`.
+  * `failureReason` String - Error description called back if the print fails.
 
 Prints window's web page. When `silent` is set to `true`, Electron will pick
 the system's default printer if `deviceName` is empty and the default settings for printing.
@@ -1709,14 +1695,10 @@ Returns `Boolean` - If *offscreen rendering* is enabled returns whether it is cu
 If *offscreen rendering* is enabled sets the frame rate to the specified number.
 Only values between 1 and 60 are accepted.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `contents.getFrameRate()`
 
 Returns `Integer` - If *offscreen rendering* is enabled returns the current frame rate.
 
-**[Deprecated](modernization/property-updates.md)**
-
 #### `contents.invalidate()`
 
 Schedules a full repaint of the window this web contents is in.

docs/api/web-frame.md

@@ -22,11 +22,13 @@ The `WebFrame` class has the following instance methods:
 
 ### `webFrame.setZoomFactor(factor)`
 
-* `factor` Number - Zoom factor.
+* `factor` Double - Zoom factor; default is 1.0.
 
 Changes the zoom factor to the specified factor. Zoom factor is
 zoom percent divided by 100, so 300% = 3.0.
 
+The factor must be greater than 0.0.
+
 ### `webFrame.getZoomFactor()`
 
 Returns `Number` - The current zoom factor.
@@ -122,13 +124,20 @@ by its key, which is returned from `webFrame.insertCSS(css)`.
 
 Inserts `text` to the focused element.
 
-### `webFrame.executeJavaScript(code[, userGesture])`
+### `webFrame.executeJavaScript(code[, userGesture, callback])`
 
 * `code` String
 * `userGesture` Boolean (optional) - Default is `false`.
+* `callback` Function (optional) - Called after script has been executed. Unless
+  the frame is suspended (e.g. showing a modal alert), execution will be
+  synchronous and the callback will be invoked before the method returns. For
+  compatibility with an older version of this method, the error parameter is
+  second.
+  * `result` Any
+  * `error` Error
 
-Returns `Promise<any>` - A promise that resolves with the result of the executed code
-or is rejected if the result of the code is a rejected promise.
+Returns `Promise<any>` - A promise that resolves with the result of the executed
+code or is rejected if execution throws or results in a rejected promise.
 
 Evaluates `code` in page.
 
@@ -136,14 +145,24 @@ In the browser window some HTML APIs like `requestFullScreen` can only be
 invoked by a gesture from the user. Setting `userGesture` to `true` will remove
 this limitation.
 
-### `webFrame.executeJavaScriptInIsolatedWorld(worldId, scripts[, userGesture])`
+### `webFrame.executeJavaScriptInIsolatedWorld(worldId, scripts[, userGesture, callback])`
 
-* `worldId` Integer - The ID of the world to run the javascript in, `0` is the default world, `999` is the world used by Electrons `contextIsolation` feature.  You can provide any integer here.
+* `worldId` Integer - The ID of the world to run the javascript
+            in, `0` is the default main world (where content runs), `999` is the
+            world used by Electron's `contextIsolation` feature. Accepts values
+            in the range 1..536870911.
 * `scripts` [WebSource[]](structures/web-source.md)
 * `userGesture` Boolean (optional) - Default is `false`.
+* `callback` Function (optional) - Called after script has been executed. Unless
+  the frame is suspended (e.g. showing a modal alert), execution will be
+  synchronous and the callback will be invoked before the method returns.  For
+  compatibility with an older version of this method, the error parameter is
+  second.
+  * `result` Any
+  * `error` Error
 
-Returns `Promise<any>` - A promise that resolves with the result of the executed code
-or is rejected if the result of the code is a rejected promise.
+Returns `Promise<any>` - A promise that resolves with the result of the executed
+code or is rejected if execution throws or results in a rejected promise.
 
 Works like `executeJavaScript` but evaluates `scripts` in an isolated context.
 

docs/api/web-request.md

@@ -146,6 +146,7 @@ response are visible by the time this listener is fired.
     * `timestamp` Double
     * `statusLine` String
     * `statusCode` Integer
+    * `requestHeaders` Record<string, string>
     * `responseHeaders` Record<string, string[]> (optional)
   * `callback` Function
     * `headersReceivedResponse` Object
@@ -228,6 +229,7 @@ redirect is about to occur.
     * `fromCache` Boolean
     * `statusCode` Integer
     * `statusLine` String
+    * `error` String
 
 The `listener` will be called with `listener(details)` when a request is
 completed.

docs/tutorial/mojave-dark-mode-guide.md

@@ -1,29 +1,40 @@
-# Mojave Dark Mode
+# Supporting macOS Dark Mode
 
 In macOS 10.14 Mojave, Apple introduced a new [system-wide dark mode](https://developer.apple.com/design/human-interface-guidelines/macos/visual-design/dark-mode/)
-for all macOS computers.  If your app does have a dark mode, you can make your Electron app
-follow the system-wide dark mode setting using [the nativeTheme api](../api/native-theme.md).
+for all macOS computers.  If your Electron app has a dark mode, you can make it follow the
+system-wide dark mode setting using [the `nativeTheme` api](../api/native-theme.md).
 
-In macOS 10.15 Catalina, Apple introduced a new "automatic" dark mode option for all macOS computers. In order
-for the `nativeTheme.shouldUseDarkColors` and `Tray` APIs to work correctly in this mode on Catalina you need to either have `NSRequiresAquaSystemAppearance` set to `false` in your `Info.plist` file or be on Electron `>=7.0.0`.
+In macOS 10.15 Catalina, Apple introduced a new "automatic" dark mode option for all macOS computers.
+In order for the `nativeTheme.shouldUseDarkColors` and `Tray` APIs to work correctly in this mode on
+Catalina, you need to either have `NSRequiresAquaSystemAppearance` set to `false` in your
+`Info.plist` file, or be on Electron `>=7.0.0`. Both [Electron Packager][electron-packager] and
+[Electron Forge][electron-forge] have a [`darwinDarkModeSupport` option][packager-darwindarkmode-api]
+to automate the `Info.plist` changes during app build time.
 
 ## Automatically updating the native interfaces
 
-"Native Interfaces" include the file picker, window border, dialogs, context menus and more; basically anything where
-the UI comes from macOS and not your app.  The default behavior as of Electron 7.0.0 is to opt in to this automatic
-theming from the OS.  If you wish to opt out you must set the `NSRequiresAquaSystemAppearance` key in the `Info.plist` file
-to `true`.  Please note that once Electron starts building against the 10.14 SDK it will not be possible for you to opt
-out of this theming.
+"Native Interfaces" include the file picker, window border, dialogs, context menus and more; basically,
+anything where the UI comes from macOS and not your app. As of Electron 7.0.0, the default behavior
+is to opt in to this automatic theming from the OS. If you wish to opt out and are using Electron
+> 8.0.0, you must set the `NSRequiresAquaSystemAppearance` key in the `Info.plist` file to `true`.
+Please note that Electron 8.0.0 and above will not let your opt out of this theming, due to the use
+of the macOS 10.14 SDK.
 
 ## Automatically updating your own interfaces
 
-If your app has its own dark mode you should toggle it on and off in sync with the system's dark mode setting.  You can do
-this by listening for the theme updated event on Electron's `nativeTheme` module.  E.g.
+If your app has its own dark mode, you should toggle it on and off in sync with the system's dark
+mode setting. You can do this by listening for the theme updated event on Electron's `nativeTheme` module.
 
-```js
+For example:
+
+```javascript
 const { nativeTheme } = require('electron')
 
 nativeTheme.on('updated', function theThemeHasChanged () {
   updateMyAppTheme(nativeTheme.shouldUseDarkColors)
 })
 ```
+
+[electron-forge]: https://www.electronforge.io/
+[electron-packager]: https://github.com/electron/electron-packager
+[packager-darwindarkmode-api]: https://electron.github.io/electron-packager/master/interfaces/electronpackager.options.html#darwindarkmodesupport

electron_paks.gni

@@ -92,10 +92,14 @@ template("electron_extra_paks") {
     }
     if (enable_electron_extensions) {
       sources += [
+        "$root_gen_dir/chrome/component_extension_resources.pak",
         "$root_gen_dir/extensions/extensions_renderer_resources.pak",
         "$root_gen_dir/extensions/extensions_resources.pak",
       ]
-      deps += [ "//extensions:extensions_resources" ]
+      deps += [
+        "//chrome/browser/resources:component_extension_resources",
+        "//extensions:extensions_resources",
+      ]
     }
   }
 }

electron_resources.grd

@@ -17,7 +17,8 @@
       <part file="electron_strings.grdp" />
     </messages>
     <includes>
-      <include name="IDR_CONTENT_SHELL_DEVTOOLS_DISCOVERY_PAGE" file="${target_gen_dir}\shell_devtools_discovery_page.html" use_base_dir="false" type="BINDATA" />
+      <include name="IDR_CONTENT_SHELL_DEVTOOLS_DISCOVERY_PAGE" file="${target_gen_dir}/shell_devtools_discovery_page.html" use_base_dir="false" type="BINDATA" />
+      <include name="IDR_PDF_MANIFEST" file="../chrome/browser/resources/pdf/manifest.json" type="BINDATA" />
     </includes>
   </release>
 </grit>

filenames.auto.gni

@@ -45,6 +45,7 @@ auto_filenames = {
     "docs/api/remote.md",
     "docs/api/sandbox-option.md",
     "docs/api/screen.md",
+    "docs/api/service-workers.md",
     "docs/api/session.md",
     "docs/api/shell.md",
     "docs/api/structures",
@@ -110,6 +111,7 @@ auto_filenames = {
     "docs/api/structures/remove-password.md",
     "docs/api/structures/scrubber-item.md",
     "docs/api/structures/segmented-control-segment.md",
+    "docs/api/structures/service-worker-info.md",
     "docs/api/structures/shared-worker-info.md",
     "docs/api/structures/shortcut-details.md",
     "docs/api/structures/size.md",

filenames.gni

@@ -88,6 +88,8 @@ filenames = {
     "shell/browser/api/electron_api_protocol.h",
     "shell/browser/api/electron_api_screen.cc",
     "shell/browser/api/electron_api_screen.h",
+    "shell/browser/api/electron_api_service_worker_context.cc",
+    "shell/browser/api/electron_api_service_worker_context.h",
     "shell/browser/api/electron_api_session.cc",
     "shell/browser/api/electron_api_session.h",
     "shell/browser/api/electron_api_system_preferences.cc",
@@ -234,12 +236,15 @@ filenames = {
     "shell/browser/net/node_stream_loader.h",
     "shell/browser/net/proxying_url_loader_factory.cc",
     "shell/browser/net/proxying_url_loader_factory.h",
+    "shell/browser/net/proxying_websocket.cc",
+    "shell/browser/net/proxying_websocket.h",
     "shell/browser/net/resolve_proxy_helper.cc",
     "shell/browser/net/resolve_proxy_helper.h",
     "shell/browser/net/system_network_context_manager.cc",
     "shell/browser/net/system_network_context_manager.h",
     "shell/browser/net/url_pipe_loader.cc",
     "shell/browser/net/url_pipe_loader.h",
+    "shell/browser/net/web_request_api_interface.h",
     "shell/browser/network_hints_handler_impl.cc",
     "shell/browser/network_hints_handler_impl.h",
     "shell/browser/node_debugger.cc",
@@ -276,6 +281,8 @@ filenames = {
     "shell/browser/notifications/win/win32_notification.h",
     "shell/browser/notifications/win/windows_toast_notification.cc",
     "shell/browser/notifications/win/windows_toast_notification.h",
+    "shell/browser/plugins/plugin_utils.cc",
+    "shell/browser/plugins/plugin_utils.h",
     "shell/browser/pref_store_delegate.cc",
     "shell/browser/pref_store_delegate.h",
     "shell/browser/relauncher.cc",
@@ -551,8 +558,11 @@ filenames = {
     "shell/common/skia_util.h",
     "shell/common/v8_value_converter.cc",
     "shell/common/v8_value_converter.h",
-    "shell/renderer/api/context_bridge/render_frame_context_bridge_store.cc",
-    "shell/renderer/api/context_bridge/render_frame_context_bridge_store.h",
+    "shell/common/world_ids.h",
+    "shell/renderer/api/context_bridge/object_cache.cc",
+    "shell/renderer/api/context_bridge/object_cache.h",
+    "shell/renderer/api/context_bridge/render_frame_function_store.cc",
+    "shell/renderer/api/context_bridge/render_frame_function_store.h",
     "shell/renderer/api/electron_api_context_bridge.cc",
     "shell/renderer/api/electron_api_context_bridge.h",
     "shell/renderer/api/electron_api_renderer_ipc.cc",
@@ -591,44 +601,54 @@ filenames = {
   ]
 
   lib_sources_extensions = [
+    "shell/browser/extensions/api/i18n/i18n_api.cc",
+    "shell/browser/extensions/api/i18n/i18n_api.h",
+    "shell/browser/extensions/api/resources_private/resources_private_api.cc",
+    "shell/browser/extensions/api/resources_private/resources_private_api.h",
     "shell/browser/extensions/api/runtime/electron_runtime_api_delegate.cc",
     "shell/browser/extensions/api/runtime/electron_runtime_api_delegate.h",
     "shell/browser/extensions/api/tabs/tabs_api.cc",
     "shell/browser/extensions/api/tabs/tabs_api.h",
-    "shell/browser/extensions/electron_extensions_browser_client.cc",
-    "shell/browser/extensions/electron_extensions_browser_client.h",
+    "shell/browser/extensions/api/streams_private/streams_private_api.cc",
+    "shell/browser/extensions/api/streams_private/streams_private_api.h",
     "shell/browser/extensions/electron_browser_context_keyed_service_factories.cc",
     "shell/browser/extensions/electron_browser_context_keyed_service_factories.h",
+    "shell/browser/extensions/electron_component_extension_resource_manager.cc",
+    "shell/browser/extensions/electron_component_extension_resource_manager.h",
     "shell/browser/extensions/electron_display_info_provider.cc",
     "shell/browser/extensions/electron_display_info_provider.h",
     "shell/browser/extensions/electron_extension_host_delegate.cc",
     "shell/browser/extensions/electron_extension_host_delegate.h",
     "shell/browser/extensions/electron_extension_loader.cc",
     "shell/browser/extensions/electron_extension_loader.h",
+    "shell/browser/extensions/electron_extension_message_filter.cc",
+    "shell/browser/extensions/electron_extension_message_filter.h",
     "shell/browser/extensions/electron_extension_system.cc",
     "shell/browser/extensions/electron_extension_system.h",
     "shell/browser/extensions/electron_extension_system_factory.cc",
     "shell/browser/extensions/electron_extension_system_factory.h",
     "shell/browser/extensions/electron_extension_web_contents_observer.cc",
     "shell/browser/extensions/electron_extension_web_contents_observer.h",
-    "shell/browser/extensions/electron_navigation_ui_data.cc",
-    "shell/browser/extensions/electron_navigation_ui_data.h",
-    "shell/browser/extensions/electron_process_manager_delegate.cc",
-    "shell/browser/extensions/electron_process_manager_delegate.h",
     "shell/browser/extensions/electron_extensions_api_client.cc",
     "shell/browser/extensions/electron_extensions_api_client.h",
     "shell/browser/extensions/electron_extensions_browser_api_provider.cc",
     "shell/browser/extensions/electron_extensions_browser_api_provider.h",
+    "shell/browser/extensions/electron_extensions_browser_client.cc",
+    "shell/browser/extensions/electron_extensions_browser_client.h",
     "shell/browser/extensions/electron_messaging_delegate.cc",
     "shell/browser/extensions/electron_messaging_delegate.h",
+    "shell/browser/extensions/electron_navigation_ui_data.cc",
+    "shell/browser/extensions/electron_navigation_ui_data.h",
+    "shell/browser/extensions/electron_process_manager_delegate.cc",
+    "shell/browser/extensions/electron_process_manager_delegate.h",
     "shell/common/extensions/electron_extensions_api_provider.cc",
     "shell/common/extensions/electron_extensions_api_provider.h",
     "shell/common/extensions/electron_extensions_client.cc",
     "shell/common/extensions/electron_extensions_client.h",
-    "shell/renderer/extensions/electron_extensions_renderer_client.cc",
-    "shell/renderer/extensions/electron_extensions_renderer_client.h",
     "shell/renderer/extensions/electron_extensions_dispatcher_delegate.cc",
     "shell/renderer/extensions/electron_extensions_dispatcher_delegate.h",
+    "shell/renderer/extensions/electron_extensions_renderer_client.cc",
+    "shell/renderer/extensions/electron_extensions_renderer_client.h",
   ]
 
   app_sources = [

filenames.hunspell.gni

@@ -44,7 +44,7 @@ hunspell_dictionaries = [
   "//third_party/hunspell_dictionaries/ta-IN-3-0.bdic",
   "//third_party/hunspell_dictionaries/tg-TG-5-0.bdic",
   "//third_party/hunspell_dictionaries/tr-TR-4-0.bdic",
-  "//third_party/hunspell_dictionaries/uk-UA-3-0.bdic",
+  "//third_party/hunspell_dictionaries/uk-UA-4-0.bdic",
   "//third_party/hunspell_dictionaries/vi-VN-3-0.bdic",
   "//third_party/hunspell_dictionaries/xx-XX-3-0.bdic",
 ]

lib/browser/api/app.ts

@@ -1,21 +1,44 @@
-import * as fs from 'fs'
-import * as path from 'path'
+import * as fs from 'fs';
+import * as path from 'path';
 
-import { deprecate, Menu } from 'electron'
-import { EventEmitter } from 'events'
+import { Menu } from 'electron';
+import { EventEmitter } from 'events';
 
-const bindings = process.electronBinding('app')
-const commandLine = process.electronBinding('command_line')
-const { app, App } = bindings
+const bindings = process.electronBinding('app');
+const commandLine = process.electronBinding('command_line');
+const { app, App } = bindings;
 
 // Only one app object permitted.
-export default app
+export default app;
 
-let dockMenu: Electron.Menu | null = null
+let dockMenu: Electron.Menu | null = null;
 
 // App is an EventEmitter.
-Object.setPrototypeOf(App.prototype, EventEmitter.prototype)
-EventEmitter.call(app as any)
+Object.setPrototypeOf(App.prototype, EventEmitter.prototype);
+EventEmitter.call(app as any);
+
+// Properties.
+
+const nativeASGetter = app.isAccessibilitySupportEnabled;
+const nativeASSetter = app.setAccessibilitySupportEnabled;
+Object.defineProperty(App.prototype, 'accessibilitySupportEnabled', {
+  get: () => nativeASGetter.call(app),
+  set: (enabled) => nativeASSetter.call(app, enabled)
+});
+
+const nativeBCGetter = app.getBadgeCount;
+const nativeBCSetter = app.setBadgeCount;
+Object.defineProperty(App.prototype, 'badgeCount', {
+  get: () => nativeBCGetter.call(app),
+  set: (count) => nativeBCSetter.call(app, count)
+});
+
+const nativeNGetter = app.getName;
+const nativeNSetter = app.setName;
+Object.defineProperty(App.prototype, 'name', {
+  get: () => nativeNGetter.call(app),
+  set: (name) => nativeNSetter.call(app, name)
+});
 
 Object.assign(app, {
   commandLine: {
@@ -24,99 +47,94 @@ Object.assign(app, {
     appendSwitch: (theSwitch: string, value?: string) => commandLine.appendSwitch(String(theSwitch), typeof value === 'undefined' ? value : String(value)),
     appendArgument: (arg: string) => commandLine.appendArgument(String(arg))
   } as Electron.CommandLine
-})
+});
 
 // we define this here because it'd be overly complicated to
 // do in native land
 Object.defineProperty(app, 'applicationMenu', {
   get () {
-    return Menu.getApplicationMenu()
+    return Menu.getApplicationMenu();
   },
   set (menu: Electron.Menu | null) {
-    return Menu.setApplicationMenu(menu)
+    return Menu.setApplicationMenu(menu);
   }
-})
+});
 
 App.prototype.isPackaged = (() => {
-  const execFile = path.basename(process.execPath).toLowerCase()
+  const execFile = path.basename(process.execPath).toLowerCase();
   if (process.platform === 'win32') {
-    return execFile !== 'electron.exe'
+    return execFile !== 'electron.exe';
   }
-  return execFile !== 'electron'
-})()
+  return execFile !== 'electron';
+})();
 
 app._setDefaultAppPaths = (packagePath) => {
   // Set the user path according to application's name.
-  app.setPath('userData', path.join(app.getPath('appData'), app.name!))
-  app.setPath('userCache', path.join(app.getPath('cache'), app.name!))
-  app.setAppPath(packagePath)
+  app.setPath('userData', path.join(app.getPath('appData'), app.name!));
+  app.setPath('userCache', path.join(app.getPath('cache'), app.name!));
+  app.setAppPath(packagePath);
 
   // Add support for --user-data-dir=
   if (app.commandLine.hasSwitch('user-data-dir')) {
-    const userDataDir = app.commandLine.getSwitchValue('user-data-dir')
-    if (path.isAbsolute(userDataDir)) app.setPath('userData', userDataDir)
+    const userDataDir = app.commandLine.getSwitchValue('user-data-dir');
+    if (path.isAbsolute(userDataDir)) app.setPath('userData', userDataDir);
   }
-}
+};
 
 if (process.platform === 'darwin') {
-  const setDockMenu = app.dock!.setMenu
+  const setDockMenu = app.dock!.setMenu;
   app.dock!.setMenu = (menu) => {
-    dockMenu = menu
-    setDockMenu(menu)
-  }
-  app.dock!.getMenu = () => dockMenu
+    dockMenu = menu;
+    setDockMenu(menu);
+  };
+  app.dock!.getMenu = () => dockMenu;
 }
 
 if (process.platform === 'linux') {
-  const patternVmRSS = /^VmRSS:\s*(\d+) kB$/m
-  const patternVmHWM = /^VmHWM:\s*(\d+) kB$/m
+  const patternVmRSS = /^VmRSS:\s*(\d+) kB$/m;
+  const patternVmHWM = /^VmHWM:\s*(\d+) kB$/m;
 
   const getStatus = (pid: number) => {
     try {
-      return fs.readFileSync(`/proc/${pid}/status`, 'utf8')
+      return fs.readFileSync(`/proc/${pid}/status`, 'utf8');
     } catch {
-      return ''
+      return '';
     }
-  }
+  };
 
   const getEntry = (file: string, pattern: RegExp) => {
-    const match = file.match(pattern)
-    return match ? parseInt(match[1], 10) : 0
-  }
+    const match = file.match(pattern);
+    return match ? parseInt(match[1], 10) : 0;
+  };
 
   const getProcessMemoryInfo = (pid: number) => {
-    const file = getStatus(pid)
+    const file = getStatus(pid);
 
     return {
       workingSetSize: getEntry(file, patternVmRSS),
       peakWorkingSetSize: getEntry(file, patternVmHWM)
-    }
-  }
+    };
+  };
 
-  const nativeFn = app.getAppMetrics
+  const nativeFn = app.getAppMetrics;
   app.getAppMetrics = () => {
-    const metrics = nativeFn.call(app)
+    const metrics = nativeFn.call(app);
     for (const metric of metrics) {
-      metric.memory = getProcessMemoryInfo(metric.pid)
+      metric.memory = getProcessMemoryInfo(metric.pid);
     }
 
-    return metrics
-  }
+    return metrics;
+  };
 }
 
 // Routes the events to webContents.
-const events = ['certificate-error', 'select-client-certificate']
+const events = ['certificate-error', 'select-client-certificate'];
 for (const name of events) {
   app.on(name as 'certificate-error', (event, webContents, ...args: any[]) => {
-    webContents.emit(name, event, ...args)
-  })
+    webContents.emit(name, event, ...args);
+  });
 }
 
-// Property Deprecations
-deprecate.fnToProperty(App.prototype, 'accessibilitySupportEnabled', '_isAccessibilitySupportEnabled', '_setAccessibilitySupportEnabled')
-deprecate.fnToProperty(App.prototype, 'badgeCount', '_getBadgeCount', '_setBadgeCount')
-deprecate.fnToProperty(App.prototype, 'name', '_getName', '_setName')
-
 // Wrappers for native classes.
-const { DownloadItem } = process.electronBinding('download_item')
-Object.setPrototypeOf(DownloadItem.prototype, EventEmitter.prototype)
+const { DownloadItem } = process.electronBinding('download_item');
+Object.setPrototypeOf(DownloadItem.prototype, EventEmitter.prototype);

lib/browser/api/auto-updater.js

@@ -1,7 +1,7 @@
-'use strict'
+'use strict';
 
 if (process.platform === 'win32') {
-  module.exports = require('@electron/internal/browser/api/auto-updater/auto-updater-win')
+  module.exports = require('@electron/internal/browser/api/auto-updater/auto-updater-win');
 } else {
-  module.exports = require('@electron/internal/browser/api/auto-updater/auto-updater-native')
+  module.exports = require('@electron/internal/browser/api/auto-updater/auto-updater-native');
 }

lib/browser/api/auto-updater/auto-updater-native.js

@@ -1,10 +1,10 @@
-'use strict'
+'use strict';
 
-const EventEmitter = require('events').EventEmitter
-const { autoUpdater, AutoUpdater } = process.electronBinding('auto_updater')
+const EventEmitter = require('events').EventEmitter;
+const { autoUpdater, AutoUpdater } = process.electronBinding('auto_updater');
 
 // AutoUpdater is an EventEmitter.
-Object.setPrototypeOf(AutoUpdater.prototype, EventEmitter.prototype)
-EventEmitter.call(autoUpdater)
+Object.setPrototypeOf(AutoUpdater.prototype, EventEmitter.prototype);
+EventEmitter.call(autoUpdater);
 
-module.exports = autoUpdater
+module.exports = autoUpdater;

lib/browser/api/auto-updater/auto-updater-win.js

@@ -1,74 +1,74 @@
-'use strict'
+'use strict';
 
-const { app } = require('electron')
-const { EventEmitter } = require('events')
-const squirrelUpdate = require('@electron/internal/browser/api/auto-updater/squirrel-update-win')
+const { app } = require('electron');
+const { EventEmitter } = require('events');
+const squirrelUpdate = require('@electron/internal/browser/api/auto-updater/squirrel-update-win');
 
 class AutoUpdater extends EventEmitter {
   quitAndInstall () {
     if (!this.updateAvailable) {
-      return this.emitError('No update available, can\'t quit and install')
+      return this.emitError('No update available, can\'t quit and install');
     }
-    squirrelUpdate.processStart()
-    app.quit()
+    squirrelUpdate.processStart();
+    app.quit();
   }
 
   getFeedURL () {
-    return this.updateURL
+    return this.updateURL;
   }
 
   setFeedURL (options) {
-    let updateURL
+    let updateURL;
     if (typeof options === 'object') {
       if (typeof options.url === 'string') {
-        updateURL = options.url
+        updateURL = options.url;
       } else {
-        throw new Error('Expected options object to contain a \'url\' string property in setFeedUrl call')
+        throw new Error('Expected options object to contain a \'url\' string property in setFeedUrl call');
       }
     } else if (typeof options === 'string') {
-      updateURL = options
+      updateURL = options;
     } else {
-      throw new Error('Expected an options object with a \'url\' property to be provided')
+      throw new Error('Expected an options object with a \'url\' property to be provided');
     }
-    this.updateURL = updateURL
+    this.updateURL = updateURL;
   }
 
   checkForUpdates () {
     if (!this.updateURL) {
-      return this.emitError('Update URL is not set')
+      return this.emitError('Update URL is not set');
     }
     if (!squirrelUpdate.supported()) {
-      return this.emitError('Can not find Squirrel')
+      return this.emitError('Can not find Squirrel');
     }
-    this.emit('checking-for-update')
+    this.emit('checking-for-update');
     squirrelUpdate.checkForUpdate(this.updateURL, (error, update) => {
       if (error != null) {
-        return this.emitError(error)
+        return this.emitError(error);
       }
       if (update == null) {
-        return this.emit('update-not-available')
+        return this.emit('update-not-available');
       }
-      this.updateAvailable = true
-      this.emit('update-available')
+      this.updateAvailable = true;
+      this.emit('update-available');
       squirrelUpdate.update(this.updateURL, (error) => {
         if (error != null) {
-          return this.emitError(error)
+          return this.emitError(error);
         }
-        const { releaseNotes, version } = update
+        const { releaseNotes, version } = update;
         // Date is not available on Windows, so fake it.
-        const date = new Date()
+        const date = new Date();
         this.emit('update-downloaded', {}, releaseNotes, version, date, this.updateURL, () => {
-          this.quitAndInstall()
-        })
-      })
-    })
+          this.quitAndInstall();
+        });
+      });
+    });
   }
 
   // Private: Emit both error object and message, this is to keep compatibility
   // with Old APIs.
   emitError (message) {
-    this.emit('error', new Error(message), message)
+    this.emit('error', new Error(message), message);
   }
 }
 
-module.exports = new AutoUpdater()
+module.exports = new AutoUpdater();

lib/browser/api/auto-updater/squirrel-update-win.js

@@ -1,24 +1,24 @@
-'use strict'
+'use strict';
 
-const fs = require('fs')
-const path = require('path')
-const spawn = require('child_process').spawn
+const fs = require('fs');
+const path = require('path');
+const spawn = require('child_process').spawn;
 
 // i.e. my-app/app-0.1.13/
-const appFolder = path.dirname(process.execPath)
+const appFolder = path.dirname(process.execPath);
 
 // i.e. my-app/Update.exe
-const updateExe = path.resolve(appFolder, '..', 'Update.exe')
-const exeName = path.basename(process.execPath)
-let spawnedArgs = []
-let spawnedProcess
+const updateExe = path.resolve(appFolder, '..', 'Update.exe');
+const exeName = path.basename(process.execPath);
+let spawnedArgs = [];
+let spawnedProcess;
 
-const isSameArgs = (args) => args.length === spawnedArgs.length && args.every((e, i) => e === spawnedArgs[i])
+const isSameArgs = (args) => args.length === spawnedArgs.length && args.every((e, i) => e === spawnedArgs[i]);
 
 // Spawn a command and invoke the callback when it completes with an error
 // and the output from standard out.
 const spawnUpdate = function (args, detached, callback) {
-  let error, errorEmitted, stderr, stdout
+  let error, errorEmitted, stderr, stdout;
 
   try {
     // Ensure we don't spawn multiple squirrel processes
@@ -28,92 +28,92 @@ const spawnUpdate = function (args, detached, callback) {
     if (spawnedProcess && !isSameArgs(args)) {
       // Disabled for backwards compatibility:
       // eslint-disable-next-line standard/no-callback-literal
-      return callback(`AutoUpdater process with arguments ${args} is already running`)
+      return callback(`AutoUpdater process with arguments ${args} is already running`);
     } else if (!spawnedProcess) {
       spawnedProcess = spawn(updateExe, args, {
         detached: detached,
         windowsHide: true
-      })
-      spawnedArgs = args || []
+      });
+      spawnedArgs = args || [];
     }
   } catch (error1) {
-    error = error1
+    error = error1;
 
     // Shouldn't happen, but still guard it.
     process.nextTick(function () {
-      return callback(error)
-    })
-    return
+      return callback(error);
+    });
+    return;
   }
-  stdout = ''
-  stderr = ''
+  stdout = '';
+  stderr = '';
 
-  spawnedProcess.stdout.on('data', (data) => { stdout += data })
-  spawnedProcess.stderr.on('data', (data) => { stderr += data })
+  spawnedProcess.stdout.on('data', (data) => { stdout += data; });
+  spawnedProcess.stderr.on('data', (data) => { stderr += data; });
 
-  errorEmitted = false
+  errorEmitted = false;
   spawnedProcess.on('error', (error) => {
-    errorEmitted = true
-    callback(error)
-  })
+    errorEmitted = true;
+    callback(error);
+  });
 
   return spawnedProcess.on('exit', function (code, signal) {
-    spawnedProcess = undefined
-    spawnedArgs = []
+    spawnedProcess = undefined;
+    spawnedArgs = [];
 
     // We may have already emitted an error.
     if (errorEmitted) {
-      return
+      return;
     }
 
     // Process terminated with error.
     if (code !== 0) {
       // Disabled for backwards compatibility:
       // eslint-disable-next-line standard/no-callback-literal
-      return callback(`Command failed: ${signal != null ? signal : code}\n${stderr}`)
+      return callback(`Command failed: ${signal != null ? signal : code}\n${stderr}`);
     }
 
     // Success.
-    callback(null, stdout)
-  })
-}
+    callback(null, stdout);
+  });
+};
 
 // Start an instance of the installed app.
 exports.processStart = function () {
-  return spawnUpdate(['--processStartAndWait', exeName], true, function () {})
-}
+  return spawnUpdate(['--processStartAndWait', exeName], true, function () {});
+};
 
 // Download the releases specified by the URL and write new results to stdout.
 exports.checkForUpdate = function (updateURL, callback) {
   return spawnUpdate(['--checkForUpdate', updateURL], false, function (error, stdout) {
-    let ref, ref1, update
+    let ref, ref1, update;
     if (error != null) {
-      return callback(error)
+      return callback(error);
     }
     try {
       // Last line of output is the JSON details about the releases
-      const json = stdout.trim().split('\n').pop()
-      update = (ref = JSON.parse(json)) != null ? (ref1 = ref.releasesToApply) != null ? typeof ref1.pop === 'function' ? ref1.pop() : void 0 : void 0 : void 0
+      const json = stdout.trim().split('\n').pop();
+      update = (ref = JSON.parse(json)) != null ? (ref1 = ref.releasesToApply) != null ? typeof ref1.pop === 'function' ? ref1.pop() : void 0 : void 0 : void 0;
     } catch {
       // Disabled for backwards compatibility:
       // eslint-disable-next-line standard/no-callback-literal
-      return callback(`Invalid result:\n${stdout}`)
+      return callback(`Invalid result:\n${stdout}`);
     }
-    return callback(null, update)
-  })
-}
+    return callback(null, update);
+  });
+};
 
 // Update the application to the latest remote version specified by URL.
 exports.update = function (updateURL, callback) {
-  return spawnUpdate(['--update', updateURL], false, callback)
-}
+  return spawnUpdate(['--update', updateURL], false, callback);
+};
 
 // Is the Update.exe installed with the current application?
 exports.supported = function () {
   try {
-    fs.accessSync(updateExe, fs.R_OK)
-    return true
+    fs.accessSync(updateExe, fs.R_OK);
+    return true;
   } catch {
-    return false
+    return false;
   }
-}
+};

lib/browser/api/browser-view.js

@@ -1,16 +1,16 @@
-'use strict'
+'use strict';
 
-const { EventEmitter } = require('events')
-const { BrowserView } = process.electronBinding('browser_view')
+const { EventEmitter } = require('events');
+const { BrowserView } = process.electronBinding('browser_view');
 
-Object.setPrototypeOf(BrowserView.prototype, EventEmitter.prototype)
+Object.setPrototypeOf(BrowserView.prototype, EventEmitter.prototype);
 
 BrowserView.fromWebContents = (webContents) => {
   for (const view of BrowserView.getAllViews()) {
-    if (view.webContents.equal(webContents)) return view
+    if (view.webContents.equal(webContents)) return view;
   }
 
-  return null
-}
+  return null;
+};
 
-module.exports = BrowserView
+module.exports = BrowserView;

lib/browser/api/browser-window.js

@@ -1,49 +1,49 @@
-'use strict'
+'use strict';
 
-const electron = require('electron')
-const { WebContentsView, TopLevelWindow, deprecate } = electron
-const { BrowserWindow } = process.electronBinding('window')
+const electron = require('electron');
+const { WebContentsView, TopLevelWindow, deprecate } = electron;
+const { BrowserWindow } = process.electronBinding('window');
 
-Object.setPrototypeOf(BrowserWindow.prototype, TopLevelWindow.prototype)
+Object.setPrototypeOf(BrowserWindow.prototype, TopLevelWindow.prototype);
 
 BrowserWindow.prototype._init = function () {
   // Call parent class's _init.
-  TopLevelWindow.prototype._init.call(this)
+  TopLevelWindow.prototype._init.call(this);
 
   // Avoid recursive require.
-  const { app } = electron
+  const { app } = electron;
 
   // Create WebContentsView.
-  this.setContentView(new WebContentsView(this.webContents))
+  this.setContentView(new WebContentsView(this.webContents));
 
-  const nativeSetBounds = this.setBounds
+  const nativeSetBounds = this.setBounds;
   this.setBounds = (bounds, ...opts) => {
     bounds = {
       ...this.getBounds(),
       ...bounds
-    }
-    nativeSetBounds.call(this, bounds, ...opts)
-  }
+    };
+    nativeSetBounds.call(this, bounds, ...opts);
+  };
 
   // window.resizeTo(...)
   // window.moveTo(...)
   this.webContents.on('move', (event, size) => {
-    this.setBounds(size)
-  })
+    this.setBounds(size);
+  });
 
   // Hide the auto-hide menu when webContents is focused.
   this.webContents.on('activate', () => {
     if (process.platform !== 'darwin' && this.autoHideMenuBar && this.isMenuBarVisible()) {
-      this.setMenuBarVisibility(false)
+      this.setMenuBarVisibility(false);
     }
-  })
+  });
 
   // Change window title to page title.
   this.webContents.on('page-title-updated', (event, title, ...args) => {
     // Route the event to BrowserWindow.
-    this.emit('page-title-updated', event, title, ...args)
-    if (!this.isDestroyed() && !event.defaultPrevented) this.setTitle(title)
-  })
+    this.emit('page-title-updated', event, title, ...args);
+    if (!this.isDestroyed() && !event.defaultPrevented) this.setTitle(title);
+  });
 
   // Sometimes the webContents doesn't get focus when window is shown, so we
   // have to force focusing on webContents in this case. The safest way is to
@@ -54,144 +54,172 @@ BrowserWindow.prototype._init = function () {
   // Finder, we still do it on all platforms in case of other bugs we don't
   // know.
   this.webContents.once('load-url', function () {
-    this.focus()
-  })
+    this.focus();
+  });
 
   // Redirect focus/blur event to app instance too.
   this.on('blur', (event) => {
-    app.emit('browser-window-blur', event, this)
-  })
+    app.emit('browser-window-blur', event, this);
+  });
   this.on('focus', (event) => {
-    app.emit('browser-window-focus', event, this)
-  })
+    app.emit('browser-window-focus', event, this);
+  });
 
   // Subscribe to visibilityState changes and pass to renderer process.
-  let isVisible = this.isVisible() && !this.isMinimized()
+  let isVisible = this.isVisible() && !this.isMinimized();
   const visibilityChanged = () => {
-    const newState = this.isVisible() && !this.isMinimized()
+    const newState = this.isVisible() && !this.isMinimized();
     if (isVisible !== newState) {
-      isVisible = newState
-      const visibilityState = isVisible ? 'visible' : 'hidden'
-      this.webContents.emit('-window-visibility-change', visibilityState)
+      isVisible = newState;
+      const visibilityState = isVisible ? 'visible' : 'hidden';
+      this.webContents.emit('-window-visibility-change', visibilityState);
     }
-  }
+  };
 
-  const visibilityEvents = ['show', 'hide', 'minimize', 'maximize', 'restore']
+  const visibilityEvents = ['show', 'hide', 'minimize', 'maximize', 'restore'];
   for (const event of visibilityEvents) {
-    this.on(event, visibilityChanged)
+    this.on(event, visibilityChanged);
   }
 
   // Notify the creation of the window.
-  const event = process.electronBinding('event').createEmpty()
-  app.emit('browser-window-created', event, this)
+  const event = process.electronBinding('event').createEmpty();
+  app.emit('browser-window-created', event, this);
 
   Object.defineProperty(this, 'devToolsWebContents', {
     enumerable: true,
     configurable: false,
     get () {
-      return this.webContents.devToolsWebContents
+      return this.webContents.devToolsWebContents;
     }
-  })
-}
+  });
+
+  // Properties
+
+  Object.defineProperty(this, 'autoHideMenuBar', {
+    get: () => this.isMenuBarAutoHide(),
+    set: (autoHide) => this.setAutoHideMenuBar(autoHide)
+  });
+
+  Object.defineProperty(this, 'minimizable', {
+    get: () => this.isMinimizable(),
+    set: (min) => this.setMinimizable(min)
+  });
+
+  Object.defineProperty(this, 'maximizable', {
+    get: () => this.isMaximizable(),
+    set: (max) => this.setMaximizable(max)
+  });
+
+  Object.defineProperty(this, 'resizable', {
+    get: () => this.isResizable(),
+    set: (res) => this.setResizable(res)
+  });
+
+  Object.defineProperty(this, 'fullScreenable', {
+    get: () => this.isFullScreenable(),
+    set: (full) => this.setFullScreenable(full)
+  });
+
+  Object.defineProperty(this, 'closable', {
+    get: () => this.isClosable(),
+    set: (close) => this.setClosable(close)
+  });
+
+  Object.defineProperty(this, 'movable', {
+    get: () => this.isMovable(),
+    set: (move) => this.setMovable(move)
+  });
+};
 
 const isBrowserWindow = (win) => {
-  return win && win.constructor.name === 'BrowserWindow'
-}
+  return win && win.constructor.name === 'BrowserWindow';
+};
 
 BrowserWindow.fromId = (id) => {
-  const win = TopLevelWindow.fromId(id)
-  return isBrowserWindow(win) ? win : null
-}
+  const win = TopLevelWindow.fromId(id);
+  return isBrowserWindow(win) ? win : null;
+};
 
 BrowserWindow.getAllWindows = () => {
-  return TopLevelWindow.getAllWindows().filter(isBrowserWindow)
-}
+  return TopLevelWindow.getAllWindows().filter(isBrowserWindow);
+};
 
 BrowserWindow.getFocusedWindow = () => {
   for (const window of BrowserWindow.getAllWindows()) {
-    if (window.isFocused() || window.isDevToolsFocused()) return window
+    if (window.isFocused() || window.isDevToolsFocused()) return window;
   }
-  return null
-}
+  return null;
+};
 
 BrowserWindow.fromWebContents = (webContents) => {
   for (const window of BrowserWindow.getAllWindows()) {
-    if (window.webContents && window.webContents.equal(webContents)) return window
+    if (window.webContents && window.webContents.equal(webContents)) return window;
   }
 
-  return null
-}
+  return null;
+};
 
 BrowserWindow.fromBrowserView = (browserView) => {
   for (const window of BrowserWindow.getAllWindows()) {
-    if (window.getBrowserView() === browserView) return window
+    if (window.getBrowserView() === browserView) return window;
   }
 
-  return null
-}
+  return null;
+};
 
 // Helpers.
 Object.assign(BrowserWindow.prototype, {
   loadURL (...args) {
-    return this.webContents.loadURL(...args)
+    return this.webContents.loadURL(...args);
   },
   getURL (...args) {
-    return this.webContents.getURL()
+    return this.webContents.getURL();
   },
   loadFile (...args) {
-    return this.webContents.loadFile(...args)
+    return this.webContents.loadFile(...args);
   },
   reload (...args) {
-    return this.webContents.reload(...args)
+    return this.webContents.reload(...args);
   },
   send (...args) {
-    return this.webContents.send(...args)
+    return this.webContents.send(...args);
   },
   openDevTools (...args) {
-    return this.webContents.openDevTools(...args)
+    return this.webContents.openDevTools(...args);
   },
   closeDevTools () {
-    return this.webContents.closeDevTools()
+    return this.webContents.closeDevTools();
   },
   isDevToolsOpened () {
-    return this.webContents.isDevToolsOpened()
+    return this.webContents.isDevToolsOpened();
   },
   isDevToolsFocused () {
-    return this.webContents.isDevToolsFocused()
+    return this.webContents.isDevToolsFocused();
   },
   toggleDevTools () {
-    return this.webContents.toggleDevTools()
+    return this.webContents.toggleDevTools();
   },
   inspectElement (...args) {
-    return this.webContents.inspectElement(...args)
+    return this.webContents.inspectElement(...args);
   },
   inspectSharedWorker () {
-    return this.webContents.inspectSharedWorker()
+    return this.webContents.inspectSharedWorker();
   },
   inspectServiceWorker () {
-    return this.webContents.inspectServiceWorker()
+    return this.webContents.inspectServiceWorker();
   },
   showDefinitionForSelection () {
-    return this.webContents.showDefinitionForSelection()
+    return this.webContents.showDefinitionForSelection();
   },
   capturePage (...args) {
-    return this.webContents.capturePage(...args)
+    return this.webContents.capturePage(...args);
   },
   setTouchBar (touchBar) {
-    electron.TouchBar._setOnWindow(touchBar, this)
+    electron.TouchBar._setOnWindow(touchBar, this);
   },
   setBackgroundThrottling (allowed) {
-    this.webContents.setBackgroundThrottling(allowed)
+    this.webContents.setBackgroundThrottling(allowed);
   }
-})
+});
 
-// Deprecations
-deprecate.fnToProperty(BrowserWindow.prototype, 'autoHideMenuBar', '_isMenuBarAutoHide', '_setAutoHideMenuBar')
-deprecate.fnToProperty(BrowserWindow.prototype, 'minimizable', '_isMinimizable', '_setMinimizable')
-deprecate.fnToProperty(BrowserWindow.prototype, 'maximizable', '_isMaximizable', '_setMaximizable')
-deprecate.fnToProperty(BrowserWindow.prototype, 'resizable', '_isResizable', '_setResizable')
-deprecate.fnToProperty(BrowserWindow.prototype, 'fullScreenable', '_isFullScreenable', '_setFullScreenable')
-deprecate.fnToProperty(BrowserWindow.prototype, 'closable', '_isClosable', '_setClosable')
-deprecate.fnToProperty(BrowserWindow.prototype, 'movable', '_isMovable', '_setMovable')
-
-module.exports = BrowserWindow
+module.exports = BrowserWindow;

lib/browser/api/content-tracing.js

@@ -1,2 +1,2 @@
-'use strict'
-module.exports = process.electronBinding('content_tracing')
+'use strict';
+module.exports = process.electronBinding('content_tracing');

lib/browser/api/crash-reporter.js

@@ -1,12 +1,12 @@
-'use strict'
+'use strict';
 
-const CrashReporter = require('@electron/internal/common/crash-reporter')
-const { crashReporterInit } = require('@electron/internal/browser/crash-reporter-init')
+const CrashReporter = require('@electron/internal/common/crash-reporter');
+const { crashReporterInit } = require('@electron/internal/browser/crash-reporter-init');
 
 class CrashReporterMain extends CrashReporter {
   init (options) {
-    return crashReporterInit(options)
+    return crashReporterInit(options);
   }
 }
 
-module.exports = new CrashReporterMain()
+module.exports = new CrashReporterMain();

lib/browser/api/dialog.js

@@ -1,13 +1,13 @@
-'use strict'
+'use strict';
 
-const { app, BrowserWindow, deprecate } = require('electron')
-const binding = process.electronBinding('dialog')
-const v8Util = process.electronBinding('v8_util')
+const { app, BrowserWindow, deprecate } = require('electron');
+const binding = process.electronBinding('dialog');
+const v8Util = process.electronBinding('v8_util');
 
 const DialogType = {
   OPEN: 'OPEN',
   SAVE: 'SAVE'
-}
+};
 
 const saveFileDialogProperties = {
   createDirectory: 1 << 0,
@@ -15,7 +15,7 @@ const saveFileDialogProperties = {
   treatPackageAsDirectory: 1 << 2,
   showOverwriteConfirmation: 1 << 3,
   dontAddToRecent: 1 << 4
-}
+};
 
 const openFileDialogProperties = {
   openFile: 1 << 0,
@@ -27,15 +27,15 @@ const openFileDialogProperties = {
   noResolveAliases: 1 << 6, // macOS
   treatPackageAsDirectory: 1 << 7, // macOS
   dontAddToRecent: 1 << 8 // Windows
-}
+};
 
 const normalizeAccessKey = (text) => {
-  if (typeof text !== 'string') return text
+  if (typeof text !== 'string') return text;
 
   // macOS does not have access keys so remove single ampersands
   // and replace double ampersands with a single ampersand
   if (process.platform === 'darwin') {
-    return text.replace(/&(&?)/g, '$1')
+    return text.replace(/&(&?)/g, '$1');
   }
 
   // Linux uses a single underscore as an access key prefix so escape
@@ -44,41 +44,41 @@ const normalizeAccessKey = (text) => {
   // a single underscore
   if (process.platform === 'linux') {
     return text.replace(/_/g, '__').replace(/&(.?)/g, (match, after) => {
-      if (after === '&') return after
-      return `_${after}`
-    })
+      if (after === '&') return after;
+      return `_${after}`;
+    });
   }
 
-  return text
-}
+  return text;
+};
 
 const checkAppInitialized = function () {
   if (!app.isReady()) {
-    throw new Error('dialog module can only be used after app is ready')
+    throw new Error('dialog module can only be used after app is ready');
   }
-}
+};
 
 const setupDialogProperties = (type, properties) => {
-  const dialogPropertiesTypes = (type === DialogType.OPEN) ? openFileDialogProperties : saveFileDialogProperties
-  let dialogProperties = 0
+  const dialogPropertiesTypes = (type === DialogType.OPEN) ? openFileDialogProperties : saveFileDialogProperties;
+  let dialogProperties = 0;
   for (const prop in dialogPropertiesTypes) {
     if (properties.includes(prop)) {
-      dialogProperties |= dialogPropertiesTypes[prop]
+      dialogProperties |= dialogPropertiesTypes[prop];
     }
   }
 
-  return dialogProperties
-}
+  return dialogProperties;
+};
 
 const saveDialog = (sync, window, options) => {
-  checkAppInitialized()
+  checkAppInitialized();
 
   if (window && window.constructor !== BrowserWindow) {
-    options = window
-    window = null
+    options = window;
+    window = null;
   }
 
-  if (options == null) options = { title: 'Save' }
+  if (options == null) options = { title: 'Save' };
 
   const {
     buttonLabel = '',
@@ -90,33 +90,33 @@ const saveDialog = (sync, window, options) => {
     securityScopedBookmarks = false,
     nameFieldLabel = '',
     showsTagField = true
-  } = options
+  } = options;
 
-  if (typeof title !== 'string') throw new TypeError('Title must be a string')
-  if (typeof buttonLabel !== 'string') throw new TypeError('Button label must be a string')
-  if (typeof defaultPath !== 'string') throw new TypeError('Default path must be a string')
-  if (typeof message !== 'string') throw new TypeError('Message must be a string')
-  if (typeof nameFieldLabel !== 'string') throw new TypeError('Name field label must be a string')
+  if (typeof title !== 'string') throw new TypeError('Title must be a string');
+  if (typeof buttonLabel !== 'string') throw new TypeError('Button label must be a string');
+  if (typeof defaultPath !== 'string') throw new TypeError('Default path must be a string');
+  if (typeof message !== 'string') throw new TypeError('Message must be a string');
+  if (typeof nameFieldLabel !== 'string') throw new TypeError('Name field label must be a string');
 
-  const settings = { buttonLabel, defaultPath, filters, title, message, securityScopedBookmarks, nameFieldLabel, showsTagField, window }
-  settings.properties = setupDialogProperties(DialogType.SAVE, properties)
+  const settings = { buttonLabel, defaultPath, filters, title, message, securityScopedBookmarks, nameFieldLabel, showsTagField, window };
+  settings.properties = setupDialogProperties(DialogType.SAVE, properties);
 
-  return (sync) ? binding.showSaveDialogSync(settings) : binding.showSaveDialog(settings)
-}
+  return (sync) ? binding.showSaveDialogSync(settings) : binding.showSaveDialog(settings);
+};
 
 const openDialog = (sync, window, options) => {
-  checkAppInitialized()
+  checkAppInitialized();
 
   if (window && window.constructor !== BrowserWindow) {
-    options = window
-    window = null
+    options = window;
+    window = null;
   }
 
   if (options == null) {
     options = {
       title: 'Open',
       properties: ['openFile']
-    }
+    };
   }
 
   const {
@@ -127,33 +127,33 @@ const openDialog = (sync, window, options) => {
     title = '',
     message = '',
     securityScopedBookmarks = false
-  } = options
+  } = options;
 
-  if (!Array.isArray(properties)) throw new TypeError('Properties must be an array')
+  if (!Array.isArray(properties)) throw new TypeError('Properties must be an array');
 
-  if (typeof title !== 'string') throw new TypeError('Title must be a string')
-  if (typeof buttonLabel !== 'string') throw new TypeError('Button label must be a string')
-  if (typeof defaultPath !== 'string') throw new TypeError('Default path must be a string')
-  if (typeof message !== 'string') throw new TypeError('Message must be a string')
+  if (typeof title !== 'string') throw new TypeError('Title must be a string');
+  if (typeof buttonLabel !== 'string') throw new TypeError('Button label must be a string');
+  if (typeof defaultPath !== 'string') throw new TypeError('Default path must be a string');
+  if (typeof message !== 'string') throw new TypeError('Message must be a string');
 
-  const settings = { title, buttonLabel, defaultPath, filters, message, securityScopedBookmarks, window }
-  settings.properties = setupDialogProperties(DialogType.OPEN, properties)
+  const settings = { title, buttonLabel, defaultPath, filters, message, securityScopedBookmarks, window };
+  settings.properties = setupDialogProperties(DialogType.OPEN, properties);
 
-  return (sync) ? binding.showOpenDialogSync(settings) : binding.showOpenDialog(settings)
-}
+  return (sync) ? binding.showOpenDialogSync(settings) : binding.showOpenDialog(settings);
+};
 
 const messageBox = (sync, window, options) => {
-  checkAppInitialized()
+  checkAppInitialized();
 
   if (window && window.constructor !== BrowserWindow) {
-    options = window
-    window = null
+    options = window;
+    window = null;
   }
 
-  if (options == null) options = { type: 'none' }
+  if (options == null) options = { type: 'none' };
 
-  const messageBoxTypes = ['none', 'info', 'warning', 'error', 'question']
-  const messageBoxOptions = { noLink: 1 << 0 }
+  const messageBoxTypes = ['none', 'info', 'warning', 'error', 'question'];
+  const messageBoxOptions = { noLink: 1 << 0 };
 
   let {
     buttons = [],
@@ -167,32 +167,32 @@ const messageBox = (sync, window, options) => {
     message = '',
     title = '',
     type = 'none'
-  } = options
+  } = options;
 
-  const messageBoxType = messageBoxTypes.indexOf(type)
-  if (messageBoxType === -1) throw new TypeError('Invalid message box type')
-  if (!Array.isArray(buttons)) throw new TypeError('Buttons must be an array')
-  if (options.normalizeAccessKeys) buttons = buttons.map(normalizeAccessKey)
-  if (typeof title !== 'string') throw new TypeError('Title must be a string')
-  if (typeof noLink !== 'boolean') throw new TypeError('noLink must be a boolean')
-  if (typeof message !== 'string') throw new TypeError('Message must be a string')
-  if (typeof detail !== 'string') throw new TypeError('Detail must be a string')
-  if (typeof checkboxLabel !== 'string') throw new TypeError('checkboxLabel must be a string')
+  const messageBoxType = messageBoxTypes.indexOf(type);
+  if (messageBoxType === -1) throw new TypeError('Invalid message box type');
+  if (!Array.isArray(buttons)) throw new TypeError('Buttons must be an array');
+  if (options.normalizeAccessKeys) buttons = buttons.map(normalizeAccessKey);
+  if (typeof title !== 'string') throw new TypeError('Title must be a string');
+  if (typeof noLink !== 'boolean') throw new TypeError('noLink must be a boolean');
+  if (typeof message !== 'string') throw new TypeError('Message must be a string');
+  if (typeof detail !== 'string') throw new TypeError('Detail must be a string');
+  if (typeof checkboxLabel !== 'string') throw new TypeError('checkboxLabel must be a string');
 
-  checkboxChecked = !!checkboxChecked
+  checkboxChecked = !!checkboxChecked;
   if (checkboxChecked && !checkboxLabel) {
-    throw new Error('checkboxChecked requires that checkboxLabel also be passed')
+    throw new Error('checkboxChecked requires that checkboxLabel also be passed');
   }
 
   // Choose a default button to get selected when dialog is cancelled.
   if (cancelId == null) {
     // If the defaultId is set to 0, ensure the cancel button is a different index (1)
-    cancelId = (defaultId === 0 && buttons.length > 1) ? 1 : 0
+    cancelId = (defaultId === 0 && buttons.length > 1) ? 1 : 0;
     for (let i = 0; i < buttons.length; i++) {
-      const text = buttons[i].toLowerCase()
+      const text = buttons[i].toLowerCase();
       if (text === 'cancel' || text === 'no') {
-        cancelId = i
-        break
+        cancelId = i;
+        break;
       }
     }
   }
@@ -210,57 +210,57 @@ const messageBox = (sync, window, options) => {
     checkboxLabel,
     checkboxChecked,
     icon
-  }
+  };
 
   if (sync) {
-    return binding.showMessageBoxSync(settings)
+    return binding.showMessageBoxSync(settings);
   } else {
-    return binding.showMessageBox(settings)
+    return binding.showMessageBox(settings);
   }
-}
+};
 
 module.exports = {
   showOpenDialog: function (window, options) {
-    return openDialog(false, window, options)
+    return openDialog(false, window, options);
   },
 
   showOpenDialogSync: function (window, options) {
-    return openDialog(true, window, options)
+    return openDialog(true, window, options);
   },
 
   showSaveDialog: function (window, options) {
-    return saveDialog(false, window, options)
+    return saveDialog(false, window, options);
   },
 
   showSaveDialogSync: function (window, options) {
-    return saveDialog(true, window, options)
+    return saveDialog(true, window, options);
   },
 
   showMessageBox: function (window, options) {
-    return messageBox(false, window, options)
+    return messageBox(false, window, options);
   },
 
   showMessageBoxSync: function (window, options) {
-    return messageBox(true, window, options)
+    return messageBox(true, window, options);
   },
 
   showErrorBox: function (...args) {
-    return binding.showErrorBox(...args)
+    return binding.showErrorBox(...args);
   },
 
   showCertificateTrustDialog: function (window, options) {
-    if (window && window.constructor !== BrowserWindow) options = window
+    if (window && window.constructor !== BrowserWindow) options = window;
     if (options == null || typeof options !== 'object') {
-      throw new TypeError('options must be an object')
+      throw new TypeError('options must be an object');
     }
 
-    const { certificate, message = '' } = options
+    const { certificate, message = '' } = options;
     if (certificate == null || typeof certificate !== 'object') {
-      throw new TypeError('certificate must be an object')
+      throw new TypeError('certificate must be an object');
     }
 
-    if (typeof message !== 'string') throw new TypeError('message must be a string')
+    if (typeof message !== 'string') throw new TypeError('message must be a string');
 
-    return binding.showCertificateTrustDialog(window, certificate, message)
+    return binding.showCertificateTrustDialog(window, certificate, message);
   }
-}
+};

lib/browser/api/exports/electron.ts

@@ -1,8 +1,8 @@
-import { defineProperties } from '@electron/internal/common/define-properties'
-import { commonModuleList } from '@electron/internal/common/api/module-list'
-import { browserModuleList } from '@electron/internal/browser/api/module-list'
+import { defineProperties } from '@electron/internal/common/define-properties';
+import { commonModuleList } from '@electron/internal/common/api/module-list';
+import { browserModuleList } from '@electron/internal/browser/api/module-list';
 
-module.exports = {}
+module.exports = {};
 
-defineProperties(module.exports, commonModuleList)
-defineProperties(module.exports, browserModuleList)
+defineProperties(module.exports, commonModuleList);
+defineProperties(module.exports, browserModuleList);

lib/browser/api/global-shortcut.js

@@ -1,3 +1,3 @@
-'use strict'
+'use strict';
 
-module.exports = process.electronBinding('global_shortcut').globalShortcut
+module.exports = process.electronBinding('global_shortcut').globalShortcut;

lib/browser/api/in-app-purchase.js

@@ -1,22 +1,22 @@
-'use strict'
+'use strict';
 
-const { deprecate } = require('electron')
+const { deprecate } = require('electron');
 
 if (process.platform === 'darwin') {
-  const { EventEmitter } = require('events')
-  const { inAppPurchase, InAppPurchase } = process.electronBinding('in_app_purchase')
+  const { EventEmitter } = require('events');
+  const { inAppPurchase, InAppPurchase } = process.electronBinding('in_app_purchase');
 
   // inAppPurchase is an EventEmitter.
-  Object.setPrototypeOf(InAppPurchase.prototype, EventEmitter.prototype)
-  EventEmitter.call(inAppPurchase)
+  Object.setPrototypeOf(InAppPurchase.prototype, EventEmitter.prototype);
+  EventEmitter.call(inAppPurchase);
 
-  module.exports = inAppPurchase
+  module.exports = inAppPurchase;
 } else {
   module.exports = {
     purchaseProduct: (productID, quantity, callback) => {
-      throw new Error('The inAppPurchase module can only be used on macOS')
+      throw new Error('The inAppPurchase module can only be used on macOS');
     },
     canMakePayments: () => false,
     getReceiptURL: () => ''
-  }
+  };
 }

lib/browser/api/ipc-main.ts

@@ -1,8 +1,8 @@
-import { IpcMainImpl } from '@electron/internal/browser/ipc-main-impl'
+import { IpcMainImpl } from '@electron/internal/browser/ipc-main-impl';
 
-const ipcMain = new IpcMainImpl()
+const ipcMain = new IpcMainImpl();
 
 // Do not throw exception when channel name is "error".
-ipcMain.on('error', () => {})
+ipcMain.on('error', () => {});
 
-export default ipcMain
+export default ipcMain;

lib/browser/api/menu-item-roles.js

@@ -1,15 +1,15 @@
-'use strict'
+'use strict';
 
-const { app } = require('electron')
+const { app } = require('electron');
 
-const isMac = process.platform === 'darwin'
-const isWindows = process.platform === 'win32'
-const isLinux = process.platform === 'linux'
+const isMac = process.platform === 'darwin';
+const isWindows = process.platform === 'win32';
+const isLinux = process.platform === 'linux';
 
 const roles = {
   about: {
     get label () {
-      return isLinux ? 'About' : `About ${app.name}`
+      return isLinux ? 'About' : `About ${app.name}`;
     }
   },
   close: {
@@ -38,7 +38,7 @@ const roles = {
     accelerator: 'Shift+CmdOrCtrl+R',
     nonNativeMacOSRole: true,
     windowMethod: (window) => {
-      window.webContents.reloadIgnoringCache()
+      window.webContents.reloadIgnoringCache();
     }
   },
   front: {
@@ -49,7 +49,7 @@ const roles = {
   },
   hide: {
     get label () {
-      return `Hide ${app.name}`
+      return `Hide ${app.name}`;
     },
     accelerator: 'Command+H'
   },
@@ -77,9 +77,9 @@ const roles = {
   quit: {
     get label () {
       switch (process.platform) {
-        case 'darwin': return `Quit ${app.name}`
-        case 'win32': return 'Exit'
-        default: return 'Quit'
+        case 'darwin': return `Quit ${app.name}`;
+        case 'win32': return 'Exit';
+        default: return 'Quit';
       }
     },
     accelerator: isWindows ? undefined : 'CommandOrControl+Q',
@@ -101,7 +101,7 @@ const roles = {
     accelerator: 'CommandOrControl+0',
     nonNativeMacOSRole: true,
     webContentsMethod: (webContents) => {
-      webContents.zoomLevel = 0
+      webContents.zoomLevel = 0;
     }
   },
   selectall: {
@@ -134,7 +134,7 @@ const roles = {
     label: 'Toggle Full Screen',
     accelerator: isMac ? 'Control+Command+F' : 'F11',
     windowMethod: (window) => {
-      window.setFullScreen(!window.isFullScreen())
+      window.setFullScreen(!window.isFullScreen());
     }
   },
   undo: {
@@ -156,7 +156,7 @@ const roles = {
     accelerator: 'CommandOrControl+Plus',
     nonNativeMacOSRole: true,
     webContentsMethod: (webContents) => {
-      webContents.zoomLevel += 0.5
+      webContents.zoomLevel += 0.5;
     }
   },
   zoomout: {
@@ -164,13 +164,13 @@ const roles = {
     accelerator: 'CommandOrControl+-',
     nonNativeMacOSRole: true,
     webContentsMethod: (webContents) => {
-      webContents.zoomLevel -= 0.5
+      webContents.zoomLevel -= 0.5;
     }
   },
   // App submenu should be used for Mac only
   appmenu: {
     get label () {
-      return app.name
+      return app.name;
     },
     submenu: [
       { role: 'about' },
@@ -249,71 +249,71 @@ const roles = {
       ])
     ]
   }
-}
+};
 
-exports.roleList = roles
+exports.roleList = roles;
 
 const canExecuteRole = (role) => {
-  if (!roles.hasOwnProperty(role)) return false
-  if (!isMac) return true
+  if (!roles.hasOwnProperty(role)) return false;
+  if (!isMac) return true;
 
   // macOS handles all roles natively except for a few
-  return roles[role].nonNativeMacOSRole
-}
+  return roles[role].nonNativeMacOSRole;
+};
 
 exports.getDefaultLabel = (role) => {
-  return roles.hasOwnProperty(role) ? roles[role].label : ''
-}
+  return roles.hasOwnProperty(role) ? roles[role].label : '';
+};
 
 exports.getDefaultAccelerator = (role) => {
-  if (roles.hasOwnProperty(role)) return roles[role].accelerator
-}
+  if (roles.hasOwnProperty(role)) return roles[role].accelerator;
+};
 
 exports.shouldRegisterAccelerator = (role) => {
-  const hasRoleRegister = roles.hasOwnProperty(role) && roles[role].registerAccelerator !== undefined
-  return hasRoleRegister ? roles[role].registerAccelerator : true
-}
+  const hasRoleRegister = roles.hasOwnProperty(role) && roles[role].registerAccelerator !== undefined;
+  return hasRoleRegister ? roles[role].registerAccelerator : true;
+};
 
 exports.getDefaultSubmenu = (role) => {
-  if (!roles.hasOwnProperty(role)) return
+  if (!roles.hasOwnProperty(role)) return;
 
-  let { submenu } = roles[role]
+  let { submenu } = roles[role];
 
   // remove null items from within the submenu
   if (Array.isArray(submenu)) {
-    submenu = submenu.filter((item) => item != null)
+    submenu = submenu.filter((item) => item != null);
   }
 
-  return submenu
-}
+  return submenu;
+};
 
 exports.execute = (role, focusedWindow, focusedWebContents) => {
-  if (!canExecuteRole(role)) return false
+  if (!canExecuteRole(role)) return false;
 
-  const { appMethod, webContentsMethod, windowMethod } = roles[role]
+  const { appMethod, webContentsMethod, windowMethod } = roles[role];
 
   if (appMethod) {
-    app[appMethod]()
-    return true
+    app[appMethod]();
+    return true;
   }
 
   if (windowMethod && focusedWindow != null) {
     if (typeof windowMethod === 'function') {
-      windowMethod(focusedWindow)
+      windowMethod(focusedWindow);
     } else {
-      focusedWindow[windowMethod]()
+      focusedWindow[windowMethod]();
     }
-    return true
+    return true;
   }
 
   if (webContentsMethod && focusedWebContents != null) {
     if (typeof webContentsMethod === 'function') {
-      webContentsMethod(focusedWebContents)
+      webContentsMethod(focusedWebContents);
     } else {
-      focusedWebContents[webContentsMethod]()
+      focusedWebContents[webContentsMethod]();
     }
-    return true
+    return true;
   }
 
-  return false
-}
+  return false;
+};

lib/browser/api/menu-item.js

@@ -1,87 +1,87 @@
-'use strict'
+'use strict';
 
-const roles = require('@electron/internal/browser/api/menu-item-roles')
+const roles = require('@electron/internal/browser/api/menu-item-roles');
 
-let nextCommandId = 0
+let nextCommandId = 0;
 
 const MenuItem = function (options) {
-  const { Menu } = require('electron')
+  const { Menu } = require('electron');
 
   // Preserve extra fields specified by user
   for (const key in options) {
-    if (!(key in this)) this[key] = options[key]
+    if (!(key in this)) this[key] = options[key];
   }
   if (typeof this.role === 'string' || this.role instanceof String) {
-    this.role = this.role.toLowerCase()
+    this.role = this.role.toLowerCase();
   }
-  this.submenu = this.submenu || roles.getDefaultSubmenu(this.role)
+  this.submenu = this.submenu || roles.getDefaultSubmenu(this.role);
   if (this.submenu != null && this.submenu.constructor !== Menu) {
-    this.submenu = Menu.buildFromTemplate(this.submenu)
+    this.submenu = Menu.buildFromTemplate(this.submenu);
   }
   if (this.type == null && this.submenu != null) {
-    this.type = 'submenu'
+    this.type = 'submenu';
   }
   if (this.type === 'submenu' && (this.submenu == null || this.submenu.constructor !== Menu)) {
-    throw new Error('Invalid submenu')
+    throw new Error('Invalid submenu');
   }
 
-  this.overrideReadOnlyProperty('type', 'normal')
-  this.overrideReadOnlyProperty('role')
-  this.overrideReadOnlyProperty('accelerator')
-  this.overrideReadOnlyProperty('icon')
-  this.overrideReadOnlyProperty('submenu')
+  this.overrideReadOnlyProperty('type', 'normal');
+  this.overrideReadOnlyProperty('role');
+  this.overrideReadOnlyProperty('accelerator');
+  this.overrideReadOnlyProperty('icon');
+  this.overrideReadOnlyProperty('submenu');
 
-  this.overrideProperty('label', roles.getDefaultLabel(this.role))
-  this.overrideProperty('sublabel', '')
-  this.overrideProperty('toolTip', '')
-  this.overrideProperty('enabled', true)
-  this.overrideProperty('visible', true)
-  this.overrideProperty('checked', false)
-  this.overrideProperty('acceleratorWorksWhenHidden', true)
-  this.overrideProperty('registerAccelerator', roles.shouldRegisterAccelerator(this.role))
+  this.overrideProperty('label', roles.getDefaultLabel(this.role));
+  this.overrideProperty('sublabel', '');
+  this.overrideProperty('toolTip', '');
+  this.overrideProperty('enabled', true);
+  this.overrideProperty('visible', true);
+  this.overrideProperty('checked', false);
+  this.overrideProperty('acceleratorWorksWhenHidden', true);
+  this.overrideProperty('registerAccelerator', roles.shouldRegisterAccelerator(this.role));
 
   if (!MenuItem.types.includes(this.type)) {
-    throw new Error(`Unknown menu item type: ${this.type}`)
+    throw new Error(`Unknown menu item type: ${this.type}`);
   }
 
-  this.overrideReadOnlyProperty('commandId', ++nextCommandId)
+  this.overrideReadOnlyProperty('commandId', ++nextCommandId);
 
-  const click = options.click
+  const click = options.click;
   this.click = (event, focusedWindow, focusedWebContents) => {
     // Manually flip the checked flags when clicked.
     if (this.type === 'checkbox' || this.type === 'radio') {
-      this.checked = !this.checked
+      this.checked = !this.checked;
     }
 
     if (!roles.execute(this.role, focusedWindow, focusedWebContents)) {
       if (typeof click === 'function') {
-        click(this, focusedWindow, event)
+        click(this, focusedWindow, event);
       } else if (typeof this.selector === 'string' && process.platform === 'darwin') {
-        Menu.sendActionToFirstResponder(this.selector)
+        Menu.sendActionToFirstResponder(this.selector);
       }
     }
-  }
-}
+  };
+};
 
-MenuItem.types = ['normal', 'separator', 'submenu', 'checkbox', 'radio']
+MenuItem.types = ['normal', 'separator', 'submenu', 'checkbox', 'radio'];
 
 MenuItem.prototype.getDefaultRoleAccelerator = function () {
-  return roles.getDefaultAccelerator(this.role)
-}
+  return roles.getDefaultAccelerator(this.role);
+};
 
 MenuItem.prototype.overrideProperty = function (name, defaultValue = null) {
   if (this[name] == null) {
-    this[name] = defaultValue
+    this[name] = defaultValue;
   }
-}
+};
 
 MenuItem.prototype.overrideReadOnlyProperty = function (name, defaultValue) {
-  this.overrideProperty(name, defaultValue)
+  this.overrideProperty(name, defaultValue);
   Object.defineProperty(this, name, {
     enumerable: true,
     writable: false,
     value: this[name]
-  })
-}
+  });
+};
 
-module.exports = MenuItem
+module.exports = MenuItem;

lib/browser/api/menu-utils.js

@@ -1,41 +1,41 @@
-'use strict'
+'use strict';
 
 function splitArray (arr, predicate) {
   const result = arr.reduce((multi, item) => {
-    const current = multi[multi.length - 1]
+    const current = multi[multi.length - 1];
     if (predicate(item)) {
-      if (current.length > 0) multi.push([])
+      if (current.length > 0) multi.push([]);
     } else {
-      current.push(item)
+      current.push(item);
     }
-    return multi
-  }, [[]])
+    return multi;
+  }, [[]]);
 
   if (result[result.length - 1].length === 0) {
-    return result.slice(0, result.length - 1)
+    return result.slice(0, result.length - 1);
   }
-  return result
+  return result;
 }
 
 function joinArrays (arrays, joinIDs) {
   return arrays.reduce((joined, arr, i) => {
     if (i > 0 && arr.length) {
       if (joinIDs.length > 0) {
-        joined.push(joinIDs[0])
-        joinIDs.splice(0, 1)
+        joined.push(joinIDs[0]);
+        joinIDs.splice(0, 1);
       } else {
-        joined.push({ type: 'separator' })
+        joined.push({ type: 'separator' });
       }
     }
-    return joined.concat(arr)
-  }, [])
+    return joined.concat(arr);
+  }, []);
 }
 
 function pushOntoMultiMap (map, key, value) {
   if (!map.has(key)) {
-    map.set(key, [])
+    map.set(key, []);
   }
-  map.get(key).push(value)
+  map.get(key).push(value);
 }
 
 function indexOfGroupContainingID (groups, id, ignoreGroup) {
@@ -45,102 +45,102 @@ function indexOfGroupContainingID (groups, id, ignoreGroup) {
       candidateGroup.some(
         candidateItem => candidateItem.id === id
       )
-  )
+  );
 }
 
 // Sort nodes topologically using a depth-first approach. Encountered cycles
 // are broken.
 function sortTopologically (originalOrder, edgesById) {
-  const sorted = []
-  const marked = new Set()
+  const sorted = [];
+  const marked = new Set();
 
   const visit = (mark) => {
-    if (marked.has(mark)) return
-    marked.add(mark)
-    const edges = edgesById.get(mark)
+    if (marked.has(mark)) return;
+    marked.add(mark);
+    const edges = edgesById.get(mark);
     if (edges != null) {
-      edges.forEach(visit)
+      edges.forEach(visit);
     }
-    sorted.push(mark)
-  }
+    sorted.push(mark);
+  };
 
-  originalOrder.forEach(visit)
-  return sorted
+  originalOrder.forEach(visit);
+  return sorted;
 }
 
 function attemptToMergeAGroup (groups) {
   for (let i = 0; i < groups.length; i++) {
-    const group = groups[i]
+    const group = groups[i];
     for (const item of group) {
-      const toIDs = [...(item.before || []), ...(item.after || [])]
+      const toIDs = [...(item.before || []), ...(item.after || [])];
       for (const id of toIDs) {
-        const index = indexOfGroupContainingID(groups, id, group)
-        if (index === -1) continue
-        const mergeTarget = groups[index]
+        const index = indexOfGroupContainingID(groups, id, group);
+        if (index === -1) continue;
+        const mergeTarget = groups[index];
 
-        mergeTarget.push(...group)
-        groups.splice(i, 1)
-        return true
+        mergeTarget.push(...group);
+        groups.splice(i, 1);
+        return true;
       }
     }
   }
-  return false
+  return false;
 }
 
 function mergeGroups (groups) {
-  let merged = true
+  let merged = true;
   while (merged) {
-    merged = attemptToMergeAGroup(groups)
+    merged = attemptToMergeAGroup(groups);
   }
-  return groups
+  return groups;
 }
 
 function sortItemsInGroup (group) {
-  const originalOrder = group.map((node, i) => i)
-  const edges = new Map()
-  const idToIndex = new Map(group.map((item, i) => [item.id, i]))
+  const originalOrder = group.map((node, i) => i);
+  const edges = new Map();
+  const idToIndex = new Map(group.map((item, i) => [item.id, i]));
 
   group.forEach((item, i) => {
     if (item.before) {
       item.before.forEach(toID => {
-        const to = idToIndex.get(toID)
+        const to = idToIndex.get(toID);
         if (to != null) {
-          pushOntoMultiMap(edges, to, i)
+          pushOntoMultiMap(edges, to, i);
         }
-      })
+      });
     }
     if (item.after) {
       item.after.forEach(toID => {
-        const to = idToIndex.get(toID)
+        const to = idToIndex.get(toID);
         if (to != null) {
-          pushOntoMultiMap(edges, i, to)
+          pushOntoMultiMap(edges, i, to);
         }
-      })
+      });
     }
-  })
+  });
 
-  const sortedNodes = sortTopologically(originalOrder, edges)
-  return sortedNodes.map(i => group[i])
+  const sortedNodes = sortTopologically(originalOrder, edges);
+  return sortedNodes.map(i => group[i]);
 }
 
 function findEdgesInGroup (groups, i, edges) {
-  const group = groups[i]
+  const group = groups[i];
   for (const item of group) {
     if (item.beforeGroupContaining) {
       for (const id of item.beforeGroupContaining) {
-        const to = indexOfGroupContainingID(groups, id, group)
+        const to = indexOfGroupContainingID(groups, id, group);
         if (to !== -1) {
-          pushOntoMultiMap(edges, to, i)
-          return
+          pushOntoMultiMap(edges, to, i);
+          return;
         }
       }
     }
     if (item.afterGroupContaining) {
       for (const id of item.afterGroupContaining) {
-        const to = indexOfGroupContainingID(groups, id, group)
+        const to = indexOfGroupContainingID(groups, id, group);
         if (to !== -1) {
-          pushOntoMultiMap(edges, i, to)
-          return
+          pushOntoMultiMap(edges, i, to);
+          return;
         }
       }
     }
@@ -148,29 +148,29 @@ function findEdgesInGroup (groups, i, edges) {
 }
 
 function sortGroups (groups) {
-  const originalOrder = groups.map((item, i) => i)
-  const edges = new Map()
+  const originalOrder = groups.map((item, i) => i);
+  const edges = new Map();
 
   for (let i = 0; i < groups.length; i++) {
-    findEdgesInGroup(groups, i, edges)
+    findEdgesInGroup(groups, i, edges);
   }
 
-  const sortedGroupIndexes = sortTopologically(originalOrder, edges)
-  return sortedGroupIndexes.map(i => groups[i])
+  const sortedGroupIndexes = sortTopologically(originalOrder, edges);
+  return sortedGroupIndexes.map(i => groups[i]);
 }
 
 function sortMenuItems (menuItems) {
-  const isSeparator = (item) => item.type === 'separator'
-  const separators = menuItems.filter(i => i.type === 'separator')
+  const isSeparator = (item) => item.type === 'separator';
+  const separators = menuItems.filter(i => i.type === 'separator');
 
   // Split the items into their implicit groups based upon separators.
-  const groups = splitArray(menuItems, isSeparator)
-  const mergedGroups = mergeGroups(groups)
-  const mergedGroupsWithSortedItems = mergedGroups.map(sortItemsInGroup)
-  const sortedGroups = sortGroups(mergedGroupsWithSortedItems)
+  const groups = splitArray(menuItems, isSeparator);
+  const mergedGroups = mergeGroups(groups);
+  const mergedGroupsWithSortedItems = mergedGroups.map(sortItemsInGroup);
+  const sortedGroups = sortGroups(mergedGroupsWithSortedItems);
 
-  const joined = joinArrays(sortedGroups, separators)
-  return joined
+  const joined = joinArrays(sortedGroups, separators);
+  return joined;
 }
 
-module.exports = { sortMenuItems }
+module.exports = { sortMenuItems };

lib/browser/api/menu.js

@@ -1,16 +1,16 @@
-'use strict'
+'use strict';
 
-const { TopLevelWindow, MenuItem, webContents } = require('electron')
-const { sortMenuItems } = require('@electron/internal/browser/api/menu-utils')
-const EventEmitter = require('events').EventEmitter
-const v8Util = process.electronBinding('v8_util')
-const bindings = process.electronBinding('menu')
+const { TopLevelWindow, MenuItem, webContents } = require('electron');
+const { sortMenuItems } = require('@electron/internal/browser/api/menu-utils');
+const EventEmitter = require('events').EventEmitter;
+const v8Util = process.electronBinding('v8_util');
+const bindings = process.electronBinding('menu');
 
-const { Menu } = bindings
-let applicationMenu = null
-let groupIdIndex = 0
+const { Menu } = bindings;
+let applicationMenu = null;
+let groupIdIndex = 0;
 
-Object.setPrototypeOf(Menu.prototype, EventEmitter.prototype)
+Object.setPrototypeOf(Menu.prototype, EventEmitter.prototype);
 
 // Menu Delegate.
 // This object should hold no reference to |Menu| to avoid cyclic reference.
@@ -20,172 +20,172 @@ const delegate = {
   shouldCommandIdWorkWhenHidden: (menu, id) => menu.commandsMap[id] ? menu.commandsMap[id].acceleratorWorksWhenHidden : undefined,
   isCommandIdVisible: (menu, id) => menu.commandsMap[id] ? menu.commandsMap[id].visible : undefined,
   getAcceleratorForCommandId: (menu, id, useDefaultAccelerator) => {
-    const command = menu.commandsMap[id]
-    if (!command) return
-    if (command.accelerator != null) return command.accelerator
-    if (useDefaultAccelerator) return command.getDefaultRoleAccelerator()
+    const command = menu.commandsMap[id];
+    if (!command) return;
+    if (command.accelerator != null) return command.accelerator;
+    if (useDefaultAccelerator) return command.getDefaultRoleAccelerator();
   },
   shouldRegisterAcceleratorForCommandId: (menu, id) => menu.commandsMap[id] ? menu.commandsMap[id].registerAccelerator : undefined,
   executeCommand: (menu, event, id) => {
-    const command = menu.commandsMap[id]
-    if (!command) return
-    command.click(event, TopLevelWindow.getFocusedWindow(), webContents.getFocusedWebContents())
+    const command = menu.commandsMap[id];
+    if (!command) return;
+    command.click(event, TopLevelWindow.getFocusedWindow(), webContents.getFocusedWebContents());
   },
   menuWillShow: (menu) => {
     // Ensure radio groups have at least one menu item selected
-    for (const id in menu.groupsMap) {
-      const found = menu.groupsMap[id].find(item => item.checked) || null
-      if (!found) v8Util.setHiddenValue(menu.groupsMap[id][0], 'checked', true)
+    for (const id of Object.keys(menu.groupsMap)) {
+      const found = menu.groupsMap[id].find(item => item.checked) || null;
+      if (!found) v8Util.setHiddenValue(menu.groupsMap[id][0], 'checked', true);
     }
   }
-}
+};
 
 /* Instance Methods */
 
 Menu.prototype._init = function () {
-  this.commandsMap = {}
-  this.groupsMap = {}
-  this.items = []
-  this.delegate = delegate
-}
+  this.commandsMap = {};
+  this.groupsMap = {};
+  this.items = [];
+  this.delegate = delegate;
+};
 
 Menu.prototype.popup = function (options = {}) {
   if (options == null || typeof options !== 'object') {
-    throw new TypeError('Options must be an object')
+    throw new TypeError('Options must be an object');
   }
-  let { window, x, y, positioningItem, callback } = options
+  let { window, x, y, positioningItem, callback } = options;
 
   // no callback passed
-  if (!callback || typeof callback !== 'function') callback = () => {}
+  if (!callback || typeof callback !== 'function') callback = () => {};
 
   // set defaults
-  if (typeof x !== 'number') x = -1
-  if (typeof y !== 'number') y = -1
-  if (typeof positioningItem !== 'number') positioningItem = -1
+  if (typeof x !== 'number') x = -1;
+  if (typeof y !== 'number') y = -1;
+  if (typeof positioningItem !== 'number') positioningItem = -1;
 
   // find which window to use
-  const wins = TopLevelWindow.getAllWindows()
+  const wins = TopLevelWindow.getAllWindows();
   if (!wins || wins.indexOf(window) === -1) {
-    window = TopLevelWindow.getFocusedWindow()
+    window = TopLevelWindow.getFocusedWindow();
     if (!window && wins && wins.length > 0) {
-      window = wins[0]
+      window = wins[0];
     }
     if (!window) {
-      throw new Error(`Cannot open Menu without a TopLevelWindow present`)
+      throw new Error(`Cannot open Menu without a TopLevelWindow present`);
     }
   }
 
-  this.popupAt(window, x, y, positioningItem, callback)
-  return { browserWindow: window, x, y, position: positioningItem }
-}
+  this.popupAt(window, x, y, positioningItem, callback);
+  return { browserWindow: window, x, y, position: positioningItem };
+};
 
 Menu.prototype.closePopup = function (window) {
   if (window instanceof TopLevelWindow) {
-    this.closePopupAt(window.id)
+    this.closePopupAt(window.id);
   } else {
     // Passing -1 (invalid) would make closePopupAt close the all menu runners
     // belong to this menu.
-    this.closePopupAt(-1)
+    this.closePopupAt(-1);
   }
-}
+};
 
 Menu.prototype.getMenuItemById = function (id) {
-  const items = this.items
+  const items = this.items;
 
-  let found = items.find(item => item.id === id) || null
+  let found = items.find(item => item.id === id) || null;
   for (let i = 0; !found && i < items.length; i++) {
     if (items[i].submenu) {
-      found = items[i].submenu.getMenuItemById(id)
+      found = items[i].submenu.getMenuItemById(id);
     }
   }
-  return found
-}
+  return found;
+};
 
 Menu.prototype.append = function (item) {
-  return this.insert(this.getItemCount(), item)
-}
+  return this.insert(this.getItemCount(), item);
+};
 
 Menu.prototype.insert = function (pos, item) {
   if ((item ? item.constructor : void 0) !== MenuItem) {
-    throw new TypeError('Invalid item')
+    throw new TypeError('Invalid item');
   }
 
   if (pos < 0) {
-    throw new RangeError(`Position ${pos} cannot be less than 0`)
+    throw new RangeError(`Position ${pos} cannot be less than 0`);
   } else if (pos > this.getItemCount()) {
-    throw new RangeError(`Position ${pos} cannot be greater than the total MenuItem count`)
+    throw new RangeError(`Position ${pos} cannot be greater than the total MenuItem count`);
   }
 
   // insert item depending on its type
-  insertItemByType.call(this, item, pos)
+  insertItemByType.call(this, item, pos);
 
   // set item properties
-  if (item.sublabel) this.setSublabel(pos, item.sublabel)
-  if (item.toolTip) this.setToolTip(pos, item.toolTip)
-  if (item.icon) this.setIcon(pos, item.icon)
-  if (item.role) this.setRole(pos, item.role)
+  if (item.sublabel) this.setSublabel(pos, item.sublabel);
+  if (item.toolTip) this.setToolTip(pos, item.toolTip);
+  if (item.icon) this.setIcon(pos, item.icon);
+  if (item.role) this.setRole(pos, item.role);
 
   // Make menu accessable to items.
-  item.overrideReadOnlyProperty('menu', this)
+  item.overrideReadOnlyProperty('menu', this);
 
   // Remember the items.
-  this.items.splice(pos, 0, item)
-  this.commandsMap[item.commandId] = item
-}
+  this.items.splice(pos, 0, item);
+  this.commandsMap[item.commandId] = item;
+};
 
 Menu.prototype._callMenuWillShow = function () {
-  if (this.delegate) this.delegate.menuWillShow(this)
+  if (this.delegate) this.delegate.menuWillShow(this);
   this.items.forEach(item => {
-    if (item.submenu) item.submenu._callMenuWillShow()
-  })
-}
+    if (item.submenu) item.submenu._callMenuWillShow();
+  });
+};
 
 /* Static Methods */
 
-Menu.getApplicationMenu = () => applicationMenu
+Menu.getApplicationMenu = () => applicationMenu;
 
-Menu.sendActionToFirstResponder = bindings.sendActionToFirstResponder
+Menu.sendActionToFirstResponder = bindings.sendActionToFirstResponder;
 
 // set application menu with a preexisting menu
 Menu.setApplicationMenu = function (menu) {
   if (menu && menu.constructor !== Menu) {
-    throw new TypeError('Invalid menu')
+    throw new TypeError('Invalid menu');
   }
 
-  applicationMenu = menu
-  v8Util.setHiddenValue(global, 'applicationMenuSet', true)
+  applicationMenu = menu;
+  v8Util.setHiddenValue(global, 'applicationMenuSet', true);
 
   if (process.platform === 'darwin') {
-    if (!menu) return
-    menu._callMenuWillShow()
-    bindings.setApplicationMenu(menu)
+    if (!menu) return;
+    menu._callMenuWillShow();
+    bindings.setApplicationMenu(menu);
   } else {
-    const windows = TopLevelWindow.getAllWindows()
-    return windows.map(w => w.setMenu(menu))
+    const windows = TopLevelWindow.getAllWindows();
+    return windows.map(w => w.setMenu(menu));
   }
-}
+};
 
 Menu.buildFromTemplate = function (template) {
   if (!Array.isArray(template)) {
-    throw new TypeError('Invalid template for Menu: Menu template must be an array')
+    throw new TypeError('Invalid template for Menu: Menu template must be an array');
   }
   if (!areValidTemplateItems(template)) {
-    throw new TypeError('Invalid template for MenuItem: must have at least one of label, role or type')
+    throw new TypeError('Invalid template for MenuItem: must have at least one of label, role or type');
   }
-  const filtered = removeExtraSeparators(template)
-  const sorted = sortTemplate(filtered)
+  const filtered = removeExtraSeparators(template);
+  const sorted = sortTemplate(filtered);
 
-  const menu = new Menu()
+  const menu = new Menu();
   sorted.forEach(item => {
     if (item instanceof MenuItem) {
-      menu.append(item)
+      menu.append(item);
     } else {
-      menu.append(new MenuItem(item))
+      menu.append(new MenuItem(item));
     }
-  })
+  });
 
-  return menu
-}
+  return menu;
+};
 
 /* Helper Functions */
 
@@ -196,51 +196,50 @@ function areValidTemplateItems (template) {
     typeof item === 'object' &&
     (item.hasOwnProperty('label') ||
      item.hasOwnProperty('role') ||
-     item.type === 'separator'))
+     item.type === 'separator'));
 }
 
 function sortTemplate (template) {
-  const sorted = sortMenuItems(template)
-  for (const id in sorted) {
-    const item = sorted[id]
+  const sorted = sortMenuItems(template);
+  for (const item of sorted) {
     if (Array.isArray(item.submenu)) {
-      item.submenu = sortTemplate(item.submenu)
+      item.submenu = sortTemplate(item.submenu);
     }
   }
-  return sorted
+  return sorted;
 }
 
 // Search between separators to find a radio menu item and return its group id
 function generateGroupId (items, pos) {
   if (pos > 0) {
     for (let idx = pos - 1; idx >= 0; idx--) {
-      if (items[idx].type === 'radio') return items[idx].groupId
-      if (items[idx].type === 'separator') break
+      if (items[idx].type === 'radio') return items[idx].groupId;
+      if (items[idx].type === 'separator') break;
     }
   } else if (pos < items.length) {
     for (let idx = pos; idx <= items.length - 1; idx++) {
-      if (items[idx].type === 'radio') return items[idx].groupId
-      if (items[idx].type === 'separator') break
+      if (items[idx].type === 'radio') return items[idx].groupId;
+      if (items[idx].type === 'separator') break;
     }
   }
-  groupIdIndex += 1
-  return groupIdIndex
+  groupIdIndex += 1;
+  return groupIdIndex;
 }
 
 function removeExtraSeparators (items) {
   // fold adjacent separators together
   let ret = items.filter((e, idx, arr) => {
-    if (e.visible === false) return true
-    return e.type !== 'separator' || idx === 0 || arr[idx - 1].type !== 'separator'
-  })
+    if (e.visible === false) return true;
+    return e.type !== 'separator' || idx === 0 || arr[idx - 1].type !== 'separator';
+  });
 
   // remove edge separators
   ret = ret.filter((e, idx, arr) => {
-    if (e.visible === false) return true
-    return e.type !== 'separator' || (idx !== 0 && idx !== arr.length - 1)
-  })
+    if (e.visible === false) return true;
+    return e.type !== 'separator' || (idx !== 0 && idx !== arr.length - 1);
+  });
 
-  return ret
+  return ret;
 }
 
 function insertItemByType (item, pos) {
@@ -251,28 +250,28 @@ function insertItemByType (item, pos) {
     submenu: () => this.insertSubMenu(pos, item.commandId, item.label, item.submenu),
     radio: () => {
       // Grouping radio menu items
-      item.overrideReadOnlyProperty('groupId', generateGroupId(this.items, pos))
+      item.overrideReadOnlyProperty('groupId', generateGroupId(this.items, pos));
       if (this.groupsMap[item.groupId] == null) {
-        this.groupsMap[item.groupId] = []
+        this.groupsMap[item.groupId] = [];
       }
-      this.groupsMap[item.groupId].push(item)
+      this.groupsMap[item.groupId].push(item);
 
       // Setting a radio menu item should flip other items in the group.
-      v8Util.setHiddenValue(item, 'checked', item.checked)
+      v8Util.setHiddenValue(item, 'checked', item.checked);
       Object.defineProperty(item, 'checked', {
         enumerable: true,
         get: () => v8Util.getHiddenValue(item, 'checked'),
         set: () => {
           this.groupsMap[item.groupId].forEach(other => {
-            if (other !== item) v8Util.setHiddenValue(other, 'checked', false)
-          })
-          v8Util.setHiddenValue(item, 'checked', true)
+            if (other !== item) v8Util.setHiddenValue(other, 'checked', false);
+          });
+          v8Util.setHiddenValue(item, 'checked', true);
         }
-      })
-      this.insertRadioItem(pos, item.commandId, item.label, item.groupId)
+      });
+      this.insertRadioItem(pos, item.commandId, item.label, item.groupId);
     }
-  }
-  types[item.type]()
+  };
+  types[item.type]();
 }
 
-module.exports = Menu
+module.exports = Menu;

lib/browser/api/module-keys.js

@@ -1,11 +1,11 @@
-'use strict'
+'use strict';
 
 // TODO: Figure out a way to not duplicate this information between here and module-list
 // It is currently duplicated as module-list "require"s all the browser API file and the
 // remote module in the renderer process depends on that file.  As a result webpack
 // includes all the browser API files in the renderer process as well and we want to avoid that
 
-const features = process.electronBinding('features')
+const features = process.electronBinding('features');
 
 // Browser side modules, please sort alphabetically.
 module.exports = [
@@ -37,7 +37,7 @@ module.exports = [
   { name: 'View' },
   { name: 'webContents' },
   { name: 'WebContentsView' }
-]
+];
 
 if (features.isViewApiEnabled()) {
   module.exports.push(
@@ -48,5 +48,5 @@ if (features.isViewApiEnabled()) {
     { name: 'MdTextButton' },
     { name: 'ResizeArea' },
     { name: 'TextField' }
-  )
+  );
 }

lib/browser/api/module-list.ts

@@ -1,6 +1,6 @@
 // TODO: Updating this file also required updating the module-keys file
 
-const features = process.electronBinding('features')
+const features = process.electronBinding('features');
 
 // Browser side modules, please sort alphabetically.
 export const browserModuleList: ElectronInternal.ModuleEntry[] = [
@@ -32,7 +32,7 @@ export const browserModuleList: ElectronInternal.ModuleEntry[] = [
   { name: 'View', loader: () => require('./view') },
   { name: 'webContents', loader: () => require('./web-contents') },
   { name: 'WebContentsView', loader: () => require('./web-contents-view') }
-]
+];
 
 if (features.isViewApiEnabled()) {
   browserModuleList.push(
@@ -43,5 +43,5 @@ if (features.isViewApiEnabled()) {
     { name: 'MdTextButton', loader: () => require('./views/md-text-button') },
     { name: 'ResizeArea', loader: () => require('./views/resize-area') },
     { name: 'TextField', loader: () => require('./views/text-field') }
-  )
+  );
 }

lib/browser/api/native-theme.ts

@@ -1,8 +1,8 @@
-import { EventEmitter } from 'events'
+import { EventEmitter } from 'events';
 
-const { NativeTheme, nativeTheme } = process.electronBinding('native_theme')
+const { NativeTheme, nativeTheme } = process.electronBinding('native_theme');
 
-Object.setPrototypeOf(NativeTheme.prototype, EventEmitter.prototype)
-EventEmitter.call(nativeTheme as any)
+Object.setPrototypeOf(NativeTheme.prototype, EventEmitter.prototype);
+EventEmitter.call(nativeTheme as any);
 
-module.exports = nativeTheme
+module.exports = nativeTheme;

lib/browser/api/net-log.js

@@ -1,32 +1,32 @@
-'use strict'
+'use strict';
 
 // TODO(deepak1556): Deprecate and remove standalone netLog module,
 // it is now a property of session module.
-const { app, session } = require('electron')
+const { app, session } = require('electron');
 
 // Fallback to default session.
 Object.setPrototypeOf(module.exports, new Proxy({}, {
   get (target, property) {
-    if (!app.isReady()) return
+    if (!app.isReady()) return;
 
-    const netLog = session.defaultSession.netLog
+    const netLog = session.defaultSession.netLog;
 
-    if (!Object.getPrototypeOf(netLog).hasOwnProperty(property)) return
+    if (!Object.getPrototypeOf(netLog).hasOwnProperty(property)) return;
 
     // check for properties on the prototype chain  that aren't functions
-    if (typeof netLog[property] !== 'function') return netLog[property]
+    if (typeof netLog[property] !== 'function') return netLog[property];
 
     // Returning a native function directly would throw error.
-    return (...args) => netLog[property](...args)
+    return (...args) => netLog[property](...args);
   },
 
   ownKeys () {
-    if (!app.isReady()) return []
+    if (!app.isReady()) return [];
 
-    return Object.getOwnPropertyNames(Object.getPrototypeOf(session.defaultSession.netLog))
+    return Object.getOwnPropertyNames(Object.getPrototypeOf(session.defaultSession.netLog));
   },
 
   getOwnPropertyDescriptor (target) {
-    return { configurable: true, enumerable: true }
+    return { configurable: true, enumerable: true };
   }
-}))
+}));

lib/browser/api/net.js

@@ -1,16 +1,16 @@
-'use strict'
+'use strict';
 
-const url = require('url')
-const { EventEmitter } = require('events')
-const { Readable, Writable } = require('stream')
-const { app } = require('electron')
-const { Session } = process.electronBinding('session')
-const { net, Net, _isValidHeaderName, _isValidHeaderValue } = process.electronBinding('net')
-const { URLLoader } = net
+const url = require('url');
+const { EventEmitter } = require('events');
+const { Readable, Writable } = require('stream');
+const { app } = require('electron');
+const { Session } = process.electronBinding('session');
+const { net, Net, _isValidHeaderName, _isValidHeaderValue } = process.electronBinding('net');
+const { URLLoader } = net;
 
-Object.setPrototypeOf(URLLoader.prototype, EventEmitter.prototype)
+Object.setPrototypeOf(URLLoader.prototype, EventEmitter.prototype);
 
-const kSupportedProtocols = new Set(['http:', 'https:'])
+const kSupportedProtocols = new Set(['http:', 'https:']);
 
 // set of headers that Node.js discards duplicates for
 // see https://nodejs.org/api/http.html#http_message_headers
@@ -33,27 +33,27 @@ const discardableDuplicateHeaders = new Set([
   'server',
   'age',
   'expires'
-])
+]);
 
 class IncomingMessage extends Readable {
   constructor (responseHead) {
-    super()
-    this._shouldPush = false
-    this._data = []
-    this._responseHead = responseHead
+    super();
+    this._shouldPush = false;
+    this._data = [];
+    this._responseHead = responseHead;
   }
 
   get statusCode () {
-    return this._responseHead.statusCode
+    return this._responseHead.statusCode;
   }
 
   get statusMessage () {
-    return this._responseHead.statusMessage
+    return this._responseHead.statusMessage;
   }
 
   get headers () {
-    const filteredHeaders = {}
-    const { rawHeaders } = this._responseHead
+    const filteredHeaders = {};
+    const { rawHeaders } = this._responseHead;
     rawHeaders.forEach(header => {
       if (Object.prototype.hasOwnProperty.call(filteredHeaders, header.key) &&
           discardableDuplicateHeaders.has(header.key)) {
@@ -63,145 +63,145 @@ class IncomingMessage extends Readable {
           // keep set-cookie as an array per Node.js rules
           // see https://nodejs.org/api/http.html#http_message_headers
           if (Object.prototype.hasOwnProperty.call(filteredHeaders, header.key)) {
-            filteredHeaders[header.key].push(header.value)
+            filteredHeaders[header.key].push(header.value);
           } else {
-            filteredHeaders[header.key] = [header.value]
+            filteredHeaders[header.key] = [header.value];
           }
         } else {
           // for non-cookie headers, the values are joined together with ', '
           if (Object.prototype.hasOwnProperty.call(filteredHeaders, header.key)) {
-            filteredHeaders[header.key] += `, ${header.value}`
+            filteredHeaders[header.key] += `, ${header.value}`;
           } else {
-            filteredHeaders[header.key] = header.value
+            filteredHeaders[header.key] = header.value;
           }
         }
       }
-    })
-    return filteredHeaders
+    });
+    return filteredHeaders;
   }
 
   get httpVersion () {
-    return `${this.httpVersionMajor}.${this.httpVersionMinor}`
+    return `${this.httpVersionMajor}.${this.httpVersionMinor}`;
   }
 
   get httpVersionMajor () {
-    return this._responseHead.httpVersion.major
+    return this._responseHead.httpVersion.major;
   }
 
   get httpVersionMinor () {
-    return this._responseHead.httpVersion.minor
+    return this._responseHead.httpVersion.minor;
   }
 
   get rawTrailers () {
-    throw new Error('HTTP trailers are not supported')
+    throw new Error('HTTP trailers are not supported');
   }
 
   get trailers () {
-    throw new Error('HTTP trailers are not supported')
+    throw new Error('HTTP trailers are not supported');
   }
 
   _storeInternalData (chunk) {
-    this._data.push(chunk)
-    this._pushInternalData()
+    this._data.push(chunk);
+    this._pushInternalData();
   }
 
   _pushInternalData () {
     while (this._shouldPush && this._data.length > 0) {
-      const chunk = this._data.shift()
-      this._shouldPush = this.push(chunk)
+      const chunk = this._data.shift();
+      this._shouldPush = this.push(chunk);
     }
   }
 
   _read () {
-    this._shouldPush = true
-    this._pushInternalData()
+    this._shouldPush = true;
+    this._pushInternalData();
   }
 }
 
 /** Writable stream that buffers up everything written to it. */
 class SlurpStream extends Writable {
   constructor () {
-    super()
-    this._data = Buffer.alloc(0)
+    super();
+    this._data = Buffer.alloc(0);
   }
   _write (chunk, encoding, callback) {
-    this._data = Buffer.concat([this._data, chunk])
-    callback()
+    this._data = Buffer.concat([this._data, chunk]);
+    callback();
   }
-  data () { return this._data }
+  data () { return this._data; }
 }
 
 class ChunkedBodyStream extends Writable {
   constructor (clientRequest) {
-    super()
-    this._clientRequest = clientRequest
+    super();
+    this._clientRequest = clientRequest;
   }
 
   _write (chunk, encoding, callback) {
     if (this._downstream) {
-      this._downstream.write(chunk).then(callback, callback)
+      this._downstream.write(chunk).then(callback, callback);
     } else {
       // the contract of _write is that we won't be called again until we call
       // the callback, so we're good to just save a single chunk.
-      this._pendingChunk = chunk
-      this._pendingCallback = callback
+      this._pendingChunk = chunk;
+      this._pendingCallback = callback;
 
       // The first write to a chunked body stream begins the request.
-      this._clientRequest._startRequest()
+      this._clientRequest._startRequest();
     }
   }
 
   _final (callback) {
-    this._downstream.done()
-    callback()
+    this._downstream.done();
+    callback();
   }
 
   startReading (pipe) {
     if (this._downstream) {
-      throw new Error('two startReading calls???')
+      throw new Error('two startReading calls???');
     }
-    this._downstream = pipe
+    this._downstream = pipe;
     if (this._pendingChunk) {
       const doneWriting = (maybeError) => {
-        const cb = this._pendingCallback
-        delete this._pendingCallback
-        delete this._pendingChunk
-        cb(maybeError)
-      }
-      this._downstream.write(this._pendingChunk).then(doneWriting, doneWriting)
+        const cb = this._pendingCallback;
+        delete this._pendingCallback;
+        delete this._pendingChunk;
+        cb(maybeError);
+      };
+      this._downstream.write(this._pendingChunk).then(doneWriting, doneWriting);
     }
   }
 }
 
 function parseOptions (options) {
   if (typeof options === 'string') {
-    options = url.parse(options)
+    options = url.parse(options);
   } else {
-    options = { ...options }
+    options = { ...options };
   }
 
-  const method = (options.method || 'GET').toUpperCase()
-  let urlStr = options.url
+  const method = (options.method || 'GET').toUpperCase();
+  let urlStr = options.url;
 
   if (!urlStr) {
-    const urlObj = {}
-    const protocol = options.protocol || 'http:'
+    const urlObj = {};
+    const protocol = options.protocol || 'http:';
     if (!kSupportedProtocols.has(protocol)) {
-      throw new Error('Protocol "' + protocol + '" not supported')
+      throw new Error('Protocol "' + protocol + '" not supported');
     }
-    urlObj.protocol = protocol
+    urlObj.protocol = protocol;
 
     if (options.host) {
-      urlObj.host = options.host
+      urlObj.host = options.host;
     } else {
       if (options.hostname) {
-        urlObj.hostname = options.hostname
+        urlObj.hostname = options.hostname;
       } else {
-        urlObj.hostname = 'localhost'
+        urlObj.hostname = 'localhost';
       }
 
       if (options.port) {
-        urlObj.port = options.port
+        urlObj.port = options.port;
       }
     }
 
@@ -212,203 +212,204 @@ function parseOptions (options) {
       // well, and b) possibly too restrictive for real-world usage. That's
       // why it only scans for spaces because those are guaranteed to create
       // an invalid request.
-      throw new TypeError('Request path contains unescaped characters')
+      throw new TypeError('Request path contains unescaped characters');
     }
-    const pathObj = url.parse(options.path || '/')
-    urlObj.pathname = pathObj.pathname
-    urlObj.search = pathObj.search
-    urlObj.hash = pathObj.hash
-    urlStr = url.format(urlObj)
+    const pathObj = url.parse(options.path || '/');
+    urlObj.pathname = pathObj.pathname;
+    urlObj.search = pathObj.search;
+    urlObj.hash = pathObj.hash;
+    urlStr = url.format(urlObj);
   }
 
-  const redirectPolicy = options.redirect || 'follow'
+  const redirectPolicy = options.redirect || 'follow';
   if (!['follow', 'error', 'manual'].includes(redirectPolicy)) {
-    throw new Error('redirect mode should be one of follow, error or manual')
+    throw new Error('redirect mode should be one of follow, error or manual');
   }
 
   if (options.headers != null && typeof options.headers !== 'object') {
-    throw new TypeError('headers must be an object')
+    throw new TypeError('headers must be an object');
   }
 
   const urlLoaderOptions = {
     method: method,
     url: urlStr,
     redirectPolicy,
-    extraHeaders: options.headers || {}
-  }
+    extraHeaders: options.headers || {},
+    useSessionCookies: options.useSessionCookies || false
+  };
   for (const [name, value] of Object.entries(urlLoaderOptions.extraHeaders)) {
     if (!_isValidHeaderName(name)) {
-      throw new Error(`Invalid header name: '${name}'`)
+      throw new Error(`Invalid header name: '${name}'`);
     }
     if (!_isValidHeaderValue(value.toString())) {
-      throw new Error(`Invalid value for header '${name}': '${value}'`)
+      throw new Error(`Invalid value for header '${name}': '${value}'`);
     }
   }
   if (options.session) {
     if (options.session instanceof Session) {
-      urlLoaderOptions.session = options.session
+      urlLoaderOptions.session = options.session;
     } else {
-      throw new TypeError('`session` should be an instance of the Session class')
+      throw new TypeError('`session` should be an instance of the Session class');
     }
   } else if (options.partition) {
     if (typeof options.partition === 'string') {
-      urlLoaderOptions.partition = options.partition
+      urlLoaderOptions.partition = options.partition;
     } else {
-      throw new TypeError('`partition` should be a string')
+      throw new TypeError('`partition` should be a string');
     }
   }
-  return urlLoaderOptions
+  return urlLoaderOptions;
 }
 
 class ClientRequest extends Writable {
   constructor (options, callback) {
-    super({ autoDestroy: true })
+    super({ autoDestroy: true });
 
     if (!app.isReady()) {
-      throw new Error('net module can only be used after app is ready')
+      throw new Error('net module can only be used after app is ready');
     }
 
     if (callback) {
-      this.once('response', callback)
+      this.once('response', callback);
     }
 
-    const { redirectPolicy, ...urlLoaderOptions } = parseOptions(options)
-    this._urlLoaderOptions = urlLoaderOptions
-    this._redirectPolicy = redirectPolicy
-    this._started = false
+    const { redirectPolicy, ...urlLoaderOptions } = parseOptions(options);
+    this._urlLoaderOptions = urlLoaderOptions;
+    this._redirectPolicy = redirectPolicy;
+    this._started = false;
   }
 
   set chunkedEncoding (value) {
     if (this._started) {
-      throw new Error('chunkedEncoding can only be set before the request is started')
+      throw new Error('chunkedEncoding can only be set before the request is started');
     }
     if (typeof this._chunkedEncoding !== 'undefined') {
-      throw new Error('chunkedEncoding can only be set once')
+      throw new Error('chunkedEncoding can only be set once');
     }
-    this._chunkedEncoding = !!value
+    this._chunkedEncoding = !!value;
     if (this._chunkedEncoding) {
-      this._body = new ChunkedBodyStream(this)
+      this._body = new ChunkedBodyStream(this);
       this._urlLoaderOptions.body = (pipe) => {
-        this._body.startReading(pipe)
-      }
+        this._body.startReading(pipe);
+      };
     }
   }
 
   setHeader (name, value) {
     if (typeof name !== 'string') {
-      throw new TypeError('`name` should be a string in setHeader(name, value)')
+      throw new TypeError('`name` should be a string in setHeader(name, value)');
     }
     if (value == null) {
-      throw new Error('`value` required in setHeader("' + name + '", value)')
+      throw new Error('`value` required in setHeader("' + name + '", value)');
     }
     if (this._started || this._firstWrite) {
-      throw new Error('Can\'t set headers after they are sent')
+      throw new Error('Can\'t set headers after they are sent');
     }
     if (!_isValidHeaderName(name)) {
-      throw new Error(`Invalid header name: '${name}'`)
+      throw new Error(`Invalid header name: '${name}'`);
     }
     if (!_isValidHeaderValue(value.toString())) {
-      throw new Error(`Invalid value for header '${name}': '${value}'`)
+      throw new Error(`Invalid value for header '${name}': '${value}'`);
     }
 
-    const key = name.toLowerCase()
-    this._urlLoaderOptions.extraHeaders[key] = value
+    const key = name.toLowerCase();
+    this._urlLoaderOptions.extraHeaders[key] = value;
   }
 
   getHeader (name) {
     if (name == null) {
-      throw new Error('`name` is required for getHeader(name)')
+      throw new Error('`name` is required for getHeader(name)');
     }
 
-    const key = name.toLowerCase()
-    return this._urlLoaderOptions.extraHeaders[key]
+    const key = name.toLowerCase();
+    return this._urlLoaderOptions.extraHeaders[key];
   }
 
   removeHeader (name) {
     if (name == null) {
-      throw new Error('`name` is required for removeHeader(name)')
+      throw new Error('`name` is required for removeHeader(name)');
     }
 
     if (this._started || this._firstWrite) {
-      throw new Error('Can\'t remove headers after they are sent')
+      throw new Error('Can\'t remove headers after they are sent');
     }
 
-    const key = name.toLowerCase()
-    delete this._urlLoaderOptions.extraHeaders[key]
+    const key = name.toLowerCase();
+    delete this._urlLoaderOptions.extraHeaders[key];
   }
 
   _write (chunk, encoding, callback) {
-    this._firstWrite = true
+    this._firstWrite = true;
     if (!this._body) {
-      this._body = new SlurpStream()
+      this._body = new SlurpStream();
       this._body.on('finish', () => {
-        this._urlLoaderOptions.body = this._body.data()
-        this._startRequest()
-      })
+        this._urlLoaderOptions.body = this._body.data();
+        this._startRequest();
+      });
     }
     // TODO: is this the right way to forward to another stream?
-    this._body.write(chunk, encoding, callback)
+    this._body.write(chunk, encoding, callback);
   }
 
   _final (callback) {
     if (this._body) {
       // TODO: is this the right way to forward to another stream?
-      this._body.end(callback)
+      this._body.end(callback);
     } else {
       // end() called without a body, go ahead and start the request
-      this._startRequest()
-      callback()
+      this._startRequest();
+      callback();
     }
   }
 
   _startRequest () {
-    this._started = true
+    this._started = true;
     const stringifyValues = (obj) => {
-      const ret = {}
-      for (const k in obj) {
-        ret[k] = obj[k].toString()
+      const ret = {};
+      for (const k of Object.keys(obj)) {
+        ret[k] = obj[k].toString();
       }
-      return ret
-    }
-    const opts = { ...this._urlLoaderOptions, extraHeaders: stringifyValues(this._urlLoaderOptions.extraHeaders) }
-    this._urlLoader = new URLLoader(opts)
+      return ret;
+    };
+    const opts = { ...this._urlLoaderOptions, extraHeaders: stringifyValues(this._urlLoaderOptions.extraHeaders) };
+    this._urlLoader = new URLLoader(opts);
     this._urlLoader.on('response-started', (event, finalUrl, responseHead) => {
-      const response = this._response = new IncomingMessage(responseHead)
-      this.emit('response', response)
-    })
+      const response = this._response = new IncomingMessage(responseHead);
+      this.emit('response', response);
+    });
     this._urlLoader.on('data', (event, data) => {
-      this._response._storeInternalData(Buffer.from(data))
-    })
+      this._response._storeInternalData(Buffer.from(data));
+    });
     this._urlLoader.on('complete', () => {
-      if (this._response) { this._response._storeInternalData(null) }
-    })
+      if (this._response) { this._response._storeInternalData(null); }
+    });
     this._urlLoader.on('error', (event, netErrorString) => {
-      const error = new Error(netErrorString)
-      if (this._response) this._response.destroy(error)
-      this._die(error)
-    })
+      const error = new Error(netErrorString);
+      if (this._response) this._response.destroy(error);
+      this._die(error);
+    });
 
     this._urlLoader.on('login', (event, authInfo, callback) => {
-      const handled = this.emit('login', authInfo, callback)
+      const handled = this.emit('login', authInfo, callback);
       if (!handled) {
         // If there were no listeners, cancel the authentication request.
-        callback()
+        callback();
       }
-    })
+    });
 
     this._urlLoader.on('redirect', (event, redirectInfo, headers) => {
-      const { statusCode, newMethod, newUrl } = redirectInfo
+      const { statusCode, newMethod, newUrl } = redirectInfo;
       if (this._redirectPolicy === 'error') {
-        this._die(new Error(`Attempted to redirect, but redirect policy was 'error'`))
+        this._die(new Error(`Attempted to redirect, but redirect policy was 'error'`));
       } else if (this._redirectPolicy === 'manual') {
-        let _followRedirect = false
-        this._followRedirectCb = () => { _followRedirect = true }
+        let _followRedirect = false;
+        this._followRedirectCb = () => { _followRedirect = true; };
         try {
-          this.emit('redirect', statusCode, newMethod, newUrl, headers)
+          this.emit('redirect', statusCode, newMethod, newUrl, headers);
         } finally {
-          this._followRedirectCb = null
+          this._followRedirectCb = null;
           if (!_followRedirect && !this._aborted) {
-            this._die(new Error('Redirect was cancelled'))
+            this._die(new Error('Redirect was cancelled'));
           }
         }
       } else if (this._redirectPolicy === 'follow') {
@@ -416,61 +417,61 @@ class ClientRequest extends Writable {
         // allowed but does nothing. (Perhaps it should throw an error
         // though...? Since the redirect will happen regardless.)
         try {
-          this._followRedirectCb = () => {}
-          this.emit('redirect', statusCode, newMethod, newUrl, headers)
+          this._followRedirectCb = () => {};
+          this.emit('redirect', statusCode, newMethod, newUrl, headers);
         } finally {
-          this._followRedirectCb = null
+          this._followRedirectCb = null;
         }
       } else {
-        this._die(new Error(`Unexpected redirect policy '${this._redirectPolicy}'`))
+        this._die(new Error(`Unexpected redirect policy '${this._redirectPolicy}'`));
       }
-    })
+    });
 
     this._urlLoader.on('upload-progress', (event, position, total) => {
-      this._uploadProgress = { active: true, started: true, current: position, total }
-      this.emit('upload-progress', position, total) // Undocumented, for now
-    })
+      this._uploadProgress = { active: true, started: true, current: position, total };
+      this.emit('upload-progress', position, total); // Undocumented, for now
+    });
 
     this._urlLoader.on('download-progress', (event, current) => {
       if (this._response) {
-        this._response.emit('download-progress', current) // Undocumented, for now
+        this._response.emit('download-progress', current); // Undocumented, for now
       }
-    })
+    });
   }
 
   followRedirect () {
     if (this._followRedirectCb) {
-      this._followRedirectCb()
+      this._followRedirectCb();
     } else {
-      throw new Error('followRedirect() called, but was not waiting for a redirect')
+      throw new Error('followRedirect() called, but was not waiting for a redirect');
     }
   }
 
   abort () {
     if (!this._aborted) {
-      process.nextTick(() => { this.emit('abort') })
+      process.nextTick(() => { this.emit('abort'); });
     }
-    this._aborted = true
-    this._die()
+    this._aborted = true;
+    this._die();
   }
 
   _die (err) {
-    this.destroy(err)
+    this.destroy(err);
     if (this._urlLoader) {
-      this._urlLoader.cancel()
-      if (this._response) this._response.destroy(err)
+      this._urlLoader.cancel();
+      if (this._response) this._response.destroy(err);
     }
   }
 
   getUploadProgress () {
-    return this._uploadProgress ? { ...this._uploadProgress } : { active: false }
+    return this._uploadProgress ? { ...this._uploadProgress } : { active: false };
   }
 }
 
 Net.prototype.request = function (options, callback) {
-  return new ClientRequest(options, callback)
-}
+  return new ClientRequest(options, callback);
+};
 
-net.ClientRequest = ClientRequest
+net.ClientRequest = ClientRequest;
 
-module.exports = net
+module.exports = net;

lib/browser/api/notification.js

@@ -1,10 +1,10 @@
-'use strict'
+'use strict';
 
-const { EventEmitter } = require('events')
-const { Notification, isSupported } = process.electronBinding('notification')
+const { EventEmitter } = require('events');
+const { Notification, isSupported } = process.electronBinding('notification');
 
-Object.setPrototypeOf(Notification.prototype, EventEmitter.prototype)
+Object.setPrototypeOf(Notification.prototype, EventEmitter.prototype);
 
-Notification.isSupported = isSupported
+Notification.isSupported = isSupported;
 
-module.exports = Notification
+module.exports = Notification;

lib/browser/api/power-monitor.ts

@@ -1,14 +1,14 @@
-'use strict'
+'use strict';
 
-import { createLazyInstance } from '../utils'
+import { createLazyInstance } from '../utils';
 
-const { EventEmitter } = require('events')
-const { createPowerMonitor, PowerMonitor } = process.electronBinding('power_monitor')
+const { EventEmitter } = require('events');
+const { createPowerMonitor, PowerMonitor } = process.electronBinding('power_monitor');
 
 // PowerMonitor is an EventEmitter.
-Object.setPrototypeOf(PowerMonitor.prototype, EventEmitter.prototype)
+Object.setPrototypeOf(PowerMonitor.prototype, EventEmitter.prototype);
 
-const powerMonitor = createLazyInstance(createPowerMonitor, PowerMonitor, true)
+const powerMonitor = createLazyInstance(createPowerMonitor, PowerMonitor, true);
 
 if (process.platform === 'linux') {
   // In order to delay system shutdown when e.preventDefault() is invoked
@@ -18,21 +18,21 @@ if (process.platform === 'linux') {
   //
   // So here we watch for 'shutdown' listeners to be added or removed and
   // set or unset our shutdown delay lock accordingly.
-  const { app } = require('electron')
+  const { app } = require('electron');
   app.whenReady().then(() => {
     powerMonitor.on('newListener', (event: string) => {
       // whenever the listener count is incremented to one...
       if (event === 'shutdown' && powerMonitor.listenerCount('shutdown') === 0) {
-        powerMonitor.blockShutdown()
+        powerMonitor.blockShutdown();
       }
-    })
+    });
     powerMonitor.on('removeListener', (event: string) => {
       // whenever the listener count is decremented to zero...
       if (event === 'shutdown' && powerMonitor.listenerCount('shutdown') === 0) {
-        powerMonitor.unblockShutdown()
+        powerMonitor.unblockShutdown();
       }
-    })
-  })
+    });
+  });
 }
 
-module.exports = powerMonitor
+module.exports = powerMonitor;

lib/browser/api/power-save-blocker.js

@@ -1,3 +1,3 @@
-'use strict'
+'use strict';
 
-module.exports = process.electronBinding('power_save_blocker').powerSaveBlocker
+module.exports = process.electronBinding('power_save_blocker').powerSaveBlocker;

lib/browser/api/protocol.ts

@@ -1,29 +1,29 @@
-import { app, session } from 'electron'
+import { app, session } from 'electron';
 
 // Global protocol APIs.
-const protocol = process.electronBinding('protocol')
+const protocol = process.electronBinding('protocol');
 
 // Fallback protocol APIs of default session.
 Object.setPrototypeOf(protocol, new Proxy({}, {
   get (_target, property) {
-    if (!app.isReady()) return
+    if (!app.isReady()) return;
 
-    const protocol = session.defaultSession!.protocol
-    if (!Object.getPrototypeOf(protocol).hasOwnProperty(property)) return
+    const protocol = session.defaultSession!.protocol;
+    if (!Object.getPrototypeOf(protocol).hasOwnProperty(property)) return;
 
     // Returning a native function directly would throw error.
-    return (...args: any[]) => (protocol[property as keyof Electron.Protocol] as Function)(...args)
+    return (...args: any[]) => (protocol[property as keyof Electron.Protocol] as Function)(...args);
   },
 
   ownKeys () {
-    if (!app.isReady()) return []
+    if (!app.isReady()) return [];
 
-    return Object.getOwnPropertyNames(Object.getPrototypeOf(session.defaultSession!.protocol))
+    return Object.getOwnPropertyNames(Object.getPrototypeOf(session.defaultSession!.protocol));
   },
 
   getOwnPropertyDescriptor () {
-    return { configurable: true, enumerable: true }
+    return { configurable: true, enumerable: true };
   }
-}))
+}));
 
-export default protocol
+export default protocol;

lib/browser/api/screen.ts

@@ -1,10 +1,10 @@
-'use strict'
+'use strict';
 
-import { createLazyInstance } from '../utils'
-const { EventEmitter } = require('events')
-const { Screen, createScreen } = process.electronBinding('screen')
+import { createLazyInstance } from '../utils';
+const { EventEmitter } = require('events');
+const { Screen, createScreen } = process.electronBinding('screen');
 
 // Screen is an EventEmitter.
-Object.setPrototypeOf(Screen.prototype, EventEmitter.prototype)
+Object.setPrototypeOf(Screen.prototype, EventEmitter.prototype);
 
-module.exports = createLazyInstance(createScreen, Screen, true)
+module.exports = createLazyInstance(createScreen, Screen, true);

lib/browser/api/session.js

@@ -1,53 +1,54 @@
-'use strict'
+'use strict';
 
-const { EventEmitter } = require('events')
-const { app, deprecate } = require('electron')
-const { fromPartition, Session, Cookies, NetLog, Protocol } = process.electronBinding('session')
+const { EventEmitter } = require('events');
+const { app, deprecate } = require('electron');
+const { fromPartition, Session, Cookies, NetLog, Protocol, ServiceWorkerContext } = process.electronBinding('session');
 
 // Public API.
 Object.defineProperties(exports, {
   defaultSession: {
     enumerable: true,
-    get () { return fromPartition('') }
+    get () { return fromPartition(''); }
   },
   fromPartition: {
     enumerable: true,
     value: fromPartition
   }
-})
+});
 
-Object.setPrototypeOf(Session.prototype, EventEmitter.prototype)
-Object.setPrototypeOf(Cookies.prototype, EventEmitter.prototype)
+Object.setPrototypeOf(Cookies.prototype, EventEmitter.prototype);
+Object.setPrototypeOf(ServiceWorkerContext.prototype, EventEmitter.prototype);
+Object.setPrototypeOf(Session.prototype, EventEmitter.prototype);
 
 Session.prototype._init = function () {
-  app.emit('session-created', this)
-}
+  app.emit('session-created', this);
+};
 
-const _originalStartLogging = NetLog.prototype.startLogging
+const _originalStartLogging = NetLog.prototype.startLogging;
 NetLog.prototype.startLogging = function (path, ...args) {
-  this._currentlyLoggingPath = path
+  this._currentlyLoggingPath = path;
   try {
-    return _originalStartLogging.call(this, path, ...args)
+    return _originalStartLogging.call(this, path, ...args);
   } catch (e) {
-    this._currentlyLoggingPath = null
-    throw e
+    this._currentlyLoggingPath = null;
+    throw e;
   }
-}
+};
 
-const _originalStopLogging = NetLog.prototype.stopLogging
+const _originalStopLogging = NetLog.prototype.stopLogging;
 NetLog.prototype.stopLogging = function () {
-  const logPath = this._currentlyLoggingPath
-  this._currentlyLoggingPath = null
-  return _originalStopLogging.call(this).then(() => logPath)
-}
+  const logPath = this._currentlyLoggingPath;
+  this._currentlyLoggingPath = null;
+  return _originalStopLogging.call(this).then(() => logPath);
+};
 
-const currentlyLoggingPathDeprecated = deprecate.warnOnce('currentlyLoggingPath')
+const currentlyLoggingPathDeprecated = deprecate.warnOnce('currentlyLoggingPath');
 Object.defineProperties(NetLog.prototype, {
   currentlyLoggingPath: {
     enumerable: true,
     get () {
-      currentlyLoggingPathDeprecated()
-      return this._currentlyLoggingPath == null ? '' : this._currentlyLoggingPath
+      currentlyLoggingPathDeprecated();
+      return this._currentlyLoggingPath == null ? '' : this._currentlyLoggingPath;
     }
   }
-})
+});

lib/browser/api/system-preferences.ts

@@ -1,42 +1,41 @@
-import { EventEmitter } from 'events'
-import { deprecate } from 'electron'
-const { systemPreferences, SystemPreferences } = process.electronBinding('system_preferences')
+import { EventEmitter } from 'events';
+import { deprecate } from 'electron';
+const { systemPreferences, SystemPreferences } = process.electronBinding('system_preferences');
 
 // SystemPreferences is an EventEmitter.
-Object.setPrototypeOf(SystemPreferences.prototype, EventEmitter.prototype)
-EventEmitter.call(systemPreferences)
+Object.setPrototypeOf(SystemPreferences.prototype, EventEmitter.prototype);
+EventEmitter.call(systemPreferences);
 
-if ('appLevelAppearance' in systemPreferences) {
-  deprecate.fnToProperty(
-    SystemPreferences.prototype,
-    'appLevelAppearance',
-    '_getAppLevelAppearance',
-    '_setAppLevelAppearance'
-  )
+if ('getAppLevelAppearance' in systemPreferences) {
+  const nativeALAGetter = systemPreferences.getAppLevelAppearance;
+  const nativeALASetter = systemPreferences.setAppLevelAppearance;
+  Object.defineProperty(SystemPreferences.prototype, 'appLevelAppearance', {
+    get: () => nativeALAGetter.call(systemPreferences),
+    set: (appearance) => nativeALASetter.call(systemPreferences, appearance)
+  });
 }
 
-if ('effectiveAppearance' in systemPreferences) {
-  deprecate.fnToProperty(
-    SystemPreferences.prototype,
-    'effectiveAppearance',
-    '_getEffectiveAppearance'
-  )
+if ('getEffectiveAppearance' in systemPreferences) {
+  const nativeEAGetter = systemPreferences.getAppLevelAppearance;
+  Object.defineProperty(SystemPreferences.prototype, 'effectiveAppearance', {
+    get: () => nativeEAGetter.call(systemPreferences)
+  });
 }
 
 SystemPreferences.prototype.isDarkMode = deprecate.moveAPI(
   SystemPreferences.prototype.isDarkMode,
   'systemPreferences.isDarkMode()',
   'nativeTheme.shouldUseDarkColors'
-)
+);
 SystemPreferences.prototype.isInvertedColorScheme = deprecate.moveAPI(
   SystemPreferences.prototype.isInvertedColorScheme,
   'systemPreferences.isInvertedColorScheme()',
   'nativeTheme.shouldUseInvertedColorScheme'
-)
+);
 SystemPreferences.prototype.isHighContrastColorScheme = deprecate.moveAPI(
   SystemPreferences.prototype.isHighContrastColorScheme,
   'systemPreferences.isHighContrastColorScheme()',
   'nativeTheme.shouldUseHighContrastColors'
-)
+);
 
-module.exports = systemPreferences
+module.exports = systemPreferences;

lib/browser/api/top-level-window.js

@@ -1,24 +1,24 @@
-'use strict'
+'use strict';
 
-const electron = require('electron')
-const { EventEmitter } = require('events')
-const { TopLevelWindow } = process.electronBinding('top_level_window')
+const electron = require('electron');
+const { EventEmitter } = require('events');
+const { TopLevelWindow } = process.electronBinding('top_level_window');
 
-Object.setPrototypeOf(TopLevelWindow.prototype, EventEmitter.prototype)
+Object.setPrototypeOf(TopLevelWindow.prototype, EventEmitter.prototype);
 
 TopLevelWindow.prototype._init = function () {
   // Avoid recursive require.
-  const { app } = electron
+  const { app } = electron;
 
   // Simulate the application menu on platforms other than macOS.
   if (process.platform !== 'darwin') {
-    const menu = app.applicationMenu
-    if (menu) this.setMenu(menu)
+    const menu = app.applicationMenu;
+    if (menu) this.setMenu(menu);
   }
-}
+};
 
 TopLevelWindow.getFocusedWindow = () => {
-  return TopLevelWindow.getAllWindows().find((win) => win.isFocused())
-}
+  return TopLevelWindow.getAllWindows().find((win) => win.isFocused());
+};
 
-module.exports = TopLevelWindow
+module.exports = TopLevelWindow;

lib/browser/api/touch-bar.js

@@ -1,337 +1,349 @@
-'use strict'
+'use strict';
 
-const { EventEmitter } = require('events')
+const { EventEmitter } = require('events');
 
-let nextItemID = 1
+let nextItemID = 1;
 
 class TouchBar extends EventEmitter {
   // Bind a touch bar to a window
   static _setOnWindow (touchBar, window) {
     if (window._touchBar != null) {
-      window._touchBar._removeFromWindow(window)
+      window._touchBar._removeFromWindow(window);
     }
 
     if (touchBar == null) {
-      window._setTouchBarItems([])
-      return
+      window._setTouchBarItems([]);
+      return;
     }
 
     if (Array.isArray(touchBar)) {
-      touchBar = new TouchBar(touchBar)
+      touchBar = new TouchBar(touchBar);
     }
-    touchBar._addToWindow(window)
+    touchBar._addToWindow(window);
   }
 
   constructor (options) {
-    super()
+    super();
 
     if (options == null) {
-      throw new Error('Must specify options object as first argument')
+      throw new Error('Must specify options object as first argument');
     }
 
-    let { items, escapeItem } = options
+    let { items, escapeItem } = options;
 
     if (!Array.isArray(items)) {
-      items = []
+      items = [];
     }
 
     this.changeListener = (item) => {
-      this.emit('change', item.id, item.type)
-    }
+      this.emit('change', item.id, item.type);
+    };
 
-    this.windowListeners = {}
-    this.items = {}
-    this.ordereredItems = []
-    this.escapeItem = escapeItem
+    this.windowListeners = {};
+    this.items = {};
+    this.ordereredItems = [];
+    this.escapeItem = escapeItem;
 
     const registerItem = (item) => {
-      this.items[item.id] = item
-      item.on('change', this.changeListener)
+      this.items[item.id] = item;
+      item.on('change', this.changeListener);
       if (item.child instanceof TouchBar) {
-        item.child.ordereredItems.forEach(registerItem)
+        item.child.ordereredItems.forEach(registerItem);
       }
-    }
+    };
+
+    const idSet = new Set();
     items.forEach((item) => {
       if (!(item instanceof TouchBarItem)) {
-        throw new Error('Each item must be an instance of TouchBarItem')
+        throw new Error('Each item must be an instance of TouchBarItem');
       }
-      this.ordereredItems.push(item)
-      registerItem(item)
-    })
+
+      if (!idSet.has(item.id)) {
+        idSet.add(item.id);
+      } else {
+        throw new Error('Cannot add a single instance of TouchBarItem multiple times in a TouchBar');
+      }
+    });
+
+    // register in separate loop after all items are validated
+    for (const item of items) {
+      this.ordereredItems.push(item);
+      registerItem(item);
+    }
   }
 
   set escapeItem (item) {
     if (item != null && !(item instanceof TouchBarItem)) {
-      throw new Error('Escape item must be an instance of TouchBarItem')
+      throw new Error('Escape item must be an instance of TouchBarItem');
     }
     if (this.escapeItem != null) {
-      this.escapeItem.removeListener('change', this.changeListener)
+      this.escapeItem.removeListener('change', this.changeListener);
     }
-    this._escapeItem = item
+    this._escapeItem = item;
     if (this.escapeItem != null) {
-      this.escapeItem.on('change', this.changeListener)
+      this.escapeItem.on('change', this.changeListener);
     }
-    this.emit('escape-item-change', item)
+    this.emit('escape-item-change', item);
   }
 
   get escapeItem () {
-    return this._escapeItem
+    return this._escapeItem;
   }
 
   _addToWindow (window) {
-    const { id } = window
+    const { id } = window;
 
     // Already added to window
-    if (this.windowListeners.hasOwnProperty(id)) return
+    if (this.windowListeners.hasOwnProperty(id)) return;
 
-    window._touchBar = this
+    window._touchBar = this;
 
     const changeListener = (itemID) => {
-      window._refreshTouchBarItem(itemID)
-    }
-    this.on('change', changeListener)
+      window._refreshTouchBarItem(itemID);
+    };
+    this.on('change', changeListener);
 
     const escapeItemListener = (item) => {
-      window._setEscapeTouchBarItem(item != null ? item : {})
-    }
-    this.on('escape-item-change', escapeItemListener)
+      window._setEscapeTouchBarItem(item != null ? item : {});
+    };
+    this.on('escape-item-change', escapeItemListener);
 
     const interactionListener = (event, itemID, details) => {
-      let item = this.items[itemID]
+      let item = this.items[itemID];
       if (item == null && this.escapeItem != null && this.escapeItem.id === itemID) {
-        item = this.escapeItem
+        item = this.escapeItem;
       }
       if (item != null && item.onInteraction != null) {
-        item.onInteraction(details)
+        item.onInteraction(details);
       }
-    }
-    window.on('-touch-bar-interaction', interactionListener)
+    };
+    window.on('-touch-bar-interaction', interactionListener);
 
     const removeListeners = () => {
-      this.removeListener('change', changeListener)
-      this.removeListener('escape-item-change', escapeItemListener)
-      window.removeListener('-touch-bar-interaction', interactionListener)
-      window.removeListener('closed', removeListeners)
-      window._touchBar = null
-      delete this.windowListeners[id]
+      this.removeListener('change', changeListener);
+      this.removeListener('escape-item-change', escapeItemListener);
+      window.removeListener('-touch-bar-interaction', interactionListener);
+      window.removeListener('closed', removeListeners);
+      window._touchBar = null;
+      delete this.windowListeners[id];
       const unregisterItems = (items) => {
         for (const item of items) {
-          item.removeListener('change', this.changeListener)
+          item.removeListener('change', this.changeListener);
           if (item.child instanceof TouchBar) {
-            unregisterItems(item.child.ordereredItems)
+            unregisterItems(item.child.ordereredItems);
           }
         }
-      }
-      unregisterItems(this.ordereredItems)
+      };
+      unregisterItems(this.ordereredItems);
       if (this.escapeItem) {
-        this.escapeItem.removeListener('change', this.changeListener)
+        this.escapeItem.removeListener('change', this.changeListener);
       }
-    }
-    window.once('closed', removeListeners)
-    this.windowListeners[id] = removeListeners
+    };
+    window.once('closed', removeListeners);
+    this.windowListeners[id] = removeListeners;
 
-    window._setTouchBarItems(this.ordereredItems)
-    escapeItemListener(this.escapeItem)
+    window._setTouchBarItems(this.ordereredItems);
+    escapeItemListener(this.escapeItem);
   }
 
   _removeFromWindow (window) {
-    const removeListeners = this.windowListeners[window.id]
-    if (removeListeners != null) removeListeners()
+    const removeListeners = this.windowListeners[window.id];
+    if (removeListeners != null) removeListeners();
   }
 }
 
 class TouchBarItem extends EventEmitter {
   constructor () {
-    super()
-    this._addImmutableProperty('id', `${nextItemID++}`)
-    this._parents = []
+    super();
+    this._addImmutableProperty('id', `${nextItemID++}`);
+    this._parents = [];
   }
 
   _addImmutableProperty (name, value) {
     Object.defineProperty(this, name, {
       get: function () {
-        return value
+        return value;
       },
       set: function () {
-        throw new Error(`Cannot override property ${name}`)
+        throw new Error(`Cannot override property ${name}`);
       },
       enumerable: true,
       configurable: false
-    })
+    });
   }
 
   _addLiveProperty (name, initialValue) {
-    const privateName = `_${name}`
-    this[privateName] = initialValue
+    const privateName = `_${name}`;
+    this[privateName] = initialValue;
     Object.defineProperty(this, name, {
       get: function () {
-        return this[privateName]
+        return this[privateName];
       },
       set: function (value) {
-        this[privateName] = value
-        this.emit('change', this)
+        this[privateName] = value;
+        this.emit('change', this);
       },
       enumerable: true
-    })
+    });
   }
 
   _addParent (item) {
-    const existing = this._parents.some(test => test.id === item.id)
+    const existing = this._parents.some(test => test.id === item.id);
     if (!existing) {
       this._parents.push({
         id: item.id,
         type: item.type
-      })
+      });
     }
   }
 }
 
 TouchBar.TouchBarButton = class TouchBarButton extends TouchBarItem {
   constructor (config) {
-    super()
-    if (config == null) config = {}
-    this._addImmutableProperty('type', 'button')
-    this._addLiveProperty('label', config.label)
-    this._addLiveProperty('accessibilityLabel', config.accessibilityLabel)
-    this._addLiveProperty('backgroundColor', config.backgroundColor)
-    this._addLiveProperty('icon', config.icon)
-    this._addLiveProperty('iconPosition', config.iconPosition)
-    this._addLiveProperty('enabled', typeof config.enabled !== 'boolean' ? true : config.enabled)
+    super();
+    if (config == null) config = {};
+    this._addImmutableProperty('type', 'button');
+    this._addLiveProperty('label', config.label);
+    this._addLiveProperty('accessibilityLabel', config.accessibilityLabel);
+    this._addLiveProperty('backgroundColor', config.backgroundColor);
+    this._addLiveProperty('icon', config.icon);
+    this._addLiveProperty('iconPosition', config.iconPosition);
+    this._addLiveProperty('enabled', typeof config.enabled !== 'boolean' ? true : config.enabled);
     if (typeof config.click === 'function') {
       this._addImmutableProperty('onInteraction', () => {
-        config.click()
-      })
+        config.click();
+      });
     }
   }
-}
+};
 
 TouchBar.TouchBarColorPicker = class TouchBarColorPicker extends TouchBarItem {
   constructor (config) {
-    super()
-    if (config == null) config = {}
-    this._addImmutableProperty('type', 'colorpicker')
-    this._addLiveProperty('availableColors', config.availableColors)
-    this._addLiveProperty('selectedColor', config.selectedColor)
+    super();
+    if (config == null) config = {};
+    this._addImmutableProperty('type', 'colorpicker');
+    this._addLiveProperty('availableColors', config.availableColors);
+    this._addLiveProperty('selectedColor', config.selectedColor);
 
     if (typeof config.change === 'function') {
       this._addImmutableProperty('onInteraction', (details) => {
-        this._selectedColor = details.color
-        config.change(details.color)
-      })
+        this._selectedColor = details.color;
+        config.change(details.color);
+      });
     }
   }
-}
+};
 
 TouchBar.TouchBarGroup = class TouchBarGroup extends TouchBarItem {
   constructor (config) {
-    super()
-    if (config == null) config = {}
-    this._addImmutableProperty('type', 'group')
-    const defaultChild = (config.items instanceof TouchBar) ? config.items : new TouchBar(config.items)
-    this._addLiveProperty('child', defaultChild)
-    this.child.ordereredItems.forEach((item) => item._addParent(this))
+    super();
+    if (config == null) config = {};
+    this._addImmutableProperty('type', 'group');
+    const defaultChild = (config.items instanceof TouchBar) ? config.items : new TouchBar(config.items);
+    this._addLiveProperty('child', defaultChild);
+    this.child.ordereredItems.forEach((item) => item._addParent(this));
   }
-}
+};
 
 TouchBar.TouchBarLabel = class TouchBarLabel extends TouchBarItem {
   constructor (config) {
-    super()
-    if (config == null) config = {}
-    this._addImmutableProperty('type', 'label')
-    this._addLiveProperty('label', config.label)
-    this._addLiveProperty('accessibilityLabel', config.accessibilityLabel)
-    this._addLiveProperty('textColor', config.textColor)
+    super();
+    if (config == null) config = {};
+    this._addImmutableProperty('type', 'label');
+    this._addLiveProperty('label', config.label);
+    this._addLiveProperty('accessibilityLabel', config.accessibilityLabel);
+    this._addLiveProperty('textColor', config.textColor);
   }
-}
+};
 
 TouchBar.TouchBarPopover = class TouchBarPopover extends TouchBarItem {
   constructor (config) {
-    super()
-    if (config == null) config = {}
-    this._addImmutableProperty('type', 'popover')
-    this._addLiveProperty('label', config.label)
-    this._addLiveProperty('icon', config.icon)
-    this._addLiveProperty('showCloseButton', config.showCloseButton)
-    const defaultChild = (config.items instanceof TouchBar) ? config.items : new TouchBar(config.items)
-    this._addLiveProperty('child', defaultChild)
-    this.child.ordereredItems.forEach((item) => item._addParent(this))
+    super();
+    if (config == null) config = {};
+    this._addImmutableProperty('type', 'popover');
+    this._addLiveProperty('label', config.label);
+    this._addLiveProperty('icon', config.icon);
+    this._addLiveProperty('showCloseButton', config.showCloseButton);
+    const defaultChild = (config.items instanceof TouchBar) ? config.items : new TouchBar(config.items);
+    this._addLiveProperty('child', defaultChild);
+    this.child.ordereredItems.forEach((item) => item._addParent(this));
   }
-}
+};
 
 TouchBar.TouchBarSlider = class TouchBarSlider extends TouchBarItem {
   constructor (config) {
-    super()
-    if (config == null) config = {}
-    this._addImmutableProperty('type', 'slider')
-    this._addLiveProperty('label', config.label)
-    this._addLiveProperty('minValue', config.minValue)
-    this._addLiveProperty('maxValue', config.maxValue)
-    this._addLiveProperty('value', config.value)
+    super();
+    if (config == null) config = {};
+    this._addImmutableProperty('type', 'slider');
+    this._addLiveProperty('label', config.label);
+    this._addLiveProperty('minValue', config.minValue);
+    this._addLiveProperty('maxValue', config.maxValue);
+    this._addLiveProperty('value', config.value);
 
     if (typeof config.change === 'function') {
       this._addImmutableProperty('onInteraction', (details) => {
-        this._value = details.value
-        config.change(details.value)
-      })
+        this._value = details.value;
+        config.change(details.value);
+      });
     }
   }
-}
+};
 
 TouchBar.TouchBarSpacer = class TouchBarSpacer extends TouchBarItem {
   constructor (config) {
-    super()
-    if (config == null) config = {}
-    this._addImmutableProperty('type', 'spacer')
-    this._addImmutableProperty('size', config.size)
+    super();
+    if (config == null) config = {};
+    this._addImmutableProperty('type', 'spacer');
+    this._addImmutableProperty('size', config.size);
   }
-}
+};
 
 TouchBar.TouchBarSegmentedControl = class TouchBarSegmentedControl extends TouchBarItem {
   constructor (config) {
-    super()
-    if (config == null) config = {}
-    this._addImmutableProperty('type', 'segmented_control')
-    this._addLiveProperty('segmentStyle', config.segmentStyle)
-    this._addLiveProperty('segments', config.segments || [])
-    this._addLiveProperty('selectedIndex', config.selectedIndex)
-    this._addLiveProperty('mode', config.mode)
+    super();
+    if (config == null) config = {};
+    this._addImmutableProperty('type', 'segmented_control');
+    this._addLiveProperty('segmentStyle', config.segmentStyle);
+    this._addLiveProperty('segments', config.segments || []);
+    this._addLiveProperty('selectedIndex', config.selectedIndex);
+    this._addLiveProperty('mode', config.mode);
 
     if (typeof config.change === 'function') {
       this._addImmutableProperty('onInteraction', (details) => {
-        this._selectedIndex = details.selectedIndex
-        config.change(details.selectedIndex, details.isSelected)
-      })
+        this._selectedIndex = details.selectedIndex;
+        config.change(details.selectedIndex, details.isSelected);
+      });
     }
   }
-}
+};
 
 TouchBar.TouchBarScrubber = class TouchBarScrubber extends TouchBarItem {
   constructor (config) {
-    super()
-    if (config == null) config = {}
-    let { select, highlight } = config
-    this._addImmutableProperty('type', 'scrubber')
-    this._addLiveProperty('items', config.items)
-    this._addLiveProperty('selectedStyle', config.selectedStyle || null)
-    this._addLiveProperty('overlayStyle', config.overlayStyle || null)
-    this._addLiveProperty('showArrowButtons', config.showArrowButtons || false)
-    this._addLiveProperty('mode', config.mode || 'free')
+    super();
+    if (config == null) config = {};
+    let { select, highlight } = config;
+    this._addImmutableProperty('type', 'scrubber');
+    this._addLiveProperty('items', config.items);
+    this._addLiveProperty('selectedStyle', config.selectedStyle || null);
+    this._addLiveProperty('overlayStyle', config.overlayStyle || null);
+    this._addLiveProperty('showArrowButtons', config.showArrowButtons || false);
+    this._addLiveProperty('mode', config.mode || 'free');
 
-    const cont = typeof config.continuous === 'undefined' ? true : config.continuous
-    this._addLiveProperty('continuous', cont)
+    const cont = typeof config.continuous === 'undefined' ? true : config.continuous;
+    this._addLiveProperty('continuous', cont);
 
     if (typeof select === 'function' || typeof highlight === 'function') {
-      if (select == null) select = () => {}
-      if (highlight == null) highlight = () => {}
+      if (select == null) select = () => {};
+      if (highlight == null) highlight = () => {};
       this._addImmutableProperty('onInteraction', (details) => {
         if (details.type === 'select' && typeof select === 'function') {
-          select(details.selectedIndex)
+          select(details.selectedIndex);
         } else if (details.type === 'highlight' && typeof highlight === 'function') {
-          highlight(details.highlightedIndex)
+          highlight(details.highlightedIndex);
         }
-      })
+      });
     }
   }
-}
+};
 
-module.exports = TouchBar
+module.exports = TouchBar;

lib/browser/api/tray.js

@@ -1,9 +1,9 @@
-'use strict'
+'use strict';
 
-const { EventEmitter } = require('events')
-const { deprecate } = require('electron')
-const { Tray } = process.electronBinding('tray')
+const { EventEmitter } = require('events');
+const { deprecate } = require('electron');
+const { Tray } = process.electronBinding('tray');
 
-Object.setPrototypeOf(Tray.prototype, EventEmitter.prototype)
+Object.setPrototypeOf(Tray.prototype, EventEmitter.prototype);
 
-module.exports = Tray
+module.exports = Tray;

lib/browser/api/view.js

@@ -1,11 +1,11 @@
-'use strict'
+'use strict';
 
-const { EventEmitter } = require('events')
-const { View } = process.electronBinding('view')
+const { EventEmitter } = require('events');
+const { View } = process.electronBinding('view');
 
-Object.setPrototypeOf(View.prototype, EventEmitter.prototype)
+Object.setPrototypeOf(View.prototype, EventEmitter.prototype);
 
 View.prototype._init = function () {
-}
+};
 
-module.exports = View
+module.exports = View;

lib/browser/api/views/box-layout.js

@@ -1,15 +1,15 @@
-'use strict'
+'use strict';
 
-const electron = require('electron')
+const electron = require('electron');
 
-const { LayoutManager } = electron
-const { BoxLayout } = process.electronBinding('box_layout')
+const { LayoutManager } = electron;
+const { BoxLayout } = process.electronBinding('box_layout');
 
-Object.setPrototypeOf(BoxLayout.prototype, LayoutManager.prototype)
+Object.setPrototypeOf(BoxLayout.prototype, LayoutManager.prototype);
 
 BoxLayout.prototype._init = function () {
   // Call parent class's _init.
-  LayoutManager.prototype._init.call(this)
-}
+  LayoutManager.prototype._init.call(this);
+};
 
-module.exports = BoxLayout
+module.exports = BoxLayout;

lib/browser/api/views/button.js

@@ -1,15 +1,15 @@
-'use strict'
+'use strict';
 
-const electron = require('electron')
+const electron = require('electron');
 
-const { View } = electron
-const { Button } = process.electronBinding('button')
+const { View } = electron;
+const { Button } = process.electronBinding('button');
 
-Object.setPrototypeOf(Button.prototype, View.prototype)
+Object.setPrototypeOf(Button.prototype, View.prototype);
 
 Button.prototype._init = function () {
   // Call parent class's _init.
-  View.prototype._init.call(this)
-}
+  View.prototype._init.call(this);
+};
 
-module.exports = Button
+module.exports = Button;

lib/browser/api/views/label-button.js

@@ -1,15 +1,15 @@
-'use strict'
+'use strict';
 
-const electron = require('electron')
+const electron = require('electron');
 
-const { Button } = electron
-const { LabelButton } = process.electronBinding('label_button')
+const { Button } = electron;
+const { LabelButton } = process.electronBinding('label_button');
 
-Object.setPrototypeOf(LabelButton.prototype, Button.prototype)
+Object.setPrototypeOf(LabelButton.prototype, Button.prototype);
 
 LabelButton.prototype._init = function () {
   // Call parent class's _init.
-  Button.prototype._init.call(this)
-}
+  Button.prototype._init.call(this);
+};
 
-module.exports = LabelButton
+module.exports = LabelButton;

lib/browser/api/views/layout-manager.js

@@ -1,8 +1,8 @@
-'use strict'
+'use strict';
 
-const { LayoutManager } = process.electronBinding('layout_manager')
+const { LayoutManager } = process.electronBinding('layout_manager');
 
 LayoutManager.prototype._init = function () {
-}
+};
 
-module.exports = LayoutManager
+module.exports = LayoutManager;

lib/browser/api/views/md-text-button.js

@@ -1,15 +1,15 @@
-'use strict'
+'use strict';
 
-const electron = require('electron')
+const electron = require('electron');
 
-const { LabelButton } = electron
-const { MdTextButton } = process.electronBinding('md_text_button')
+const { LabelButton } = electron;
+const { MdTextButton } = process.electronBinding('md_text_button');
 
-Object.setPrototypeOf(MdTextButton.prototype, LabelButton.prototype)
+Object.setPrototypeOf(MdTextButton.prototype, LabelButton.prototype);
 
 MdTextButton.prototype._init = function () {
   // Call parent class's _init.
-  LabelButton.prototype._init.call(this)
-}
+  LabelButton.prototype._init.call(this);
+};
 
-module.exports = MdTextButton
+module.exports = MdTextButton;

lib/browser/api/views/resize-area.js

@@ -1,15 +1,15 @@
-'use strict'
+'use strict';
 
-const electron = require('electron')
+const electron = require('electron');
 
-const { View } = electron
-const { ResizeArea } = process.electronBinding('resize_area')
+const { View } = electron;
+const { ResizeArea } = process.electronBinding('resize_area');
 
-Object.setPrototypeOf(ResizeArea.prototype, View.prototype)
+Object.setPrototypeOf(ResizeArea.prototype, View.prototype);
 
 ResizeArea.prototype._init = function () {
   // Call parent class's _init.
-  View.prototype._init.call(this)
-}
+  View.prototype._init.call(this);
+};
 
-module.exports = ResizeArea
+module.exports = ResizeArea;

lib/browser/api/views/text-field.js

@@ -1,15 +1,15 @@
-'use strict'
+'use strict';
 
-const electron = require('electron')
+const electron = require('electron');
 
-const { View } = electron
-const { TextField } = process.electronBinding('text_field')
+const { View } = electron;
+const { TextField } = process.electronBinding('text_field');
 
-Object.setPrototypeOf(TextField.prototype, View.prototype)
+Object.setPrototypeOf(TextField.prototype, View.prototype);
 
 TextField.prototype._init = function () {
   // Call parent class's _init.
-  View.prototype._init.call(this)
-}
+  View.prototype._init.call(this);
+};
 
-module.exports = TextField
+module.exports = TextField;

lib/browser/api/web-contents-view.js

@@ -1,15 +1,15 @@
-'use strict'
+'use strict';
 
-const electron = require('electron')
+const electron = require('electron');
 
-const { View } = electron
-const { WebContentsView } = process.electronBinding('web_contents_view')
+const { View } = electron;
+const { WebContentsView } = process.electronBinding('web_contents_view');
 
-Object.setPrototypeOf(WebContentsView.prototype, View.prototype)
+Object.setPrototypeOf(WebContentsView.prototype, View.prototype);
 
 WebContentsView.prototype._init = function () {
   // Call parent class's _init.
-  View.prototype._init.call(this)
-}
+  View.prototype._init.call(this);
+};
 
-module.exports = WebContentsView
+module.exports = WebContentsView;

lib/browser/api/web-contents.js

@@ -1,26 +1,26 @@
-'use strict'
+'use strict';
 
-const features = process.electronBinding('features')
-const { EventEmitter } = require('events')
-const electron = require('electron')
-const path = require('path')
-const url = require('url')
-const { app, ipcMain, session, deprecate } = electron
+const features = process.electronBinding('features');
+const { EventEmitter } = require('events');
+const electron = require('electron');
+const path = require('path');
+const url = require('url');
+const { app, ipcMain, session, deprecate } = electron;
 
-const { internalWindowOpen } = require('@electron/internal/browser/guest-window-manager')
-const NavigationController = require('@electron/internal/browser/navigation-controller')
-const { ipcMainInternal } = require('@electron/internal/browser/ipc-main-internal')
-const ipcMainUtils = require('@electron/internal/browser/ipc-main-internal-utils')
+const { internalWindowOpen } = require('@electron/internal/browser/guest-window-manager');
+const NavigationController = require('@electron/internal/browser/navigation-controller');
+const { ipcMainInternal } = require('@electron/internal/browser/ipc-main-internal');
+const ipcMainUtils = require('@electron/internal/browser/ipc-main-internal-utils');
 
 // session is not used here, the purpose is to make sure session is initalized
 // before the webContents module.
 // eslint-disable-next-line
 session
 
-let nextId = 0
+let nextId = 0;
 const getNextId = function () {
-  return ++nextId
-}
+  return ++nextId;
+};
 
 // Stock page sizes
 const PDFPageSizes = {
@@ -61,7 +61,7 @@ const PDFPageSizes = {
     width_microns: 279400,
     custom_display_name: 'Tabloid'
   }
-}
+};
 
 // Default printing setting
 const defaultPrintingSetting = {
@@ -93,83 +93,83 @@ const defaultPrintingSetting = {
   // 2 = color - see ColorModel in //printing/print_job_constants.h
   color: 2,
   collate: true
-}
+};
 
 // JavaScript implementations of WebContents.
-const binding = process.electronBinding('web_contents')
-const { WebContents } = binding
+const binding = process.electronBinding('web_contents');
+const { WebContents } = binding;
 
-Object.setPrototypeOf(NavigationController.prototype, EventEmitter.prototype)
-Object.setPrototypeOf(WebContents.prototype, NavigationController.prototype)
+Object.setPrototypeOf(NavigationController.prototype, EventEmitter.prototype);
+Object.setPrototypeOf(WebContents.prototype, NavigationController.prototype);
 
 // WebContents::send(channel, args..)
 // WebContents::sendToAll(channel, args..)
 WebContents.prototype.send = function (channel, ...args) {
   if (typeof channel !== 'string') {
-    throw new Error('Missing required channel argument')
+    throw new Error('Missing required channel argument');
   }
 
-  const internal = false
-  const sendToAll = false
+  const internal = false;
+  const sendToAll = false;
 
-  return this._send(internal, sendToAll, channel, args)
-}
+  return this._send(internal, sendToAll, channel, args);
+};
 
 WebContents.prototype.sendToAll = function (channel, ...args) {
   if (typeof channel !== 'string') {
-    throw new Error('Missing required channel argument')
+    throw new Error('Missing required channel argument');
   }
 
-  const internal = false
-  const sendToAll = true
+  const internal = false;
+  const sendToAll = true;
 
-  return this._send(internal, sendToAll, channel, args)
-}
+  return this._send(internal, sendToAll, channel, args);
+};
 
 WebContents.prototype._sendInternal = function (channel, ...args) {
   if (typeof channel !== 'string') {
-    throw new Error('Missing required channel argument')
+    throw new Error('Missing required channel argument');
   }
 
-  const internal = true
-  const sendToAll = false
+  const internal = true;
+  const sendToAll = false;
 
-  return this._send(internal, sendToAll, channel, args)
-}
+  return this._send(internal, sendToAll, channel, args);
+};
 WebContents.prototype._sendInternalToAll = function (channel, ...args) {
   if (typeof channel !== 'string') {
-    throw new Error('Missing required channel argument')
+    throw new Error('Missing required channel argument');
   }
 
-  const internal = true
-  const sendToAll = true
+  const internal = true;
+  const sendToAll = true;
 
-  return this._send(internal, sendToAll, channel, args)
-}
+  return this._send(internal, sendToAll, channel, args);
+};
 WebContents.prototype.sendToFrame = function (frameId, channel, ...args) {
   if (typeof channel !== 'string') {
-    throw new Error('Missing required channel argument')
+    throw new Error('Missing required channel argument');
   } else if (typeof frameId !== 'number') {
-    throw new Error('Missing required frameId argument')
+    throw new Error('Missing required frameId argument');
   }
 
-  const internal = false
-  const sendToAll = false
+  const internal = false;
+  const sendToAll = false;
 
-  return this._sendToFrame(internal, sendToAll, frameId, channel, args)
-}
+  return this._sendToFrame(internal, sendToAll, frameId, channel, args);
+};
 WebContents.prototype._sendToFrameInternal = function (frameId, channel, ...args) {
   if (typeof channel !== 'string') {
-    throw new Error('Missing required channel argument')
+    throw new Error('Missing required channel argument');
   } else if (typeof frameId !== 'number') {
-    throw new Error('Missing required frameId argument')
+    throw new Error('Missing required frameId argument');
   }
 
-  const internal = true
-  const sendToAll = false
+  const internal = true;
+  const sendToAll = false;
 
-  return this._sendToFrame(internal, sendToAll, frameId, channel, args)
-}
+  return this._sendToFrame(internal, sendToAll, frameId, channel, args);
+};
 
 // Following methods are mapped to webFrame.
 const webFrameMethods = [
@@ -177,138 +177,138 @@ const webFrameMethods = [
   'insertText',
   'removeInsertedCSS',
   'setVisualZoomLevelLimits'
-]
+];
 
 for (const method of webFrameMethods) {
   WebContents.prototype[method] = function (...args) {
-    return ipcMainUtils.invokeInWebContents(this, false, 'ELECTRON_INTERNAL_RENDERER_WEB_FRAME_METHOD', method, ...args)
-  }
+    return ipcMainUtils.invokeInWebContents(this, false, 'ELECTRON_INTERNAL_RENDERER_WEB_FRAME_METHOD', method, ...args);
+  };
 }
 
 const waitTillCanExecuteJavaScript = async (webContents) => {
-  if (webContents.getURL() && !webContents.isLoadingMainFrame()) return
+  if (webContents.getURL() && !webContents.isLoadingMainFrame()) return;
 
   return new Promise((resolve) => {
     webContents.once('did-stop-loading', () => {
-      resolve()
-    })
-  })
-}
+      resolve();
+    });
+  });
+};
 
 // Make sure WebContents::executeJavaScript would run the code only when the
 // WebContents has been loaded.
 WebContents.prototype.executeJavaScript = async function (code, hasUserGesture) {
-  await waitTillCanExecuteJavaScript(this)
-  return ipcMainUtils.invokeInWebContents(this, false, 'ELECTRON_INTERNAL_RENDERER_WEB_FRAME_METHOD', 'executeJavaScript', code, hasUserGesture)
-}
+  await waitTillCanExecuteJavaScript(this);
+  return ipcMainUtils.invokeInWebContents(this, false, 'ELECTRON_INTERNAL_RENDERER_WEB_FRAME_METHOD', 'executeJavaScript', code, hasUserGesture);
+};
 WebContents.prototype.executeJavaScriptInIsolatedWorld = async function (code, hasUserGesture) {
-  await waitTillCanExecuteJavaScript(this)
-  return ipcMainUtils.invokeInWebContents(this, false, 'ELECTRON_INTERNAL_RENDERER_WEB_FRAME_METHOD', 'executeJavaScriptInIsolatedWorld', code, hasUserGesture)
-}
+  await waitTillCanExecuteJavaScript(this);
+  return ipcMainUtils.invokeInWebContents(this, false, 'ELECTRON_INTERNAL_RENDERER_WEB_FRAME_METHOD', 'executeJavaScriptInIsolatedWorld', code, hasUserGesture);
+};
 
 // Translate the options of printToPDF.
 WebContents.prototype.printToPDF = function (options) {
   const printSettings = {
     ...defaultPrintingSetting,
     requestID: getNextId()
-  }
+  };
 
   if (options.landscape !== undefined) {
     if (typeof options.landscape !== 'boolean') {
-      const error = new Error('landscape must be a Boolean')
-      return Promise.reject(error)
+      const error = new Error('landscape must be a Boolean');
+      return Promise.reject(error);
     }
-    printSettings.landscape = options.landscape
+    printSettings.landscape = options.landscape;
   }
 
   if (options.scaleFactor !== undefined) {
     if (typeof options.scaleFactor !== 'number') {
-      const error = new Error('scaleFactor must be a Number')
-      return Promise.reject(error)
+      const error = new Error('scaleFactor must be a Number');
+      return Promise.reject(error);
     }
-    printSettings.scaleFactor = options.scaleFactor
+    printSettings.scaleFactor = options.scaleFactor;
   }
 
   if (options.marginsType !== undefined) {
     if (typeof options.marginsType !== 'number') {
-      const error = new Error('marginsType must be a Number')
-      return Promise.reject(error)
+      const error = new Error('marginsType must be a Number');
+      return Promise.reject(error);
     }
-    printSettings.marginsType = options.marginsType
+    printSettings.marginsType = options.marginsType;
   }
 
   if (options.printSelectionOnly !== undefined) {
     if (typeof options.printSelectionOnly !== 'boolean') {
-      const error = new Error('printSelectionOnly must be a Boolean')
-      return Promise.reject(error)
+      const error = new Error('printSelectionOnly must be a Boolean');
+      return Promise.reject(error);
     }
-    printSettings.shouldPrintSelectionOnly = options.printSelectionOnly
+    printSettings.shouldPrintSelectionOnly = options.printSelectionOnly;
   }
 
   if (options.printBackground !== undefined) {
     if (typeof options.printBackground !== 'boolean') {
-      const error = new Error('printBackground must be a Boolean')
-      return Promise.reject(error)
+      const error = new Error('printBackground must be a Boolean');
+      return Promise.reject(error);
     }
-    printSettings.shouldPrintBackgrounds = options.printBackground
+    printSettings.shouldPrintBackgrounds = options.printBackground;
   }
 
   if (options.pageRanges !== undefined) {
-    const pageRanges = options.pageRanges
+    const pageRanges = options.pageRanges;
     if (!pageRanges.hasOwnProperty('from') || !pageRanges.hasOwnProperty('to')) {
-      const error = new Error(`pageRanges must be an Object with 'from' and 'to' properties`)
-      return Promise.reject(error)
+      const error = new Error(`pageRanges must be an Object with 'from' and 'to' properties`);
+      return Promise.reject(error);
     }
 
     if (typeof pageRanges.from !== 'number') {
-      const error = new Error('pageRanges.from must be a Number')
-      return Promise.reject(error)
+      const error = new Error('pageRanges.from must be a Number');
+      return Promise.reject(error);
     }
 
     if (typeof pageRanges.to !== 'number') {
-      const error = new Error('pageRanges.to must be a Number')
-      return Promise.reject(error)
+      const error = new Error('pageRanges.to must be a Number');
+      return Promise.reject(error);
     }
 
     // Chromium uses 1-based page ranges, so increment each by 1.
     printSettings.pageRange = [{
       from: pageRanges.from + 1,
       to: pageRanges.to + 1
-    }]
+    }];
   }
 
   if (options.headerFooter !== undefined) {
-    const headerFooter = options.headerFooter
-    printSettings.headerFooterEnabled = true
+    const headerFooter = options.headerFooter;
+    printSettings.headerFooterEnabled = true;
     if (typeof headerFooter === 'object') {
       if (!headerFooter.url || !headerFooter.title) {
-        const error = new Error('url and title properties are required for headerFooter')
-        return Promise.reject(error)
+        const error = new Error('url and title properties are required for headerFooter');
+        return Promise.reject(error);
       }
       if (typeof headerFooter.title !== 'string') {
-        const error = new Error('headerFooter.title must be a String')
-        return Promise.reject(error)
+        const error = new Error('headerFooter.title must be a String');
+        return Promise.reject(error);
       }
-      printSettings.title = headerFooter.title
+      printSettings.title = headerFooter.title;
 
       if (typeof headerFooter.url !== 'string') {
-        const error = new Error('headerFooter.url must be a String')
-        return Promise.reject(error)
+        const error = new Error('headerFooter.url must be a String');
+        return Promise.reject(error);
       }
-      printSettings.url = headerFooter.url
+      printSettings.url = headerFooter.url;
     } else {
-      const error = new Error('headerFooter must be an Object')
-      return Promise.reject(error)
+      const error = new Error('headerFooter must be an Object');
+      return Promise.reject(error);
     }
   }
 
   // Optionally set size for PDF.
   if (options.pageSize !== undefined) {
-    const pageSize = options.pageSize
+    const pageSize = options.pageSize;
     if (typeof pageSize === 'object') {
       if (!pageSize.height || !pageSize.width) {
-        const error = new Error('height and width properties are required for pageSize')
-        return Promise.reject(error)
+        const error = new Error('height and width properties are required for pageSize');
+        return Promise.reject(error);
       }
       // Dimensions in Microns
       // 1 meter = 10^6 microns
@@ -317,28 +317,28 @@ WebContents.prototype.printToPDF = function (options) {
         custom_display_name: 'Custom',
         height_microns: Math.ceil(pageSize.height),
         width_microns: Math.ceil(pageSize.width)
-      }
+      };
     } else if (PDFPageSizes[pageSize]) {
-      printSettings.mediaSize = PDFPageSizes[pageSize]
+      printSettings.mediaSize = PDFPageSizes[pageSize];
     } else {
-      const error = new Error(`Unsupported pageSize: ${pageSize}`)
-      return Promise.reject(error)
+      const error = new Error(`Unsupported pageSize: ${pageSize}`);
+      return Promise.reject(error);
     }
   } else {
-    printSettings.mediaSize = PDFPageSizes['A4']
+    printSettings.mediaSize = PDFPageSizes['A4'];
   }
 
   // Chromium expects this in a 0-100 range number, not as float
-  printSettings.scaleFactor = Math.ceil(printSettings.scaleFactor) % 100
+  printSettings.scaleFactor = Math.ceil(printSettings.scaleFactor) % 100;
   // PrinterType enum from //printing/print_job_constants.h
-  printSettings.printerType = 2
+  printSettings.printerType = 2;
   if (features.isPrintingEnabled()) {
-    return this._printToPDF(printSettings)
+    return this._printToPDF(printSettings);
   } else {
-    const error = new Error('Printing feature is disabled')
-    return Promise.reject(error)
+    const error = new Error('Printing feature is disabled');
+    return Promise.reject(error);
   }
-}
+};
 
 WebContents.prototype.print = function (options = {}, callback) {
   // TODO(codebytere): deduplicate argument sanitization by moving rest of
@@ -346,10 +346,10 @@ WebContents.prototype.print = function (options = {}, callback) {
   if (typeof options === 'object') {
     // Optionally set size for PDF.
     if (options.pageSize !== undefined) {
-      const pageSize = options.pageSize
+      const pageSize = options.pageSize;
       if (typeof pageSize === 'object') {
         if (!pageSize.height || !pageSize.width) {
-          throw new Error('height and width properties are required for pageSize')
+          throw new Error('height and width properties are required for pageSize');
         }
         // Dimensions in Microns - 1 meter = 10^6 microns
         options.mediaSize = {
@@ -357,40 +357,40 @@ WebContents.prototype.print = function (options = {}, callback) {
           custom_display_name: 'Custom',
           height_microns: Math.ceil(pageSize.height),
           width_microns: Math.ceil(pageSize.width)
-        }
+        };
       } else if (PDFPageSizes[pageSize]) {
-        options.mediaSize = PDFPageSizes[pageSize]
+        options.mediaSize = PDFPageSizes[pageSize];
       } else {
-        throw new Error(`Unsupported pageSize: ${pageSize}`)
+        throw new Error(`Unsupported pageSize: ${pageSize}`);
       }
     }
   }
 
   if (features.isPrintingEnabled()) {
     if (callback) {
-      this._print(options, callback)
+      this._print(options, callback);
     } else {
-      this._print(options)
+      this._print(options);
     }
   } else {
-    console.error('Error: Printing feature is disabled.')
+    console.error('Error: Printing feature is disabled.');
   }
-}
+};
 
 WebContents.prototype.getPrinters = function () {
   if (features.isPrintingEnabled()) {
-    return this._getPrinters()
+    return this._getPrinters();
   } else {
-    console.error('Error: Printing feature is disabled.')
-    return []
+    console.error('Error: Printing feature is disabled.');
+    return [];
   }
-}
+};
 
 WebContents.prototype.loadFile = function (filePath, options = {}) {
   if (typeof filePath !== 'string') {
-    throw new Error('Must pass filePath as a string')
+    throw new Error('Must pass filePath as a string');
   }
-  const { query, search, hash } = options
+  const { query, search, hash } = options;
 
   return this.loadURL(url.format({
     protocol: 'file',
@@ -399,99 +399,99 @@ WebContents.prototype.loadFile = function (filePath, options = {}) {
     query,
     search,
     hash
-  }))
-}
+  }));
+};
 
 const addReplyToEvent = (event) => {
   event.reply = (...args) => {
-    event.sender.sendToFrame(event.frameId, ...args)
-  }
-}
+    event.sender.sendToFrame(event.frameId, ...args);
+  };
+};
 
 const addReplyInternalToEvent = (event) => {
   Object.defineProperty(event, '_replyInternal', {
     configurable: false,
     enumerable: false,
     value: (...args) => {
-      event.sender._sendToFrameInternal(event.frameId, ...args)
+      event.sender._sendToFrameInternal(event.frameId, ...args);
     }
-  })
-}
+  });
+};
 
 const addReturnValueToEvent = (event) => {
   Object.defineProperty(event, 'returnValue', {
     set: (value) => event.sendReply([value]),
     get: () => {}
-  })
-}
+  });
+};
 
 // Add JavaScript wrappers for WebContents class.
 WebContents.prototype._init = function () {
   // The navigation controller.
-  NavigationController.call(this, this)
+  NavigationController.call(this, this);
 
   // Every remote callback from renderer process would add a listener to the
   // render-view-deleted event, so ignore the listeners warning.
-  this.setMaxListeners(0)
+  this.setMaxListeners(0);
 
   // Dispatch IPC messages to the ipc module.
   this.on('-ipc-message', function (event, internal, channel, args) {
     if (internal) {
-      addReplyInternalToEvent(event)
-      ipcMainInternal.emit(channel, event, ...args)
+      addReplyInternalToEvent(event);
+      ipcMainInternal.emit(channel, event, ...args);
     } else {
-      addReplyToEvent(event)
-      this.emit('ipc-message', event, channel, ...args)
-      ipcMain.emit(channel, event, ...args)
+      addReplyToEvent(event);
+      this.emit('ipc-message', event, channel, ...args);
+      ipcMain.emit(channel, event, ...args);
     }
-  })
+  });
 
   this.on('-ipc-invoke', function (event, internal, channel, args) {
-    event._reply = (result) => event.sendReply({ result })
+    event._reply = (result) => event.sendReply({ result });
     event._throw = (error) => {
-      console.error(`Error occurred in handler for '${channel}':`, error)
-      event.sendReply({ error: error.toString() })
-    }
-    const target = internal ? ipcMainInternal : ipcMain
+      console.error(`Error occurred in handler for '${channel}':`, error);
+      event.sendReply({ error: error.toString() });
+    };
+    const target = internal ? ipcMainInternal : ipcMain;
     if (target._invokeHandlers.has(channel)) {
-      target._invokeHandlers.get(channel)(event, ...args)
+      target._invokeHandlers.get(channel)(event, ...args);
     } else {
-      event._throw(`No handler registered for '${channel}'`)
+      event._throw(`No handler registered for '${channel}'`);
     }
-  })
+  });
 
   this.on('-ipc-message-sync', function (event, internal, channel, args) {
-    addReturnValueToEvent(event)
+    addReturnValueToEvent(event);
     if (internal) {
-      addReplyInternalToEvent(event)
-      ipcMainInternal.emit(channel, event, ...args)
+      addReplyInternalToEvent(event);
+      ipcMainInternal.emit(channel, event, ...args);
     } else {
-      addReplyToEvent(event)
-      this.emit('ipc-message-sync', event, channel, ...args)
-      ipcMain.emit(channel, event, ...args)
+      addReplyToEvent(event);
+      this.emit('ipc-message-sync', event, channel, ...args);
+      ipcMain.emit(channel, event, ...args);
     }
-  })
+  });
 
   // Handle context menu action request from pepper plugin.
   this.on('pepper-context-menu', function (event, params, callback) {
     // Access Menu via electron.Menu to prevent circular require.
-    const menu = electron.Menu.buildFromTemplate(params.menu)
+    const menu = electron.Menu.buildFromTemplate(params.menu);
     menu.popup({
       window: event.sender.getOwnerBrowserWindow(),
       x: params.x,
       y: params.y,
       callback
-    })
-  })
+    });
+  });
 
   this.on('crashed', (event, ...args) => {
-    app.emit('renderer-process-crashed', event, this, ...args)
-  })
+    app.emit('renderer-process-crashed', event, this, ...args);
+  });
 
   // The devtools requests the webContents to reload.
   this.on('devtools-reload-page', function () {
-    this.reload()
-  })
+    this.reload();
+  });
 
   // Handle window.open for BrowserWindow and BrowserView.
   if (['browserView', 'window'].includes(this.getType())) {
@@ -503,9 +503,9 @@ WebContents.prototype._init = function () {
         show: true,
         width: 800,
         height: 600
-      }
-      internalWindowOpen(event, url, referrer, frameName, disposition, options, additionalFeatures, postData)
-    })
+      };
+      internalWindowOpen(event, url, referrer, frameName, disposition, options, additionalFeatures, postData);
+    });
 
     // Create a new browser window for the native implementation of
     // "window.open", used in sandbox and nativeWindowOpen mode.
@@ -513,8 +513,8 @@ WebContents.prototype._init = function () {
       userGesture, left, top, width, height, url, frameName) => {
       if ((disposition !== 'foreground-tab' && disposition !== 'new-window' &&
            disposition !== 'background-tab')) {
-        event.preventDefault()
-        return
+        event.preventDefault();
+        return;
       }
 
       const options = {
@@ -524,54 +524,74 @@ WebContents.prototype._init = function () {
         width: width || 800,
         height: height || 600,
         webContents
-      }
-      const referrer = { url: '', policy: 'default' }
-      internalWindowOpen(event, url, referrer, frameName, disposition, options)
-    })
+      };
+      const referrer = { url: '', policy: 'default' };
+      internalWindowOpen(event, url, referrer, frameName, disposition, options);
+    });
   }
 
   this.on('login', (event, ...args) => {
-    app.emit('login', event, this, ...args)
-  })
+    app.emit('login', event, this, ...args);
+  });
 
-  const event = process.electronBinding('event').createEmpty()
-  app.emit('web-contents-created', event, this)
-}
+  const event = process.electronBinding('event').createEmpty();
+  app.emit('web-contents-created', event, this);
 
-// Deprecations
-deprecate.fnToProperty(WebContents.prototype, 'audioMuted', '_isAudioMuted', '_setAudioMuted')
-deprecate.fnToProperty(WebContents.prototype, 'userAgent', '_getUserAgent', '_setUserAgent')
-deprecate.fnToProperty(WebContents.prototype, 'zoomLevel', '_getZoomLevel', '_setZoomLevel')
-deprecate.fnToProperty(WebContents.prototype, 'zoomFactor', '_getZoomFactor', '_setZoomFactor')
-deprecate.fnToProperty(WebContents.prototype, 'frameRate', '_getFrameRate', '_setFrameRate')
+  // Properties
+
+  Object.defineProperty(this, 'audioMuted', {
+    get: () => this.isAudioMuted(),
+    set: (muted) => this.setAudioMuted(muted)
+  });
+
+  Object.defineProperty(this, 'userAgent', {
+    get: () => this.getUserAgent(),
+    set: (agent) => this.setUserAgent(agent)
+  });
+
+  Object.defineProperty(this, 'zoomLevel', {
+    get: () => this.getZoomLevel(),
+    set: (level) => this.setZoomLevel(level)
+  });
+
+  Object.defineProperty(this, 'zoomFactor', {
+    get: () => this.getZoomFactor(),
+    set: (factor) => this.setZoomFactor(factor)
+  });
+
+  Object.defineProperty(this, 'frameRate', {
+    get: () => this.getFrameRate(),
+    set: (rate) => this.setFrameRate(rate)
+  });
+};
 
 // JavaScript wrapper of Debugger.
-const { Debugger } = process.electronBinding('debugger')
-Object.setPrototypeOf(Debugger.prototype, EventEmitter.prototype)
+const { Debugger } = process.electronBinding('debugger');
+Object.setPrototypeOf(Debugger.prototype, EventEmitter.prototype);
 
 // Public APIs.
 module.exports = {
   create (options = {}) {
-    return binding.create(options)
+    return binding.create(options);
   },
 
   fromId (id) {
-    return binding.fromId(id)
+    return binding.fromId(id);
   },
 
   getFocusedWebContents () {
-    let focused = null
+    let focused = null;
     for (const contents of binding.getAllWebContents()) {
-      if (!contents.isFocused()) continue
-      if (focused == null) focused = contents
+      if (!contents.isFocused()) continue;
+      if (focused == null) focused = contents;
       // Return webview web contents which may be embedded inside another
       // web contents that is also reporting as focused
-      if (contents.getType() === 'webview') return contents
+      if (contents.getType() === 'webview') return contents;
     }
-    return focused
+    return focused;
   },
 
   getAllWebContents () {
-    return binding.getAllWebContents()
+    return binding.getAllWebContents();
   }
-}
+};

lib/browser/chrome-extension-shim.js

@@ -1,37 +1,37 @@
-'use strict'
+'use strict';
 
 // This is a temporary shim to aid in transition from the old
 // BrowserWindow-based extensions stuff to the new native-backed extensions
 // API.
 
 if (!process.electronBinding('features').isExtensionsEnabled()) {
-  throw new Error('Attempted to load JS chrome-extension shim without //extensions support enabled')
+  throw new Error('Attempted to load JS chrome-extension shim without //extensions support enabled');
 }
 
-const { app, session, BrowserWindow, deprecate } = require('electron')
+const { app, session, BrowserWindow, deprecate } = require('electron');
 
 app.whenReady().then(function () {
   const addExtension = function (srcDirectory) {
-    return session.defaultSession.loadExtension(srcDirectory)
-  }
+    return session.defaultSession.loadExtension(srcDirectory);
+  };
 
   const removeExtension = function (name) {
-    const extension = session.defaultSession.getAllExtensions().find(e => e.name === name)
-    if (extension) { session.defaultSession.removeExtension(extension.id) }
-  }
+    const extension = session.defaultSession.getAllExtensions().find(e => e.name === name);
+    if (extension) { session.defaultSession.removeExtension(extension.id); }
+  };
 
   const getExtensions = function () {
-    const extensions = {}
+    const extensions = {};
     session.defaultSession.getAllExtensions().forEach(e => {
-      extensions[e.name] = e
-    })
-    return extensions
-  }
+      extensions[e.name] = e;
+    });
+    return extensions;
+  };
 
-  BrowserWindow.addExtension = deprecate.moveAPI(addExtension, 'BrowserWindow.addExtension', 'session.loadExtension')
-  BrowserWindow.removeExtension = deprecate.moveAPI(removeExtension, 'BrowserWindow.removeExtension', 'session.removeExtension')
-  BrowserWindow.getExtensions = deprecate.moveAPI(getExtensions, 'BrowserWindow.getExtensions', 'session.getAllExtensions')
-  BrowserWindow.addDevToolsExtension = deprecate.moveAPI(addExtension, 'BrowserWindow.addDevToolsExtension', 'session.loadExtension')
-  BrowserWindow.removeDevToolsExtension = deprecate.moveAPI(removeExtension, 'BrowserWindow.removeDevToolsExtension', 'session.removeExtension')
-  BrowserWindow.getDevToolsExtensions = deprecate.moveAPI(getExtensions, 'BrowserWindow.getDevToolsExtensions', 'session.getAllExtensions')
-})
+  BrowserWindow.addExtension = deprecate.moveAPI(addExtension, 'BrowserWindow.addExtension', 'session.loadExtension');
+  BrowserWindow.removeExtension = deprecate.moveAPI(removeExtension, 'BrowserWindow.removeExtension', 'session.removeExtension');
+  BrowserWindow.getExtensions = deprecate.moveAPI(getExtensions, 'BrowserWindow.getExtensions', 'session.getAllExtensions');
+  BrowserWindow.addDevToolsExtension = deprecate.moveAPI(addExtension, 'BrowserWindow.addDevToolsExtension', 'session.loadExtension');
+  BrowserWindow.removeDevToolsExtension = deprecate.moveAPI(removeExtension, 'BrowserWindow.removeDevToolsExtension', 'session.removeExtension');
+  BrowserWindow.getDevToolsExtensions = deprecate.moveAPI(getExtensions, 'BrowserWindow.getDevToolsExtensions', 'session.getAllExtensions');
+});

lib/browser/chrome-extension.js

@@ -1,105 +1,105 @@
-'use strict'
+'use strict';
 
 if (process.electronBinding('features').isExtensionsEnabled()) {
-  throw new Error('Attempted to load JS chrome-extension polyfill with //extensions support enabled')
+  throw new Error('Attempted to load JS chrome-extension polyfill with //extensions support enabled');
 }
 
-const { app, webContents, BrowserWindow } = require('electron')
-const { getAllWebContents } = process.electronBinding('web_contents')
-const { ipcMainInternal } = require('@electron/internal/browser/ipc-main-internal')
-const ipcMainUtils = require('@electron/internal/browser/ipc-main-internal-utils')
+const { app, webContents, BrowserWindow } = require('electron');
+const { getAllWebContents } = process.electronBinding('web_contents');
+const { ipcMainInternal } = require('@electron/internal/browser/ipc-main-internal');
+const ipcMainUtils = require('@electron/internal/browser/ipc-main-internal-utils');
 
-const { Buffer } = require('buffer')
-const fs = require('fs')
-const path = require('path')
-const url = require('url')
-const util = require('util')
+const { Buffer } = require('buffer');
+const fs = require('fs');
+const path = require('path');
+const url = require('url');
+const util = require('util');
 
 // Mapping between extensionId(hostname) and manifest.
-const manifestMap = {} // extensionId => manifest
-const manifestNameMap = {} // name => manifest
-const devToolsExtensionNames = new Set()
+const manifestMap = {}; // extensionId => manifest
+const manifestNameMap = {}; // name => manifest
+const devToolsExtensionNames = new Set();
 
 const generateExtensionIdFromName = function (name) {
-  return name.replace(/[\W_]+/g, '-').toLowerCase()
-}
+  return name.replace(/[\W_]+/g, '-').toLowerCase();
+};
 
 const isWindowOrWebView = function (webContents) {
-  const type = webContents.getType()
-  return type === 'window' || type === 'webview'
-}
+  const type = webContents.getType();
+  return type === 'window' || type === 'webview';
+};
 
 const isBackgroundPage = function (webContents) {
-  return webContents.getType() === 'backgroundPage'
-}
+  return webContents.getType() === 'backgroundPage';
+};
 
 // Create or get manifest object from |srcDirectory|.
 const getManifestFromPath = function (srcDirectory) {
-  let manifest
-  let manifestContent
+  let manifest;
+  let manifestContent;
 
   try {
-    manifestContent = fs.readFileSync(path.join(srcDirectory, 'manifest.json'))
+    manifestContent = fs.readFileSync(path.join(srcDirectory, 'manifest.json'));
   } catch (readError) {
-    console.warn(`Reading ${path.join(srcDirectory, 'manifest.json')} failed.`)
-    console.warn(readError.stack || readError)
-    throw readError
+    console.warn(`Reading ${path.join(srcDirectory, 'manifest.json')} failed.`);
+    console.warn(readError.stack || readError);
+    throw readError;
   }
 
   try {
-    manifest = JSON.parse(manifestContent)
+    manifest = JSON.parse(manifestContent);
   } catch (parseError) {
-    console.warn(`Parsing ${path.join(srcDirectory, 'manifest.json')} failed.`)
-    console.warn(parseError.stack || parseError)
-    throw parseError
+    console.warn(`Parsing ${path.join(srcDirectory, 'manifest.json')} failed.`);
+    console.warn(parseError.stack || parseError);
+    throw parseError;
   }
 
   if (!manifestNameMap[manifest.name]) {
-    const extensionId = generateExtensionIdFromName(manifest.name)
-    manifestMap[extensionId] = manifestNameMap[manifest.name] = manifest
+    const extensionId = generateExtensionIdFromName(manifest.name);
+    manifestMap[extensionId] = manifestNameMap[manifest.name] = manifest;
 
     let extensionURL = url.format({
       protocol: 'chrome-extension',
       slashes: true,
       hostname: extensionId,
       pathname: manifest.devtools_page
-    })
+    });
 
     // Chromium requires that startPage matches '([^:]+:\/\/[^/]*)\/'
     // We also can't use the file:// protocol here since that would make Chromium
     // treat all extension resources as being relative to root which we don't want.
-    if (!manifest.devtools_page) extensionURL += '/'
+    if (!manifest.devtools_page) extensionURL += '/';
 
     Object.assign(manifest, {
       srcDirectory: srcDirectory,
       extensionId: extensionId,
       startPage: extensionURL
-    })
+    });
 
-    return manifest
+    return manifest;
   } else if (manifest && manifest.name) {
-    console.warn(`Attempted to load extension "${manifest.name}" that has already been loaded.`)
-    return manifest
+    console.warn(`Attempted to load extension "${manifest.name}" that has already been loaded.`);
+    return manifest;
   }
-}
+};
 
 // Manage the background pages.
-const backgroundPages = {}
+const backgroundPages = {};
 
 const startBackgroundPages = function (manifest) {
-  if (backgroundPages[manifest.extensionId] || !manifest.background) return
+  if (backgroundPages[manifest.extensionId] || !manifest.background) return;
 
-  let html
-  let name
+  let html;
+  let name;
   if (manifest.background.page) {
-    name = manifest.background.page
-    html = fs.readFileSync(path.join(manifest.srcDirectory, manifest.background.page))
+    name = manifest.background.page;
+    html = fs.readFileSync(path.join(manifest.srcDirectory, manifest.background.page));
   } else {
-    name = '_generated_background_page.html'
+    name = '_generated_background_page.html';
     const scripts = manifest.background.scripts.map((name) => {
-      return `<script src="${name}"></script>`
-    }).join('')
-    html = Buffer.from(`<html><body>${scripts}</body></html>`)
+      return `<script src="${name}"></script>`;
+    }).join('');
+    html = Buffer.from(`<html><body>${scripts}</body></html>`);
   }
 
   const contents = webContents.create({
@@ -107,36 +107,36 @@ const startBackgroundPages = function (manifest) {
     type: 'backgroundPage',
     sandbox: true,
     enableRemoteModule: false
-  })
-  backgroundPages[manifest.extensionId] = { html: html, webContents: contents, name: name }
+  });
+  backgroundPages[manifest.extensionId] = { html: html, webContents: contents, name: name };
   contents.loadURL(url.format({
     protocol: 'chrome-extension',
     slashes: true,
     hostname: manifest.extensionId,
     pathname: name
-  }))
-}
+  }));
+};
 
 const removeBackgroundPages = function (manifest) {
-  if (!backgroundPages[manifest.extensionId]) return
+  if (!backgroundPages[manifest.extensionId]) return;
 
-  backgroundPages[manifest.extensionId].webContents.destroy()
-  delete backgroundPages[manifest.extensionId]
-}
+  backgroundPages[manifest.extensionId].webContents.destroy();
+  delete backgroundPages[manifest.extensionId];
+};
 
 const sendToBackgroundPages = function (...args) {
   for (const page of Object.values(backgroundPages)) {
     if (!page.webContents.isDestroyed()) {
-      page.webContents._sendInternalToAll(...args)
+      page.webContents._sendInternalToAll(...args);
     }
   }
-}
+};
 
 // Dispatch web contents events to Chrome APIs
 const hookWebContentsEvents = function (webContents) {
-  const tabId = webContents.id
+  const tabId = webContents.id;
 
-  sendToBackgroundPages('CHROME_TABS_ONCREATED')
+  sendToBackgroundPages('CHROME_TABS_ONCREATED');
 
   webContents.on('will-navigate', (event, url) => {
     sendToBackgroundPages('CHROME_WEBNAVIGATION_ONBEFORENAVIGATE', {
@@ -146,8 +146,8 @@ const hookWebContentsEvents = function (webContents) {
       tabId: tabId,
       timeStamp: Date.now(),
       url: url
-    })
-  })
+    });
+  });
 
   webContents.on('did-navigate', (event, url) => {
     sendToBackgroundPages('CHROME_WEBNAVIGATION_ONCOMPLETED', {
@@ -157,189 +157,189 @@ const hookWebContentsEvents = function (webContents) {
       tabId: tabId,
       timeStamp: Date.now(),
       url: url
-    })
-  })
+    });
+  });
 
   webContents.once('destroyed', () => {
-    sendToBackgroundPages('CHROME_TABS_ONREMOVED', tabId)
-  })
-}
+    sendToBackgroundPages('CHROME_TABS_ONREMOVED', tabId);
+  });
+};
 
 // Handle the chrome.* API messages.
-let nextId = 0
+let nextId = 0;
 
 ipcMainUtils.handleSync('CHROME_RUNTIME_CONNECT', function (event, extensionId, connectInfo) {
   if (isBackgroundPage(event.sender)) {
-    throw new Error('chrome.runtime.connect is not supported in background page')
+    throw new Error('chrome.runtime.connect is not supported in background page');
   }
 
-  const page = backgroundPages[extensionId]
+  const page = backgroundPages[extensionId];
   if (!page || page.webContents.isDestroyed()) {
-    throw new Error(`Connect to unknown extension ${extensionId}`)
+    throw new Error(`Connect to unknown extension ${extensionId}`);
   }
 
-  const tabId = page.webContents.id
-  const portId = ++nextId
+  const tabId = page.webContents.id;
+  const portId = ++nextId;
 
   event.sender.once('render-view-deleted', () => {
-    if (page.webContents.isDestroyed()) return
-    page.webContents._sendInternalToAll(`CHROME_PORT_DISCONNECT_${portId}`)
-  })
-  page.webContents._sendInternalToAll(`CHROME_RUNTIME_ONCONNECT_${extensionId}`, event.sender.id, portId, connectInfo)
+    if (page.webContents.isDestroyed()) return;
+    page.webContents._sendInternalToAll(`CHROME_PORT_DISCONNECT_${portId}`);
+  });
+  page.webContents._sendInternalToAll(`CHROME_RUNTIME_ONCONNECT_${extensionId}`, event.sender.id, portId, connectInfo);
 
-  return { tabId, portId }
-})
+  return { tabId, portId };
+});
 
 ipcMainUtils.handleSync('CHROME_EXTENSION_MANIFEST', function (event, extensionId) {
-  const manifest = manifestMap[extensionId]
+  const manifest = manifestMap[extensionId];
   if (!manifest) {
-    throw new Error(`Invalid extensionId: ${extensionId}`)
+    throw new Error(`Invalid extensionId: ${extensionId}`);
   }
-  return manifest
-})
+  return manifest;
+});
 
 ipcMainInternal.handle('CHROME_RUNTIME_SEND_MESSAGE', async function (event, extensionId, message) {
   if (isBackgroundPage(event.sender)) {
-    throw new Error('chrome.runtime.sendMessage is not supported in background page')
+    throw new Error('chrome.runtime.sendMessage is not supported in background page');
   }
 
-  const page = backgroundPages[extensionId]
+  const page = backgroundPages[extensionId];
   if (!page || page.webContents.isDestroyed()) {
-    throw new Error(`Connect to unknown extension ${extensionId}`)
+    throw new Error(`Connect to unknown extension ${extensionId}`);
   }
 
-  return ipcMainUtils.invokeInWebContents(page.webContents, true, `CHROME_RUNTIME_ONMESSAGE_${extensionId}`, event.sender.id, message)
-})
+  return ipcMainUtils.invokeInWebContents(page.webContents, true, `CHROME_RUNTIME_ONMESSAGE_${extensionId}`, event.sender.id, message);
+});
 
 ipcMainInternal.handle('CHROME_TABS_SEND_MESSAGE', async function (event, tabId, extensionId, message) {
-  const contents = webContents.fromId(tabId)
+  const contents = webContents.fromId(tabId);
   if (!contents) {
-    throw new Error(`Sending message to unknown tab ${tabId}`)
+    throw new Error(`Sending message to unknown tab ${tabId}`);
   }
 
-  const senderTabId = isBackgroundPage(event.sender) ? null : event.sender.id
+  const senderTabId = isBackgroundPage(event.sender) ? null : event.sender.id;
 
-  return ipcMainUtils.invokeInWebContents(contents, true, `CHROME_RUNTIME_ONMESSAGE_${extensionId}`, senderTabId, message)
-})
+  return ipcMainUtils.invokeInWebContents(contents, true, `CHROME_RUNTIME_ONMESSAGE_${extensionId}`, senderTabId, message);
+});
 
 const getLanguage = () => {
-  return app.getLocale().replace(/-.*$/, '').toLowerCase()
-}
+  return app.getLocale().replace(/-.*$/, '').toLowerCase();
+};
 
 const getMessagesPath = (extensionId) => {
-  const metadata = manifestMap[extensionId]
+  const metadata = manifestMap[extensionId];
   if (!metadata) {
-    throw new Error(`Invalid extensionId: ${extensionId}`)
+    throw new Error(`Invalid extensionId: ${extensionId}`);
   }
 
-  const localesDirectory = path.join(metadata.srcDirectory, '_locales')
-  const language = getLanguage()
+  const localesDirectory = path.join(metadata.srcDirectory, '_locales');
+  const language = getLanguage();
 
   try {
-    const filename = path.join(localesDirectory, language, 'messages.json')
-    fs.accessSync(filename, fs.constants.R_OK)
-    return filename
+    const filename = path.join(localesDirectory, language, 'messages.json');
+    fs.accessSync(filename, fs.constants.R_OK);
+    return filename;
   } catch {
-    const defaultLocale = metadata.default_locale || 'en'
-    return path.join(localesDirectory, defaultLocale, 'messages.json')
+    const defaultLocale = metadata.default_locale || 'en';
+    return path.join(localesDirectory, defaultLocale, 'messages.json');
   }
-}
+};
 
 ipcMainUtils.handleSync('CHROME_GET_MESSAGES', async function (event, extensionId) {
-  const messagesPath = getMessagesPath(extensionId)
-  return fs.promises.readFile(messagesPath, 'utf8')
-})
+  const messagesPath = getMessagesPath(extensionId);
+  return fs.promises.readFile(messagesPath, 'utf8');
+});
 
-const validStorageTypes = new Set(['sync', 'local'])
+const validStorageTypes = new Set(['sync', 'local']);
 
 const getChromeStoragePath = (storageType, extensionId) => {
   if (!validStorageTypes.has(storageType)) {
-    throw new Error(`Invalid storageType: ${storageType}`)
+    throw new Error(`Invalid storageType: ${storageType}`);
   }
 
   if (!manifestMap[extensionId]) {
-    throw new Error(`Invalid extensionId: ${extensionId}`)
+    throw new Error(`Invalid extensionId: ${extensionId}`);
   }
 
-  return path.join(app.getPath('userData'), `/Chrome Storage/${extensionId}-${storageType}.json`)
-}
+  return path.join(app.getPath('userData'), `/Chrome Storage/${extensionId}-${storageType}.json`);
+};
 
 ipcMainInternal.handle('CHROME_STORAGE_READ', async function (event, storageType, extensionId) {
-  const filePath = getChromeStoragePath(storageType, extensionId)
+  const filePath = getChromeStoragePath(storageType, extensionId);
 
   try {
-    return await fs.promises.readFile(filePath, 'utf8')
+    return await fs.promises.readFile(filePath, 'utf8');
   } catch (error) {
     if (error.code === 'ENOENT') {
-      return null
+      return null;
     } else {
-      throw error
+      throw error;
     }
   }
-})
+});
 
 ipcMainInternal.handle('CHROME_STORAGE_WRITE', async function (event, storageType, extensionId, data) {
-  const filePath = getChromeStoragePath(storageType, extensionId)
+  const filePath = getChromeStoragePath(storageType, extensionId);
 
   try {
-    await fs.promises.mkdir(path.dirname(filePath), { recursive: true })
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
   } catch {
     // we just ignore the errors of mkdir
   }
 
-  return fs.promises.writeFile(filePath, data, 'utf8')
-})
+  return fs.promises.writeFile(filePath, data, 'utf8');
+});
 
 const isChromeExtension = function (pageURL) {
-  const { protocol } = url.parse(pageURL)
-  return protocol === 'chrome-extension:'
-}
+  const { protocol } = url.parse(pageURL);
+  return protocol === 'chrome-extension:';
+};
 
 const assertChromeExtension = function (contents, api) {
-  const pageURL = contents._getURL()
+  const pageURL = contents._getURL();
   if (!isChromeExtension(pageURL)) {
-    console.error(`Blocked ${pageURL} from calling ${api}`)
-    throw new Error(`Blocked ${api}`)
+    console.error(`Blocked ${pageURL} from calling ${api}`);
+    throw new Error(`Blocked ${api}`);
   }
-}
+};
 
 ipcMainInternal.handle('CHROME_TABS_EXECUTE_SCRIPT', async function (event, tabId, extensionId, details) {
-  assertChromeExtension(event.sender, 'chrome.tabs.executeScript()')
+  assertChromeExtension(event.sender, 'chrome.tabs.executeScript()');
 
-  const contents = webContents.fromId(tabId)
+  const contents = webContents.fromId(tabId);
   if (!contents) {
-    throw new Error(`Sending message to unknown tab ${tabId}`)
+    throw new Error(`Sending message to unknown tab ${tabId}`);
   }
 
-  let code, url
+  let code, url;
   if (details.file) {
-    const manifest = manifestMap[extensionId]
-    code = String(fs.readFileSync(path.join(manifest.srcDirectory, details.file)))
-    url = `chrome-extension://${extensionId}${details.file}`
+    const manifest = manifestMap[extensionId];
+    code = String(fs.readFileSync(path.join(manifest.srcDirectory, details.file)));
+    url = `chrome-extension://${extensionId}${details.file}`;
   } else {
-    code = details.code
-    url = `chrome-extension://${extensionId}/${String(Math.random()).substr(2, 8)}.js`
+    code = details.code;
+    url = `chrome-extension://${extensionId}/${String(Math.random()).substr(2, 8)}.js`;
   }
 
-  return ipcMainUtils.invokeInWebContents(contents, false, 'CHROME_TABS_EXECUTE_SCRIPT', extensionId, url, code)
-})
+  return ipcMainUtils.invokeInWebContents(contents, false, 'CHROME_TABS_EXECUTE_SCRIPT', extensionId, url, code);
+});
 
 exports.getContentScripts = () => {
-  return Object.values(contentScripts)
-}
+  return Object.values(contentScripts);
+};
 
 // Transfer the content scripts to renderer.
-const contentScripts = {}
+const contentScripts = {};
 
 const injectContentScripts = function (manifest) {
-  if (contentScripts[manifest.name] || !manifest.content_scripts) return
+  if (contentScripts[manifest.name] || !manifest.content_scripts) return;
 
   const readArrayOfFiles = function (relativePath) {
     return {
       url: `chrome-extension://${manifest.extensionId}/${relativePath}`,
       code: String(fs.readFileSync(path.join(manifest.srcDirectory, relativePath)))
-    }
-  }
+    };
+  };
 
   const contentScriptToEntry = function (script) {
     return {
@@ -348,25 +348,25 @@ const injectContentScripts = function (manifest) {
       css: script.css ? script.css.map(readArrayOfFiles) : [],
       runAt: script.run_at || 'document_idle',
       allFrames: script.all_frames || false
-    }
-  }
+    };
+  };
 
   try {
     const entry = {
       extensionId: manifest.extensionId,
       contentScripts: manifest.content_scripts.map(contentScriptToEntry)
-    }
-    contentScripts[manifest.name] = entry
+    };
+    contentScripts[manifest.name] = entry;
   } catch (e) {
-    console.error('Failed to read content scripts', e)
+    console.error('Failed to read content scripts', e);
   }
-}
+};
 
 const removeContentScripts = function (manifest) {
-  if (!contentScripts[manifest.name]) return
+  if (!contentScripts[manifest.name]) return;
 
-  delete contentScripts[manifest.name]
-}
+  delete contentScripts[manifest.name];
+};
 
 // Transfer the |manifest| to a format that can be recognized by the
 // |DevToolsAPI.addExtensions|.
@@ -376,167 +376,167 @@ const manifestToExtensionInfo = function (manifest) {
     srcDirectory: manifest.srcDirectory,
     name: manifest.name,
     exposeExperimentalAPIs: true
-  }
-}
+  };
+};
 
 // Load the extensions for the window.
 const loadExtension = function (manifest) {
-  startBackgroundPages(manifest)
-  injectContentScripts(manifest)
-}
+  startBackgroundPages(manifest);
+  injectContentScripts(manifest);
+};
 
 const loadDevToolsExtensions = function (win, manifests) {
-  if (!win.devToolsWebContents) return
+  if (!win.devToolsWebContents) return;
 
-  manifests.forEach(loadExtension)
+  manifests.forEach(loadExtension);
 
-  const extensionInfoArray = manifests.map(manifestToExtensionInfo)
+  const extensionInfoArray = manifests.map(manifestToExtensionInfo);
   extensionInfoArray.forEach((extension) => {
-    win.devToolsWebContents._grantOriginAccess(extension.startPage)
-  })
+    win.devToolsWebContents._grantOriginAccess(extension.startPage);
+  });
 
   extensionInfoArray.forEach((extensionInfo) => {
-    const info = JSON.stringify(extensionInfo)
-    win.devToolsWebContents.executeJavaScript(`Extensions.extensionServer._addExtension(${info})`)
-  })
-}
+    const info = JSON.stringify(extensionInfo);
+    win.devToolsWebContents.executeJavaScript(`Extensions.extensionServer._addExtension(${info})`);
+  });
+};
 
 app.on('web-contents-created', function (event, webContents) {
-  if (!isWindowOrWebView(webContents)) return
+  if (!isWindowOrWebView(webContents)) return;
 
-  hookWebContentsEvents(webContents)
+  hookWebContentsEvents(webContents);
   webContents.on('devtools-opened', function () {
-    loadDevToolsExtensions(webContents, Object.values(manifestMap))
-  })
-})
+    loadDevToolsExtensions(webContents, Object.values(manifestMap));
+  });
+});
 
 // The chrome-extension: can map a extension URL request to real file path.
 const chromeExtensionHandler = function (request, callback) {
-  const parsed = url.parse(request.url)
-  if (!parsed.hostname || !parsed.path) return callback()
+  const parsed = url.parse(request.url);
+  if (!parsed.hostname || !parsed.path) return callback();
 
-  const manifest = manifestMap[parsed.hostname]
-  if (!manifest) return callback()
+  const manifest = manifestMap[parsed.hostname];
+  if (!manifest) return callback();
 
-  const page = backgroundPages[parsed.hostname]
+  const page = backgroundPages[parsed.hostname];
   if (page && parsed.path === `/${page.name}`) {
     // Disabled due to false positive in StandardJS
     // eslint-disable-next-line standard/no-callback-literal
     return callback({
       mimeType: 'text/html',
       data: page.html
-    })
+    });
   }
 
   fs.readFile(path.join(manifest.srcDirectory, parsed.path), function (err, content) {
     if (err) {
       // Disabled due to false positive in StandardJS
       // eslint-disable-next-line standard/no-callback-literal
-      return callback(-6) // FILE_NOT_FOUND
+      return callback(-6); // FILE_NOT_FOUND
     } else {
-      return callback(content)
+      return callback(content);
     }
-  })
-}
+  });
+};
 
 app.on('session-created', function (ses) {
-  ses.protocol.registerBufferProtocol('chrome-extension', chromeExtensionHandler)
-})
+  ses.protocol.registerBufferProtocol('chrome-extension', chromeExtensionHandler);
+});
 
 // The persistent path of "DevTools Extensions" preference file.
-let loadedDevToolsExtensionsPath = null
+let loadedDevToolsExtensionsPath = null;
 
 app.on('will-quit', function () {
   try {
     const loadedDevToolsExtensions = Array.from(devToolsExtensionNames)
-      .map(name => manifestNameMap[name].srcDirectory)
+      .map(name => manifestNameMap[name].srcDirectory);
     if (loadedDevToolsExtensions.length > 0) {
       try {
-        fs.mkdirSync(path.dirname(loadedDevToolsExtensionsPath))
+        fs.mkdirSync(path.dirname(loadedDevToolsExtensionsPath));
       } catch {
         // Ignore error
       }
-      fs.writeFileSync(loadedDevToolsExtensionsPath, JSON.stringify(loadedDevToolsExtensions))
+      fs.writeFileSync(loadedDevToolsExtensionsPath, JSON.stringify(loadedDevToolsExtensions));
     } else {
-      fs.unlinkSync(loadedDevToolsExtensionsPath)
+      fs.unlinkSync(loadedDevToolsExtensionsPath);
     }
   } catch {
     // Ignore error
   }
-})
+});
 
 // We can not use protocol or BrowserWindow until app is ready.
 app.whenReady().then(function () {
   // The public API to add/remove extensions.
   BrowserWindow.addExtension = function (srcDirectory) {
-    const manifest = getManifestFromPath(srcDirectory)
+    const manifest = getManifestFromPath(srcDirectory);
     if (manifest) {
-      loadExtension(manifest)
+      loadExtension(manifest);
       for (const webContents of getAllWebContents()) {
         if (isWindowOrWebView(webContents)) {
-          loadDevToolsExtensions(webContents, [manifest])
+          loadDevToolsExtensions(webContents, [manifest]);
         }
       }
-      return manifest.name
+      return manifest.name;
     }
-  }
+  };
 
   BrowserWindow.removeExtension = function (name) {
-    const manifest = manifestNameMap[name]
-    if (!manifest) return
+    const manifest = manifestNameMap[name];
+    if (!manifest) return;
 
-    removeBackgroundPages(manifest)
-    removeContentScripts(manifest)
-    delete manifestMap[manifest.extensionId]
-    delete manifestNameMap[name]
-  }
+    removeBackgroundPages(manifest);
+    removeContentScripts(manifest);
+    delete manifestMap[manifest.extensionId];
+    delete manifestNameMap[name];
+  };
 
   BrowserWindow.getExtensions = function () {
-    const extensions = {}
+    const extensions = {};
     Object.keys(manifestNameMap).forEach(function (name) {
-      const manifest = manifestNameMap[name]
-      extensions[name] = { name: manifest.name, version: manifest.version }
-    })
-    return extensions
-  }
+      const manifest = manifestNameMap[name];
+      extensions[name] = { name: manifest.name, version: manifest.version };
+    });
+    return extensions;
+  };
 
   BrowserWindow.addDevToolsExtension = function (srcDirectory) {
-    const manifestName = BrowserWindow.addExtension(srcDirectory)
+    const manifestName = BrowserWindow.addExtension(srcDirectory);
     if (manifestName) {
-      devToolsExtensionNames.add(manifestName)
+      devToolsExtensionNames.add(manifestName);
     }
-    return manifestName
-  }
+    return manifestName;
+  };
 
   BrowserWindow.removeDevToolsExtension = function (name) {
-    BrowserWindow.removeExtension(name)
-    devToolsExtensionNames.delete(name)
-  }
+    BrowserWindow.removeExtension(name);
+    devToolsExtensionNames.delete(name);
+  };
 
   BrowserWindow.getDevToolsExtensions = function () {
-    const extensions = BrowserWindow.getExtensions()
-    const devExtensions = {}
+    const extensions = BrowserWindow.getExtensions();
+    const devExtensions = {};
     Array.from(devToolsExtensionNames).forEach(function (name) {
-      if (!extensions[name]) return
-      devExtensions[name] = extensions[name]
-    })
-    return devExtensions
-  }
+      if (!extensions[name]) return;
+      devExtensions[name] = extensions[name];
+    });
+    return devExtensions;
+  };
 
   // Load persisted extensions.
-  loadedDevToolsExtensionsPath = path.join(app.getPath('userData'), 'DevTools Extensions')
+  loadedDevToolsExtensionsPath = path.join(app.getPath('userData'), 'DevTools Extensions');
   try {
-    const loadedDevToolsExtensions = JSON.parse(fs.readFileSync(loadedDevToolsExtensionsPath))
+    const loadedDevToolsExtensions = JSON.parse(fs.readFileSync(loadedDevToolsExtensionsPath));
     if (Array.isArray(loadedDevToolsExtensions)) {
       for (const srcDirectory of loadedDevToolsExtensions) {
         // Start background pages and set content scripts.
-        BrowserWindow.addDevToolsExtension(srcDirectory)
+        BrowserWindow.addDevToolsExtension(srcDirectory);
       }
     }
   } catch (error) {
     if (process.env.ELECTRON_ENABLE_LOGGING && error.code !== 'ENOENT') {
-      console.error('Failed to load browser extensions from directory:', loadedDevToolsExtensionsPath)
-      console.error(error)
+      console.error('Failed to load browser extensions from directory:', loadedDevToolsExtensionsPath);
+      console.error(error);
     }
   }
-})
+});

lib/browser/crash-reporter-init.js

@@ -1,25 +1,25 @@
-'use strict'
+'use strict';
 
-const { app } = require('electron')
-const path = require('path')
+const { app } = require('electron');
+const path = require('path');
 
 const getTempDirectory = function () {
   try {
-    return app.getPath('temp')
+    return app.getPath('temp');
   } catch {
     // Delibrately laze-load the os module, this file is on the hot
     // path when booting Electron and os takes between 5 - 8ms to load and we do not need it yet
-    return require('os').tmpdir()
+    return require('os').tmpdir();
   }
-}
+};
 
 exports.crashReporterInit = function (options) {
-  const productName = options.productName || app.name
-  const crashesDirectory = path.join(getTempDirectory(), `${productName} Crashes`)
+  const productName = options.productName || app.name;
+  const crashesDirectory = path.join(getTempDirectory(), `${productName} Crashes`);
 
   return {
     productName,
     crashesDirectory,
     appVersion: app.getVersion()
-  }
-}
+  };
+};

lib/browser/default-menu.ts

@@ -1,11 +1,11 @@
-import { shell, Menu } from 'electron'
+import { shell, Menu } from 'electron';
 
-const v8Util = process.electronBinding('v8_util')
+const v8Util = process.electronBinding('v8_util');
 
-const isMac = process.platform === 'darwin'
+const isMac = process.platform === 'darwin';
 
 export const setDefaultApplicationMenu = () => {
-  if (v8Util.getHiddenValue<boolean>(global, 'applicationMenuSet')) return
+  if (v8Util.getHiddenValue<boolean>(global, 'applicationMenuSet')) return;
 
   const helpMenu: Electron.MenuItemConstructorOptions = {
     role: 'help',
@@ -13,32 +13,32 @@ export const setDefaultApplicationMenu = () => {
       {
         label: 'Learn More',
         click: async () => {
-          await shell.openExternal('https://electronjs.org')
+          await shell.openExternal('https://electronjs.org');
         }
       },
       {
         label: 'Documentation',
         click: async () => {
-          const version = process.versions.electron
-          await shell.openExternal(`https://github.com/electron/electron/tree/v${version}/docs#readme`)
+          const version = process.versions.electron;
+          await shell.openExternal(`https://github.com/electron/electron/tree/v${version}/docs#readme`);
         }
       },
       {
         label: 'Community Discussions',
         click: async () => {
-          await shell.openExternal('https://discuss.atom.io/c/electron')
+          await shell.openExternal('https://discuss.atom.io/c/electron');
         }
       },
       {
         label: 'Search Issues',
         click: async () => {
-          await shell.openExternal('https://github.com/electron/electron/issues')
+          await shell.openExternal('https://github.com/electron/electron/issues');
         }
       }
     ]
-  }
+  };
 
-  const macAppMenu: Electron.MenuItemConstructorOptions = { role: 'appMenu' }
+  const macAppMenu: Electron.MenuItemConstructorOptions = { role: 'appMenu' };
   const template: Electron.MenuItemConstructorOptions[] = [
     ...(isMac ? [macAppMenu] : []),
     { role: 'fileMenu' },
@@ -46,8 +46,8 @@ export const setDefaultApplicationMenu = () => {
     { role: 'viewMenu' },
     { role: 'windowMenu' },
     helpMenu
-  ]
+  ];
 
-  const menu = Menu.buildFromTemplate(template)
-  Menu.setApplicationMenu(menu)
-}
+  const menu = Menu.buildFromTemplate(template);
+  Menu.setApplicationMenu(menu);
+};

lib/browser/desktop-capturer.ts

@@ -1,66 +1,66 @@
-import { EventEmitter } from 'events'
+import { EventEmitter } from 'events';
 
-const { createDesktopCapturer } = process.electronBinding('desktop_capturer')
+const { createDesktopCapturer } = process.electronBinding('desktop_capturer');
 
-const deepEqual = (a: ElectronInternal.GetSourcesOptions, b: ElectronInternal.GetSourcesOptions) => JSON.stringify(a) === JSON.stringify(b)
+const deepEqual = (a: ElectronInternal.GetSourcesOptions, b: ElectronInternal.GetSourcesOptions) => JSON.stringify(a) === JSON.stringify(b);
 
 let currentlyRunning: {
   options: ElectronInternal.GetSourcesOptions;
   getSources: Promise<ElectronInternal.GetSourcesResult[]>;
-}[] = []
+}[] = [];
 
 export const getSources = (event: Electron.IpcMainEvent, options: ElectronInternal.GetSourcesOptions) => {
   for (const running of currentlyRunning) {
     if (deepEqual(running.options, options)) {
       // If a request is currently running for the same options
       // return that promise
-      return running.getSources
+      return running.getSources;
     }
   }
 
   const getSources = new Promise<ElectronInternal.GetSourcesResult[]>((resolve, reject) => {
-    let capturer: ElectronInternal.DesktopCapturer | null = createDesktopCapturer()
+    let capturer: ElectronInternal.DesktopCapturer | null = createDesktopCapturer();
 
     const stopRunning = () => {
       if (capturer) {
-        capturer.emit = null
-        capturer = null
+        capturer.emit = null;
+        capturer = null;
       }
       // Remove from currentlyRunning once we resolve or reject
-      currentlyRunning = currentlyRunning.filter(running => running.options !== options)
-    }
+      currentlyRunning = currentlyRunning.filter(running => running.options !== options);
+    };
 
-    const emitter = new EventEmitter()
+    const emitter = new EventEmitter();
 
     emitter.once('error', (event, error: string) => {
-      stopRunning()
-      reject(error)
-    })
+      stopRunning();
+      reject(error);
+    });
 
     emitter.once('finished', (event, sources: Electron.DesktopCapturerSource[], fetchWindowIcons: boolean) => {
-      stopRunning()
+      stopRunning();
       resolve(sources.map(source => ({
         id: source.id,
         name: source.name,
         thumbnail: source.thumbnail.toDataURL(),
         display_id: source.display_id,
         appIcon: (fetchWindowIcons && source.appIcon) ? source.appIcon.toDataURL() : null
-      })))
-    })
+      })));
+    });
 
-    capturer.emit = emitter.emit.bind(emitter)
-    capturer.startHandling(options.captureWindow, options.captureScreen, options.thumbnailSize, options.fetchWindowIcons)
+    capturer.emit = emitter.emit.bind(emitter);
+    capturer.startHandling(options.captureWindow, options.captureScreen, options.thumbnailSize, options.fetchWindowIcons);
 
     // If the WebContents is destroyed before receiving result, just remove the
     // reference to emit and the capturer itself so that it never dispatches
     // back to the renderer
-    event.sender.once('destroyed', () => stopRunning())
-  })
+    event.sender.once('destroyed', () => stopRunning());
+  });
 
   currentlyRunning.push({
     options,
     getSources
-  })
+  });
 
-  return getSources
-}
+  return getSources;
+};

lib/browser/devtools.ts

@@ -1,9 +1,9 @@
-import { dialog, Menu } from 'electron'
-import * as fs from 'fs'
-import * as url from 'url'
+import { dialog, Menu } from 'electron';
+import * as fs from 'fs';
+import * as url from 'url';
 
-import { ipcMainInternal } from '@electron/internal/browser/ipc-main-internal'
-import * as ipcMainUtils from '@electron/internal/browser/ipc-main-internal-utils'
+import { ipcMainInternal } from '@electron/internal/browser/ipc-main-internal';
+import * as ipcMainUtils from '@electron/internal/browser/ipc-main-internal-utils';
 
 const convertToMenuTemplate = function (items: ContextMenuItem[], handler: (id: number) => void) {
   return items.map(function (item) {
@@ -23,15 +23,15 @@ const convertToMenuTemplate = function (items: ContextMenuItem[], handler: (id:
       type: 'normal',
       label: item.label,
       enabled: item.enabled
-    }
+    };
 
     if (item.id != null) {
-      transformed.click = () => handler(item.id)
+      transformed.click = () => handler(item.id);
     }
 
-    return transformed
-  })
-}
+    return transformed;
+  });
+};
 
 const getEditMenuItems = function (): Electron.MenuItemConstructorOptions[] {
   return [
@@ -44,56 +44,56 @@ const getEditMenuItems = function (): Electron.MenuItemConstructorOptions[] {
     { role: 'pasteAndMatchStyle' },
     { role: 'delete' },
     { role: 'selectAll' }
-  ]
-}
+  ];
+};
 
 const isChromeDevTools = function (pageURL: string) {
-  const { protocol } = url.parse(pageURL)
-  return protocol === 'devtools:'
-}
+  const { protocol } = url.parse(pageURL);
+  return protocol === 'devtools:';
+};
 
 const assertChromeDevTools = function (contents: Electron.WebContents, api: string) {
-  const pageURL = contents._getURL()
+  const pageURL = contents._getURL();
   if (!isChromeDevTools(pageURL)) {
-    console.error(`Blocked ${pageURL} from calling ${api}`)
-    throw new Error(`Blocked ${api}`)
+    console.error(`Blocked ${pageURL} from calling ${api}`);
+    throw new Error(`Blocked ${api}`);
   }
-}
+};
 
 ipcMainInternal.handle('ELECTRON_INSPECTOR_CONTEXT_MENU', function (event: Electron.IpcMainInvokeEvent, items: ContextMenuItem[], isEditMenu: boolean) {
   return new Promise(resolve => {
-    assertChromeDevTools(event.sender, 'window.InspectorFrontendHost.showContextMenuAtPoint()')
+    assertChromeDevTools(event.sender, 'window.InspectorFrontendHost.showContextMenuAtPoint()');
 
-    const template = isEditMenu ? getEditMenuItems() : convertToMenuTemplate(items, resolve)
-    const menu = Menu.buildFromTemplate(template)
-    const window = event.sender.getOwnerBrowserWindow()
+    const template = isEditMenu ? getEditMenuItems() : convertToMenuTemplate(items, resolve);
+    const menu = Menu.buildFromTemplate(template);
+    const window = event.sender.getOwnerBrowserWindow();
 
-    menu.popup({ window, callback: () => resolve() })
-  })
-})
+    menu.popup({ window, callback: () => resolve() });
+  });
+});
 
 ipcMainInternal.handle('ELECTRON_INSPECTOR_SELECT_FILE', async function (event: Electron.IpcMainInvokeEvent) {
-  assertChromeDevTools(event.sender, 'window.UI.createFileSelectorElement()')
+  assertChromeDevTools(event.sender, 'window.UI.createFileSelectorElement()');
 
-  const result = await dialog.showOpenDialog({})
-  if (result.canceled) return []
+  const result = await dialog.showOpenDialog({});
+  if (result.canceled) return [];
 
-  const path = result.filePaths[0]
-  const data = await fs.promises.readFile(path)
+  const path = result.filePaths[0];
+  const data = await fs.promises.readFile(path);
 
-  return [path, data]
-})
+  return [path, data];
+});
 
 ipcMainUtils.handleSync('ELECTRON_INSPECTOR_CONFIRM', async function (event: Electron.IpcMainInvokeEvent, message: string = '', title: string = '') {
-  assertChromeDevTools(event.sender, 'window.confirm()')
+  assertChromeDevTools(event.sender, 'window.confirm()');
 
   const options = {
     message: String(message),
     title: String(title),
     buttons: ['OK', 'Cancel'],
     cancelId: 1
-  }
-  const window = event.sender.getOwnerBrowserWindow()
-  const { response } = await dialog.showMessageBox(window, options)
-  return response === 0
-})
+  };
+  const window = event.sender.getOwnerBrowserWindow();
+  const { response } = await dialog.showMessageBox(window, options);
+  return response === 0;
+});

lib/browser/guest-view-manager.js

@@ -1,14 +1,14 @@
-'use strict'
+'use strict';
 
-const { webContents } = require('electron')
-const { ipcMainInternal } = require('@electron/internal/browser/ipc-main-internal')
-const ipcMainUtils = require('@electron/internal/browser/ipc-main-internal-utils')
-const parseFeaturesString = require('@electron/internal/common/parse-features-string')
-const { syncMethods, asyncMethods } = require('@electron/internal/common/web-view-methods')
-const { serialize } = require('@electron/internal/common/type-utils')
+const { webContents } = require('electron');
+const { ipcMainInternal } = require('@electron/internal/browser/ipc-main-internal');
+const ipcMainUtils = require('@electron/internal/browser/ipc-main-internal-utils');
+const parseFeaturesString = require('@electron/internal/common/parse-features-string');
+const { syncMethods, asyncMethods, properties } = require('@electron/internal/common/web-view-methods');
+const { serialize } = require('@electron/internal/common/type-utils');
 
 // Doesn't exist in early initialization.
-let webViewManager = null
+let webViewManager = null;
 
 const supportedWebViewEvents = [
   'load-commit',
@@ -43,155 +43,155 @@ const supportedWebViewEvents = [
   'found-in-page',
   'did-change-theme-color',
   'update-target-url'
-]
+];
 
-const guestInstances = {}
-const embedderElementsMap = {}
+const guestInstances = {};
+const embedderElementsMap = {};
 
 function sanitizeOptionsForGuest (options) {
-  const ret = { ...options }
+  const ret = { ...options };
   // WebContents values can't be sent over IPC.
-  delete ret.webContents
-  return ret
+  delete ret.webContents;
+  return ret;
 }
 
 // Create a new guest instance.
 const createGuest = function (embedder, params) {
   if (webViewManager == null) {
-    webViewManager = process.electronBinding('web_view_manager')
+    webViewManager = process.electronBinding('web_view_manager');
   }
 
   const guest = webContents.create({
     type: 'webview',
     partition: params.partition,
     embedder: embedder
-  })
-  const guestInstanceId = guest.id
+  });
+  const guestInstanceId = guest.id;
   guestInstances[guestInstanceId] = {
     guest: guest,
     embedder: embedder
-  }
+  };
 
   // Clear the guest from map when it is destroyed.
   guest.once('destroyed', () => {
-    if (guestInstanceId in guestInstances) {
-      detachGuest(embedder, guestInstanceId)
+    if (Object.prototype.hasOwnProperty.call(guestInstances, guestInstanceId)) {
+      detachGuest(embedder, guestInstanceId);
     }
-  })
+  });
 
   // Init guest web view after attached.
   guest.once('did-attach', function (event) {
-    params = this.attachParams
-    delete this.attachParams
+    params = this.attachParams;
+    delete this.attachParams;
 
-    const previouslyAttached = this.viewInstanceId != null
-    this.viewInstanceId = params.instanceId
+    const previouslyAttached = this.viewInstanceId != null;
+    this.viewInstanceId = params.instanceId;
 
     // Only load URL and set size on first attach
     if (previouslyAttached) {
-      return
+      return;
     }
 
     if (params.src) {
-      const opts = {}
+      const opts = {};
       if (params.httpreferrer) {
-        opts.httpReferrer = params.httpreferrer
+        opts.httpReferrer = params.httpreferrer;
       }
       if (params.useragent) {
-        opts.userAgent = params.useragent
+        opts.userAgent = params.useragent;
       }
-      this.loadURL(params.src, opts)
+      this.loadURL(params.src, opts);
     }
-    embedder.emit('did-attach-webview', event, guest)
-  })
+    embedder.emit('did-attach-webview', event, guest);
+  });
 
   const sendToEmbedder = (channel, ...args) => {
     if (!embedder.isDestroyed()) {
-      embedder._sendInternal(`${channel}-${guest.viewInstanceId}`, ...args)
+      embedder._sendInternal(`${channel}-${guest.viewInstanceId}`, ...args);
     }
-  }
+  };
 
   // Dispatch events to embedder.
   const fn = function (event) {
     guest.on(event, function (_, ...args) {
-      sendToEmbedder('ELECTRON_GUEST_VIEW_INTERNAL_DISPATCH_EVENT', event, ...args)
-    })
-  }
+      sendToEmbedder('ELECTRON_GUEST_VIEW_INTERNAL_DISPATCH_EVENT', event, ...args);
+    });
+  };
   for (const event of supportedWebViewEvents) {
-    fn(event)
+    fn(event);
   }
 
   guest.on('new-window', function (event, url, frameName, disposition, options, additionalFeatures, referrer) {
     sendToEmbedder('ELECTRON_GUEST_VIEW_INTERNAL_DISPATCH_EVENT', 'new-window', url,
       frameName, disposition, sanitizeOptionsForGuest(options),
-      additionalFeatures, referrer)
-  })
+      additionalFeatures, referrer);
+  });
 
   // Dispatch guest's IPC messages to embedder.
   guest.on('ipc-message-host', function (_, channel, args) {
-    sendToEmbedder('ELECTRON_GUEST_VIEW_INTERNAL_IPC_MESSAGE', channel, ...args)
-  })
+    sendToEmbedder('ELECTRON_GUEST_VIEW_INTERNAL_IPC_MESSAGE', channel, ...args);
+  });
 
   // Notify guest of embedder window visibility when it is ready
   // FIXME Remove once https://github.com/electron/electron/issues/6828 is fixed
   guest.on('dom-ready', function () {
-    const guestInstance = guestInstances[guestInstanceId]
+    const guestInstance = guestInstances[guestInstanceId];
     if (guestInstance != null && guestInstance.visibilityState != null) {
-      guest._sendInternal('ELECTRON_GUEST_INSTANCE_VISIBILITY_CHANGE', guestInstance.visibilityState)
+      guest._sendInternal('ELECTRON_GUEST_INSTANCE_VISIBILITY_CHANGE', guestInstance.visibilityState);
     }
-  })
+  });
 
   // Forward internal web contents event to embedder to handle
   // native window.open setup
   guest.on('-add-new-contents', (...args) => {
     if (guest.getLastWebPreferences().nativeWindowOpen === true) {
-      const embedder = getEmbedder(guestInstanceId)
+      const embedder = getEmbedder(guestInstanceId);
       if (embedder != null) {
-        embedder.emit('-add-new-contents', ...args)
+        embedder.emit('-add-new-contents', ...args);
       }
     }
-  })
+  });
 
-  return guestInstanceId
-}
+  return guestInstanceId;
+};
 
 // Attach the guest to an element of embedder.
 const attachGuest = function (event, embedderFrameId, elementInstanceId, guestInstanceId, params) {
-  const embedder = event.sender
+  const embedder = event.sender;
   // Destroy the old guest when attaching.
-  const key = `${embedder.id}-${elementInstanceId}`
-  const oldGuestInstanceId = embedderElementsMap[key]
+  const key = `${embedder.id}-${elementInstanceId}`;
+  const oldGuestInstanceId = embedderElementsMap[key];
   if (oldGuestInstanceId != null) {
     // Reattachment to the same guest is just a no-op.
     if (oldGuestInstanceId === guestInstanceId) {
-      return
+      return;
     }
 
-    const oldGuestInstance = guestInstances[oldGuestInstanceId]
+    const oldGuestInstance = guestInstances[oldGuestInstanceId];
     if (oldGuestInstance) {
-      oldGuestInstance.guest.detachFromOuterFrame()
+      oldGuestInstance.guest.detachFromOuterFrame();
     }
   }
 
-  const guestInstance = guestInstances[guestInstanceId]
+  const guestInstance = guestInstances[guestInstanceId];
   // If this isn't a valid guest instance then do nothing.
   if (!guestInstance) {
-    throw new Error(`Invalid guestInstanceId: ${guestInstanceId}`)
+    throw new Error(`Invalid guestInstanceId: ${guestInstanceId}`);
   }
-  const { guest } = guestInstance
+  const { guest } = guestInstance;
   if (guest.hostWebContents !== event.sender) {
-    throw new Error(`Access denied to guestInstanceId: ${guestInstanceId}`)
+    throw new Error(`Access denied to guestInstanceId: ${guestInstanceId}`);
   }
 
   // If this guest is already attached to an element then remove it
   if (guestInstance.elementInstanceId) {
-    const oldKey = `${guestInstance.embedder.id}-${guestInstance.elementInstanceId}`
-    delete embedderElementsMap[oldKey]
+    const oldKey = `${guestInstance.embedder.id}-${guestInstance.elementInstanceId}`;
+    delete embedderElementsMap[oldKey];
 
     // Remove guest from embedder if moving across web views
     if (guest.viewInstanceId !== params.instanceId) {
-      webViewManager.removeGuest(guestInstance.embedder, guestInstanceId)
-      guestInstance.embedder._sendInternal(`ELECTRON_GUEST_VIEW_INTERNAL_DESTROY_GUEST-${guest.viewInstanceId}`)
+      webViewManager.removeGuest(guestInstance.embedder, guestInstanceId);
+      guestInstance.embedder._sendInternal(`ELECTRON_GUEST_VIEW_INTERNAL_DESTROY_GUEST-${guest.viewInstanceId}`);
     }
   }
 
@@ -206,7 +206,7 @@ const attachGuest = function (event, embedderFrameId, elementInstanceId, guestIn
     webSecurity: !params.disablewebsecurity,
     enableBlinkFeatures: params.blinkfeatures,
     disableBlinkFeatures: params.disableblinkfeatures
-  }
+  };
 
   // parse the 'webpreferences' attribute string, if set
   // this uses the same parsing rules as window.open uses for its features
@@ -214,14 +214,14 @@ const attachGuest = function (event, embedderFrameId, elementInstanceId, guestIn
     parseFeaturesString(params.webpreferences, function (key, value) {
       if (value === undefined) {
         // no value was specified, default it to true
-        value = true
+        value = true;
       }
-      webPreferences[key] = value
-    })
+      webPreferences[key] = value;
+    });
   }
 
   if (params.preload) {
-    webPreferences.preloadURL = params.preload
+    webPreferences.preloadURL = params.preload;
   }
 
   // Security options that guest will always inherit from embedder
@@ -233,185 +233,203 @@ const attachGuest = function (event, embedderFrameId, elementInstanceId, guestIn
     ['enableRemoteModule', false],
     ['sandbox', true],
     ['nodeIntegrationInSubFrames', false]
-  ])
+  ]);
 
   // Inherit certain option values from embedder
-  const lastWebPreferences = embedder.getLastWebPreferences()
+  const lastWebPreferences = embedder.getLastWebPreferences();
   for (const [name, value] of inheritedWebPreferences) {
     if (lastWebPreferences[name] === value) {
-      webPreferences[name] = value
+      webPreferences[name] = value;
     }
   }
 
-  embedder.emit('will-attach-webview', event, webPreferences, params)
+  embedder.emit('will-attach-webview', event, webPreferences, params);
   if (event.defaultPrevented) {
-    if (guest.viewInstanceId == null) guest.viewInstanceId = params.instanceId
-    guest.destroy()
-    return
+    if (guest.viewInstanceId == null) guest.viewInstanceId = params.instanceId;
+    guest.destroy();
+    return;
   }
 
-  guest.attachParams = params
-  embedderElementsMap[key] = guestInstanceId
+  guest.attachParams = params;
+  embedderElementsMap[key] = guestInstanceId;
 
-  guest.setEmbedder(embedder)
-  guestInstance.embedder = embedder
-  guestInstance.elementInstanceId = elementInstanceId
+  guest.setEmbedder(embedder);
+  guestInstance.embedder = embedder;
+  guestInstance.elementInstanceId = elementInstanceId;
 
-  watchEmbedder(embedder)
+  watchEmbedder(embedder);
 
-  webViewManager.addGuest(guestInstanceId, elementInstanceId, embedder, guest, webPreferences)
-  guest.attachToIframe(embedder, embedderFrameId)
-}
+  webViewManager.addGuest(guestInstanceId, elementInstanceId, embedder, guest, webPreferences);
+  guest.attachToIframe(embedder, embedderFrameId);
+};
 
 // Remove an guest-embedder relationship.
 const detachGuest = function (embedder, guestInstanceId) {
-  const guestInstance = guestInstances[guestInstanceId]
+  const guestInstance = guestInstances[guestInstanceId];
   if (embedder !== guestInstance.embedder) {
-    return
+    return;
   }
 
-  webViewManager.removeGuest(embedder, guestInstanceId)
-  delete guestInstances[guestInstanceId]
+  webViewManager.removeGuest(embedder, guestInstanceId);
+  delete guestInstances[guestInstanceId];
 
-  const key = `${embedder.id}-${guestInstance.elementInstanceId}`
-  delete embedderElementsMap[key]
-}
+  const key = `${embedder.id}-${guestInstance.elementInstanceId}`;
+  delete embedderElementsMap[key];
+};
 
 // Once an embedder has had a guest attached we watch it for destruction to
 // destroy any remaining guests.
-const watchedEmbedders = new Set()
+const watchedEmbedders = new Set();
 const watchEmbedder = function (embedder) {
   if (watchedEmbedders.has(embedder)) {
-    return
+    return;
   }
-  watchedEmbedders.add(embedder)
+  watchedEmbedders.add(embedder);
 
   // Forward embedder window visiblity change events to guest
   const onVisibilityChange = function (visibilityState) {
-    for (const guestInstanceId in guestInstances) {
-      const guestInstance = guestInstances[guestInstanceId]
-      guestInstance.visibilityState = visibilityState
+    for (const guestInstanceId of Object.keys(guestInstances)) {
+      const guestInstance = guestInstances[guestInstanceId];
+      guestInstance.visibilityState = visibilityState;
       if (guestInstance.embedder === embedder) {
-        guestInstance.guest._sendInternal('ELECTRON_GUEST_INSTANCE_VISIBILITY_CHANGE', visibilityState)
+        guestInstance.guest._sendInternal('ELECTRON_GUEST_INSTANCE_VISIBILITY_CHANGE', visibilityState);
       }
     }
-  }
-  embedder.on('-window-visibility-change', onVisibilityChange)
+  };
+  embedder.on('-window-visibility-change', onVisibilityChange);
 
   embedder.once('will-destroy', () => {
     // Usually the guestInstances is cleared when guest is destroyed, but it
     // may happen that the embedder gets manually destroyed earlier than guest,
     // and the embedder will be invalid in the usual code path.
-    for (const guestInstanceId in guestInstances) {
-      const guestInstance = guestInstances[guestInstanceId]
+    for (const guestInstanceId of Object.keys(guestInstances)) {
+      const guestInstance = guestInstances[guestInstanceId];
       if (guestInstance.embedder === embedder) {
-        detachGuest(embedder, parseInt(guestInstanceId))
+        detachGuest(embedder, parseInt(guestInstanceId));
       }
     }
     // Clear the listeners.
-    embedder.removeListener('-window-visibility-change', onVisibilityChange)
-    watchedEmbedders.delete(embedder)
-  })
-}
+    embedder.removeListener('-window-visibility-change', onVisibilityChange);
+    watchedEmbedders.delete(embedder);
+  });
+};
 
-const isWebViewTagEnabledCache = new WeakMap()
+const isWebViewTagEnabledCache = new WeakMap();
 
 const isWebViewTagEnabled = function (contents) {
   if (!isWebViewTagEnabledCache.has(contents)) {
-    const webPreferences = contents.getLastWebPreferences() || {}
-    isWebViewTagEnabledCache.set(contents, !!webPreferences.webviewTag)
+    const webPreferences = contents.getLastWebPreferences() || {};
+    isWebViewTagEnabledCache.set(contents, !!webPreferences.webviewTag);
   }
 
-  return isWebViewTagEnabledCache.get(contents)
-}
+  return isWebViewTagEnabledCache.get(contents);
+};
 
 const makeSafeHandler = function (channel, handler) {
   return (event, ...args) => {
     if (isWebViewTagEnabled(event.sender)) {
-      return handler(event, ...args)
+      return handler(event, ...args);
     } else {
-      console.error(`<webview> IPC message ${channel} sent by WebContents with <webview> disabled (${event.sender.id})`)
-      throw new Error('<webview> disabled')
+      console.error(`<webview> IPC message ${channel} sent by WebContents with <webview> disabled (${event.sender.id})`);
+      throw new Error('<webview> disabled');
     }
-  }
-}
+  };
+};
 
 const handleMessage = function (channel, handler) {
-  ipcMainInternal.handle(channel, makeSafeHandler(channel, handler))
-}
+  ipcMainInternal.handle(channel, makeSafeHandler(channel, handler));
+};
 
 const handleMessageSync = function (channel, handler) {
-  ipcMainUtils.handleSync(channel, makeSafeHandler(channel, handler))
-}
+  ipcMainUtils.handleSync(channel, makeSafeHandler(channel, handler));
+};
 
 handleMessage('ELECTRON_GUEST_VIEW_MANAGER_CREATE_GUEST', function (event, params) {
-  return createGuest(event.sender, params)
-})
+  return createGuest(event.sender, params);
+});
 
 handleMessage('ELECTRON_GUEST_VIEW_MANAGER_ATTACH_GUEST', function (event, embedderFrameId, elementInstanceId, guestInstanceId, params) {
   try {
-    attachGuest(event, embedderFrameId, elementInstanceId, guestInstanceId, params)
+    attachGuest(event, embedderFrameId, elementInstanceId, guestInstanceId, params);
   } catch (error) {
-    console.error(`Guest attach failed: ${error}`)
+    console.error(`Guest attach failed: ${error}`);
   }
-})
+});
 
 // this message is sent by the actual <webview>
 ipcMainInternal.on('ELECTRON_GUEST_VIEW_MANAGER_FOCUS_CHANGE', function (event, focus, guestInstanceId) {
-  const guest = getGuest(guestInstanceId)
+  const guest = getGuest(guestInstanceId);
   if (guest === event.sender) {
-    event.sender.emit('focus-change', {}, focus, guestInstanceId)
+    event.sender.emit('focus-change', {}, focus, guestInstanceId);
   } else {
-    console.error(`focus-change for guestInstanceId: ${guestInstanceId}`)
+    console.error(`focus-change for guestInstanceId: ${guestInstanceId}`);
   }
-})
+});
 
 handleMessage('ELECTRON_GUEST_VIEW_MANAGER_CALL', function (event, guestInstanceId, method, args) {
-  const guest = getGuestForWebContents(guestInstanceId, event.sender)
+  const guest = getGuestForWebContents(guestInstanceId, event.sender);
   if (!asyncMethods.has(method)) {
-    throw new Error(`Invalid method: ${method}`)
+    throw new Error(`Invalid method: ${method}`);
   }
 
-  return guest[method](...args)
-})
+  return guest[method](...args);
+});
 
 handleMessageSync('ELECTRON_GUEST_VIEW_MANAGER_CALL', function (event, guestInstanceId, method, args) {
-  const guest = getGuestForWebContents(guestInstanceId, event.sender)
+  const guest = getGuestForWebContents(guestInstanceId, event.sender);
   if (!syncMethods.has(method)) {
-    throw new Error(`Invalid method: ${method}`)
+    throw new Error(`Invalid method: ${method}`);
   }
 
-  return guest[method](...args)
-})
+  return guest[method](...args);
+});
+
+handleMessageSync('ELECTRON_GUEST_VIEW_MANAGER_PROPERTY_GET', function (event, guestInstanceId, property) {
+  const guest = getGuestForWebContents(guestInstanceId, event.sender);
+  if (!properties.has(property)) {
+    throw new Error(`Invalid property: ${property}`);
+  }
+
+  return guest[property];
+});
+
+handleMessageSync('ELECTRON_GUEST_VIEW_MANAGER_PROPERTY_SET', function (event, guestInstanceId, property, val) {
+  const guest = getGuestForWebContents(guestInstanceId, event.sender);
+  if (!properties.has(property)) {
+    throw new Error(`Invalid property: ${property}`);
+  }
+
+  guest[property] = val;
+});
 
 handleMessage('ELECTRON_GUEST_VIEW_MANAGER_CAPTURE_PAGE', async function (event, guestInstanceId, args) {
-  const guest = getGuestForWebContents(guestInstanceId, event.sender)
+  const guest = getGuestForWebContents(guestInstanceId, event.sender);
 
-  return serialize(await guest.capturePage(...args))
-})
+  return serialize(await guest.capturePage(...args));
+});
 
 // Returns WebContents from its guest id hosted in given webContents.
 const getGuestForWebContents = function (guestInstanceId, contents) {
-  const guest = getGuest(guestInstanceId)
+  const guest = getGuest(guestInstanceId);
   if (!guest) {
-    throw new Error(`Invalid guestInstanceId: ${guestInstanceId}`)
+    throw new Error(`Invalid guestInstanceId: ${guestInstanceId}`);
   }
   if (guest.hostWebContents !== contents) {
-    throw new Error(`Access denied to guestInstanceId: ${guestInstanceId}`)
+    throw new Error(`Access denied to guestInstanceId: ${guestInstanceId}`);
   }
-  return guest
-}
+  return guest;
+};
 
 // Returns WebContents from its guest id.
 const getGuest = function (guestInstanceId) {
-  const guestInstance = guestInstances[guestInstanceId]
-  if (guestInstance != null) return guestInstance.guest
-}
+  const guestInstance = guestInstances[guestInstanceId];
+  if (guestInstance != null) return guestInstance.guest;
+};
 
 // Returns the embedder of the guest.
 const getEmbedder = function (guestInstanceId) {
-  const guestInstance = guestInstances[guestInstanceId]
-  if (guestInstance != null) return guestInstance.embedder
-}
+  const guestInstance = guestInstances[guestInstanceId];
+  if (guestInstance != null) return guestInstance.embedder;
+};
 
-exports.isWebViewTagEnabled = isWebViewTagEnabled
+exports.isWebViewTagEnabled = isWebViewTagEnabled;

lib/browser/guest-window-manager.js

@@ -1,14 +1,14 @@
-'use strict'
+'use strict';
 
-const electron = require('electron')
-const { BrowserWindow } = electron
-const { isSameOrigin } = process.electronBinding('v8_util')
-const { ipcMainInternal } = require('@electron/internal/browser/ipc-main-internal')
-const ipcMainUtils = require('@electron/internal/browser/ipc-main-internal-utils')
-const parseFeaturesString = require('@electron/internal/common/parse-features-string')
+const electron = require('electron');
+const { BrowserWindow } = electron;
+const { isSameOrigin } = process.electronBinding('v8_util');
+const { ipcMainInternal } = require('@electron/internal/browser/ipc-main-internal');
+const ipcMainUtils = require('@electron/internal/browser/ipc-main-internal-utils');
+const parseFeaturesString = require('@electron/internal/common/parse-features-string');
 
-const hasProp = {}.hasOwnProperty
-const frameToGuest = new Map()
+const hasProp = {}.hasOwnProperty;
+const frameToGuest = new Map();
 
 // Security options that child windows will always inherit from parent windows
 const inheritedWebPreferences = new Map([
@@ -20,109 +20,109 @@ const inheritedWebPreferences = new Map([
   ['sandbox', true],
   ['webviewTag', false],
   ['nodeIntegrationInSubFrames', false]
-])
+]);
 
 // Copy attribute of |parent| to |child| if it is not defined in |child|.
 const mergeOptions = function (child, parent, visited) {
   // Check for circular reference.
-  if (visited == null) visited = new Set()
-  if (visited.has(parent)) return
+  if (visited == null) visited = new Set();
+  if (visited.has(parent)) return;
 
-  visited.add(parent)
+  visited.add(parent);
   for (const key in parent) {
-    if (key === 'type') continue
-    if (!hasProp.call(parent, key)) continue
-    if (key in child && key !== 'webPreferences') continue
+    if (key === 'type') continue;
+    if (!hasProp.call(parent, key)) continue;
+    if (key in child && key !== 'webPreferences') continue;
 
-    const value = parent[key]
+    const value = parent[key];
     if (typeof value === 'object' && !Array.isArray(value)) {
-      child[key] = mergeOptions(child[key] || {}, value, visited)
+      child[key] = mergeOptions(child[key] || {}, value, visited);
     } else {
-      child[key] = value
+      child[key] = value;
     }
   }
-  visited.delete(parent)
+  visited.delete(parent);
 
-  return child
-}
+  return child;
+};
 
 // Merge |options| with the |embedder|'s window's options.
 const mergeBrowserWindowOptions = function (embedder, options) {
   if (options.webPreferences == null) {
-    options.webPreferences = {}
+    options.webPreferences = {};
   }
   if (embedder.browserWindowOptions != null) {
-    let parentOptions = embedder.browserWindowOptions
+    let parentOptions = embedder.browserWindowOptions;
 
     // if parent's visibility is available, that overrides 'show' flag (#12125)
-    const win = BrowserWindow.fromWebContents(embedder.webContents)
+    const win = BrowserWindow.fromWebContents(embedder.webContents);
     if (win != null) {
-      parentOptions = { ...embedder.browserWindowOptions, show: win.isVisible() }
+      parentOptions = { ...embedder.browserWindowOptions, show: win.isVisible() };
     }
 
     // Inherit the original options if it is a BrowserWindow.
-    mergeOptions(options, parentOptions)
+    mergeOptions(options, parentOptions);
   } else {
     // Or only inherit webPreferences if it is a webview.
-    mergeOptions(options.webPreferences, embedder.getLastWebPreferences())
+    mergeOptions(options.webPreferences, embedder.getLastWebPreferences());
   }
 
   // Inherit certain option values from parent window
-  const webPreferences = embedder.getLastWebPreferences()
+  const webPreferences = embedder.getLastWebPreferences();
   for (const [name, value] of inheritedWebPreferences) {
     if (webPreferences[name] === value) {
-      options.webPreferences[name] = value
+      options.webPreferences[name] = value;
     }
   }
 
   if (!webPreferences.nativeWindowOpen) {
     // Sets correct openerId here to give correct options to 'new-window' event handler
-    options.webPreferences.openerId = embedder.id
+    options.webPreferences.openerId = embedder.id;
   }
 
-  return options
-}
+  return options;
+};
 
 // Setup a new guest with |embedder|
 const setupGuest = function (embedder, frameName, guest, options) {
   // When |embedder| is destroyed we should also destroy attached guest, and if
   // guest is closed by user then we should prevent |embedder| from double
   // closing guest.
-  const guestId = guest.webContents.id
+  const guestId = guest.webContents.id;
   const closedByEmbedder = function () {
-    guest.removeListener('closed', closedByUser)
-    guest.destroy()
-  }
+    guest.removeListener('closed', closedByUser);
+    guest.destroy();
+  };
   const closedByUser = function () {
-    embedder._sendInternal('ELECTRON_GUEST_WINDOW_MANAGER_WINDOW_CLOSED_' + guestId)
-    embedder.removeListener('current-render-view-deleted', closedByEmbedder)
-  }
-  embedder.once('current-render-view-deleted', closedByEmbedder)
-  guest.once('closed', closedByUser)
+    embedder._sendInternal('ELECTRON_GUEST_WINDOW_MANAGER_WINDOW_CLOSED_' + guestId);
+    embedder.removeListener('current-render-view-deleted', closedByEmbedder);
+  };
+  embedder.once('current-render-view-deleted', closedByEmbedder);
+  guest.once('closed', closedByUser);
   if (frameName) {
-    frameToGuest.set(frameName, guest)
-    guest.frameName = frameName
+    frameToGuest.set(frameName, guest);
+    guest.frameName = frameName;
     guest.once('closed', function () {
-      frameToGuest.delete(frameName)
-    })
+      frameToGuest.delete(frameName);
+    });
   }
-  return guestId
-}
+  return guestId;
+};
 
 // Create a new guest created by |embedder| with |options|.
 const createGuest = function (embedder, url, referrer, frameName, options, postData) {
-  let guest = frameToGuest.get(frameName)
+  let guest = frameToGuest.get(frameName);
   if (frameName && (guest != null)) {
-    guest.loadURL(url)
-    return guest.webContents.id
+    guest.loadURL(url);
+    return guest.webContents.id;
   }
 
   // Remember the embedder window's id.
   if (options.webPreferences == null) {
-    options.webPreferences = {}
+    options.webPreferences = {};
   }
 
-  guest = new BrowserWindow(options)
+  guest = new BrowserWindow(options);
   if (!options.webContents) {
     // We should not call `loadURL` if the window was constructed from an
     // existing webContents (window.open in a sandboxed renderer).
@@ -131,236 +131,236 @@ const createGuest = function (embedder, url, referrer, frameName, options, postD
     // webContents is not necessary (it will navigate there anyway).
     const loadOptions = {
       httpReferrer: referrer
-    }
+    };
     if (postData != null) {
-      loadOptions.postData = postData
-      loadOptions.extraHeaders = 'content-type: application/x-www-form-urlencoded'
+      loadOptions.postData = postData;
+      loadOptions.extraHeaders = 'content-type: application/x-www-form-urlencoded';
       if (postData.length > 0) {
-        const postDataFront = postData[0].bytes.toString()
-        const boundary = /^--.*[^-\r\n]/.exec(postDataFront)
+        const postDataFront = postData[0].bytes.toString();
+        const boundary = /^--.*[^-\r\n]/.exec(postDataFront);
         if (boundary != null) {
-          loadOptions.extraHeaders = `content-type: multipart/form-data; boundary=${boundary[0].substr(2)}`
+          loadOptions.extraHeaders = `content-type: multipart/form-data; boundary=${boundary[0].substr(2)}`;
         }
       }
     }
-    guest.loadURL(url, loadOptions)
+    guest.loadURL(url, loadOptions);
   }
 
-  return setupGuest(embedder, frameName, guest, options)
-}
+  return setupGuest(embedder, frameName, guest, options);
+};
 
 const getGuestWindow = function (guestContents) {
-  let guestWindow = BrowserWindow.fromWebContents(guestContents)
+  let guestWindow = BrowserWindow.fromWebContents(guestContents);
   if (guestWindow == null) {
-    const hostContents = guestContents.hostWebContents
+    const hostContents = guestContents.hostWebContents;
     if (hostContents != null) {
-      guestWindow = BrowserWindow.fromWebContents(hostContents)
+      guestWindow = BrowserWindow.fromWebContents(hostContents);
     }
   }
   if (!guestWindow) {
-    throw new Error('getGuestWindow failed')
+    throw new Error('getGuestWindow failed');
   }
-  return guestWindow
-}
+  return guestWindow;
+};
 
 const isChildWindow = function (sender, target) {
-  return target.getLastWebPreferences().openerId === sender.id
-}
+  return target.getLastWebPreferences().openerId === sender.id;
+};
 
 const isRelatedWindow = function (sender, target) {
-  return isChildWindow(sender, target) || isChildWindow(target, sender)
-}
+  return isChildWindow(sender, target) || isChildWindow(target, sender);
+};
 
 const isScriptableWindow = function (sender, target) {
-  return isRelatedWindow(sender, target) && isSameOrigin(sender.getURL(), target.getURL())
-}
+  return isRelatedWindow(sender, target) && isSameOrigin(sender.getURL(), target.getURL());
+};
 
 const isNodeIntegrationEnabled = function (sender) {
-  return sender.getLastWebPreferences().nodeIntegration === true
-}
+  return sender.getLastWebPreferences().nodeIntegration === true;
+};
 
 // Checks whether |sender| can access the |target|:
 const canAccessWindow = function (sender, target) {
   return isChildWindow(sender, target) ||
          isScriptableWindow(sender, target) ||
-         isNodeIntegrationEnabled(sender)
-}
+         isNodeIntegrationEnabled(sender);
+};
 
 // Routed window.open messages with raw options
 ipcMainInternal.on('ELECTRON_GUEST_WINDOW_MANAGER_WINDOW_OPEN', (event, url, frameName, features) => {
-  if (url == null || url === '') url = 'about:blank'
-  if (frameName == null) frameName = ''
-  if (features == null) features = ''
+  if (url == null || url === '') url = 'about:blank';
+  if (frameName == null) frameName = '';
+  if (features == null) features = '';
 
-  const options = {}
+  const options = {};
 
-  const ints = ['x', 'y', 'width', 'height', 'minWidth', 'maxWidth', 'minHeight', 'maxHeight', 'zoomFactor']
-  const webPreferences = ['zoomFactor', 'nodeIntegration', 'enableRemoteModule', 'preload', 'javascript', 'contextIsolation', 'webviewTag']
-  const disposition = 'new-window'
+  const ints = ['x', 'y', 'width', 'height', 'minWidth', 'maxWidth', 'minHeight', 'maxHeight', 'zoomFactor'];
+  const webPreferences = ['zoomFactor', 'nodeIntegration', 'enableRemoteModule', 'preload', 'javascript', 'contextIsolation', 'webviewTag'];
+  const disposition = 'new-window';
 
   // Used to store additional features
-  const additionalFeatures = []
+  const additionalFeatures = [];
 
   // Parse the features
   parseFeaturesString(features, function (key, value) {
     if (value === undefined) {
-      additionalFeatures.push(key)
+      additionalFeatures.push(key);
     } else {
       // Don't allow webPreferences to be set since it must be an object
       // that cannot be directly overridden
-      if (key === 'webPreferences') return
+      if (key === 'webPreferences') return;
 
       if (webPreferences.includes(key)) {
         if (options.webPreferences == null) {
-          options.webPreferences = {}
+          options.webPreferences = {};
         }
-        options.webPreferences[key] = value
+        options.webPreferences[key] = value;
       } else {
-        options[key] = value
+        options[key] = value;
       }
     }
-  })
+  });
   if (options.left) {
     if (options.x == null) {
-      options.x = options.left
+      options.x = options.left;
     }
   }
   if (options.top) {
     if (options.y == null) {
-      options.y = options.top
+      options.y = options.top;
     }
   }
   if (options.title == null) {
-    options.title = frameName
+    options.title = frameName;
   }
   if (options.width == null) {
-    options.width = 800
+    options.width = 800;
   }
   if (options.height == null) {
-    options.height = 600
+    options.height = 600;
   }
 
   for (const name of ints) {
     if (options[name] != null) {
-      options[name] = parseInt(options[name], 10)
+      options[name] = parseInt(options[name], 10);
     }
   }
 
-  const referrer = { url: '', policy: 'default' }
-  internalWindowOpen(event, url, referrer, frameName, disposition, options, additionalFeatures)
-})
+  const referrer = { url: '', policy: 'default' };
+  internalWindowOpen(event, url, referrer, frameName, disposition, options, additionalFeatures);
+});
 
 // Routed window.open messages with fully parsed options
 function internalWindowOpen (event, url, referrer, frameName, disposition, options, additionalFeatures, postData) {
-  options = mergeBrowserWindowOptions(event.sender, options)
-  event.sender.emit('new-window', event, url, frameName, disposition, options, additionalFeatures, referrer)
-  const { newGuest } = event
+  options = mergeBrowserWindowOptions(event.sender, options);
+  event.sender.emit('new-window', event, url, frameName, disposition, options, additionalFeatures, referrer);
+  const { newGuest } = event;
   if ((event.sender.getType() === 'webview' && event.sender.getLastWebPreferences().disablePopups) || event.defaultPrevented) {
     if (newGuest != null) {
       if (options.webContents === newGuest.webContents) {
         // the webContents is not changed, so set defaultPrevented to false to
         // stop the callers of this event from destroying the webContents.
-        event.defaultPrevented = false
+        event.defaultPrevented = false;
       }
-      event.returnValue = setupGuest(event.sender, frameName, newGuest, options)
+      event.returnValue = setupGuest(event.sender, frameName, newGuest, options);
     } else {
-      event.returnValue = null
+      event.returnValue = null;
     }
   } else {
-    event.returnValue = createGuest(event.sender, url, referrer, frameName, options, postData)
+    event.returnValue = createGuest(event.sender, url, referrer, frameName, options, postData);
   }
 }
 
 const makeSafeHandler = function (handler) {
   return (event, guestId, ...args) => {
     // Access webContents via electron to prevent circular require.
-    const guestContents = electron.webContents.fromId(guestId)
+    const guestContents = electron.webContents.fromId(guestId);
     if (!guestContents) {
-      throw new Error(`Invalid guestId: ${guestId}`)
+      throw new Error(`Invalid guestId: ${guestId}`);
     }
 
-    return handler(event, guestContents, ...args)
-  }
-}
+    return handler(event, guestContents, ...args);
+  };
+};
 
 const handleMessage = function (channel, handler) {
-  ipcMainInternal.handle(channel, makeSafeHandler(handler))
-}
+  ipcMainInternal.handle(channel, makeSafeHandler(handler));
+};
 
 const handleMessageSync = function (channel, handler) {
-  ipcMainUtils.handleSync(channel, makeSafeHandler(handler))
-}
+  ipcMainUtils.handleSync(channel, makeSafeHandler(handler));
+};
 
 const securityCheck = function (contents, guestContents, check) {
   if (!check(contents, guestContents)) {
-    console.error(`Blocked ${contents.getURL()} from accessing guestId: ${guestContents.id}`)
-    throw new Error(`Access denied to guestId: ${guestContents.id}`)
+    console.error(`Blocked ${contents.getURL()} from accessing guestId: ${guestContents.id}`);
+    throw new Error(`Access denied to guestId: ${guestContents.id}`);
   }
-}
+};
 
 const windowMethods = new Set([
   'destroy',
   'focus',
   'blur'
-])
+]);
 
 handleMessage('ELECTRON_GUEST_WINDOW_MANAGER_WINDOW_METHOD', (event, guestContents, method, ...args) => {
-  securityCheck(event.sender, guestContents, canAccessWindow)
+  securityCheck(event.sender, guestContents, canAccessWindow);
 
   if (!windowMethods.has(method)) {
-    console.error(`Blocked ${event.sender.getURL()} from calling method: ${method}`)
-    throw new Error(`Invalid method: ${method}`)
+    console.error(`Blocked ${event.sender.getURL()} from calling method: ${method}`);
+    throw new Error(`Invalid method: ${method}`);
   }
 
-  return getGuestWindow(guestContents)[method](...args)
-})
+  return getGuestWindow(guestContents)[method](...args);
+});
 
 handleMessage('ELECTRON_GUEST_WINDOW_MANAGER_WINDOW_POSTMESSAGE', (event, guestContents, message, targetOrigin, sourceOrigin) => {
   if (targetOrigin == null) {
-    targetOrigin = '*'
+    targetOrigin = '*';
   }
 
   // The W3C does not seem to have word on how postMessage should work when the
   // origins do not match, so we do not do |canAccessWindow| check here since
   // postMessage across origins is useful and not harmful.
-  securityCheck(event.sender, guestContents, isRelatedWindow)
+  securityCheck(event.sender, guestContents, isRelatedWindow);
 
   if (targetOrigin === '*' || isSameOrigin(guestContents.getURL(), targetOrigin)) {
-    const sourceId = event.sender.id
-    guestContents._sendInternal('ELECTRON_GUEST_WINDOW_POSTMESSAGE', sourceId, message, sourceOrigin)
+    const sourceId = event.sender.id;
+    guestContents._sendInternal('ELECTRON_GUEST_WINDOW_POSTMESSAGE', sourceId, message, sourceOrigin);
   }
-})
+});
 
 const webContentsMethodsAsync = new Set([
   'loadURL',
   'executeJavaScript',
   'print'
-])
+]);
 
 handleMessage('ELECTRON_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD', (event, guestContents, method, ...args) => {
-  securityCheck(event.sender, guestContents, canAccessWindow)
+  securityCheck(event.sender, guestContents, canAccessWindow);
 
   if (!webContentsMethodsAsync.has(method)) {
-    console.error(`Blocked ${event.sender.getURL()} from calling method: ${method}`)
-    throw new Error(`Invalid method: ${method}`)
+    console.error(`Blocked ${event.sender.getURL()} from calling method: ${method}`);
+    throw new Error(`Invalid method: ${method}`);
   }
 
-  return guestContents[method](...args)
-})
+  return guestContents[method](...args);
+});
 
 const webContentsMethodsSync = new Set([
   'getURL'
-])
+]);
 
 handleMessageSync('ELECTRON_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD', (event, guestContents, method, ...args) => {
-  securityCheck(event.sender, guestContents, canAccessWindow)
+  securityCheck(event.sender, guestContents, canAccessWindow);
 
   if (!webContentsMethodsSync.has(method)) {
-    console.error(`Blocked ${event.sender.getURL()} from calling method: ${method}`)
-    throw new Error(`Invalid method: ${method}`)
+    console.error(`Blocked ${event.sender.getURL()} from calling method: ${method}`);
+    throw new Error(`Invalid method: ${method}`);
   }
 
-  return guestContents[method](...args)
-})
+  return guestContents[method](...args);
+});
 
-exports.internalWindowOpen = internalWindowOpen
+exports.internalWindowOpen = internalWindowOpen;

lib/browser/init.ts

@@ -1,45 +1,47 @@
-import { Buffer } from 'buffer'
-import * as fs from 'fs'
-import * as path from 'path'
-import * as util from 'util'
+import { Buffer } from 'buffer';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as util from 'util';
 
-const Module = require('module')
+const Module = require('module');
 
 // We modified the original process.argv to let node.js load the init.js,
 // we need to restore it here.
-process.argv.splice(1, 1)
+process.argv.splice(1, 1);
 
 // Clear search paths.
-require('../common/reset-search-paths')
+require('../common/reset-search-paths');
 
 // Import common settings.
-require('@electron/internal/common/init')
+require('@electron/internal/common/init');
 
 if (process.platform === 'win32') {
   // Redirect node's console to use our own implementations, since node can not
   // handle console output when running as GUI program.
-  const consoleLog = (format: any, ...args: any[]) => {
-    return process.log(util.format(format, ...args) + '\n')
-  }
+  const consoleLog = (...args: any[]) => {
+    // @ts-ignore this typing is incorrect; 'format' is an optional parameter
+    // See https://nodejs.org/api/util.html#util_util_format_format_args
+    return process.log(util.format(...args) + '\n');
+  };
   const streamWrite: NodeJS.WritableStream['write'] = function (chunk: Buffer | string, encoding?: any, callback?: Function) {
     if (Buffer.isBuffer(chunk)) {
-      chunk = chunk.toString(encoding)
+      chunk = chunk.toString(encoding);
     }
-    process.log(chunk)
+    process.log(chunk);
     if (callback) {
-      callback()
+      callback();
     }
-    return true
-  }
-  console.log = console.error = console.warn = consoleLog
-  process.stdout.write = process.stderr.write = streamWrite
+    return true;
+  };
+  console.log = console.error = console.warn = consoleLog;
+  process.stdout.write = process.stderr.write = streamWrite;
 }
 
 // Don't quit on fatal error.
 process.on('uncaughtException', function (error) {
   // Do nothing if the user has a custom uncaught exception handler.
   if (process.listenerCount('uncaughtException') > 1) {
-    return
+    return;
   }
 
   // Show error in GUI.
@@ -48,18 +50,18 @@ process.on('uncaughtException', function (error) {
   // so we import it inside the handler down here
   import('electron')
     .then(({ dialog }) => {
-      const stack = error.stack ? error.stack : `${error.name}: ${error.message}`
-      const message = 'Uncaught Exception:\n' + stack
-      dialog.showErrorBox('A JavaScript error occurred in the main process', message)
-    })
-})
+      const stack = error.stack ? error.stack : `${error.name}: ${error.message}`;
+      const message = 'Uncaught Exception:\n' + stack;
+      dialog.showErrorBox('A JavaScript error occurred in the main process', message);
+    });
+});
 
 // Emit 'exit' event on quit.
-const { app } = require('electron')
+const { app } = require('electron');
 
 app.on('quit', function (event, exitCode) {
-  process.emit('exit', exitCode)
-})
+  process.emit('exit', exitCode);
+});
 
 if (process.platform === 'win32') {
   // If we are a Squirrel.Windows-installed app, set app user model ID
@@ -76,141 +78,141 @@ if (process.platform === 'win32') {
   // form `com.squirrel.PACKAGE-NAME.OUREXE`. We need to call
   // app.setAppUserModelId with a matching identifier so that renderer processes
   // will inherit this value.
-  const updateDotExe = path.join(path.dirname(process.execPath), '..', 'update.exe')
+  const updateDotExe = path.join(path.dirname(process.execPath), '..', 'update.exe');
 
   if (fs.existsSync(updateDotExe)) {
-    const packageDir = path.dirname(path.resolve(updateDotExe))
-    const packageName = path.basename(packageDir).replace(/\s/g, '')
-    const exeName = path.basename(process.execPath).replace(/\.exe$/i, '').replace(/\s/g, '')
+    const packageDir = path.dirname(path.resolve(updateDotExe));
+    const packageName = path.basename(packageDir).replace(/\s/g, '');
+    const exeName = path.basename(process.execPath).replace(/\.exe$/i, '').replace(/\s/g, '');
 
-    app.setAppUserModelId(`com.squirrel.${packageName}.${exeName}`)
+    app.setAppUserModelId(`com.squirrel.${packageName}.${exeName}`);
   }
 }
 
 // Map process.exit to app.exit, which quits gracefully.
-process.exit = app.exit as () => never
+process.exit = app.exit as () => never;
 
 // Load the RPC server.
-require('@electron/internal/browser/rpc-server')
+require('@electron/internal/browser/rpc-server');
 
 // Load the guest view manager.
-require('@electron/internal/browser/guest-view-manager')
-require('@electron/internal/browser/guest-window-manager')
+require('@electron/internal/browser/guest-view-manager');
+require('@electron/internal/browser/guest-window-manager');
 
 // Now we try to load app's package.json.
-let packagePath = null
-let packageJson = null
-const searchPaths = ['app', 'app.asar', 'default_app.asar']
+let packagePath = null;
+let packageJson = null;
+const searchPaths = ['app', 'app.asar', 'default_app.asar'];
 
 if (process.resourcesPath) {
   for (packagePath of searchPaths) {
     try {
-      packagePath = path.join(process.resourcesPath, packagePath)
-      packageJson = Module._load(path.join(packagePath, 'package.json'))
-      break
+      packagePath = path.join(process.resourcesPath, packagePath);
+      packageJson = Module._load(path.join(packagePath, 'package.json'));
+      break;
     } catch {
-      continue
+      continue;
     }
   }
 }
 
 if (packageJson == null) {
   process.nextTick(function () {
-    return process.exit(1)
-  })
-  throw new Error('Unable to find a valid app')
+    return process.exit(1);
+  });
+  throw new Error('Unable to find a valid app');
 }
 
 // Set application's version.
 if (packageJson.version != null) {
-  app.setVersion(packageJson.version)
+  app.setVersion(packageJson.version);
 }
 
 // Set application's name.
 if (packageJson.productName != null) {
-  app.name = `${packageJson.productName}`.trim()
+  app.name = `${packageJson.productName}`.trim();
 } else if (packageJson.name != null) {
-  app.name = `${packageJson.name}`.trim()
+  app.name = `${packageJson.name}`.trim();
 }
 
 // Set application's desktop name.
 if (packageJson.desktopName != null) {
-  app.setDesktopName(packageJson.desktopName)
+  app.setDesktopName(packageJson.desktopName);
 } else {
-  app.setDesktopName(`${app.name}.desktop`)
+  app.setDesktopName(`${app.name}.desktop`);
 }
 
 // Set v8 flags, delibrately lazy load so that apps that do not use this
 // feature do not pay the price
 if (packageJson.v8Flags != null) {
-  require('v8').setFlagsFromString(packageJson.v8Flags)
+  require('v8').setFlagsFromString(packageJson.v8Flags);
 }
 
-app._setDefaultAppPaths(packagePath)
+app._setDefaultAppPaths(packagePath);
 
 // Load the chrome devtools support.
-require('@electron/internal/browser/devtools')
+require('@electron/internal/browser/devtools');
 
-const features = process.electronBinding('features')
+const features = process.electronBinding('features');
 
 // Load the chrome extension support.
 if (features.isExtensionsEnabled()) {
-  require('@electron/internal/browser/chrome-extension-shim')
+  require('@electron/internal/browser/chrome-extension-shim');
 } else {
-  require('@electron/internal/browser/chrome-extension')
+  require('@electron/internal/browser/chrome-extension');
 }
 
 if (features.isRemoteModuleEnabled()) {
-  require('@electron/internal/browser/remote/server')
+  require('@electron/internal/browser/remote/server');
 }
 
 // Load protocol module to ensure it is populated on app ready
-require('@electron/internal/browser/api/protocol')
+require('@electron/internal/browser/api/protocol');
 
 // Set main startup script of the app.
-const mainStartupScript = packageJson.main || 'index.js'
+const mainStartupScript = packageJson.main || 'index.js';
 
-const KNOWN_XDG_DESKTOP_VALUES = ['Pantheon', 'Unity:Unity7', 'pop:GNOME']
+const KNOWN_XDG_DESKTOP_VALUES = ['Pantheon', 'Unity:Unity7', 'pop:GNOME'];
 
 function currentPlatformSupportsAppIndicator () {
-  if (process.platform !== 'linux') return false
-  const currentDesktop = process.env.XDG_CURRENT_DESKTOP
+  if (process.platform !== 'linux') return false;
+  const currentDesktop = process.env.XDG_CURRENT_DESKTOP;
 
-  if (!currentDesktop) return false
-  if (KNOWN_XDG_DESKTOP_VALUES.includes(currentDesktop)) return true
+  if (!currentDesktop) return false;
+  if (KNOWN_XDG_DESKTOP_VALUES.includes(currentDesktop)) return true;
   // ubuntu based or derived session (default ubuntu one, communitheme…) supports
   // indicator too.
-  if (/ubuntu/ig.test(currentDesktop)) return true
+  if (/ubuntu/ig.test(currentDesktop)) return true;
 
-  return false
+  return false;
 }
 
 // Workaround for electron/electron#5050 and electron/electron#9046
 if (currentPlatformSupportsAppIndicator()) {
-  process.env.XDG_CURRENT_DESKTOP = 'Unity'
+  process.env.XDG_CURRENT_DESKTOP = 'Unity';
 }
 
 // Quit when all windows are closed and no other one is listening to this.
 app.on('window-all-closed', () => {
   if (app.listenerCount('window-all-closed') === 1) {
-    app.quit()
+    app.quit();
   }
-})
+});
 
-const { setDefaultApplicationMenu } = require('@electron/internal/browser/default-menu')
+const { setDefaultApplicationMenu } = require('@electron/internal/browser/default-menu');
 
 // Create default menu.
 //
 // Note that the task must be added before loading any app, so we can make sure
 // the call is maded before any user window is created, otherwise the default
 // menu may show even when user explicitly hides the menu.
-app.whenReady().then(setDefaultApplicationMenu)
+app.whenReady().then(setDefaultApplicationMenu);
 
 if (packagePath) {
   // Finally load app's main.js and transfer control to C++.
-  process._firstFileName = Module._resolveFilename(path.join(packagePath, mainStartupScript), null, false)
-  Module._load(path.join(packagePath, mainStartupScript), Module, true)
+  process._firstFileName = Module._resolveFilename(path.join(packagePath, mainStartupScript), null, false);
+  Module._load(path.join(packagePath, mainStartupScript), Module, true);
 } else {
-  console.error('Failed to locate a valid package to load (app, app.asar or default_app.asar)')
-  console.error('This normally means you\'ve damaged the Electron package somehow')
+  console.error('Failed to locate a valid package to load (app, app.asar or default_app.asar)');
+  console.error('This normally means you\'ve damaged the Electron package somehow');
 }

lib/browser/ipc-main-impl.ts

@@ -1,33 +1,33 @@
-import { EventEmitter } from 'events'
-import { IpcMainInvokeEvent } from 'electron'
+import { EventEmitter } from 'events';
+import { IpcMainInvokeEvent } from 'electron';
 
 export class IpcMainImpl extends EventEmitter {
   private _invokeHandlers: Map<string, (e: IpcMainInvokeEvent, ...args: any[]) => void> = new Map();
 
   handle: Electron.IpcMain['handle'] = (method, fn) => {
     if (this._invokeHandlers.has(method)) {
-      throw new Error(`Attempted to register a second handler for '${method}'`)
+      throw new Error(`Attempted to register a second handler for '${method}'`);
     }
     if (typeof fn !== 'function') {
-      throw new Error(`Expected handler to be a function, but found type '${typeof fn}'`)
+      throw new Error(`Expected handler to be a function, but found type '${typeof fn}'`);
     }
     this._invokeHandlers.set(method, async (e, ...args) => {
       try {
-        (e as any)._reply(await Promise.resolve(fn(e, ...args)))
+        (e as any)._reply(await Promise.resolve(fn(e, ...args)));
       } catch (err) {
-        (e as any)._throw(err)
+        (e as any)._throw(err);
       }
-    })
+    });
   }
 
   handleOnce: Electron.IpcMain['handleOnce'] = (method, fn) => {
     this.handle(method, (e, ...args) => {
-      this.removeHandler(method)
-      return fn(e, ...args)
-    })
+      this.removeHandler(method);
+      return fn(e, ...args);
+    });
   }
 
   removeHandler (method: string) {
-    this._invokeHandlers.delete(method)
+    this._invokeHandlers.delete(method);
   }
 }

lib/browser/ipc-main-internal-utils.ts

@@ -1,44 +1,44 @@
-import { ipcMainInternal } from '@electron/internal/browser/ipc-main-internal'
+import { ipcMainInternal } from '@electron/internal/browser/ipc-main-internal';
 
 type IPCHandler = (event: Electron.IpcMainInvokeEvent, ...args: any[]) => any
 
 export const handleSync = function <T extends IPCHandler> (channel: string, handler: T) {
   ipcMainInternal.on(channel, async (event, ...args) => {
     try {
-      event.returnValue = [null, await handler(event, ...args)]
+      event.returnValue = [null, await handler(event, ...args)];
     } catch (error) {
-      event.returnValue = [error]
+      event.returnValue = [error];
     }
-  })
-}
+  });
+};
 
-let nextId = 0
+let nextId = 0;
 
 export function invokeInWebContents<T> (sender: Electron.WebContentsInternal, sendToAll: boolean, command: string, ...args: any[]) {
   return new Promise<T>((resolve, reject) => {
-    const requestId = ++nextId
-    const channel = `${command}_RESPONSE_${requestId}`
+    const requestId = ++nextId;
+    const channel = `${command}_RESPONSE_${requestId}`;
     ipcMainInternal.on(channel, function handler (
       event, error: Electron.SerializedError, result: any
     ) {
       if (event.sender !== sender) {
-        console.error(`Reply to ${command} sent by unexpected WebContents (${event.sender.id})`)
-        return
+        console.error(`Reply to ${command} sent by unexpected WebContents (${event.sender.id})`);
+        return;
       }
 
-      ipcMainInternal.removeListener(channel, handler)
+      ipcMainInternal.removeListener(channel, handler);
 
       if (error) {
-        reject(error)
+        reject(error);
       } else {
-        resolve(result)
+        resolve(result);
       }
-    })
+    });
 
     if (sendToAll) {
-      sender._sendInternalToAll(command, requestId, ...args)
+      sender._sendInternalToAll(command, requestId, ...args);
     } else {
-      sender._sendInternal(command, requestId, ...args)
+      sender._sendInternal(command, requestId, ...args);
     }
-  })
+  });
 }

lib/browser/ipc-main-internal.ts

@@ -1,6 +1,6 @@
-import { IpcMainImpl } from '@electron/internal/browser/ipc-main-impl'
+import { IpcMainImpl } from '@electron/internal/browser/ipc-main-impl';
 
-export const ipcMainInternal = new IpcMainImpl() as ElectronInternal.IpcMainInternal
+export const ipcMainInternal = new IpcMainImpl() as ElectronInternal.IpcMainInternal;
 
 // Do not throw exception when channel name is "error".
-ipcMainInternal.on('error', () => {})
+ipcMainInternal.on('error', () => {});

lib/browser/navigation-controller.js

@@ -1,23 +1,23 @@
-'use strict'
+'use strict';
 
-const { ipcMainInternal } = require('@electron/internal/browser/ipc-main-internal')
+const { ipcMainInternal } = require('@electron/internal/browser/ipc-main-internal');
 
 // The history operation in renderer is redirected to browser.
 ipcMainInternal.on('ELECTRON_NAVIGATION_CONTROLLER_GO_BACK', function (event) {
-  event.sender.goBack()
-})
+  event.sender.goBack();
+});
 
 ipcMainInternal.on('ELECTRON_NAVIGATION_CONTROLLER_GO_FORWARD', function (event) {
-  event.sender.goForward()
-})
+  event.sender.goForward();
+});
 
 ipcMainInternal.on('ELECTRON_NAVIGATION_CONTROLLER_GO_TO_OFFSET', function (event, offset) {
-  event.sender.goToOffset(offset)
-})
+  event.sender.goToOffset(offset);
+});
 
 ipcMainInternal.on('ELECTRON_NAVIGATION_CONTROLLER_LENGTH', function (event) {
-  event.returnValue = event.sender.length()
-})
+  event.returnValue = event.sender.length();
+});
 
 // JavaScript implementation of Chromium's NavigationController.
 // Instead of relying on Chromium for history control, we compeletely do history
@@ -26,64 +26,64 @@ ipcMainInternal.on('ELECTRON_NAVIGATION_CONTROLLER_LENGTH', function (event) {
 // process is restarted everytime.
 const NavigationController = (function () {
   function NavigationController (webContents) {
-    this.webContents = webContents
-    this.clearHistory()
+    this.webContents = webContents;
+    this.clearHistory();
 
     // webContents may have already navigated to a page.
     if (this.webContents._getURL()) {
-      this.currentIndex++
-      this.history.push(this.webContents._getURL())
+      this.currentIndex++;
+      this.history.push(this.webContents._getURL());
     }
     this.webContents.on('navigation-entry-committed', (event, url, inPage, replaceEntry) => {
       if (this.inPageIndex > -1 && !inPage) {
         // Navigated to a new page, clear in-page mark.
-        this.inPageIndex = -1
+        this.inPageIndex = -1;
       } else if (this.inPageIndex === -1 && inPage && !replaceEntry) {
         // Started in-page navigations.
-        this.inPageIndex = this.currentIndex
+        this.inPageIndex = this.currentIndex;
       }
       if (this.pendingIndex >= 0) {
         // Go to index.
-        this.currentIndex = this.pendingIndex
-        this.pendingIndex = -1
-        this.history[this.currentIndex] = url
+        this.currentIndex = this.pendingIndex;
+        this.pendingIndex = -1;
+        this.history[this.currentIndex] = url;
       } else if (replaceEntry) {
         // Non-user initialized navigation.
-        this.history[this.currentIndex] = url
+        this.history[this.currentIndex] = url;
       } else {
         // Normal navigation. Clear history.
-        this.history = this.history.slice(0, this.currentIndex + 1)
-        this.currentIndex++
-        this.history.push(url)
+        this.history = this.history.slice(0, this.currentIndex + 1);
+        this.currentIndex++;
+        this.history.push(url);
       }
-    })
+    });
   }
 
   NavigationController.prototype.loadURL = function (url, options) {
     if (options == null) {
-      options = {}
+      options = {};
     }
     const p = new Promise((resolve, reject) => {
       const resolveAndCleanup = () => {
-        removeListeners()
-        resolve()
-      }
+        removeListeners();
+        resolve();
+      };
       const rejectAndCleanup = (errorCode, errorDescription, url) => {
-        const err = new Error(`${errorDescription} (${errorCode}) loading '${typeof url === 'string' ? url.substr(0, 2048) : url}'`)
-        Object.assign(err, { errno: errorCode, code: errorDescription, url })
-        removeListeners()
-        reject(err)
-      }
+        const err = new Error(`${errorDescription} (${errorCode}) loading '${typeof url === 'string' ? url.substr(0, 2048) : url}'`);
+        Object.assign(err, { errno: errorCode, code: errorDescription, url });
+        removeListeners();
+        reject(err);
+      };
       const finishListener = () => {
-        resolveAndCleanup()
-      }
+        resolveAndCleanup();
+      };
       const failListener = (event, errorCode, errorDescription, validatedURL, isMainFrame, frameProcessId, frameRoutingId) => {
         if (isMainFrame) {
-          rejectAndCleanup(errorCode, errorDescription, validatedURL)
+          rejectAndCleanup(errorCode, errorDescription, validatedURL);
         }
-      }
+      };
 
-      let navigationStarted = false
+      let navigationStarted = false;
       const navigationListener = (event, url, isSameDocument, isMainFrame, frameProcessId, frameRoutingId, navigationId) => {
         if (isMainFrame) {
           if (navigationStarted && !isSameDocument) {
@@ -96,11 +96,11 @@ const NavigationController = (function () {
             // considered navigation events but are triggered with isSameDocument.
             // We can ignore these to allow virtual routing on page load as long
             // as the routing does not leave the document
-            return rejectAndCleanup(-3, 'ERR_ABORTED', url)
+            return rejectAndCleanup(-3, 'ERR_ABORTED', url);
           }
-          navigationStarted = true
+          navigationStarted = true;
         }
-      }
+      };
       const stopLoadingListener = () => {
         // By the time we get here, either 'finish' or 'fail' should have fired
         // if the navigation occurred. However, in some situations (e.g. when
@@ -110,134 +110,134 @@ const NavigationController = (function () {
         // TODO(jeremy): enumerate all the cases in which this can happen. If
         // the only one is with a bad scheme, perhaps ERR_INVALID_ARGUMENT
         // would be more appropriate.
-        rejectAndCleanup(-2, 'ERR_FAILED', url)
-      }
+        rejectAndCleanup(-2, 'ERR_FAILED', url);
+      };
       const removeListeners = () => {
-        this.webContents.removeListener('did-finish-load', finishListener)
-        this.webContents.removeListener('did-fail-load', failListener)
-        this.webContents.removeListener('did-start-navigation', navigationListener)
-        this.webContents.removeListener('did-stop-loading', stopLoadingListener)
-      }
-      this.webContents.on('did-finish-load', finishListener)
-      this.webContents.on('did-fail-load', failListener)
-      this.webContents.on('did-start-navigation', navigationListener)
-      this.webContents.on('did-stop-loading', stopLoadingListener)
-    })
+        this.webContents.removeListener('did-finish-load', finishListener);
+        this.webContents.removeListener('did-fail-load', failListener);
+        this.webContents.removeListener('did-start-navigation', navigationListener);
+        this.webContents.removeListener('did-stop-loading', stopLoadingListener);
+      };
+      this.webContents.on('did-finish-load', finishListener);
+      this.webContents.on('did-fail-load', failListener);
+      this.webContents.on('did-start-navigation', navigationListener);
+      this.webContents.on('did-stop-loading', stopLoadingListener);
+    });
     // Add a no-op rejection handler to silence the unhandled rejection error.
-    p.catch(() => {})
-    this.pendingIndex = -1
-    this.webContents._loadURL(url, options)
-    this.webContents.emit('load-url', url, options)
-    return p
-  }
+    p.catch(() => {});
+    this.pendingIndex = -1;
+    this.webContents._loadURL(url, options);
+    this.webContents.emit('load-url', url, options);
+    return p;
+  };
 
   NavigationController.prototype.getURL = function () {
     if (this.currentIndex === -1) {
-      return ''
+      return '';
     } else {
-      return this.history[this.currentIndex]
+      return this.history[this.currentIndex];
     }
-  }
+  };
 
   NavigationController.prototype.stop = function () {
-    this.pendingIndex = -1
-    return this.webContents._stop()
-  }
+    this.pendingIndex = -1;
+    return this.webContents._stop();
+  };
 
   NavigationController.prototype.reload = function () {
-    this.pendingIndex = this.currentIndex
-    return this.webContents._loadURL(this.getURL(), {})
-  }
+    this.pendingIndex = this.currentIndex;
+    return this.webContents._loadURL(this.getURL(), {});
+  };
 
   NavigationController.prototype.reloadIgnoringCache = function () {
-    this.pendingIndex = this.currentIndex
+    this.pendingIndex = this.currentIndex;
     return this.webContents._loadURL(this.getURL(), {
       extraHeaders: 'pragma: no-cache\n',
       reloadIgnoringCache: true
-    })
-  }
+    });
+  };
 
   NavigationController.prototype.canGoBack = function () {
-    return this.getActiveIndex() > 0
-  }
+    return this.getActiveIndex() > 0;
+  };
 
   NavigationController.prototype.canGoForward = function () {
-    return this.getActiveIndex() < this.history.length - 1
-  }
+    return this.getActiveIndex() < this.history.length - 1;
+  };
 
   NavigationController.prototype.canGoToIndex = function (index) {
-    return index >= 0 && index < this.history.length
-  }
+    return index >= 0 && index < this.history.length;
+  };
 
   NavigationController.prototype.canGoToOffset = function (offset) {
-    return this.canGoToIndex(this.currentIndex + offset)
-  }
+    return this.canGoToIndex(this.currentIndex + offset);
+  };
 
   NavigationController.prototype.clearHistory = function () {
-    this.history = []
-    this.currentIndex = -1
-    this.pendingIndex = -1
-    this.inPageIndex = -1
-  }
+    this.history = [];
+    this.currentIndex = -1;
+    this.pendingIndex = -1;
+    this.inPageIndex = -1;
+  };
 
   NavigationController.prototype.goBack = function () {
     if (!this.canGoBack()) {
-      return
+      return;
     }
-    this.pendingIndex = this.getActiveIndex() - 1
+    this.pendingIndex = this.getActiveIndex() - 1;
     if (this.inPageIndex > -1 && this.pendingIndex >= this.inPageIndex) {
-      return this.webContents._goBack()
+      return this.webContents._goBack();
     } else {
-      return this.webContents._loadURL(this.history[this.pendingIndex], {})
+      return this.webContents._loadURL(this.history[this.pendingIndex], {});
     }
-  }
+  };
 
   NavigationController.prototype.goForward = function () {
     if (!this.canGoForward()) {
-      return
+      return;
     }
-    this.pendingIndex = this.getActiveIndex() + 1
+    this.pendingIndex = this.getActiveIndex() + 1;
     if (this.inPageIndex > -1 && this.pendingIndex >= this.inPageIndex) {
-      return this.webContents._goForward()
+      return this.webContents._goForward();
     } else {
-      return this.webContents._loadURL(this.history[this.pendingIndex], {})
+      return this.webContents._loadURL(this.history[this.pendingIndex], {});
     }
-  }
+  };
 
   NavigationController.prototype.goToIndex = function (index) {
     if (!this.canGoToIndex(index)) {
-      return
+      return;
     }
-    this.pendingIndex = index
-    return this.webContents._loadURL(this.history[this.pendingIndex], {})
-  }
+    this.pendingIndex = index;
+    return this.webContents._loadURL(this.history[this.pendingIndex], {});
+  };
 
   NavigationController.prototype.goToOffset = function (offset) {
     if (!this.canGoToOffset(offset)) {
-      return
+      return;
     }
-    const pendingIndex = this.currentIndex + offset
+    const pendingIndex = this.currentIndex + offset;
     if (this.inPageIndex > -1 && pendingIndex >= this.inPageIndex) {
-      this.pendingIndex = pendingIndex
-      return this.webContents._goToOffset(offset)
+      this.pendingIndex = pendingIndex;
+      return this.webContents._goToOffset(offset);
     } else {
-      return this.goToIndex(pendingIndex)
+      return this.goToIndex(pendingIndex);
     }
-  }
+  };
 
   NavigationController.prototype.getActiveIndex = function () {
     if (this.pendingIndex === -1) {
-      return this.currentIndex
+      return this.currentIndex;
     } else {
-      return this.pendingIndex
+      return this.pendingIndex;
     }
-  }
+  };
 
   NavigationController.prototype.length = function () {
-    return this.history.length
-  }
+    return this.history.length;
+  };
 
-  return NavigationController
-})()
+  return NavigationController;
+})();
 
-module.exports = NavigationController
+module.exports = NavigationController;

lib/browser/remote/objects-registry.ts

@@ -1,12 +1,12 @@
-'use strict'
+'use strict';
 
-import { WebContents } from 'electron'
+import { WebContents } from 'electron';
 
-const v8Util = process.electronBinding('v8_util')
+const v8Util = process.electronBinding('v8_util');
 
 const getOwnerKey = (webContents: WebContents, contextId: string) => {
-  return `${webContents.id}-${contextId}`
-}
+  return `${webContents.id}-${contextId}`;
+};
 
 class ObjectsRegistry {
   private nextId: number = 0
@@ -23,29 +23,29 @@ class ObjectsRegistry {
   // registered then the already assigned ID would be returned.
   add (webContents: WebContents, contextId: string, obj: any) {
     // Get or assign an ID to the object.
-    const id = this.saveToStorage(obj)
+    const id = this.saveToStorage(obj);
 
     // Add object to the set of referenced objects.
-    const ownerKey = getOwnerKey(webContents, contextId)
-    let owner = this.owners[ownerKey]
+    const ownerKey = getOwnerKey(webContents, contextId);
+    let owner = this.owners[ownerKey];
     if (!owner) {
-      owner = this.owners[ownerKey] = new Map()
-      this.registerDeleteListener(webContents, contextId)
+      owner = this.owners[ownerKey] = new Map();
+      this.registerDeleteListener(webContents, contextId);
     }
     if (!owner.has(id)) {
-      owner.set(id, 0)
+      owner.set(id, 0);
       // Increase reference count if not referenced before.
-      this.storage[id].count++
+      this.storage[id].count++;
     }
 
-    owner.set(id, owner.get(id)! + 1)
-    return id
+    owner.set(id, owner.get(id)! + 1);
+    return id;
   }
 
   // Get an object according to its ID.
   get (id: number) {
-    const pointer = this.storage[id]
-    if (pointer != null) return pointer.object
+    const pointer = this.storage[id];
+    if (pointer != null) return pointer.object;
   }
 
   // Dereference an object according to its ID.
@@ -60,79 +60,79 @@ class ObjectsRegistry {
   // For more details on why we do renderer side ref counting see
   // https://github.com/electron/electron/pull/17464
   remove (webContents: WebContents, contextId: string, id: number, rendererSideRefCount: number) {
-    const ownerKey = getOwnerKey(webContents, contextId)
-    const owner = this.owners[ownerKey]
+    const ownerKey = getOwnerKey(webContents, contextId);
+    const owner = this.owners[ownerKey];
     if (owner && owner.has(id)) {
-      const newRefCount = owner.get(id)! - rendererSideRefCount
+      const newRefCount = owner.get(id)! - rendererSideRefCount;
 
       // Only completely remove if the number of references GCed in the
       // renderer is the same as the number of references we sent them
       if (newRefCount <= 0) {
         // Remove the reference in owner.
-        owner.delete(id)
+        owner.delete(id);
         // Dereference from the storage.
-        this.dereference(id)
+        this.dereference(id);
       } else {
-        owner.set(id, newRefCount)
+        owner.set(id, newRefCount);
       }
     }
   }
 
   // Clear all references to objects refrenced by the WebContents.
   clear (webContents: WebContents, contextId: string) {
-    const ownerKey = getOwnerKey(webContents, contextId)
-    const owner = this.owners[ownerKey]
-    if (!owner) return
+    const ownerKey = getOwnerKey(webContents, contextId);
+    const owner = this.owners[ownerKey];
+    if (!owner) return;
 
-    for (const id of owner.keys()) this.dereference(id)
+    for (const id of owner.keys()) this.dereference(id);
 
-    delete this.owners[ownerKey]
+    delete this.owners[ownerKey];
   }
 
   // Private: Saves the object into storage and assigns an ID for it.
   saveToStorage (object: any) {
-    let id: number = v8Util.getHiddenValue(object, 'atomId')
+    let id: number = v8Util.getHiddenValue(object, 'atomId');
     if (!id) {
-      id = ++this.nextId
+      id = ++this.nextId;
       this.storage[id] = {
         count: 0,
         object: object
-      }
-      v8Util.setHiddenValue(object, 'atomId', id)
+      };
+      v8Util.setHiddenValue(object, 'atomId', id);
     }
-    return id
+    return id;
   }
 
   // Private: Dereference the object from store.
   dereference (id: number) {
-    const pointer = this.storage[id]
+    const pointer = this.storage[id];
     if (pointer == null) {
-      return
+      return;
     }
-    pointer.count -= 1
+    pointer.count -= 1;
     if (pointer.count === 0) {
-      v8Util.deleteHiddenValue(pointer.object, 'atomId')
-      delete this.storage[id]
+      v8Util.deleteHiddenValue(pointer.object, 'atomId');
+      delete this.storage[id];
     }
   }
 
   // Private: Clear the storage when renderer process is destroyed.
   registerDeleteListener (webContents: WebContents, contextId: string) {
     // contextId => ${processHostId}-${contextCount}
-    const processHostId = contextId.split('-')[0]
+    const processHostId = contextId.split('-')[0];
     const listener = (_: any, deletedProcessHostId: string) => {
       if (deletedProcessHostId &&
           deletedProcessHostId.toString() === processHostId) {
-        webContents.removeListener('render-view-deleted' as any, listener)
-        this.clear(webContents, contextId)
+        webContents.removeListener('render-view-deleted' as any, listener);
+        this.clear(webContents, contextId);
       }
-    }
+    };
     // Note that the "render-view-deleted" event may not be emitted on time when
     // the renderer process get destroyed because of navigation, we rely on the
     // renderer process to send "ELECTRON_BROWSER_CONTEXT_RELEASE" message to
     // guard this situation.
-    webContents.on('render-view-deleted' as any, listener)
+    webContents.on('render-view-deleted' as any, listener);
   }
 }
 
-export default new ObjectsRegistry()
+export default new ObjectsRegistry();

lib/browser/remote/server.ts

@@ -1,29 +1,29 @@
-'use strict'
+'use strict';
 
-import * as electron from 'electron'
-import { EventEmitter } from 'events'
-import objectsRegistry from './objects-registry'
-import { ipcMainInternal } from '../ipc-main-internal'
-import { isPromise, isSerializableObject } from '@electron/internal/common/type-utils'
+import * as electron from 'electron';
+import { EventEmitter } from 'events';
+import objectsRegistry from './objects-registry';
+import { ipcMainInternal } from '../ipc-main-internal';
+import { isPromise, isSerializableObject } from '@electron/internal/common/type-utils';
 
-const v8Util = process.electronBinding('v8_util')
-const eventBinding = process.electronBinding('event')
-const features = process.electronBinding('features')
+const v8Util = process.electronBinding('v8_util');
+const eventBinding = process.electronBinding('event');
+const features = process.electronBinding('features');
 
 if (!features.isRemoteModuleEnabled()) {
-  throw new Error('remote module is disabled')
+  throw new Error('remote module is disabled');
 }
 
-const hasProp = {}.hasOwnProperty
+const hasProp = {}.hasOwnProperty;
 
 // The internal properties of Function.
 const FUNCTION_PROPERTIES = [
   'length', 'name', 'arguments', 'caller', 'prototype'
-]
+];
 
 // The remote functions in renderer processes.
 // id => Function
-const rendererFunctions = v8Util.createDoubleIDWeakMap<(...args: any[]) => void>()
+const rendererFunctions = v8Util.createDoubleIDWeakMap<(...args: any[]) => void>();
 
 type ObjectMember = {
   name: string,
@@ -35,28 +35,28 @@ type ObjectMember = {
 
 // Return the description of object's members:
 const getObjectMembers = function (object: any): ObjectMember[] {
-  let names = Object.getOwnPropertyNames(object)
+  let names = Object.getOwnPropertyNames(object);
   // For Function, we should not override following properties even though they
   // are "own" properties.
   if (typeof object === 'function') {
     names = names.filter((name) => {
-      return !FUNCTION_PROPERTIES.includes(name)
-    })
+      return !FUNCTION_PROPERTIES.includes(name);
+    });
   }
   // Map properties to descriptors.
   return names.map((name) => {
-    const descriptor = Object.getOwnPropertyDescriptor(object, name)!
-    let type: ObjectMember['type']
-    let writable = false
+    const descriptor = Object.getOwnPropertyDescriptor(object, name)!;
+    let type: ObjectMember['type'];
+    let writable = false;
     if (descriptor.get === undefined && typeof object[name] === 'function') {
-      type = 'method'
+      type = 'method';
     } else {
-      if (descriptor.set || descriptor.writable) writable = true
-      type = 'get'
+      if (descriptor.set || descriptor.writable) writable = true;
+      type = 'get';
     }
-    return { name, enumerable: descriptor.enumerable, writable, type }
-  })
-}
+    return { name, enumerable: descriptor.enumerable, writable, type };
+  });
+};
 
 type ObjProtoDescriptor = {
   members: ObjectMember[],
@@ -65,13 +65,13 @@ type ObjProtoDescriptor = {
 
 // Return the description of object's prototype.
 const getObjectPrototype = function (object: any): ObjProtoDescriptor {
-  const proto = Object.getPrototypeOf(object)
-  if (proto === null || proto === Object.prototype) return null
+  const proto = Object.getPrototypeOf(object);
+  if (proto === null || proto === Object.prototype) return null;
   return {
     members: getObjectMembers(proto),
     proto: getObjectPrototype(proto)
-  }
-}
+  };
+};
 
 type MetaType = {
   type: 'number',
@@ -118,25 +118,25 @@ type MetaType = {
 // Convert a real value into meta data.
 const valueToMeta = function (sender: electron.WebContents, contextId: string, value: any, optimizeSimpleObject = false): MetaType {
   // Determine the type of value.
-  let type: MetaType['type'] = typeof value
+  let type: MetaType['type'] = typeof value;
   if (type === 'object') {
     // Recognize certain types of objects.
     if (value instanceof Buffer) {
-      type = 'buffer'
+      type = 'buffer';
     } else if (Array.isArray(value)) {
-      type = 'array'
+      type = 'array';
     } else if (value instanceof Error) {
-      type = 'error'
+      type = 'error';
     } else if (isSerializableObject(value)) {
-      type = 'value'
+      type = 'value';
     } else if (isPromise(value)) {
-      type = 'promise'
+      type = 'promise';
     } else if (hasProp.call(value, 'callee') && value.length != null) {
       // Treat the arguments object as array.
-      type = 'array'
+      type = 'array';
     } else if (optimizeSimpleObject && v8Util.getHiddenValue(value, 'simple')) {
       // Treat simple objects as value.
-      type = 'value'
+      type = 'value';
     }
   }
 
@@ -145,7 +145,7 @@ const valueToMeta = function (sender: electron.WebContents, contextId: string, v
     return {
       type,
       members: value.map((el: any) => valueToMeta(sender, contextId, el, optimizeSimpleObject))
-    }
+    };
   } else if (type === 'object' || type === 'function') {
     return {
       type,
@@ -156,20 +156,20 @@ const valueToMeta = function (sender: electron.WebContents, contextId: string, v
       id: objectsRegistry.add(sender, contextId, value),
       members: getObjectMembers(value),
       proto: getObjectPrototype(value)
-    }
+    };
   } else if (type === 'buffer') {
-    return { type, value }
+    return { type, value };
   } else if (type === 'promise') {
     // Add default handler to prevent unhandled rejections in main process
     // Instead they should appear in the renderer process
-    value.then(function () {}, function () {})
+    value.then(function () {}, function () {});
 
     return {
       type,
       then: valueToMeta(sender, contextId, function (onFulfilled: Function, onRejected: Function) {
-        value.then(onFulfilled, onRejected)
+        value.then(onFulfilled, onRejected);
       })
-    }
+    };
   } else if (type === 'error') {
     return {
       type,
@@ -178,42 +178,42 @@ const valueToMeta = function (sender: electron.WebContents, contextId: string, v
         name,
         value: valueToMeta(sender, contextId, value[name])
       }))
-    }
+    };
   } else {
     return {
       type: 'value',
       value
-    }
+    };
   }
-}
+};
 
 const throwRPCError = function (message: string) {
-  const error = new Error(message) as Error & {code: string, errno: number}
-  error.code = 'EBADRPC'
-  error.errno = -72
-  throw error
-}
+  const error = new Error(message) as Error & {code: string, errno: number};
+  error.code = 'EBADRPC';
+  error.errno = -72;
+  throw error;
+};
 
 const removeRemoteListenersAndLogWarning = (sender: any, callIntoRenderer: (...args: any[]) => void) => {
-  const location = v8Util.getHiddenValue(callIntoRenderer, 'location')
+  const location = v8Util.getHiddenValue(callIntoRenderer, 'location');
   let message = `Attempting to call a function in a renderer window that has been closed or released.` +
-    `\nFunction provided here: ${location}`
+    `\nFunction provided here: ${location}`;
 
   if (sender instanceof EventEmitter) {
     const remoteEvents = sender.eventNames().filter((eventName) => {
-      return sender.listeners(eventName).includes(callIntoRenderer)
-    })
+      return sender.listeners(eventName).includes(callIntoRenderer);
+    });
 
     if (remoteEvents.length > 0) {
-      message += `\nRemote event names: ${remoteEvents.join(', ')}`
+      message += `\nRemote event names: ${remoteEvents.join(', ')}`;
       remoteEvents.forEach((eventName) => {
-        sender.removeListener(eventName as any, callIntoRenderer)
-      })
+        sender.removeListener(eventName as any, callIntoRenderer);
+      });
     }
   }
 
-  console.warn(message)
-}
+  console.warn(message);
+};
 
 type MetaTypeFromRenderer = {
   type: 'value',
@@ -248,300 +248,300 @@ const fakeConstructor = (constructor: Function, name: string) =>
   new Proxy(Object, {
     get (target, prop, receiver) {
       if (prop === 'name') {
-        return name
+        return name;
       } else {
-        return Reflect.get(target, prop, receiver)
+        return Reflect.get(target, prop, receiver);
       }
     }
-  })
+  });
 
 // Convert array of meta data from renderer into array of real values.
 const unwrapArgs = function (sender: electron.WebContents, frameId: number, contextId: string, args: any[]) {
   const metaToValue = function (meta: MetaTypeFromRenderer): any {
     switch (meta.type) {
       case 'value':
-        return meta.value
+        return meta.value;
       case 'remote-object':
-        return objectsRegistry.get(meta.id)
+        return objectsRegistry.get(meta.id);
       case 'array':
-        return unwrapArgs(sender, frameId, contextId, meta.value)
+        return unwrapArgs(sender, frameId, contextId, meta.value);
       case 'buffer':
-        return Buffer.from(meta.value.buffer, meta.value.byteOffset, meta.value.byteLength)
+        return Buffer.from(meta.value.buffer, meta.value.byteOffset, meta.value.byteLength);
       case 'promise':
         return Promise.resolve({
           then: metaToValue(meta.then)
-        })
+        });
       case 'object': {
         const ret: any = meta.name !== 'Object' ? Object.create({
           constructor: fakeConstructor(Object, meta.name)
-        }) : {}
+        }) : {};
 
         for (const { name, value } of meta.members) {
-          ret[name] = metaToValue(value)
+          ret[name] = metaToValue(value);
         }
-        return ret
+        return ret;
       }
       case 'function-with-return-value':
-        const returnValue = metaToValue(meta.value)
+        const returnValue = metaToValue(meta.value);
         return function () {
-          return returnValue
-        }
+          return returnValue;
+        };
       case 'function': {
         // Merge contextId and meta.id, since meta.id can be the same in
         // different webContents.
-        const objectId: [string, number] = [contextId, meta.id]
+        const objectId: [string, number] = [contextId, meta.id];
 
         // Cache the callbacks in renderer.
         if (rendererFunctions.has(objectId)) {
-          return rendererFunctions.get(objectId)
+          return rendererFunctions.get(objectId);
         }
 
         const callIntoRenderer = function (this: any, ...args: any[]) {
-          let succeed = false
+          let succeed = false;
           if (!sender.isDestroyed()) {
-            succeed = (sender as any)._sendToFrameInternal(frameId, 'ELECTRON_RENDERER_CALLBACK', contextId, meta.id, valueToMeta(sender, contextId, args))
+            succeed = (sender as any)._sendToFrameInternal(frameId, 'ELECTRON_RENDERER_CALLBACK', contextId, meta.id, valueToMeta(sender, contextId, args));
           }
           if (!succeed) {
-            removeRemoteListenersAndLogWarning(this, callIntoRenderer)
+            removeRemoteListenersAndLogWarning(this, callIntoRenderer);
           }
-        }
-        v8Util.setHiddenValue(callIntoRenderer, 'location', meta.location)
-        Object.defineProperty(callIntoRenderer, 'length', { value: meta.length })
+        };
+        v8Util.setHiddenValue(callIntoRenderer, 'location', meta.location);
+        Object.defineProperty(callIntoRenderer, 'length', { value: meta.length });
 
-        v8Util.setRemoteCallbackFreer(callIntoRenderer, frameId, contextId, meta.id, sender)
-        rendererFunctions.set(objectId, callIntoRenderer)
-        return callIntoRenderer
+        v8Util.setRemoteCallbackFreer(callIntoRenderer, frameId, contextId, meta.id, sender);
+        rendererFunctions.set(objectId, callIntoRenderer);
+        return callIntoRenderer;
       }
       default:
-        throw new TypeError(`Unknown type: ${(meta as any).type}`)
+        throw new TypeError(`Unknown type: ${(meta as any).type}`);
     }
-  }
-  return args.map(metaToValue)
-}
+  };
+  return args.map(metaToValue);
+};
 
 const isRemoteModuleEnabledImpl = function (contents: electron.WebContents) {
-  const webPreferences = (contents as any).getLastWebPreferences() || {}
-  return webPreferences.enableRemoteModule != null ? !!webPreferences.enableRemoteModule : true
-}
+  const webPreferences = (contents as any).getLastWebPreferences() || {};
+  return webPreferences.enableRemoteModule != null ? !!webPreferences.enableRemoteModule : true;
+};
 
-const isRemoteModuleEnabledCache = new WeakMap()
+const isRemoteModuleEnabledCache = new WeakMap();
 
 const isRemoteModuleEnabled = function (contents: electron.WebContents) {
   if (!isRemoteModuleEnabledCache.has(contents)) {
-    isRemoteModuleEnabledCache.set(contents, isRemoteModuleEnabledImpl(contents))
+    isRemoteModuleEnabledCache.set(contents, isRemoteModuleEnabledImpl(contents));
   }
 
-  return isRemoteModuleEnabledCache.get(contents)
-}
+  return isRemoteModuleEnabledCache.get(contents);
+};
 
 const handleRemoteCommand = function (channel: string, handler: (event: ElectronInternal.IpcMainInternalEvent, contextId: string, ...args: any[]) => void) {
   ipcMainInternal.on(channel, (event, contextId: string, ...args: any[]) => {
-    let returnValue
+    let returnValue;
     if (!isRemoteModuleEnabled(event.sender)) {
-      event.returnValue = null
-      return
+      event.returnValue = null;
+      return;
     }
 
     try {
-      returnValue = handler(event, contextId, ...args)
+      returnValue = handler(event, contextId, ...args);
     } catch (error) {
       returnValue = {
         type: 'exception',
         value: valueToMeta(event.sender, contextId, error)
-      }
+      };
     }
 
     if (returnValue !== undefined) {
-      event.returnValue = returnValue
+      event.returnValue = returnValue;
     }
-  })
-}
+  });
+};
 
 const emitCustomEvent = function (contents: electron.WebContents, eventName: string, ...args: any[]) {
-  const event = eventBinding.createWithSender(contents)
+  const event = eventBinding.createWithSender(contents);
 
-  electron.app.emit(eventName, event, contents, ...args)
-  contents.emit(eventName, event, ...args)
+  electron.app.emit(eventName, event, contents, ...args);
+  contents.emit(eventName, event, ...args);
 
-  return event
-}
+  return event;
+};
 
 const logStack = function (contents: electron.WebContents, code: string, stack: string | undefined) {
   if (stack) {
-    console.warn(`WebContents (${contents.id}): ${code}`, stack)
+    console.warn(`WebContents (${contents.id}): ${code}`, stack);
   }
-}
+};
 
 handleRemoteCommand('ELECTRON_BROWSER_WRONG_CONTEXT_ERROR', function (event, contextId, passedContextId, id) {
-  const objectId: [string, number] = [passedContextId, id]
+  const objectId: [string, number] = [passedContextId, id];
   if (!rendererFunctions.has(objectId)) {
     // Do nothing if the error has already been reported before.
-    return
+    return;
   }
-  removeRemoteListenersAndLogWarning(event.sender, rendererFunctions.get(objectId)!)
-})
+  removeRemoteListenersAndLogWarning(event.sender, rendererFunctions.get(objectId)!);
+});
 
 handleRemoteCommand('ELECTRON_BROWSER_REQUIRE', function (event, contextId, moduleName, stack) {
-  logStack(event.sender, `remote.require('${moduleName}')`, stack)
-  const customEvent = emitCustomEvent(event.sender, 'remote-require', moduleName)
+  logStack(event.sender, `remote.require('${moduleName}')`, stack);
+  const customEvent = emitCustomEvent(event.sender, 'remote-require', moduleName);
 
   if (customEvent.returnValue === undefined) {
     if (customEvent.defaultPrevented) {
-      throw new Error(`Blocked remote.require('${moduleName}')`)
+      throw new Error(`Blocked remote.require('${moduleName}')`);
     } else {
-      customEvent.returnValue = process.mainModule!.require(moduleName)
+      customEvent.returnValue = process.mainModule!.require(moduleName);
     }
   }
 
-  return valueToMeta(event.sender, contextId, customEvent.returnValue)
-})
+  return valueToMeta(event.sender, contextId, customEvent.returnValue);
+});
 
 handleRemoteCommand('ELECTRON_BROWSER_GET_BUILTIN', function (event, contextId, moduleName, stack) {
-  logStack(event.sender, `remote.getBuiltin('${moduleName}')`, stack)
-  const customEvent = emitCustomEvent(event.sender, 'remote-get-builtin', moduleName)
+  logStack(event.sender, `remote.getBuiltin('${moduleName}')`, stack);
+  const customEvent = emitCustomEvent(event.sender, 'remote-get-builtin', moduleName);
 
   if (customEvent.returnValue === undefined) {
     if (customEvent.defaultPrevented) {
-      throw new Error(`Blocked remote.getBuiltin('${moduleName}')`)
+      throw new Error(`Blocked remote.getBuiltin('${moduleName}')`);
     } else {
-      customEvent.returnValue = (electron as any)[moduleName]
+      customEvent.returnValue = (electron as any)[moduleName];
     }
   }
 
-  return valueToMeta(event.sender, contextId, customEvent.returnValue)
-})
+  return valueToMeta(event.sender, contextId, customEvent.returnValue);
+});
 
 handleRemoteCommand('ELECTRON_BROWSER_GLOBAL', function (event, contextId, globalName, stack) {
-  logStack(event.sender, `remote.getGlobal('${globalName}')`, stack)
-  const customEvent = emitCustomEvent(event.sender, 'remote-get-global', globalName)
+  logStack(event.sender, `remote.getGlobal('${globalName}')`, stack);
+  const customEvent = emitCustomEvent(event.sender, 'remote-get-global', globalName);
 
   if (customEvent.returnValue === undefined) {
     if (customEvent.defaultPrevented) {
-      throw new Error(`Blocked remote.getGlobal('${globalName}')`)
+      throw new Error(`Blocked remote.getGlobal('${globalName}')`);
     } else {
-      customEvent.returnValue = (global as any)[globalName]
+      customEvent.returnValue = (global as any)[globalName];
     }
   }
 
-  return valueToMeta(event.sender, contextId, customEvent.returnValue)
-})
+  return valueToMeta(event.sender, contextId, customEvent.returnValue);
+});
 
 handleRemoteCommand('ELECTRON_BROWSER_CURRENT_WINDOW', function (event, contextId, stack) {
-  logStack(event.sender, 'remote.getCurrentWindow()', stack)
-  const customEvent = emitCustomEvent(event.sender, 'remote-get-current-window')
+  logStack(event.sender, 'remote.getCurrentWindow()', stack);
+  const customEvent = emitCustomEvent(event.sender, 'remote-get-current-window');
 
   if (customEvent.returnValue === undefined) {
     if (customEvent.defaultPrevented) {
-      throw new Error('Blocked remote.getCurrentWindow()')
+      throw new Error('Blocked remote.getCurrentWindow()');
     } else {
-      customEvent.returnValue = event.sender.getOwnerBrowserWindow()
+      customEvent.returnValue = event.sender.getOwnerBrowserWindow();
     }
   }
 
-  return valueToMeta(event.sender, contextId, customEvent.returnValue)
-})
+  return valueToMeta(event.sender, contextId, customEvent.returnValue);
+});
 
 handleRemoteCommand('ELECTRON_BROWSER_CURRENT_WEB_CONTENTS', function (event, contextId, stack) {
-  logStack(event.sender, 'remote.getCurrentWebContents()', stack)
-  const customEvent = emitCustomEvent(event.sender, 'remote-get-current-web-contents')
+  logStack(event.sender, 'remote.getCurrentWebContents()', stack);
+  const customEvent = emitCustomEvent(event.sender, 'remote-get-current-web-contents');
 
   if (customEvent.returnValue === undefined) {
     if (customEvent.defaultPrevented) {
-      throw new Error('Blocked remote.getCurrentWebContents()')
+      throw new Error('Blocked remote.getCurrentWebContents()');
     } else {
-      customEvent.returnValue = event.sender
+      customEvent.returnValue = event.sender;
     }
   }
 
-  return valueToMeta(event.sender, contextId, customEvent.returnValue)
-})
+  return valueToMeta(event.sender, contextId, customEvent.returnValue);
+});
 
 handleRemoteCommand('ELECTRON_BROWSER_CONSTRUCTOR', function (event, contextId, id, args) {
-  args = unwrapArgs(event.sender, event.frameId, contextId, args)
-  const constructor = objectsRegistry.get(id)
+  args = unwrapArgs(event.sender, event.frameId, contextId, args);
+  const constructor = objectsRegistry.get(id);
 
   if (constructor == null) {
-    throwRPCError(`Cannot call constructor on missing remote object ${id}`)
+    throwRPCError(`Cannot call constructor on missing remote object ${id}`);
   }
 
-  return valueToMeta(event.sender, contextId, new constructor(...args))
-})
+  return valueToMeta(event.sender, contextId, new constructor(...args));
+});
 
 handleRemoteCommand('ELECTRON_BROWSER_FUNCTION_CALL', function (event, contextId, id, args) {
-  args = unwrapArgs(event.sender, event.frameId, contextId, args)
-  const func = objectsRegistry.get(id)
+  args = unwrapArgs(event.sender, event.frameId, contextId, args);
+  const func = objectsRegistry.get(id);
 
   if (func == null) {
-    throwRPCError(`Cannot call function on missing remote object ${id}`)
+    throwRPCError(`Cannot call function on missing remote object ${id}`);
   }
 
   try {
-    return valueToMeta(event.sender, contextId, func(...args), true)
+    return valueToMeta(event.sender, contextId, func(...args), true);
   } catch (error) {
     const err = new Error(`Could not call remote function '${func.name || 'anonymous'}'. Check that the function signature is correct. Underlying error: ${error.message}\nUnderlying stack: ${error.stack}\n`);
-    (err as any).cause = error
-    throw err
+    (err as any).cause = error;
+    throw err;
   }
-})
+});
 
 handleRemoteCommand('ELECTRON_BROWSER_MEMBER_CONSTRUCTOR', function (event, contextId, id, method, args) {
-  args = unwrapArgs(event.sender, event.frameId, contextId, args)
-  const object = objectsRegistry.get(id)
+  args = unwrapArgs(event.sender, event.frameId, contextId, args);
+  const object = objectsRegistry.get(id);
 
   if (object == null) {
-    throwRPCError(`Cannot call constructor '${method}' on missing remote object ${id}`)
+    throwRPCError(`Cannot call constructor '${method}' on missing remote object ${id}`);
   }
 
-  return valueToMeta(event.sender, contextId, new object[method](...args))
-})
+  return valueToMeta(event.sender, contextId, new object[method](...args));
+});
 
 handleRemoteCommand('ELECTRON_BROWSER_MEMBER_CALL', function (event, contextId, id, method, args) {
-  args = unwrapArgs(event.sender, event.frameId, contextId, args)
-  const object = objectsRegistry.get(id)
+  args = unwrapArgs(event.sender, event.frameId, contextId, args);
+  const object = objectsRegistry.get(id);
 
   if (object == null) {
-    throwRPCError(`Cannot call method '${method}' on missing remote object ${id}`)
+    throwRPCError(`Cannot call method '${method}' on missing remote object ${id}`);
   }
 
   try {
-    return valueToMeta(event.sender, contextId, object[method](...args), true)
+    return valueToMeta(event.sender, contextId, object[method](...args), true);
   } catch (error) {
     const err = new Error(`Could not call remote method '${method}'. Check that the method signature is correct. Underlying error: ${error.message}\nUnderlying stack: ${error.stack}\n`);
-    (err as any).cause = error
-    throw err
+    (err as any).cause = error;
+    throw err;
   }
-})
+});
 
 handleRemoteCommand('ELECTRON_BROWSER_MEMBER_SET', function (event, contextId, id, name, args) {
-  args = unwrapArgs(event.sender, event.frameId, contextId, args)
-  const obj = objectsRegistry.get(id)
+  args = unwrapArgs(event.sender, event.frameId, contextId, args);
+  const obj = objectsRegistry.get(id);
 
   if (obj == null) {
-    throwRPCError(`Cannot set property '${name}' on missing remote object ${id}`)
+    throwRPCError(`Cannot set property '${name}' on missing remote object ${id}`);
   }
 
-  obj[name] = args[0]
-  return null
-})
+  obj[name] = args[0];
+  return null;
+});
 
 handleRemoteCommand('ELECTRON_BROWSER_MEMBER_GET', function (event, contextId, id, name) {
-  const obj = objectsRegistry.get(id)
+  const obj = objectsRegistry.get(id);
 
   if (obj == null) {
-    throwRPCError(`Cannot get property '${name}' on missing remote object ${id}`)
+    throwRPCError(`Cannot get property '${name}' on missing remote object ${id}`);
   }
 
-  return valueToMeta(event.sender, contextId, obj[name])
-})
+  return valueToMeta(event.sender, contextId, obj[name]);
+});
 
 handleRemoteCommand('ELECTRON_BROWSER_DEREFERENCE', function (event, contextId, id, rendererSideRefCount) {
-  objectsRegistry.remove(event.sender, contextId, id, rendererSideRefCount)
-})
+  objectsRegistry.remove(event.sender, contextId, id, rendererSideRefCount);
+});
 
 handleRemoteCommand('ELECTRON_BROWSER_CONTEXT_RELEASE', (event, contextId) => {
-  objectsRegistry.clear(event.sender, contextId)
-})
+  objectsRegistry.clear(event.sender, contextId);
+});
 
 module.exports = {
   isRemoteModuleEnabled
-}
+};

lib/browser/rpc-server.js

@@ -1,118 +1,118 @@
-'use strict'
+'use strict';
 
-const electron = require('electron')
-const fs = require('fs')
+const electron = require('electron');
+const fs = require('fs');
 
-const eventBinding = process.electronBinding('event')
-const clipboard = process.electronBinding('clipboard')
-const features = process.electronBinding('features')
+const eventBinding = process.electronBinding('event');
+const clipboard = process.electronBinding('clipboard');
+const features = process.electronBinding('features');
 
-const { crashReporterInit } = require('@electron/internal/browser/crash-reporter-init')
-const { ipcMainInternal } = require('@electron/internal/browser/ipc-main-internal')
-const ipcMainUtils = require('@electron/internal/browser/ipc-main-internal-utils')
-const guestViewManager = require('@electron/internal/browser/guest-view-manager')
-const typeUtils = require('@electron/internal/common/type-utils')
+const { crashReporterInit } = require('@electron/internal/browser/crash-reporter-init');
+const { ipcMainInternal } = require('@electron/internal/browser/ipc-main-internal');
+const ipcMainUtils = require('@electron/internal/browser/ipc-main-internal-utils');
+const guestViewManager = require('@electron/internal/browser/guest-view-manager');
+const typeUtils = require('@electron/internal/common/type-utils');
 
 const emitCustomEvent = function (contents, eventName, ...args) {
-  const event = eventBinding.createWithSender(contents)
+  const event = eventBinding.createWithSender(contents);
 
-  electron.app.emit(eventName, event, contents, ...args)
-  contents.emit(eventName, event, ...args)
+  electron.app.emit(eventName, event, contents, ...args);
+  contents.emit(eventName, event, ...args);
 
-  return event
-}
+  return event;
+};
 
 const logStack = function (contents, code, stack) {
   if (stack) {
-    console.warn(`WebContents (${contents.id}): ${code}`, stack)
+    console.warn(`WebContents (${contents.id}): ${code}`, stack);
   }
-}
+};
 
 // Implements window.close()
 ipcMainInternal.on('ELECTRON_BROWSER_WINDOW_CLOSE', function (event) {
-  const window = event.sender.getOwnerBrowserWindow()
+  const window = event.sender.getOwnerBrowserWindow();
   if (window) {
-    window.close()
+    window.close();
   }
-  event.returnValue = null
-})
+  event.returnValue = null;
+});
 
 ipcMainUtils.handleSync('ELECTRON_CRASH_REPORTER_INIT', function (event, options) {
-  return crashReporterInit(options)
-})
+  return crashReporterInit(options);
+});
 
 ipcMainInternal.handle('ELECTRON_BROWSER_GET_LAST_WEB_PREFERENCES', function (event) {
-  return event.sender.getLastWebPreferences()
-})
+  return event.sender.getLastWebPreferences();
+});
 
 // Methods not listed in this set are called directly in the renderer process.
 const allowedClipboardMethods = (() => {
   switch (process.platform) {
     case 'darwin':
-      return new Set(['readFindText', 'writeFindText'])
+      return new Set(['readFindText', 'writeFindText']);
     case 'linux':
-      return new Set(Object.keys(clipboard))
+      return new Set(Object.keys(clipboard));
     default:
-      return new Set()
+      return new Set();
   }
-})()
+})();
 
-ipcMainUtils.handleSync('ELECTRON_BROWSER_CLIPBOARD', function (event, method, ...args) {
+ipcMainUtils.handleSync('ELECTRON_BROWSER_CLIPBOARD_SYNC', function (event, method, ...args) {
   if (!allowedClipboardMethods.has(method)) {
-    throw new Error(`Invalid method: ${method}`)
+    throw new Error(`Invalid method: ${method}`);
   }
 
-  return typeUtils.serialize(electron.clipboard[method](...typeUtils.deserialize(args)))
-})
+  return typeUtils.serialize(electron.clipboard[method](...typeUtils.deserialize(args)));
+});
 
 if (features.isDesktopCapturerEnabled()) {
-  const desktopCapturer = require('@electron/internal/browser/desktop-capturer')
+  const desktopCapturer = require('@electron/internal/browser/desktop-capturer');
 
   ipcMainInternal.handle('ELECTRON_BROWSER_DESKTOP_CAPTURER_GET_SOURCES', function (event, options, stack) {
-    logStack(event.sender, 'desktopCapturer.getSources()', stack)
-    const customEvent = emitCustomEvent(event.sender, 'desktop-capturer-get-sources')
+    logStack(event.sender, 'desktopCapturer.getSources()', stack);
+    const customEvent = emitCustomEvent(event.sender, 'desktop-capturer-get-sources');
 
     if (customEvent.defaultPrevented) {
-      console.error('Blocked desktopCapturer.getSources()')
-      return []
+      console.error('Blocked desktopCapturer.getSources()');
+      return [];
     }
 
-    return desktopCapturer.getSources(event, options)
-  })
+    return desktopCapturer.getSources(event, options);
+  });
 }
 
 const isRemoteModuleEnabled = features.isRemoteModuleEnabled()
   ? require('@electron/internal/browser/remote/server').isRemoteModuleEnabled
-  : () => false
+  : () => false;
 
 const getPreloadScript = async function (preloadPath) {
-  let preloadSrc = null
-  let preloadError = null
+  let preloadSrc = null;
+  let preloadError = null;
   try {
-    preloadSrc = (await fs.promises.readFile(preloadPath)).toString()
+    preloadSrc = (await fs.promises.readFile(preloadPath)).toString();
   } catch (error) {
-    preloadError = error
+    preloadError = error;
   }
-  return { preloadPath, preloadSrc, preloadError }
-}
+  return { preloadPath, preloadSrc, preloadError };
+};
 
 if (features.isExtensionsEnabled()) {
-  ipcMainUtils.handleSync('ELECTRON_GET_CONTENT_SCRIPTS', () => [])
+  ipcMainUtils.handleSync('ELECTRON_GET_CONTENT_SCRIPTS', () => []);
 } else {
-  const { getContentScripts } = require('@electron/internal/browser/chrome-extension')
-  ipcMainUtils.handleSync('ELECTRON_GET_CONTENT_SCRIPTS', () => getContentScripts())
+  const { getContentScripts } = require('@electron/internal/browser/chrome-extension');
+  ipcMainUtils.handleSync('ELECTRON_GET_CONTENT_SCRIPTS', () => getContentScripts());
 }
 
 ipcMainUtils.handleSync('ELECTRON_BROWSER_SANDBOX_LOAD', async function (event) {
-  const preloadPaths = event.sender._getPreloadPaths()
+  const preloadPaths = event.sender._getPreloadPaths();
 
-  let contentScripts = []
+  let contentScripts = [];
   if (!features.isExtensionsEnabled()) {
-    const { getContentScripts } = require('@electron/internal/browser/chrome-extension')
-    contentScripts = getContentScripts()
+    const { getContentScripts } = require('@electron/internal/browser/chrome-extension');
+    contentScripts = getContentScripts();
   }
 
-  const webPreferences = event.sender.getLastWebPreferences() || {}
+  const webPreferences = event.sender.getLastWebPreferences() || {};
 
   return {
     contentScripts,
@@ -129,9 +129,9 @@ ipcMainUtils.handleSync('ELECTRON_BROWSER_SANDBOX_LOAD', async function (event)
       versions: process.versions,
       execPath: process.helperExecPath
     }
-  }
-})
+  };
+});
 
 ipcMainInternal.on('ELECTRON_BROWSER_PRELOAD_ERROR', function (event, preloadPath, error) {
-  event.sender.emit('preload-error', event, preloadPath, error)
-})
+  event.sender.emit('preload-error', event, preloadPath, error);
+});

lib/browser/utils.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from 'events'
+import { EventEmitter } from 'events';
 
 /**
 * Creates a lazy instance of modules that can't be required before the
@@ -16,23 +16,23 @@ export function createLazyInstance (
   holder: Object,
   isEventEmitter: Boolean
 ) {
-  let lazyModule: Object
-  const module: any = {}
-  for (const method in (holder as any).prototype) {
+  let lazyModule: Object;
+  const module: any = {};
+  for (const method in (holder as any).prototype) { // eslint-disable-line guard-for-in
     module[method] = (...args: any) => {
       // create new instance of module at runtime if none exists
       if (!lazyModule) {
-        lazyModule = creator()
-        if (isEventEmitter) EventEmitter.call(lazyModule as any)
+        lazyModule = creator();
+        if (isEventEmitter) EventEmitter.call(lazyModule as any);
       }
 
       // check for properties on the prototype chain that aren't functions
       if (typeof (lazyModule as any)[method] !== 'function') {
-        return (lazyModule as any)[method]
+        return (lazyModule as any)[method];
       }
 
-      return (lazyModule as any)[method](...args)
-    }
+      return (lazyModule as any)[method](...args);
+    };
   }
-  return module
+  return module;
 }

lib/common/api/clipboard.js

@@ -1,29 +1,29 @@
-'use strict'
+'use strict';
 
-const clipboard = process.electronBinding('clipboard')
+const clipboard = process.electronBinding('clipboard');
 
 if (process.type === 'renderer') {
-  const ipcRendererUtils = require('@electron/internal/renderer/ipc-renderer-internal-utils')
-  const typeUtils = require('@electron/internal/common/type-utils')
+  const ipcRendererUtils = require('@electron/internal/renderer/ipc-renderer-internal-utils');
+  const typeUtils = require('@electron/internal/common/type-utils');
 
   const makeRemoteMethod = function (method) {
     return (...args) => {
-      args = typeUtils.serialize(args)
-      const result = ipcRendererUtils.invokeSync('ELECTRON_BROWSER_CLIPBOARD', method, ...args)
-      return typeUtils.deserialize(result)
-    }
-  }
+      args = typeUtils.serialize(args);
+      const result = ipcRendererUtils.invokeSync('ELECTRON_BROWSER_CLIPBOARD_SYNC', method, ...args);
+      return typeUtils.deserialize(result);
+    };
+  };
 
   if (process.platform === 'linux') {
     // On Linux we could not access clipboard in renderer process.
     for (const method of Object.keys(clipboard)) {
-      clipboard[method] = makeRemoteMethod(method)
+      clipboard[method] = makeRemoteMethod(method);
     }
   } else if (process.platform === 'darwin') {
     // Read/write to find pasteboard over IPC since only main process is notified of changes
-    clipboard.readFindText = makeRemoteMethod('readFindText')
-    clipboard.writeFindText = makeRemoteMethod('writeFindText')
+    clipboard.readFindText = makeRemoteMethod('readFindText');
+    clipboard.writeFindText = makeRemoteMethod('writeFindText');
   }
 }
 
-module.exports = clipboard
+module.exports = clipboard;

lib/common/api/deprecate.ts

@@ -1,95 +1,95 @@
-let deprecationHandler: ElectronInternal.DeprecationHandler | null = null
+let deprecationHandler: ElectronInternal.DeprecationHandler | null = null;
 
 function warnOnce (oldName: string, newName?: string) {
-  let warned = false
+  let warned = false;
   const msg = newName
     ? `'${oldName}' is deprecated and will be removed. Please use '${newName}' instead.`
-    : `'${oldName}' is deprecated and will be removed.`
+    : `'${oldName}' is deprecated and will be removed.`;
   return () => {
     if (!warned && !process.noDeprecation) {
-      warned = true
-      deprecate.log(msg)
+      warned = true;
+      deprecate.log(msg);
     }
-  }
+  };
 }
 
 const deprecate: ElectronInternal.DeprecationUtil = {
   warnOnce,
-  setHandler: (handler) => { deprecationHandler = handler },
+  setHandler: (handler) => { deprecationHandler = handler; },
   getHandler: () => deprecationHandler,
   warn: (oldName, newName) => {
     if (!process.noDeprecation) {
-      deprecate.log(`'${oldName}' is deprecated. Use '${newName}' instead.`)
+      deprecate.log(`'${oldName}' is deprecated. Use '${newName}' instead.`);
     }
   },
   log: (message) => {
     if (typeof deprecationHandler === 'function') {
-      deprecationHandler(message)
+      deprecationHandler(message);
     } else if (process.throwDeprecation) {
-      throw new Error(message)
+      throw new Error(message);
     } else if (process.traceDeprecation) {
-      return console.trace(message)
+      return console.trace(message);
     } else {
-      return console.warn(`(electron) ${message}`)
+      return console.warn(`(electron) ${message}`);
     }
   },
 
   // remove a function with no replacement
   removeFunction: (fn, removedName) => {
-    if (!fn) { throw Error(`'${removedName} function' is invalid or does not exist.`) }
+    if (!fn) { throw Error(`'${removedName} function' is invalid or does not exist.`); }
 
     // wrap the deprecated function to warn user
-    const warn = warnOnce(`${fn.name} function`)
+    const warn = warnOnce(`${fn.name} function`);
     return function (this: any) {
-      warn()
-      fn.apply(this, arguments)
-    }
+      warn();
+      fn.apply(this, arguments);
+    };
   },
 
   // change the name of a function
   renameFunction: (fn, newName) => {
-    const warn = warnOnce(`${fn.name} function`, `${newName} function`)
+    const warn = warnOnce(`${fn.name} function`, `${newName} function`);
     return function (this: any) {
-      warn()
-      return fn.apply(this, arguments)
-    }
+      warn();
+      return fn.apply(this, arguments);
+    };
   },
 
   moveAPI: (fn: Function, oldUsage: string, newUsage: string) => {
-    const warn = warnOnce(oldUsage, newUsage)
+    const warn = warnOnce(oldUsage, newUsage);
     return function (this: any) {
-      warn()
-      return fn.apply(this, arguments)
-    }
+      warn();
+      return fn.apply(this, arguments);
+    };
   },
 
   // change the name of an event
   event: (emitter, oldName, newName) => {
     const warn = newName.startsWith('-') /* internal event */
       ? warnOnce(`${oldName} event`)
-      : warnOnce(`${oldName} event`, `${newName} event`)
+      : warnOnce(`${oldName} event`, `${newName} event`);
     return emitter.on(newName, function (this: NodeJS.EventEmitter, ...args) {
       if (this.listenerCount(oldName) !== 0) {
-        warn()
-        this.emit(oldName, ...args)
+        warn();
+        this.emit(oldName, ...args);
       }
-    })
+    });
   },
 
   // deprecate a getter/setter function pair in favor of a property
   fnToProperty: (prototype: any, prop: string, getter: string, setter?: string) => {
     const withWarnOnce = function (obj: any, key: any, oldName: string, newName: string) {
-      const warn = warnOnce(oldName, newName)
-      const method = obj[key]
+      const warn = warnOnce(oldName, newName);
+      const method = obj[key];
       return function (this: any, ...args: any) {
-        warn()
-        return method.apply(this, args)
-      }
-    }
+        warn();
+        return method.apply(this, args);
+      };
+    };
 
-    prototype[getter.substr(1)] = withWarnOnce(prototype, getter, `${getter.substr(1)} function`, `${prop} property`)
+    prototype[getter.substr(1)] = withWarnOnce(prototype, getter, `${getter.substr(1)} function`, `${prop} property`);
     if (setter) {
-      prototype[setter.substr(1)] = withWarnOnce(prototype, setter, `${setter.substr(1)} function`, `${prop} property`)
+      prototype[setter.substr(1)] = withWarnOnce(prototype, setter, `${setter.substr(1)} function`, `${prop} property`);
     }
   },
 
@@ -97,49 +97,49 @@ const deprecate: ElectronInternal.DeprecationUtil = {
   removeProperty: (o, removedName) => {
     // if the property's already been removed, warn about it
     if (!(removedName in o)) {
-      deprecate.log(`Unable to remove property '${removedName}' from an object that lacks it.`)
+      deprecate.log(`Unable to remove property '${removedName}' from an object that lacks it.`);
     }
 
     // wrap the deprecated property in an accessor to warn
-    const warn = warnOnce(removedName)
-    let val = o[removedName]
+    const warn = warnOnce(removedName);
+    let val = o[removedName];
     return Object.defineProperty(o, removedName, {
       configurable: true,
       get: () => {
-        warn()
-        return val
+        warn();
+        return val;
       },
       set: newVal => {
-        warn()
-        val = newVal
+        warn();
+        val = newVal;
       }
-    })
+    });
   },
 
   // change the name of a property
   renameProperty: (o, oldName, newName) => {
-    const warn = warnOnce(oldName, newName)
+    const warn = warnOnce(oldName, newName);
 
     // if the new property isn't there yet,
     // inject it and warn about it
     if ((oldName in o) && !(newName in o)) {
-      warn()
-      o[newName] = (o as any)[oldName]
+      warn();
+      o[newName] = (o as any)[oldName];
     }
 
     // wrap the deprecated property in an accessor to warn
     // and redirect to the new property
     return Object.defineProperty(o, oldName, {
       get: () => {
-        warn()
-        return o[newName]
+        warn();
+        return o[newName];
       },
       set: value => {
-        warn()
-        o[newName] = value
+        warn();
+        o[newName] = value;
       }
-    })
+    });
   }
-}
+};
 
-export default deprecate
+export default deprecate;

lib/common/api/module-list.ts

@@ -5,4 +5,4 @@ export const commonModuleList: ElectronInternal.ModuleEntry[] = [
   { name: 'shell', loader: () => require('./shell') },
   // The internal modules, invisible unless you know their names.
   { name: 'deprecate', loader: () => require('./deprecate'), private: true }
-]
+];

lib/common/api/native-image.js

@@ -1,8 +1,5 @@
-'use strict'
+'use strict';
 
-const { deprecate } = require('electron')
-const { NativeImage, nativeImage } = process.electronBinding('native_image')
+const { nativeImage } = process.electronBinding('native_image');
 
-deprecate.fnToProperty(NativeImage.prototype, 'isMacTemplateImage', '_isTemplateImage', '_setTemplateImage')
-
-module.exports = nativeImage
+module.exports = nativeImage;

lib/common/api/shell.js

@@ -1,3 +1,3 @@
-'use strict'
+'use strict';
 
-module.exports = process.electronBinding('shell')
+module.exports = process.electronBinding('shell');