How to use the putout.isAssignmentPattern function in putout

if (id) {
                declare(path, node.id.name);
                
                if (!parentPath.isBlock() && !parentPath.isProgram())
                    use(path, node.id.name);
            }
            
            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,

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);
                
                continue;
            }
        }
    };
};

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);
                    },
                });