How to use @putout/engine-parser - 9 common examples

function parseNode(a) {
    if (isStr(a))
        return template.ast(a);
    
    if (!a.node)
        return a;
    
    return a.node;
}

function parseTemplate(tmpl) {
    const node = template.ast(tmpl);
    
    if (tmpl === '__object')
        return [node, __OBJECT_TYPE];
    
    if (tmpl === '__array')
        return [node, __ARRAY_TYPE];
    
    const {type} = node;
    
    return [node, type];
}

const fix = (from, to, path) => {
    const nodeFrom = template.ast(from);
    const watermark = `${from} -> ${to}`;
    
    path._putout = path._putout || [];
    
    if (path._putout.includes(watermark))
        return;
    
    if (!compare(path, nodeFrom))
        return;
    
    if (!to)
        return path.remove();
    
    const nodeTo = template.ast.fresh(to);
    const {node} = path;

const printAST = (a) => isStr(a) ? a : print(a);
const getFn = (a) => (...args) => {

find(ast, {push}) {
            const oldCode = print(ast);
            transform(ast, oldCode, name);
            const newCode = print(ast);
            
            if (newCode === oldCode)
                return;
            
            const positions = getPositions(oldCode, newCode);
            for (const start of positions) {
                const node = {
                    loc: {
                        start,
                    },
                };
                
                const path = {
                    node,

find(ast, {push}) {
            const oldCode = print(ast);
            transform(ast, oldCode, name);
            const newCode = print(ast);
            
            if (newCode === oldCode)
                return;
            
            const positions = getPositions(oldCode, newCode);
            for (const start of positions) {
                const node = {
                    loc: {
                        start,
                    },
                };
                
                const path = {
                    node,
                };

const ast = parse(clearSource, {
        parser,
        isTS,
        isFlow,
        isJSX,
    });
    
    const places = transform(ast, source, opts);
    
    if (!opts.fix)
        return {
            code: source,
            places,
        };
    
    const printed = print(ast);
    const code = `${shebang}${printed}`;
    
    return {
        code,
        places,
    };
};

const generateCode = (a) => generate(a).code;

module.exports = (source, opts) => {
    opts = defaultOpts(opts);
    const {
        parser,
        isTS,
        isFlow,
        isJSX,
    } = opts;
    
    const [clearSource, shebang] = cutShebang(source);
    const ast = parse(clearSource, {
        parser,
        isTS,
        isFlow,
        isJSX,
    });
    
    const places = transform(ast, source, opts);
    
    if (!opts.fix)
        return {
            code: source,
            places,
        };
    
    const printed = print(ast);
    const code = `${shebang}${printed}`;