code: function isConstant(node, inBooleanPosition) {
              switch (node.type) {
                  case "Literal":
                  case "ArrowFunctionExpression":
                  case "FunctionExpression":
                  case "ObjectExpression":
                  case "ArrayExpression":
                      return true;
  
                  case "UnaryExpression":
                      if (node.operator === "void") {
                          return true;
                      }
  
                      return (node.operator === "typeof" && inBooleanPosition) ||
                          isConstant(node.argument, true);
  
                  case "BinaryExpression":
                      return isConstant(node.left, false) &&
                              isConstant(node.right, false) &&
                              node.operator !== "in";
  
                  case "LogicalExpression": {
                      const isLeftConstant = isConstant(node.left, inBooleanPosition);
                      const isRightConstant = isConstant(node.right, inBooleanPosition);
                      const isLeftShortCircuit = (isLeftConstant && isLogicalIdentity(node.left, node.operator));
                      const isRightShortCircuit = (isRightConstant && isLogicalIdentity(node.right, node.operator));
  
                      return (isLeftConstant && isRightConstant) ||
                          (
  
                              // in the case of an "OR", we need to know if the right constant value is truthy
                              node.operator === "||" &&
                              isRightConstant &&
                              node.right.value &&
                              (
                                  !node.parent ||
                                  node.parent.type !== "BinaryExpression" ||
                                  !(EQUALITY_OPERATORS.includes(node.parent.operator) || RELATIONAL_OPERATORS.includes(node.parent.operator))
                              )
                          ) ||
                          isLeftShortCircuit ||
                          isRightShortCircuit;
                  }
  
                  case "AssignmentExpression":
                      return (node.operator === "=") && isConstant(node.right, inBooleanPosition);
  
                  case "SequenceExpression":
                      return isConstant(node.expressions[node.expressions.length - 1], inBooleanPosition);
  
                  // no default
              }
              return false;
          }
docs: Checks if a node has a constant truthiness value.
  @param {ASTNode} node The AST node to check.
  @param {boolean} inBooleanPosition `false` if checking branch of a condition.
  `true` in all other cases
  @returns {Bool} true when node's truthiness is constant
  @private