'use strict';

var toStr = Object.prototype.toString;
var fnToStr = Function.prototype.toString;
var isFnRegex = /^\s*(?:function)?\*/;
var hasToStringTag = require('has-tostringtag/shams')();
var getProto = Object.getPrototypeOf;

if (self.trustedTypes && self.trustedTypes.createPolicy) {
	class TrustedFunction {
  	static policy = self.trustedTypes.createPolicy('TrustedFunctionWorkaround', {
    	createScript: (_, ...args) => {
       	args.forEach( (arg) => {
         	if (!self.trustedTypes.isScript(arg)) {
           	throw new Error("TrustedScripts only, please");
         	}
       	});
       
       	// NOTE: This is insecure without parsing the arguments and body, 
       	// Malicious inputs  can escape the function body and execute immediately!
       
       	const fnArgs = args.slice(0, -1).join(',');
       	const fnBody = args.pop().toString();
       	const body = `(function anonymous(
       	${fnArgs}
       	) {
       	${fnBody}
       	})`;
       	return body;
    	}
  	});

  	constructor(...args) {
    	return (window || self).eval(TrustedFunction.policy.createScript('', ...args));
  	} 
	}
}

var getGeneratorFunc = function () { // eslint-disable-line consistent-return
	if (!hasToStringTag) {
		return false;
	}
	try {
		if (self.trustedTypes && self.trustedTypes.createPolicy) {
			return TrustedFunction('return function*() {}');
		}
		else {
			return Function('return function*() {}')();
		}
	} catch (e) {
	}
};
var GeneratorFunction;

module.exports = function isGeneratorFunction(fn) {
	if (typeof fn !== 'function') {
		return false;
	}
	if (isFnRegex.test(fnToStr.call(fn))) {
		return true;
	}
	if (!hasToStringTag) {
		var str = toStr.call(fn);
		return str === '[object GeneratorFunction]';
	}
	if (!getProto) {
		return false;
	}
	if (typeof GeneratorFunction === 'undefined') {
		var generatorFunc = getGeneratorFunc();
		GeneratorFunction = generatorFunc ? getProto(generatorFunc) : false;
	}
	return getProto(fn) === GeneratorFunction;
};