Asserts that given param is an array of functions.

@param {Function[]} configSetters Array of functions as returned by webpack blocks.
765604
function assertConfigSetters(configSetters) {
  if (!Array.isArray(configSetters)) {
    throw new Error(
      `Expected parameter 'configSetters' to be an array of functions. Instead got ${configSetters}.`
    )
  }
  if (!configSetters.every(_.isFunction)) {
    const invalidElementIndex = configSetters.findIndex(setter => !_.isFunction(setter))
    throw new Error(
      `Expected parameter 'configSetters' to be an array of functions. ` +
        `Element at index ${invalidElementIndex} is invalid: ${configSetters[invalidElementIndex]}.`
    )
  }
}
358625
public void setFunctions(java.util.Collection<Function> functions) {
        if (functions == null) {
            this.functions = null;
            return;
        }

        this.functions = new java.util.ArrayList<Function>(functions);
    }
844386
function createConfigSetString(mapEnvSettings) {
  const settingsStrsArr = map(mapEnvSettings, strFromEnvironmentVarSetting)
  const settingsStr = compact(settingsStrsArr).join(' ')
  // Get project from passed options, falling back to branch name
  const projectKey = getProjectKey(mapEnvSettings)
  return `firebase functions:config:set ${settingsStr} -P ${projectKey}`
}
42434
function validateConfig(config, parentPath) {
    if (parentPath === void 0) { parentPath = ''; }
    // forEach doesn't iterate undefined values
    for (var /** @type {?} */ i = 0; i < config.length; i++) {
        var /** @type {?} */ route = config[i];
        var /** @type {?} */ fullPath = getFullPath(parentPath, route);
        validateNode(route, fullPath);
    }
}
443285
function checkConfiguration(conf) {
    let failedChecks = 0;

    for (const path of Object.keys(CHECKS)) {
        // @todo avoid try..catch
        try {
            checkProperty(path, get(conf, path), CHECKS[path]);
        } catch (error) {
            LusterConfigurationError.ensureError(error).log();
            ++failedChecks;
        }
    }

    return failedChecks;
}
374987
function when(condition, configSetters) {
  assertConfigSetters(configSetters)

  if (condition) {
    return group(configSetters)
  } else {
    return () => config => config
  }
}
372520
function(fun /*, defaults */) {
      var defaults = _.rest(arguments);

      return function(/*args*/) {
        var args = _.toArray(arguments);
        var sz = _.size(defaults);

        for(var i = 0; i < sz; i++) {
          if (!existy(args[i]))
            args[i] = defaults[i];
        }

        return fun.apply(this, args);
      };
    }
1120657
function(functionName){
            functionName = this.string(functionName);
            if(!/^([a-zA-Z_])([a-zA-Z0-9_\-])+$/.test(functionName)){
                throw new TypeError('a valid function name is expected, ' + functionName + ' [' + (typeof functionName) + '] given');
            }
            return functionName;
        }
969406
function forEachSetter(entry, names, callback) {
  var needToCheckNames = true;

  if (names === void 0) {
    names = Object.keys(entry.setters);
    needToCheckNames = false;
  }

  var nameCount = names.length;

  for (var i = 0; i < nameCount; ++i) {
    var name = names[i];

    if (needToCheckNames &&
        ! hasOwn.call(entry.setters, name)) {
      continue;
    }

    var setters = entry.setters[name];
    var keys = Object.keys(setters);
    var keyCount = keys.length;

    for (var j = 0; j < keyCount; ++j) {
      var key = keys[j];
      var value = getExportByName(entry, name);

      callSetterIfNecessary(setters[key], name, value, callback);

      var getter = entry.getters[name];
      if (typeof getter === "function" &&
          // Sometimes a getter function will throw because it's called
          // before the variable it's supposed to return has been
          // initialized, so we need to know that the getter function has
          // run to completion at least once.
          getter.runCount > 0 &&
          getter.constant) {
        // If we happen to know that this getter function has run
        // successfully, and will never return a different value, then we
        // can forget the corresponding setter, because we've already
        // reported that constant value. Note that we can't forget the
        // getter, because we need to remember the original value in case
        // anyone tampers with entry.module.exports[name].
        delete setters[key];
      }
    }
  }
}
1294712
function verifyTsConfig(configFilePath) {
	/**
	 * @type {string[]}
	 */
	const warnings = [];
	const createConfigFileHost = {
		onUnRecoverableConfigFileDiagnostic() {},
		useCaseSensitiveFileNames: false,
		readDirectory: typescript.sys.readDirectory,
		fileExists: typescript.sys.fileExists,
		readFile: typescript.sys.readFile,
		getCurrentDirectory: typescript.sys.getCurrentDirectory,
	};
	const tsconfig = typescript.getParsedCommandLineOfConfigFile(configFilePath, {}, createConfigFileHost);
	if (!tsconfig) {
		return [`could not parse "${configFilePath}"`];
	}
	if (tsconfig.options.skipLibCheck === undefined) {
		warnings.push(
			'skipLibCheck option was NOT specified\n' +
				'By default the fork-ts-checker-webpack-plugin will check all types inside the node_modules directory\n' +
				'even for unused dependencies and slow down the type checking a lot.\n' +
				'To skip that checking add the following line to your tsconfig.json compilerOptions configuration:\n' +
				'"skipLibCheck": true\n' +
				'To keep the default behaviour with possible performance penalties set skipLibCheck to false to hide this warning.\n'
		);
	}
	if (tsconfig.options.moduleResolution === undefined) {
		warnings.push(
			'moduleResolution option was NOT specified\n' +
				'This will result in typescript warnings like "module not found".\n' +
				'To fix that add the following line to your tsconfig.json compilerOptions configuration:\n' +
				'"moduleResolution": "node"\n' +
				'To keep the default behaviour with possible type checking errors set moduleResolution to "classic" to hide this warning.\n'
		);
	}

	return warnings;
}
891231
function Config(options) {
  if (!(this instanceof Config)) {
    return new Config(options);
  }

  utils.is(this, 'config');
  use(this);

  define(this, 'count', 0);
  this.options = options || {};
  this.targets = {};
  this.tasks = {};

  if (utils.isConfig(options)) {
    this.options = {};
    this.expand(options);
    return this;
  }
}
965645
function(object, methods) {
        _.each(methods, function(method, name) {
            if (!_.isFunction(method)) {
                throw new Error('Method "' + name + '" must be a function!');
            }
            object[name] = method
        });
    }
866542
function validateConfig(config){
    let errors = [];

    if( !config.key ){
        errors.push('Missing config \'config.key\' - Undefined Trello Key');
    }
    if( !config.token ){
        errors.push('Missing config \'config.token\' - Undefined Trello Token');
    }
    return errors;
}
808454
function setSuperType(s) {
  const ss = _.isArray(s) ? s : [s]
  this.superClasses = _.uniq(this.superClasses.concat(ss))
}
1259143
function(object, property, value, setter) {
      try { object[property] = value; } catch(e) {}

      try { object.__defineGetter__(property, function() { return value; }); } catch(e) {}
      if (setter) {
        try { object.__defineSetter__(property, function() {}); } catch(e) {}
      }

      if (!wysihtml5.browser.crashesWhenDefineProperty(property)) {
        try {
          var config = {
            get: function() { return value; }
          };
          if (setter) {
            config.set = function() {};
          }
          Object.defineProperty(object, property, config);
        } catch(e) {}
      }
    }
747713
function setFilters (config) {
  const parts = config.filter.split(/[\s,]+/)
  config.filters = {
    should: {},
    ignore: {}
  }
  _.each(parts, addFilter.bind(null, config))
}
836024
function def (params, spec, errs) {
  for (var key in params) {
    if (!spec.hasOwnProperty(key)) defError(key, errs)
  }
}