'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;

class TrustedFunction {
  static policy = trustedTypes.createPolicy('TrustedFunctionWorkaround', {
    createScript: (_, ...args) => {
       args.forEach( (arg) => {
         if (!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;
};