const isProduction = process.env.NODE_ENV === 'production';
542405
function htmlBeautify(content) {
    const htmlBeautifyOptions = {
        // wrap_line_length: '80',
        indent_size: 2,
        preserve_newlines: false,
        max_preserve_newlines: 0,
        e4x: true,
        unformatted: [
            'a',
            'span',
            'img',
            'code',
            'pre',
            'sub',
            'sup',
            'em',
            'strong',
            'b',
            'i',
            'u',
            'strike',
            'big',
            'small',
            'pre',
            'h1',
            'h2',
            'h3',
            'h4',
            'h5',
            'h6'
        ]
    };

    // if (isProduction) {
    //     return content;
    // }
    return jsBeautify.html(content, htmlBeautifyOptions);
}
650295
function () {
	      if (!specialPropKeyWarningShown) {
	        specialPropKeyWarningShown = true;
	        process.env.NODE_ENV !== 'production' ? warning(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName) : void 0;
	      }
	      return undefined;
	    }
1287859
function envFromArgs(args) {
	if (!args) return 'prod';
	const envIndex = args.indexOf('--env');
	const devIndex = args.indexOf('dev');
	if (envIndex === devIndex - 1) return 'dev';
	return 'prod';
}
169489
function envVars(config, backRef)
{
  backRef = backRef || [];

  Object.keys(config).forEach(function(key)
  {
    var value;

    if (typeof config[key] == 'string')
    {
      // try simple match first, for non-empty value
      value = getVar.call(this, config[key], process.env);

      // if not, try parsing for variables
      if (!hasValue(value))
      {
        value = parseTokens.call(this, config[key], process.env);
      }

      // keep the entry if something's been resolved
      // empty or unchanged value signal otherwise
      if (hasValue(value))
      {
        config[key] = value;
      }
      else
      {
        delete config[key];
      }
    }
    else if (isObject(config[key]))
    {
      envVars.call(this, config[key], backRef.concat(key));
    }
    // Unsupported entry type
    else
    {
      throw new Error('Illegal key type for custom-environment-variables at ' + backRef.concat(key).join('.') + ': ' + Object.prototype.toString.call(config[key]));
    }
  }.bind(this));

  return config;
}
611087
function () {
        let usingNode = false;
        if (typeof process === 'object') {
            if (typeof process.versions === 'object') {
                if (typeof process.versions.node !== 'undefined') {
                    usingNode = true;
                }
            }
        }

        return usingNode;
    }
1264741
function envOrSource(env, source) {
    function getKey(keyName) {
        return env[keyName] || source[keyName];
    }
    return getKey;
}
1304728
def get_recipe_env(self, arch=None, with_flags_in_cc=True, clang=False):
        
        if arch is None:
            arch = self.filtered_archs[0]
        return arch.get_env(with_flags_in_cc=with_flags_in_cc, clang=clang)
343251
function inlineNodeEnvironmentVariables(data) {
	var dependencyGraph = data.graph;
	var configuration = data.configuration;
	var options = configuration.options;

	if (options.envify) {
		winston.info("Inlining Node-style environment variables...");
		envifyGraph(dependencyGraph, options);
		envifyGraph(data.configGraph, options);
	}

	return data;
}
166081
function () {
	    var Interface = this.constructor.Interface;
	    for (var propName in Interface) {
	      if (process.env.NODE_ENV !== 'production') {
	        Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
	      } else {
	        this[propName] = null;
	      }
	    }
	    for (var i = 0; i < shouldBeReleasedProperties.length; i++) {
	      this[shouldBeReleasedProperties[i]] = null;
	    }
	    if (process.env.NODE_ENV !== 'production') {
	      Object.defineProperty(this, 'nativeEvent', getPooledWarningPropertyDefinition('nativeEvent', null));
	      Object.defineProperty(this, 'preventDefault', getPooledWarningPropertyDefinition('preventDefault', emptyFunction));
	      Object.defineProperty(this, 'stopPropagation', getPooledWarningPropertyDefinition('stopPropagation', emptyFunction));
	    }
	  }
789232
private void convertSingleProductions(String productionName,
	    ParseTreeNode productionConstructions) throws TreeException,
	    GrammarException {
	for (ParseTreeNode productionConstruction : productionConstructions
		.getChildren("ProductionConstruction")) {
	    convertSingleProduction(productionName, productionConstruction);
	}
    }
417715
async function main () {
  console.log(`\n\n[Single step producer]`);
  const workers1 = [
    new Producer(100),
    new Producer(100),
    new Producer(100),
    new Producer(100),
    new Producer(100),
    new Consumer(200),
    new Consumer(300),
  ];
  await Promise.all(workers1.map(x => x.work()));

  console.log(`\n\n[Efficient producer]`);
  const workers2 = [
    new EfficientProducer(10),
    new Consumer(10),
    new Consumer(10),
    new Consumer(10),
    new Consumer(10),
    new Consumer(10),
    new Consumer(10),
    new Consumer(20),
    new Consumer(20),
  ];
  await Promise.all(workers2.map(x => x.work()));

  console.log(`\n\n[RejectAll() API test]`);
  const p = new Consumer(1).work();
  stock.notempty.rejectAll();
  p.then(
    () => console.error(`[ERROR] This promise should not resolve.`),
    err => console.log(`Successfully received a rejected Error - ${err.message}`)
  );
}
651367
function getEnv(key) {
  return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || '';
}
1131720
function(configPath, configNames, config) {
	var configsUsed = [];

	config = config || projectConfig;

	// work with the raw configuration object
	if (config && config.root) {
		config = config.root();
	}

	config = convict(config);
	configPath = path.resolve(appPath, configPath);
	configNames = configNames || [];

	configNames.forEach(function(configName) {
		var file;

		// Ignore local config in production mode
		if (configName == 'local' && nodeEnv === 'production') { return; }

		file = path.join(configPath, 'config-'+configName);
		file += configName === 'default' ? '.js' : '.json';

		if (fs.existsSync(file)) {

			if (configName === 'default') {
				config = convict( require(file) );
				config.load(dynamicDefaults);
			}
			else {
				config.loadFile( file );
			}

			// logging
			configName === 'default' ? configsUsed.push('xtc defaults') : configsUsed.push(configName);
		}
	});

	// be informative
	!process.env.testRun
		&& configsUsed.push('env', 'args')
		&& console.log('configuration:', configsUsed.join(' < '));

	return config;
}
278405
function isConstantFunction (node) {
  return isFunctionDefinition(node) && (
    node.attributes.constant === true ||
    node.attributes.stateMutability === 'view' ||
    node.attributes.stateMutability === 'pure'
  )
}
328048
function(nodePath) {
            const node = nodePath.value;
            imports[node.source.value] = true;
            return false;
        }
239369
function findDOMNode(componentOrElement) {
	  if (process.env.NODE_ENV !== 'production') {
	    var owner = ReactCurrentOwner.current;
	    if (owner !== null) {
	      process.env.NODE_ENV !== 'production' ? warning(owner._warnedAboutRefsInRender, '%s is accessing findDOMNode inside its render(). ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', owner.getName() || 'A component') : void 0;
	      owner._warnedAboutRefsInRender = true;
	    }
	  }
	  if (componentOrElement == null) {
	    return null;
	  }
	  if (componentOrElement.nodeType === 1) {
	    return componentOrElement;
	  }

	  var inst = ReactInstanceMap.get(componentOrElement);
	  if (inst) {
	    inst = getHostComponentFromComposite(inst);
	    return inst ? ReactDOMComponentTree.getNodeFromInstance(inst) : null;
	  }

	  if (typeof componentOrElement.render === 'function') {
	    process.env.NODE_ENV !== 'production' ? invariant(false, 'findDOMNode was called on an unmounted component.') : _prodInvariant('44');
	  } else {
	    process.env.NODE_ENV !== 'production' ? invariant(false, 'Element appears to be neither ReactComponent nor DOMNode (keys: %s)', Object.keys(componentOrElement)) : _prodInvariant('45', Object.keys(componentOrElement));
	  }
	}
1054254
private static function environment() {
	$environment = getenv('APP_ENV') ?: 'production';
	
	define('alsvanzelf\fem\ENVIRONMENT',  $environment);
	define('alsvanzelf\fem\ROOT_DIR',     realpath(__DIR__.'/../../../../').'/');
	define('alsvanzelf\fem\ROOT_DIR_APP', \alsvanzelf\fem\ROOT_DIR.'application/');
	define('alsvanzelf\fem\CLI',          (strpos(php_sapi_name(), 'cli') !== false || defined('STDIN')));
	
	if (constant('\alsvanzelf\fem\ENVIRONMENT') == false) {
		echo 'no environment set';
		exit;
	}
}