code: function isOrderUnpredictable (node) {
      while ((node = node.parent)) {
        // Special-case for IIFE, behaviour is the same as evaluating inline
        if (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
          // (() => {})()
          if (node.parent && node.parent.type === 'CallExpression' && node.parent.callee === node) {
            continue
          }
          // (function(){}).call(null)
          // this form is added by browserify to inject globals
          if (node.parent && node.parent.type === 'MemberExpression' &&
              node.parent.object === node &&
              (node.parent.property.name === 'call' || node.parent.property.name === 'apply') &&
              node.parent.parent && node.parent.parent.type === 'CallExpression') {
            continue
          }
        }
  
        // if(require('d')) is still in-order
        // the same is technically true for while(require()) and for(require();;) but those are more rare
        if (node.parent && node.parent.type === 'IfStatement' && node.parent.test === node) {
          // Skip the IfStatement
          node = node.parent
          continue
        }
  
        if (node.type === 'IfStatement' || // if(false) require()
            node.type === 'WhileStatement' || // while(false) require()
            node.type === 'ForStatement' || // for(;false;) require()
            node.type === 'ForInStatement' || // for(x in []) require()
            node.type === 'FunctionExpression' || // setTimeout(function(){ require() })
            node.type === 'FunctionDeclaration' || // function neverCalled(){ require() }
            node.type === 'ArrowFunctionExpression' // setTimeout(()=> require())
        ) {
          return true
        }
      }
      return false
    }
docs: Determine if a require() call may not be evaluated according to its linear source position This happens primarily if the call is inside a function, or inside a conditional branch