update electron to v43

electron/node_modules/dotenv-expand/lib/main.d.ts

@@ -0,0 +1,50 @@
+// TypeScript Version: 3.0
+/// <reference types="node" />
+
+export interface DotenvPopulateInput {
+  [name: string]: string;
+}
+
+export interface DotenvParseInput {
+  [name: string]: string;
+}
+
+export interface DotenvParseOutput {
+  [name: string]: string;
+}
+
+export interface DotenvExpandOptions {
+  error?: Error;
+
+  /**
+   * Default: `process.env`
+   *
+   * Specify an object to write your secrets to. Defaults to process.env environment variables.
+   *
+   * example: `const processEnv = {}; require('dotenv').config({ processEnv: processEnv })`
+   */
+  processEnv?: DotenvPopulateInput;
+
+  /**
+   * Default: `object`
+   *
+   * Object coming from dotenv's parsed result.
+   */
+  parsed?: DotenvParseInput;
+}
+
+export interface DotenvExpandOutput {
+  error?: Error;
+  parsed?: DotenvParseOutput;
+}
+
+/**
+ * Adds variable expansion on top of dotenv.
+ *
+ * See https://docs.dotenv.org
+ *
+ * @param options - additional options. example: `{ processEnv: {}, error: null, parsed: { { KEY: 'value' } }`
+ * @returns an object with a `parsed` key if successful or `error` key if an error occurred. example: { parsed: { KEY: 'value' } }
+ *
+ */
+export function expand(options?: DotenvExpandOptions): DotenvExpandOutput

electron/node_modules/dotenv-expand/lib/main.js

@@ -1,46 +1,86 @@
 'use strict'
 
-var dotenvExpand = function (config) {
-  // if ignoring process.env, use a blank object
-  var environment = config.ignoreProcessEnv ? {} : process.env
+// * /
+// *   (\\)?            # is it escaped with a backslash?
+// *   (\$)             # literal $
+// *   (?!\()           # shouldnt be followed by parenthesis
+// *   (\{?)            # first brace wrap opening
+// *   ([\w.]+)         # key
+// *   (?::-((?:\$\{(?:\$\{(?:\$\{[^}]*\}|[^}])*}|[^}])*}|[^}])+))? # optional default nested 3 times
+// *   (\}?)            # last brace warp closing
+// * /xi
 
-  var interpolate = function (envValue) {
-    var matches = envValue.match(/(.?\${?(?:[a-zA-Z0-9_]+)?}?)/g) || []
+const DOTENV_SUBSTITUTION_REGEX = /(\\)?(\$)(?!\()(\{?)([\w.]+)(?::?-((?:\$\{(?:\$\{(?:\$\{[^}]*\}|[^}])*}|[^}])*}|[^}])+))?(\}?)/gi
 
-    return matches.reduce(function (newEnv, match) {
-      var parts = /(.?)\${?([a-zA-Z0-9_]+)?}?/g.exec(match)
-      var prefix = parts[1]
-
-      var value, replacePart
-
-      if (prefix === '\\') {
-        replacePart = parts[0]
-        value = replacePart.replace('\\$', '$')
-      } else {
-        var key = parts[2]
-        replacePart = parts[0].substring(prefix.length)
-        // process.env value 'wins' over .env file's value
-        value = environment.hasOwnProperty(key) ? environment[key] : (config.parsed[key] || '')
-
-        // Resolve recursive interpolations
-        value = interpolate(value)
-      }
-
-      return newEnv.replace(replacePart, value)
-    }, envValue)
-  }
-
-  for (var configKey in config.parsed) {
-    var value = environment.hasOwnProperty(configKey) ? environment[configKey] : config.parsed[configKey]
-
-    config.parsed[configKey] = interpolate(value)
-  }
-
-  for (var processKey in config.parsed) {
-    environment[processKey] = config.parsed[processKey]
-  }
-
-  return config
+function _resolveEscapeSequences (value) {
+  return value.replace(/\\\$/g, '$')
 }
 
-module.exports = dotenvExpand
+function interpolate (value, processEnv, parsed) {
+  return value.replace(DOTENV_SUBSTITUTION_REGEX, (match, escaped, dollarSign, openBrace, key, defaultValue, closeBrace) => {
+    if (escaped === '\\') {
+      return match.slice(1)
+    } else {
+      if (processEnv[key]) {
+        if (processEnv[key] === parsed[key]) {
+          return processEnv[key]
+        } else {
+          // scenario: PASSWORD_EXPAND_NESTED=${PASSWORD_EXPAND}
+          return interpolate(processEnv[key], processEnv, parsed)
+        }
+      }
+
+      if (parsed[key]) {
+        // avoid recursion from EXPAND_SELF=$EXPAND_SELF
+        if (parsed[key] !== value) {
+          return interpolate(parsed[key], processEnv, parsed)
+        }
+      }
+
+      if (defaultValue) {
+        if (defaultValue.startsWith('$')) {
+          return interpolate(defaultValue, processEnv, parsed)
+        } else {
+          return defaultValue
+        }
+      }
+
+      return ''
+    }
+  })
+}
+
+function expand (options) {
+  let processEnv = process.env
+  if (options && options.processEnv != null) {
+    processEnv = options.processEnv
+  }
+
+  for (const key in options.parsed) {
+    let value = options.parsed[key]
+
+    const inProcessEnv = Object.prototype.hasOwnProperty.call(processEnv, key)
+    if (inProcessEnv) {
+      if (processEnv[key] === options.parsed[key]) {
+        // assume was set to processEnv from the .env file if the values match and therefore interpolate
+        value = interpolate(value, processEnv, options.parsed)
+      } else {
+        // do not interpolate - assume processEnv had the intended value even if containing a $.
+        value = processEnv[key]
+      }
+    } else {
+      // not inProcessEnv so assume interpolation for this .env key
+      value = interpolate(value, processEnv, options.parsed)
+    }
+
+    options.parsed[key] = _resolveEscapeSequences(value)
+  }
+
+  for (const processKey in options.parsed) {
+    processEnv[processKey] = options.parsed[processKey]
+  }
+
+  return options
+}
+
+module.exports.expand = expand