stuff

buildfiles/node_modules/app-builder-lib/out/electron/ElectronFramework.d.ts

@@ -0,0 +1,24 @@
+import { Configuration } from "../configuration";
+import { Framework } from "../Framework";
+import { Packager } from "../index";
+export declare type ElectronPlatformName = "darwin" | "linux" | "win32" | "mas";
+export interface ElectronDownloadOptions {
+    version?: string;
+    /**
+     * The [cache location](https://github.com/electron-userland/electron-download#cache-location).
+     */
+    cache?: string | null;
+    /**
+     * The mirror.
+     */
+    mirror?: string | null;
+    /** @private */
+    customDir?: string | null;
+    /** @private */
+    customFilename?: string | null;
+    strictSSL?: boolean;
+    isVerifyChecksum?: boolean;
+    platform?: ElectronPlatformName;
+    arch?: string;
+}
+export declare function createElectronFrameworkSupport(configuration: Configuration, packager: Packager): Promise<Framework>;

buildfiles/node_modules/app-builder-lib/out/electron/ElectronFramework.js

@@ -0,0 +1,271 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createElectronFrameworkSupport = createElectronFrameworkSupport;
+
+function _bluebirdLst() {
+  const data = _interopRequireDefault(require("bluebird-lst"));
+
+  _bluebirdLst = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _builderUtil() {
+  const data = require("builder-util");
+
+  _builderUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _fs() {
+  const data = require("builder-util/out/fs");
+
+  _fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _fsExtra() {
+  const data = require("fs-extra");
+
+  _fsExtra = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _lazyVal() {
+  const data = require("lazy-val");
+
+  _lazyVal = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var path = _interopRequireWildcard(require("path"));
+
+function _index() {
+  const data = require("../index");
+
+  _index = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _platformPackager() {
+  const data = require("../platformPackager");
+
+  _platformPackager = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _pathManager() {
+  const data = require("../util/pathManager");
+
+  _pathManager = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _electronMac() {
+  const data = require("./electronMac");
+
+  _electronMac = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _electronVersion() {
+  const data = require("./electronVersion");
+
+  _electronVersion = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function createDownloadOpts(opts, platform, arch, electronVersion) {
+  return {
+    platform,
+    arch,
+    version: electronVersion,
+    ...opts.electronDownload
+  };
+}
+
+async function beforeCopyExtraFiles(options) {
+  const packager = options.packager;
+  const appOutDir = options.appOutDir;
+
+  if (packager.platform === _index().Platform.LINUX) {
+    if (!(0, _platformPackager().isSafeToUnpackElectronOnRemoteBuildServer)(packager)) {
+      const linuxPackager = packager;
+      const executable = path.join(appOutDir, linuxPackager.executableName);
+      await (0, _fsExtra().rename)(path.join(appOutDir, "electron"), executable);
+    }
+  } else if (packager.platform === _index().Platform.WINDOWS) {
+    const executable = path.join(appOutDir, `${packager.appInfo.productFilename}.exe`);
+    await (0, _fsExtra().rename)(path.join(appOutDir, "electron.exe"), executable);
+  } else {
+    await (0, _electronMac().createMacApp)(packager, appOutDir, options.asarIntegrity, options.platformName === "mas");
+    const wantedLanguages = (0, _builderUtil().asArray)(packager.platformSpecificBuildOptions.electronLanguages);
+
+    if (wantedLanguages.length === 0) {
+      return;
+    } // noinspection SpellCheckingInspection
+
+
+    const langFileExt = ".lproj";
+    const resourcesDir = packager.getResourcesDir(appOutDir);
+    await _bluebirdLst().default.map((0, _fsExtra().readdir)(resourcesDir), file => {
+      if (!file.endsWith(langFileExt)) {
+        return;
+      }
+
+      const language = file.substring(0, file.length - langFileExt.length);
+
+      if (!wantedLanguages.includes(language)) {
+        return (0, _fsExtra().remove)(path.join(resourcesDir, file));
+      }
+
+      return;
+    }, _fs().CONCURRENCY);
+  }
+}
+
+class ElectronFramework {
+  constructor(name, version, distMacOsAppName) {
+    this.name = name;
+    this.version = version;
+    this.distMacOsAppName = distMacOsAppName; // noinspection JSUnusedGlobalSymbols
+
+    this.macOsDefaultTargets = ["zip", "dmg"]; // noinspection JSUnusedGlobalSymbols
+
+    this.defaultAppIdPrefix = "com.electron."; // noinspection JSUnusedGlobalSymbols
+
+    this.isCopyElevateHelper = true; // noinspection JSUnusedGlobalSymbols
+
+    this.isNpmRebuildRequired = true;
+  }
+
+  getDefaultIcon(platform) {
+    if (platform === _index().Platform.LINUX) {
+      return path.join((0, _pathManager().getTemplatePath)("icons"), "electron-linux");
+    } else {
+      // default icon is embedded into app skeleton
+      return null;
+    }
+  }
+
+  prepareApplicationStageDirectory(options) {
+    return unpack(options, createDownloadOpts(options.packager.config, options.platformName, options.arch, this.version), this.distMacOsAppName);
+  }
+
+  beforeCopyExtraFiles(options) {
+    return beforeCopyExtraFiles(options);
+  }
+
+}
+
+async function createElectronFrameworkSupport(configuration, packager) {
+  let version = configuration.electronVersion;
+
+  if (version == null) {
+    // for prepacked app asar no dev deps in the app.asar
+    if (packager.isPrepackedAppAsar) {
+      version = await (0, _electronVersion().getElectronVersionFromInstalled)(packager.projectDir);
+
+      if (version == null) {
+        throw new Error(`Cannot compute electron version for prepacked asar`);
+      }
+    } else {
+      version = await (0, _electronVersion().computeElectronVersion)(packager.projectDir, new (_lazyVal().Lazy)(() => Promise.resolve(packager.metadata)));
+    }
+
+    configuration.electronVersion = version;
+  }
+
+  return new ElectronFramework("electron", version, "Electron.app");
+}
+
+async function unpack(prepareOptions, options, distMacOsAppName) {
+  const packager = prepareOptions.packager;
+  const out = prepareOptions.appOutDir;
+  let dist = packager.config.electronDist;
+
+  if (dist != null) {
+    const zipFile = `electron-v${options.version}-${prepareOptions.platformName}-${options.arch}.zip`;
+    const resolvedDist = path.resolve(packager.projectDir, dist);
+
+    if ((await (0, _fs().statOrNull)(path.join(resolvedDist, zipFile))) != null) {
+      options.cache = resolvedDist;
+      dist = null;
+    }
+  }
+
+  let isFullCleanup = false;
+
+  if (dist == null) {
+    if ((0, _platformPackager().isSafeToUnpackElectronOnRemoteBuildServer)(packager)) {
+      return;
+    }
+
+    await (0, _builderUtil().executeAppBuilder)(["unpack-electron", "--configuration", JSON.stringify([options]), "--output", out, "--distMacOsAppName", distMacOsAppName]);
+  } else {
+    isFullCleanup = true;
+    const source = packager.getElectronSrcDir(dist);
+    const destination = packager.getElectronDestinationDir(out);
+
+    _builderUtil().log.info({
+      source,
+      destination
+    }, "copying Electron");
+
+    await (0, _fsExtra().emptyDir)(out);
+    await (0, _fs().copyDir)(source, destination, {
+      isUseHardLink: _fs().DO_NOT_USE_HARD_LINKS
+    });
+  }
+
+  await cleanupAfterUnpack(prepareOptions, distMacOsAppName, isFullCleanup);
+}
+
+function cleanupAfterUnpack(prepareOptions, distMacOsAppName, isFullCleanup) {
+  const out = prepareOptions.appOutDir;
+
+  const isMac = prepareOptions.packager.platform === _index().Platform.MAC;
+
+  const resourcesPath = isMac ? path.join(out, distMacOsAppName, "Contents", "Resources") : path.join(out, "resources");
+  return Promise.all([isFullCleanup ? (0, _fs().unlinkIfExists)(path.join(resourcesPath, "default_app.asar")) : Promise.resolve(), isFullCleanup ? (0, _fs().unlinkIfExists)(path.join(out, "version")) : Promise.resolve(), isMac ? Promise.resolve() : (0, _fsExtra().rename)(path.join(out, "LICENSE"), path.join(out, "LICENSE.electron.txt")).catch(() => {})]);
+} 
+// __ts-babel@6.0.4
+//# sourceMappingURL=ElectronFramework.js.map

buildfiles/node_modules/app-builder-lib/out/electron/electronMac.d.ts

@@ -0,0 +1 @@
+export {};

buildfiles/node_modules/app-builder-lib/out/electron/electronMac.js

@@ -0,0 +1,356 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMacApp = createMacApp;
+
+function _bluebirdLst() {
+  const data = _interopRequireDefault(require("bluebird-lst"));
+
+  _bluebirdLst = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _builderUtil() {
+  const data = require("builder-util");
+
+  _builderUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _fs() {
+  const data = require("builder-util/out/fs");
+
+  _fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _fsExtra() {
+  const data = require("fs-extra");
+
+  _fsExtra = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var path = _interopRequireWildcard(require("path"));
+
+function _appInfo() {
+  const data = require("../appInfo");
+
+  _appInfo = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _platformPackager() {
+  const data = require("../platformPackager");
+
+  _platformPackager = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _appBuilder() {
+  const data = require("../util/appBuilder");
+
+  _appBuilder = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function doRename(basePath, oldName, newName) {
+  return (0, _fsExtra().rename)(path.join(basePath, oldName), path.join(basePath, newName));
+}
+
+function moveHelpers(helperSuffixes, frameworksPath, appName, prefix) {
+  return _bluebirdLst().default.map(helperSuffixes, suffix => {
+    const executableBasePath = path.join(frameworksPath, `${prefix}${suffix}.app`, "Contents", "MacOS");
+    return doRename(executableBasePath, `${prefix}${suffix}`, appName + suffix).then(() => doRename(frameworksPath, `${prefix}${suffix}.app`, `${appName}${suffix}.app`));
+  });
+}
+
+function getAvailableHelperSuffixes(helperEHPlist, helperNPPlist, helperRendererPlist, helperPluginPlist, helperGPUPlist) {
+  const result = [" Helper"];
+
+  if (helperEHPlist != null) {
+    result.push(" Helper EH");
+  }
+
+  if (helperNPPlist != null) {
+    result.push(" Helper NP");
+  }
+
+  if (helperRendererPlist != null) {
+    result.push(" Helper (Renderer)");
+  }
+
+  if (helperPluginPlist != null) {
+    result.push(" Helper (Plugin)");
+  }
+
+  if (helperGPUPlist != null) {
+    result.push(" Helper (GPU)");
+  }
+
+  return result;
+}
+/** @internal */
+
+
+async function createMacApp(packager, appOutDir, asarIntegrity, isMas) {
+  const appInfo = packager.appInfo;
+  const appFilename = appInfo.productFilename;
+  const contentsPath = path.join(appOutDir, packager.info.framework.distMacOsAppName, "Contents");
+  const frameworksPath = path.join(contentsPath, "Frameworks");
+  const loginItemPath = path.join(contentsPath, "Library", "LoginItems");
+  const appPlistFilename = path.join(contentsPath, "Info.plist");
+  const helperPlistFilename = path.join(frameworksPath, "Electron Helper.app", "Contents", "Info.plist");
+  const helperEHPlistFilename = path.join(frameworksPath, "Electron Helper EH.app", "Contents", "Info.plist");
+  const helperNPPlistFilename = path.join(frameworksPath, "Electron Helper NP.app", "Contents", "Info.plist");
+  const helperRendererPlistFilename = path.join(frameworksPath, "Electron Helper (Renderer).app", "Contents", "Info.plist");
+  const helperPluginPlistFilename = path.join(frameworksPath, "Electron Helper (Plugin).app", "Contents", "Info.plist");
+  const helperGPUPlistFilename = path.join(frameworksPath, "Electron Helper (GPU).app", "Contents", "Info.plist");
+  const helperLoginPlistFilename = path.join(loginItemPath, "Electron Login Helper.app", "Contents", "Info.plist");
+  const plistContent = await (0, _appBuilder().executeAppBuilderAsJson)(["decode-plist", "-f", appPlistFilename, "-f", helperPlistFilename, "-f", helperEHPlistFilename, "-f", helperNPPlistFilename, "-f", helperRendererPlistFilename, "-f", helperPluginPlistFilename, "-f", helperGPUPlistFilename, "-f", helperLoginPlistFilename]);
+
+  if (plistContent[0] == null) {
+    throw new Error("corrupted Electron dist");
+  }
+
+  const appPlist = plistContent[0];
+  const helperPlist = plistContent[1];
+  const helperEHPlist = plistContent[2];
+  const helperNPPlist = plistContent[3];
+  const helperRendererPlist = plistContent[4];
+  const helperPluginPlist = plistContent[5];
+  const helperGPUPlist = plistContent[6];
+  const helperLoginPlist = plistContent[7]; // if an extend-info file was supplied, copy its contents in first
+
+  if (plistContent[8] != null) {
+    Object.assign(appPlist, plistContent[8]);
+  }
+
+  const buildMetadata = packager.config;
+  /**
+   * Configure bundleIdentifier for the generic Electron Helper process
+   *
+   * This was the only Helper in Electron 5 and before. Allow users to configure
+   * the bundleIdentifier for continuity.
+   */
+
+  const oldHelperBundleId = buildMetadata["helper-bundle-id"];
+
+  if (oldHelperBundleId != null) {
+    _builderUtil().log.warn("build.helper-bundle-id is deprecated, please set as build.mac.helperBundleId");
+  }
+
+  const helperBundleIdentifier = (0, _appInfo().filterCFBundleIdentifier)(packager.platformSpecificBuildOptions.helperBundleId || oldHelperBundleId || `${appInfo.macBundleIdentifier}.helper`);
+  await packager.applyCommonInfo(appPlist, contentsPath); // required for electron-updater proxy
+
+  if (!isMas) {
+    configureLocalhostAts(appPlist);
+  }
+
+  helperPlist.CFBundleExecutable = `${appFilename} Helper`;
+  helperPlist.CFBundleDisplayName = `${appInfo.productName} Helper`;
+  helperPlist.CFBundleIdentifier = helperBundleIdentifier;
+  helperPlist.CFBundleVersion = appPlist.CFBundleVersion;
+  /**
+   * Configure bundleIdentifier for Electron 5+ Helper processes
+   *
+   * In Electron 6, parts of the generic Electron Helper process were split into
+   * individual helper processes. Allow users to configure the bundleIdentifiers
+   * for continuity, specifically because macOS keychain access relies on
+   * bundleIdentifiers not changing (i.e. across versions of Electron).
+   */
+
+  function configureHelper(helper, postfix, userProvidedBundleIdentifier) {
+    helper.CFBundleExecutable = `${appFilename} Helper ${postfix}`;
+    helper.CFBundleDisplayName = `${appInfo.productName} Helper ${postfix}`;
+    helper.CFBundleIdentifier = userProvidedBundleIdentifier ? (0, _appInfo().filterCFBundleIdentifier)(userProvidedBundleIdentifier) : `${helperBundleIdentifier}.${postfix.replace(/[^a-z0-9]/gim, "")}`;
+    helper.CFBundleVersion = appPlist.CFBundleVersion;
+  }
+
+  if (helperRendererPlist != null) {
+    configureHelper(helperRendererPlist, "(Renderer)", packager.platformSpecificBuildOptions.helperRendererBundleId);
+  }
+
+  if (helperPluginPlist != null) {
+    configureHelper(helperPluginPlist, "(Plugin)", packager.platformSpecificBuildOptions.helperPluginBundleId);
+  }
+
+  if (helperGPUPlist != null) {
+    configureHelper(helperGPUPlist, "(GPU)", packager.platformSpecificBuildOptions.helperGPUBundleId);
+  }
+
+  if (helperEHPlist != null) {
+    configureHelper(helperEHPlist, "EH", packager.platformSpecificBuildOptions.helperEHBundleId);
+  }
+
+  if (helperNPPlist != null) {
+    configureHelper(helperNPPlist, "NP", packager.platformSpecificBuildOptions.helperNPBundleId);
+  }
+
+  if (helperLoginPlist != null) {
+    helperLoginPlist.CFBundleExecutable = `${appFilename} Login Helper`;
+    helperLoginPlist.CFBundleDisplayName = `${appInfo.productName} Login Helper`; // noinspection SpellCheckingInspection
+
+    helperLoginPlist.CFBundleIdentifier = `${appInfo.macBundleIdentifier}.loginhelper`;
+    helperLoginPlist.CFBundleVersion = appPlist.CFBundleVersion;
+  }
+
+  const protocols = (0, _builderUtil().asArray)(buildMetadata.protocols).concat((0, _builderUtil().asArray)(packager.platformSpecificBuildOptions.protocols));
+
+  if (protocols.length > 0) {
+    appPlist.CFBundleURLTypes = protocols.map(protocol => {
+      const schemes = (0, _builderUtil().asArray)(protocol.schemes);
+
+      if (schemes.length === 0) {
+        throw new (_builderUtil().InvalidConfigurationError)(`Protocol "${protocol.name}": must be at least one scheme specified`);
+      }
+
+      return {
+        CFBundleURLName: protocol.name,
+        CFBundleTypeRole: protocol.role || "Editor",
+        CFBundleURLSchemes: schemes.slice()
+      };
+    });
+  }
+
+  const fileAssociations = packager.fileAssociations;
+
+  if (fileAssociations.length > 0) {
+    appPlist.CFBundleDocumentTypes = await _bluebirdLst().default.map(fileAssociations, async fileAssociation => {
+      const extensions = (0, _builderUtil().asArray)(fileAssociation.ext).map(_platformPackager().normalizeExt);
+      const customIcon = await packager.getResource((0, _builderUtil().getPlatformIconFileName)(fileAssociation.icon, true), `${extensions[0]}.icns`);
+      let iconFile = appPlist.CFBundleIconFile;
+
+      if (customIcon != null) {
+        iconFile = path.basename(customIcon);
+        await (0, _fs().copyOrLinkFile)(customIcon, path.join(path.join(contentsPath, "Resources"), iconFile));
+      }
+
+      const result = {
+        CFBundleTypeExtensions: extensions,
+        CFBundleTypeName: fileAssociation.name || extensions[0],
+        CFBundleTypeRole: fileAssociation.role || "Editor",
+        LSHandlerRank: fileAssociation.rank || "Default",
+        CFBundleTypeIconFile: iconFile
+      };
+
+      if (fileAssociation.isPackage) {
+        result.LSTypeIsPackage = true;
+      }
+
+      return result;
+    });
+  }
+
+  if (asarIntegrity != null) {
+    appPlist.AsarIntegrity = JSON.stringify(asarIntegrity);
+  }
+
+  const plistDataToWrite = {
+    [appPlistFilename]: appPlist,
+    [helperPlistFilename]: helperPlist
+  };
+
+  if (helperEHPlist != null) {
+    plistDataToWrite[helperEHPlistFilename] = helperEHPlist;
+  }
+
+  if (helperNPPlist != null) {
+    plistDataToWrite[helperNPPlistFilename] = helperNPPlist;
+  }
+
+  if (helperRendererPlist != null) {
+    plistDataToWrite[helperRendererPlistFilename] = helperRendererPlist;
+  }
+
+  if (helperPluginPlist != null) {
+    plistDataToWrite[helperPluginPlistFilename] = helperPluginPlist;
+  }
+
+  if (helperGPUPlist != null) {
+    plistDataToWrite[helperGPUPlistFilename] = helperGPUPlist;
+  }
+
+  if (helperLoginPlist != null) {
+    plistDataToWrite[helperLoginPlistFilename] = helperLoginPlist;
+  }
+
+  await Promise.all([(0, _appBuilder().executeAppBuilderAndWriteJson)(["encode-plist"], plistDataToWrite), doRename(path.join(contentsPath, "MacOS"), "Electron", appPlist.CFBundleExecutable), (0, _fs().unlinkIfExists)(path.join(appOutDir, "LICENSE")), (0, _fs().unlinkIfExists)(path.join(appOutDir, "LICENSES.chromium.html"))]);
+  await moveHelpers(getAvailableHelperSuffixes(helperEHPlist, helperNPPlist, helperRendererPlist, helperPluginPlist, helperGPUPlist), frameworksPath, appFilename, "Electron");
+
+  if (helperLoginPlist != null) {
+    const prefix = "Electron";
+    const suffix = " Login Helper";
+    const executableBasePath = path.join(loginItemPath, `${prefix}${suffix}.app`, "Contents", "MacOS");
+    await doRename(executableBasePath, `${prefix}${suffix}`, appFilename + suffix).then(() => doRename(loginItemPath, `${prefix}${suffix}.app`, `${appFilename}${suffix}.app`));
+  }
+
+  const appPath = path.join(appOutDir, `${appFilename}.app`);
+  await (0, _fsExtra().rename)(path.dirname(contentsPath), appPath); // https://github.com/electron-userland/electron-builder/issues/840
+
+  const now = Date.now() / 1000;
+  await (0, _fsExtra().utimes)(appPath, now, now);
+}
+
+function configureLocalhostAts(appPlist) {
+  // https://bencoding.com/2015/07/20/app-transport-security-and-localhost/
+  let ats = appPlist.NSAppTransportSecurity;
+
+  if (ats == null) {
+    ats = {};
+    appPlist.NSAppTransportSecurity = ats;
+  }
+
+  ats.NSAllowsLocalNetworking = true; // https://github.com/electron-userland/electron-builder/issues/3377#issuecomment-446035814
+
+  ats.NSAllowsArbitraryLoads = true;
+  let exceptionDomains = ats.NSExceptionDomains;
+
+  if (exceptionDomains == null) {
+    exceptionDomains = {};
+    ats.NSExceptionDomains = exceptionDomains;
+  }
+
+  if (exceptionDomains.localhost == null) {
+    const allowHttp = {
+      NSTemporaryExceptionAllowsInsecureHTTPSLoads: false,
+      NSIncludesSubdomains: false,
+      NSTemporaryExceptionAllowsInsecureHTTPLoads: true,
+      NSTemporaryExceptionMinimumTLSVersion: "1.0",
+      NSTemporaryExceptionRequiresForwardSecrecy: false
+    };
+    exceptionDomains.localhost = allowHttp;
+    exceptionDomains["127.0.0.1"] = allowHttp;
+  }
+} 
+// __ts-babel@6.0.4
+//# sourceMappingURL=electronMac.js.map

buildfiles/node_modules/app-builder-lib/out/electron/electronVersion.d.ts

@@ -0,0 +1,8 @@
+import { Lazy } from "lazy-val";
+import { Configuration } from "../configuration";
+export declare type MetadataValue = Lazy<{
+    [key: string]: any;
+} | null>;
+export declare function getElectronVersion(projectDir: string, config?: Configuration, projectMetadata?: MetadataValue): Promise<string>;
+export declare function getElectronVersionFromInstalled(projectDir: string): Promise<any>;
+export declare function getElectronPackage(projectDir: string): Promise<any>;

buildfiles/node_modules/app-builder-lib/out/electron/electronVersion.js

@@ -0,0 +1,226 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getElectronVersion = getElectronVersion;
+exports.getElectronVersionFromInstalled = getElectronVersionFromInstalled;
+exports.getElectronPackage = getElectronPackage;
+exports.computeElectronVersion = computeElectronVersion;
+
+function _builderUtil() {
+  const data = require("builder-util");
+
+  _builderUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _builderUtilRuntime() {
+  const data = require("builder-util-runtime");
+
+  _builderUtilRuntime = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _nodeHttpExecutor() {
+  const data = require("builder-util/out/nodeHttpExecutor");
+
+  _nodeHttpExecutor = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _fsExtra() {
+  const data = require("fs-extra");
+
+  _fsExtra = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _lazyVal() {
+  const data = require("lazy-val");
+
+  _lazyVal = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var path = _interopRequireWildcard(require("path"));
+
+function _readConfigFile() {
+  const data = require("read-config-file");
+
+  _readConfigFile = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function semver() {
+  const data = _interopRequireWildcard(require("semver"));
+
+  semver = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _config() {
+  const data = require("../util/config");
+
+  _config = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const electronPackages = ["electron", "electron-prebuilt", "electron-prebuilt-compile", "electron-nightly"];
+
+async function getElectronVersion(projectDir, config, projectMetadata = new (_lazyVal().Lazy)(() => (0, _readConfigFile().orNullIfFileNotExist)((0, _fsExtra().readJson)(path.join(projectDir, "package.json"))))) {
+  if (config == null) {
+    config = await (0, _config().getConfig)(projectDir, null, null);
+  }
+
+  if (config.electronVersion != null) {
+    return config.electronVersion;
+  }
+
+  return await computeElectronVersion(projectDir, projectMetadata);
+}
+
+async function getElectronVersionFromInstalled(projectDir) {
+  for (const name of electronPackages) {
+    try {
+      return (await (0, _fsExtra().readJson)(path.join(projectDir, "node_modules", name, "package.json"))).version;
+    } catch (e) {
+      if (e.code !== "ENOENT") {
+        _builderUtil().log.warn({
+          name,
+          error: e
+        }, `cannot read electron version package.json`);
+      }
+    }
+  }
+
+  return null;
+}
+
+async function getElectronPackage(projectDir) {
+  for (const name of electronPackages) {
+    try {
+      return await (0, _fsExtra().readJson)(path.join(projectDir, "node_modules", name, "package.json"));
+    } catch (e) {
+      if (e.code !== "ENOENT") {
+        _builderUtil().log.warn({
+          name,
+          error: e
+        }, `cannot find electron in package.json`);
+      }
+    }
+  }
+
+  return null;
+}
+/** @internal */
+
+
+async function computeElectronVersion(projectDir, projectMetadata) {
+  const result = await getElectronVersionFromInstalled(projectDir);
+
+  if (result != null) {
+    return result;
+  }
+
+  const dependency = findFromPackageMetadata(await projectMetadata.value);
+
+  if ((dependency === null || dependency === void 0 ? void 0 : dependency.name) === "electron-nightly") {
+    _builderUtil().log.info("You are using a nightly version of electron, be warned that those builds are highly unstable.");
+
+    const feedXml = await _nodeHttpExecutor().httpExecutor.request({
+      hostname: "github.com",
+      path: `/electron/nightlies/releases.atom`,
+      headers: {
+        accept: "application/xml, application/atom+xml, text/xml, */*"
+      }
+    });
+    const feed = (0, _builderUtilRuntime().parseXml)(feedXml);
+    const latestRelease = feed.element("entry", false, `No published versions on GitHub`);
+    const v = latestRelease.element("link").attribute("href").match(/\/tag\/v?([^/]+)$/)[1];
+    return v.startsWith("v") ? v.substring(1) : v;
+  } else if ((dependency === null || dependency === void 0 ? void 0 : dependency.version) === "latest") {
+    _builderUtil().log.warn("Electron version is set to \"latest\", but it is recommended to set it to some more restricted version range.");
+
+    try {
+      const releaseInfo = JSON.parse(await _nodeHttpExecutor().httpExecutor.request({
+        hostname: "github.com",
+        path: `/electron/${dependency.name === "electron-nightly" ? "nightlies" : "electron"}/releases/latest`,
+        headers: {
+          accept: "application/json"
+        }
+      }));
+      const version = releaseInfo.tag_name.startsWith("v") ? releaseInfo.tag_name.substring(1) : releaseInfo.tag_name;
+
+      _builderUtil().log.info({
+        version
+      }, `resolve ${dependency.name}@${dependency.version}`);
+
+      return version;
+    } catch (e) {
+      _builderUtil().log.warn(e);
+    }
+
+    throw new (_builderUtil().InvalidConfigurationError)(`Cannot find electron dependency to get electron version in the '${path.join(projectDir, "package.json")}'`);
+  }
+
+  const version = dependency === null || dependency === void 0 ? void 0 : dependency.version;
+
+  if (version == null || !/^\d/.test(version)) {
+    const versionMessage = version == null ? "" : ` and version ("${version}") is not fixed in project`;
+    throw new (_builderUtil().InvalidConfigurationError)(`Cannot compute electron version from installed node modules - none of the possible electron modules are installed${versionMessage}.\nSee https://github.com/electron-userland/electron-builder/issues/3984#issuecomment-504968246`);
+  }
+
+  return semver().coerce(version).toString();
+}
+
+function findFromPackageMetadata(packageData) {
+  for (const name of electronPackages) {
+    const devDependencies = packageData.devDependencies;
+    let dep = devDependencies == null ? null : devDependencies[name];
+
+    if (dep == null) {
+      const dependencies = packageData.dependencies;
+      dep = dependencies == null ? null : dependencies[name];
+    }
+
+    if (dep != null) {
+      return {
+        name,
+        version: dep
+      };
+    }
+  }
+
+  return null;
+} 
+// __ts-babel@6.0.4
+//# sourceMappingURL=electronVersion.js.map