How to use the putout.isObjectPattern function in putout

}
            
            for (const paramPath of paramsPaths) {
                const {node} = paramPath;
                
                if (isIdentifier(node)) {
                    declare(paramPath, node.name);
                    continue;
                }
                
                if (isAssignmentPattern(node)) {
                    traverseAssign(paramPath);
                    continue;
                }
                
                if (isObjectPattern(node)) {
                    processObj(paramPath.get('properties'));
                    continue;
                }
            }
            
            // ArrowFunction only
            if (isIdentifier(body))
                use(path, body.name);
            
            addParams({
                path,
                params,
            });
        },
        ...jsx(use),

VariableDeclarator(path) {
            const {id, init} = path.node;
            
            const name = 'React';
            
            if (!isObjectPattern(id) || !isIdentifier(init, {name}))
                return;
            
            const propertiesPaths = path.get('id.properties');
            
            for (const propPath of propertiesPaths) {
                const {node} = propPath;
                
                if (isIdentifier(node.key, {name: 'Component'})) {
                    places.push(propPath);
                }
            }
        },
    });

VariableDeclarator(path) {
            const {node} = path;
            const {init} = node;
            const idPath = path.get('id');
            const isForIn = path.parentPath.parentPath.isForInStatement();
            
            if (isIdentifier(node.id)) {
                declare(path, node.id.name);
                isForIn && use(path, node.id.name);
            } else if (isObjectPattern(node.id)) {
                idPath.traverse({
                    ObjectProperty(propPath) {
                        if (isAssignmentPattern(propPath.node.value)) {
                            traverseAssign(propPath.get('value'));
                            return;
                        }
                        
                        if (!isIdentifier(propPath.node.value))
                            return;
                        
                        const {properties} = node.id;
                        const isOne = properties.length === 1;
                        const nodePath = isOne ? path : propPath;
                        
                        declare(nodePath, propPath.node.value.name);
                    },

return (propertiesPaths) => {
        for (const path of propertiesPaths) {
            const {value} = path.node;
            
            if (isIdentifier(value)) {
                declare(path, value.name);
                continue;
            }
            
            if (isObjectPattern(value)) {
                const process = processObjectPattern({use, declare});
                process(path.get('value.properties'));
                continue;
            }
            
            if (isAssignmentPattern(value)) {
                const useAssignment = traverseAssignmentPattern({
                    use,
                });
                useAssignment(path.get('value.right'));
                
                const leftPath = path.get('value.left');
                
                if (leftPath.isIdentifier())
                    declare(path, leftPath.node.name);