How to use the esotope-hammerhead.Syntax.UpdateExpression function in esotope-hammerhead

// Skip: function location() {}
        if ((parent.type === Syntax.FunctionExpression || parent.type === Syntax.FunctionDeclaration) &&
            parent.id === node)
            return false;

        // Skip: object.location || location.field
        if (parent.type === Syntax.MemberExpression)
            return false;

        // Skip: { location: value }
        if (parent.type === Syntax.Property && parent.key === node)
            return false;

        // Skip: location++ || location-- || ++location || --location
        if (parent.type === Syntax.UpdateExpression && (parent.operator === '++' || parent.operator === '--'))
            return false;

        // Skip: function (location) { ... } || function func(location) { ... } || location => { ... }
        if ((parent.type === Syntax.FunctionExpression || parent.type === Syntax.FunctionDeclaration ||
             parent.type === Syntax.ArrowFunctionExpression) && parent.params.indexOf(node) !== -1)
            return false;

        // Skip already transformed: __get$Loc(location)
        if (parent.type === Syntax.CallExpression && parent.callee.type === Syntax.Identifier &&
            parent.callee.name === INSTRUCTION.getLocation)
            return false;

        // Skip: class X { location () {} }
        if (parent.type === Syntax.MethodDefinition)
            return false;

// Skip: { eval: value }
            if (parent.type === Syntax.Property && parent.key === node)
                return false;

            // Skip: eval = value || function x (eval = value) { ... }
            if ((parent.type === Syntax.AssignmentExpression || parent.type === Syntax.AssignmentPattern) &&
                parent.left === node)
                return false;

            // Skip: const eval = value;
            if (parent.type === Syntax.VariableDeclarator && parent.id === node)
                return false;

            // Skip: eval++ || eval-- || ++eval || --eval
            if (parent.type === Syntax.UpdateExpression && (parent.operator === '++' || parent.operator === '--'))
                return false;

            // Skip already transformed: __get$Eval(eval)
            if (parent.type === Syntax.CallExpression && parent.callee.type === Syntax.Identifier &&
                parent.callee.name === INSTRUCTION.getEval)
                return false;

            // Skip: function x (...eval) {}
            if (parent.type === Syntax.RestElement)
                return false;

            return true;
        }

        return false;
    },

return false;

        // Skip: object.prop = value
        if (parent.type === Syntax.AssignmentExpression && parent.left === node)
            return false;

        // Skip: delete object.prop
        if (parent.type === Syntax.UnaryExpression && parent.operator === 'delete')
            return false;

        // Skip: object.prop()
        if (parent.type === Syntax.CallExpression && parent.callee === node)
            return false;

        // Skip: object.prop++ || object.prop-- || ++object.prop || --object.prop
        if (parent.type === Syntax.UpdateExpression && parent.operator === '++' || parent.operator === '--')
            return false;

        // Skip: new (object.prop)() || new (object.prop)
        if (parent.type === Syntax.NewExpression && parent.callee === node)
            return false;

        // Skip: for(object.prop in source)
        if (parent.type === Syntax.ForInStatement && parent.left === node)
            return false;

        return true;
    },

return false;

        // super[prop]
        if (node.object.type === Syntax.Super)
            return false;

        // object[prop] = value
        if (parent.type === Syntax.AssignmentExpression && parent.left === node)
            return false;

        // delete object[prop]
        if (parent.type === Syntax.UnaryExpression && parent.operator === 'delete')
            return false;

        // object[prop]++ || object[prop]-- || ++object[prop] || --object[prop]
        if (parent.type === Syntax.UpdateExpression && parent.operator === '++' || parent.operator === '--')
            return false;

        // object[prop]()
        if (parent.type === Syntax.CallExpression && parent.callee === node)
            return false;

        // new (object[prop])() || new (object[prop])
        if (parent.type === Syntax.NewExpression && parent.callee === node)
            return false;

        // for(object[prop] in source)
        if (parent.type === Syntax.ForInStatement && parent.left === node)
            return false;

        return true;
    },

// Skip: { postMessage: value }
        if (parent.type === Syntax.Property && parent.key === node)
            return false;

        // Skip: postMessage = value || function x (postMessage = value) { ... }
        if ((parent.type === Syntax.AssignmentExpression || parent.type === Syntax.AssignmentPattern) &&
            parent.left === node)
            return false;

        // Skip: const postMessage = value;
        if (parent.type === Syntax.VariableDeclarator && parent.id === node)
            return false;

        // Skip: postMessage++ || postMessage-- || ++postMessage || --postMessage
        if (parent.type === Syntax.UpdateExpression && (parent.operator === '++' || parent.operator === '--'))
            return false;

        // Skip already transformed: __get$PostMessage(postMessage) || __call$(obj, postMessage, args...);
        if (parent.type === Syntax.CallExpression && parent.callee.type === Syntax.Identifier &&
            (parent.callee.name === INSTRUCTION.getPostMessage ||
             parent.callee.name === INSTRUCTION.callMethod && parent.arguments[1] === node))
            return false;

        // Skip: function x (...postMessage) {}
        if (parent.type === Syntax.RestElement)
            return false;

        return true;
    },