@putout/printer 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) coderaiser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,37 @@
+# Printer [![NPM version][NPMIMGURL]][NPMURL]
+
+[NPMIMGURL]: https://img.shields.io/npm/v/@putout/printer.svg?style=flat&longCache=true
+[NPMURL]: https://npmjs.org/package/@putout/printer "npm"
+
+**EasyPrint** prints [**Babel AST**](https://github.com/coderaiser/estree-to-babel) to readable **JavaScript**.
+
+- ☝️ Similar to **Recast**, but simpler and easier in maintenance, since it supports only **Babel**.
+- ☝️ As opinionated as **Prettier**, but has more user-friendly output and works directly with **AST**.
+- ☝️ Like **ESLint** but without any configuration and plugins 🤷‍, also works directly with **Babel AST** only.
+
+## Install
+
+```
+npm i @putout/printer
+```
+
+## API
+
+```js
+const {print} = require('@putout/printer');
+const {parse} = require('@babel/parser');
+
+const ast = parse('const a = (b, c) => {const d = 5; return a;}');
+print(ast);
+// returns
+`
+const a = (b, c) => {
+    const d = 5;
+    return a;
+};
+`;
+```
+
+## License
+
+MIT

package/lib/expressions/arrays.js

@@ -0,0 +1,33 @@
+'use strict';
+
+module.exports.ArrayPattern = (path, {write, traverse}) => {
+    write('[');
+    
+    for (const element of path.get('elements')) {
+        traverse(element);
+    }
+    
+    write(']');
+};
+
+module.exports.ArrayExpression = (path, {write, indent, incIndent, decIndent, traverse}) => {
+    write('[');
+    incIndent();
+    
+    const elements = path.get('elements');
+    
+    for (const element of elements) {
+        write('\n');
+        indent();
+        traverse(element);
+        write(',\n');
+    }
+    
+    decIndent();
+    
+    if (elements.length)
+        indent();
+    
+    write(']');
+};
+

package/lib/expressions/assignment-expression.js

@@ -0,0 +1,25 @@
+'use strict';
+
+module.exports.AssignmentExpression = (path, {traverse, write}) => {
+    if (shouldAddNewLine(path))
+        write('\n');
+    
+    traverse(path.get('left'));
+    write(` ${path.node.operator} `);
+    traverse(path.get('right'));
+};
+
+function shouldAddNewLine({parentPath}) {
+    const prevPath = parentPath.getPrevSibling();
+    const prevPrevPath = prevPath.getPrevSibling();
+    
+    const twoPrev = prevPath.node && prevPrevPath.node;
+    
+    if (!twoPrev)
+        return false;
+    
+    if (prevPath.isExpressionStatement() && prevPath.get('expression').isAssignmentExpression())
+        return false;
+    
+    return true;
+}

package/lib/expressions/call-expression.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const {entries} = Object;
+
+module.exports.CallExpression = (path, {traverse, indent, write, writeEmptyLine, incIndent, decIndent, maybeWrite}) => {
+    const isParentCall = toLong(path) && path.parentPath.isCallExpression();
+    
+    if (shouldAddNewLine(path))
+        writeEmptyLine();
+    
+    traverse(path.get('callee'));
+    write('(');
+    
+    const args = path.get('arguments');
+    const n = args.length - 1;
+    
+    if (isParentCall)
+        incIndent();
+    
+    for (const [i, arg] of entries(args)) {
+        if (isParentCall) {
+            write('\n');
+            indent();
+        }
+        
+        traverse(arg);
+        
+        if (isParentCall) {
+            write(',');
+            continue;
+        }
+        
+        maybeWrite(i < n, ', ');
+    }
+    
+    if (isParentCall) {
+        decIndent();
+        writeEmptyLine();
+    }
+    
+    write(')');
+};
+
+function shouldAddNewLine({parentPath}) {
+    if (!parentPath.isExpressionStatement())
+        return false;
+    
+    const prevPath = parentPath.getPrevSibling();
+    const prevPrevPath = prevPath.getPrevSibling();
+    
+    if (prevPath.isStatement() && !prevPath.isExpressionStatement() && !prevPath.isVariableDeclaration())
+        return true;
+    
+    const twoPrev = prevPath.node && prevPrevPath.node;
+    
+    if (!twoPrev)
+        return false;
+    
+    if (prevPath.isExpressionStatement() && prevPath.get('expression').isCallExpression())
+        return false;
+    
+    return true;
+}
+
+function toLong(path) {
+    const args = path.get('arguments');
+    
+    for (const arg of args) {
+        if (arg.isIdentifier() && arg.node.name.length > 5)
+            return true;
+    }
+    
+    return false;
+}

package/lib/expressions/class-declaration.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const {entries} = Object;
+
+const isFirst = (path) => path.node === path.parentPath.node.body[0];
+
+module.exports.ClassDeclaration = (path, {write, maybeWrite, writeEmptyLine, indent, incIndent, decIndent, traverse}) => {
+    if (!isFirst(path)) {
+        writeEmptyLine();
+    }
+    
+    indent();
+    write('class ');
+    traverse(path.get('id'));
+    write(' {\n');
+    incIndent();
+    
+    const body = path.get('body.body');
+    const n = body.length - 1;
+    
+    for (const [i, item] of entries(body)) {
+        indent();
+        traverse(item);
+        maybeWrite(i < n, '\n');
+    }
+    
+    decIndent();
+    write('}');
+};
+

package/lib/expressions/functions.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const isFirst = (path) => path.node === path.parentPath.node.body[0];
+
+module.exports.ArrowFunctionExpression = (path, {write, traverse}) => {
+    write('(');
+    
+    const params = path.get('params');
+    const n = params.length;
+    
+    for (let i = 0; i < n; i++) {
+        traverse(params[i]);
+        
+        if (i < n - 1)
+            write(', ');
+    }
+    
+    write(') => ');
+    traverse(path.get('body'));
+};
+
+module.exports.ObjectMethod = (path, {write, traverse}) => {
+    traverse(path.get('key'));
+    write('(');
+    
+    const params = path.get('params');
+    const n = params.length - 1;
+    
+    for (let i = 0; i <= n; i++) {
+        traverse(params[i]);
+        
+        if (i < n)
+            write(', ');
+    }
+    
+    write(') ');
+    traverse(path.get('body'));
+};
+
+module.exports.FunctionDeclaration = (path, {write, traverse}) => {
+    if (!isFirst(path))
+        write('\n');
+    
+    write('function ');
+    traverse(path.get('id'));
+    write('(');
+    
+    const params = path.get('params');
+    const n = params.length - 1;
+    
+    for (let i = 0; i <= n; i++) {
+        traverse(params[i]);
+        
+        if (i < n)
+            write(', ');
+    }
+    
+    write(') ');
+    traverse(path.get('body'));
+};
+
+module.exports.ClassMethod = (path, {write, traverse}) => {
+    traverse(path.get('key'));
+    write('(');
+    
+    const params = path.get('params');
+    const n = params.length;
+    
+    for (let i = 0; i < n; i++) {
+        traverse(params[i]);
+        
+        if (i < n - 1)
+            write(', ');
+    }
+    
+    write(') ');
+    traverse(path.get('body'));
+};

package/lib/expressions/index.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const functions = require('./functions');
+const arrays = require('./arrays');
+const unaryExpressions = require('./unary-expressions');
+const memberExpressions = require('./member-expressions');
+const {ClassDeclaration} = require('./class-declaration');
+const {CallExpression} = require('./call-expression');
+const {NewExpression} = require('./new-expression');
+const {ObjectExpression} = require('./object-expression');
+const {ObjectPattern} = require('./object-pattern');
+const {AssignmentExpression} = require('./assignment-expression');
+
+module.exports = {
+    ...functions,
+    ...unaryExpressions,
+    ...arrays,
+    ...memberExpressions,
+    AssignmentExpression,
+    CallExpression,
+    ClassDeclaration,
+    NewExpression,
+    ObjectExpression,
+    ObjectPattern,
+    BinaryExpression(path, {traverse, write}) {
+        traverse(path.get('left'));
+        write(` ${path.node.operator} `);
+        traverse(path.get('right'));
+    },
+    LogicalExpression(path, {traverse, write}) {
+        traverse(path.get('left'));
+        write(` ${path.node.operator} `);
+        traverse(path.get('right'));
+    },
+};
+

package/lib/expressions/member-expressions.js

@@ -0,0 +1,28 @@
+'use strict';
+
+module.exports.MemberExpression = (path, {traverse, write}) => {
+    const {computed} = path.node;
+    const propertyPath = path.get('property');
+    
+    traverse(path.get('object'));
+    
+    if (computed) {
+        write('[');
+        traverse(propertyPath);
+        write(']');
+        
+        return;
+    }
+    
+    write('.');
+    traverse(propertyPath);
+};
+
+module.exports.OptionalMemberExpression = (path, {traverse, write}) => {
+    const propertyPath = path.get('property');
+    
+    traverse(path.get('object'));
+    
+    write('?.');
+    traverse(propertyPath);
+};

package/lib/expressions/new-expression.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const {entries} = Object;
+
+module.exports.NewExpression = (path, {write, maybeWrite, traverse, indent}) => {
+    indent();
+    write('new ');
+    traverse(path.get('callee'));
+    
+    const args = path.get('arguments');
+    write('(');
+    
+    const n = args.length - 1;
+    
+    for (const [i, arg] of entries(args)) {
+        traverse(arg);
+        maybeWrite(i < n, ', ');
+    }
+    
+    write(')');
+};
+

package/lib/expressions/object-expression.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const isBodyOfArrow = (path) => path.parentPath.node.body === path.node;
+
+module.exports.ObjectExpression = (path, {traverse, write, maybeWrite, maybeIndent, incIndent, decIndent}) => {
+    incIndent();
+    
+    const properties = path.get('properties');
+    const parens = isBodyOfArrow(path);
+    const isCall = path.parentPath.isCallExpression();
+    const isOneLine = isCall && properties.length < 2;
+    
+    maybeWrite(parens, '(');
+    write('{');
+    
+    maybeWrite(!isOneLine, '\n');
+    
+    for (const property of properties) {
+        const {shorthand, computed} = property.node;
+        
+        maybeIndent(!isOneLine);
+        
+        if (property.isObjectMethod()) {
+            traverse(property);
+            continue;
+        }
+        
+        maybeWrite(computed, '[');
+        traverse(property.get('key'));
+        maybeWrite(computed, ']');
+        
+        if (!shorthand) {
+            write(': ');
+            traverse(property.get('value'));
+        }
+        
+        maybeWrite(!isOneLine, ',\n');
+    }
+    
+    decIndent();
+    maybeIndent(!isOneLine);
+    write('}');
+    maybeWrite(parens, ')');
+};

package/lib/expressions/object-pattern.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const {entries} = Object;
+const isForOf = (path) => path.parentPath?.parentPath?.parentPath?.isForOfStatement();
+
+module.exports.ObjectPattern = (path, {traverse, maybeIndent, write, maybeWrite, incIndent, decIndent}) => {
+    incIndent();
+    
+    write('{');
+    
+    const properties = path.get('properties');
+    const n = properties.length - 1;
+    
+    const is = !isForOf(path) && !path.parentPath.isFunction() && properties.length > 1 && checkLength(properties);
+    maybeWrite(is, '\n');
+    
+    for (const [i, property] of entries(properties)) {
+        const {shorthand} = property.node;
+        maybeIndent(is);
+        traverse(property.get('key'));
+        
+        if (!shorthand) {
+            write(': ');
+            traverse(property.get('value'));
+        }
+        
+        if (is) {
+            write(',\n');
+            continue;
+        }
+        
+        if (i < n)
+            write(', ');
+    }
+    
+    decIndent();
+    maybeIndent(is);
+    write('}');
+};
+
+function checkLength(properties) {
+    for (const prop of properties) {
+        if (prop.node.value.name.length > 4)
+            return true;
+    }
+    
+    return false;
+}

package/lib/expressions/unary-expressions.js

@@ -0,0 +1,16 @@
+'use strict';
+
+module.exports.UnaryExpression = unaryExpressions;
+module.exports.UpdateExpression = unaryExpressions;
+
+function unaryExpressions(path, {traverse, write}) {
+    const {prefix, operator} = path.node;
+    
+    if (prefix)
+        write(operator);
+    
+    traverse(path.get('argument'));
+    
+    if (!prefix)
+        write(operator);
+}

package/lib/literals/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const {TemplateLiteral} = require('./template-literal');
+
+module.exports = {
+    TemplateLiteral,
+    NumericLiteral(path, {write}) {
+        write(path.node.value);
+    },
+    BooleanLiteral(path, {write}) {
+        write(path.node.value);
+    },
+    StringLiteral(path, {write}) {
+        const {value} = path.node;
+        write(`'${value}'`);
+    },
+    Identifier(path, {write}) {
+        write(path.node.name);
+    },
+};
+

package/lib/literals/template-literal.js

@@ -0,0 +1,22 @@
+'use strict';
+
+module.exports.TemplateLiteral = (path, {write, traverse}) => {
+    write('`');
+    
+    let i = 0;
+    const expressions = path.get('expressions');
+    
+    for (const element of path.node.quasis) {
+        write(element.value.raw);
+        const exp = expressions[i++];
+        
+        if (exp) {
+            write('${');
+            traverse(exp);
+            write('}');
+        }
+    }
+    
+    write('`');
+};
+

package/lib/printer.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const babelTraverse = require('@babel/traverse').default;
+const expressions = require('./expressions');
+const statements = require('./statements');
+const literals = require('./literals');
+const toSnakeCase = require('just-snake-case');
+
+const traversers = {
+    ...expressions,
+    ...statements,
+    ...literals,
+};
+
+const {DEBUG} = process.env;
+
+module.exports.print = function print(ast) {
+    const tokens = [];
+    const write = (a) => {
+        tokens.push(a);
+    };
+    
+    const indent = () => {
+        write(printIndent(i));
+    };
+    
+    const debug = (a) => maybeWrite(DEBUG, `/*__${toSnakeCase(a)}*/`);
+    const maybeWrite = (a, b) => a && write(b);
+    const maybeIndent = (a) => a && indent();
+    
+    let i = 0;
+    const incIndent = () => ++i;
+    const decIndent = () => --i;
+    
+    const writeEmptyLine = () => {
+        write('\n');
+        indent();
+    };
+    
+    const printer = {
+        incIndent,
+        decIndent,
+        indent,
+        write,
+        maybeWrite,
+        debug,
+        maybeIndent,
+        traverse,
+        writeEmptyLine,
+    };
+    
+    babelTraverse(ast, {
+        Program(path) {
+            traverse(path);
+            path.stop();
+        },
+    });
+    
+    function traverse(path) {
+        const {type} = path;
+        const currentTraverse = traversers[type];
+        
+        if (!path.node)
+            return;
+        
+        if (!currentTraverse)
+            throw Error(`Node type '${type}' is not supported yet: '${path}'`);
+        
+        currentTraverse(path, printer);
+        debug(path.type);
+    }
+    
+    return tokens.join('');
+};
+
+function printIndent(i) {
+    let result = '';
+    ++i;
+    
+    while (--i) {
+        result += '    ';
+    }
+    
+    return result;
+}
+

package/lib/statements/block-statement.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const isFirstStatement = (path) => path.get('body.0')?.isStatement();
+
+module.exports.BlockStatement = (path, {write, indent, incIndent, decIndent, traverse}) => {
+    const body = path.get('body');
+    
+    incIndent();
+    write('{');
+    
+    if (body.length > 1 || isFirstStatement(path))
+        write('\n');
+    
+    body.forEach(traverse);
+    decIndent();
+    
+    if (body.length)
+        indent();
+    
+    write('}');
+    
+    if (path.parentPath.isObjectMethod()) {
+        write(',');
+    }
+    
+    if (!/FunctionExpression/.test(path.parentPath.type))
+        write('\n');
+};
+

package/lib/statements/expression-statement.js

@@ -0,0 +1,54 @@
+'use strict';
+
+module.exports.ExpressionStatement = (path, {write, indent, traverse}) => {
+    if (isCoupleLinesExpression(path) && !isFirst(path) && shouldAddNewLine(path)) {
+        write('\n');
+        indent();
+    }
+    
+    const expressionPath = path.get('expression');
+    
+    indent();
+    traverse(expressionPath);
+    write(';\n');
+    
+    if (isStrictMode(path))
+        write('\n');
+};
+
+function isCoupleLinesExpression(path) {
+    const start = path.node.loc?.start.line;
+    const end = path.node.loc?.end.line;
+    
+    return end > start;
+}
+
+function isStrictMode(path) {
+    const expressionPath = path.get('expression');
+    
+    if (!expressionPath.isStringLiteral())
+        return false;
+    
+    const {value} = path.node.expression;
+    
+    return value === 'use strict';
+}
+
+function isFirst(path) {
+    return path.node === path.parentPath.node.body[0];
+}
+
+function shouldAddNewLine(path) {
+    const prev = path.getPrevSibling();
+    
+    if (prev.isVariableDeclaration())
+        return false;
+    
+    if (prev.isIfStatement())
+        return false;
+    
+    if (isStrictMode(prev))
+        return false;
+    
+    return true;
+}

package/lib/statements/for-of-statement.js

@@ -0,0 +1,31 @@
+'use strict';
+
+module.exports.ForOfStatement = (path, {write, indent, incIndent, traverse}) => {
+    if (!isFirst(path)) {
+        indent();
+        write('\n');
+    }
+    
+    indent();
+    write('for (');
+    traverse(path.get('left'));
+    write(' of ');
+    traverse(path.get('right'));
+    write(')');
+    
+    const bodyPath = path.get('body');
+    
+    if (bodyPath.isExpressionStatement()) {
+        incIndent();
+        write('\n');
+        traverse(bodyPath);
+        
+        return;
+    }
+    
+    write(' ');
+    traverse(bodyPath);
+};
+function isFirst(path) {
+    return path.node === path.parentPath.node.body[0];
+}

package/lib/statements/if-statement.js

@@ -0,0 +1,40 @@
+'use strict';
+
+module.exports.IfStatement = (path, {write, indent, traverse, incIndent, decIndent}) => {
+    if (!isFirst(path)) {
+        indent();
+        write('\n');
+    }
+    
+    indent();
+    write('if (');
+    traverse(path.get('test'));
+    write(')');
+    
+    const consequent = path.get('consequent');
+    
+    if (consequent.isBlockStatement()) {
+        write(' ');
+        traverse(consequent);
+        
+        return;
+    }
+    
+    write('\n');
+    incIndent();
+    traverse(consequent);
+    decIndent();
+    
+    const next = path.getNextSibling();
+    
+    if (!next.node || next.isIfStatement() || next.isExpressionStatement() || next.isReturnStatement())
+        return;
+    
+    indent();
+    write('\n');
+};
+
+function isFirst(path) {
+    return path.node === path.parentPath.node.body[0];
+}
+

package/lib/statements/index.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const {ExpressionStatement} = require('./expression-statement');
+const {VariableDeclaration} = require('./variable-declaration');
+const {IfStatement} = require('./if-statement');
+const {ForOfStatement} = require('./for-of-statement');
+const {BlockStatement} = require('./block-statement');
+
+module.exports = {
+    BlockStatement,
+    ExpressionStatement,
+    VariableDeclaration,
+    IfStatement,
+    ForOfStatement,
+    Program(path, {traverse}) {
+        path.get('body').forEach(traverse);
+    },
+    ContinueStatement(path, {write, indent}) {
+        indent();
+        write('continue;\n');
+    },
+    ReturnStatement(path, {indent, write, traverse}) {
+        indent();
+        
+        if (path?.parentPath?.node?.body?.length > 2) {
+            write('\n');
+            indent();
+        }
+        
+        write('return');
+        const argPath = path.get('argument');
+        
+        if (argPath.node) {
+            write(' ');
+            traverse(argPath);
+        }
+        
+        write(';');
+        write('\n');
+    },
+};
+

package/lib/statements/variable-declaration.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const isNextAssign = (path) => {
+    const nextPath = path.getNextSibling();
+    
+    if (!nextPath.isExpressionStatement())
+        return false;
+    
+    return nextPath.get('expression').isAssignmentExpression();
+};
+
+module.exports.VariableDeclaration = (path, {write, maybeWrite, maybeIndent, traverse}) => {
+    if (!isFirst(path) && shouldAddNewLine(path)) {
+        write('\n');
+    }
+    
+    const isParentBlock = /Program|BlockStatement/.test(path.parentPath.type);
+    
+    maybeIndent(isParentBlock);
+    write(`${path.node.kind} `);
+    traverse(path.get('declarations.0.id'));
+    
+    const initPath = path.get('declarations.0.init');
+    
+    maybeWrite(initPath.node, ' = ');
+    traverse(initPath);
+    maybeWrite(isParentBlock, ';\n');
+    
+    const is = isCoupleLinesExpression(path) && !isNextAssign(path);
+    
+    maybeIndent(is);
+    maybeWrite(is, '\n');
+};
+function isCoupleLinesExpression(path) {
+    const start = path.node?.loc?.start.line;
+    const end = path.node?.loc?.end.line;
+    
+    return end > start;
+}
+
+function shouldAddNewLine(path) {
+    const prevPath = path.getPrevSibling();
+    const nextPath = path.getNextSibling();
+    const nextNextPath = nextPath.getNextSibling();
+    
+    const twoNext = nextPath.node && nextNextPath.node;
+    
+    if (!twoNext)
+        return false;
+    
+    if (prevPath.isVariableDeclaration() || prevPath.isExpressionStatement() && prevPath.get('expression').isStringLiteral())
+        return false;
+    
+    if (prevPath.isIfStatement())
+        return false;
+    
+    return true;
+}
+
+function isFirst(path) {
+    return path.node === path.parentPath.node.body[0];
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@putout/printer",
+  "version": "1.0.0",
+  "type": "commonjs",
+  "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
+  "description": "Easiest possible opinionated Babel AST printer made with ❤️  to use in 🐊Putout",
+  "homepage": "https://github.com/putoutjs/printer#readme",
+  "main": "./lib/printer.js",
+  "release": false,
+  "tag": false,
+  "changelog": false,
+  "exports": {
+    ".": "./lib/printer.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/putoutjs/printer.git"
+  },
+  "scripts": {
+    "test": "madrun test",
+    "watch:test": "madrun watch:test",
+    "lint": "madrun lint",
+    "fresh:lint": "madrun fresh:lint",
+    "lint:fresh": "madrun lint:fresh",
+    "fix:lint": "madrun fix:lint",
+    "coverage": "madrun coverage",
+    "report": "madrun report"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.19.0",
+    "@babel/traverse": "^7.21.2",
+    "just-snake-case": "^3.2.0"
+  },
+  "keywords": [
+    "putout",
+    "printer",
+    "AST",
+    "babel",
+    "api",
+    "traverse",
+    "generate"
+  ],
+  "devDependencies": {
+    "c8": "^7.5.0",
+    "eslint": "^8.0.1",
+    "eslint-plugin-n": "^15.2.4",
+    "eslint-plugin-putout": "^17.0.0",
+    "just-kebab-case": "^4.2.0",
+    "lerna": "^6.0.1",
+    "madrun": "^9.0.0",
+    "mock-require": "^3.0.3",
+    "montag": "^1.0.0",
+    "nodemon": "^2.0.1",
+    "putout": "*",
+    "supertape": "^8.0.0",
+    "try-catch": "^3.0.0"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=16"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}