prettier 2.1.0 → 3.1.1

data/dist/ruby/nodes/return.js

@@ -1,100 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printReturn0 = exports.printReturn = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { group, ifBreak, indent, line, join, softline } = prettier_1.default;
-// You can't skip the parentheses if you have comments or certain operators with
-// lower precedence than the return keyword.
-function canSkipParens(paren) {
-    const stmts = paren.cnts;
-    // return(
-    //   foo
-    //   bar
-    // )
-    if (stmts.body.length !== 1) {
-        return false;
-    }
-    // return(
-    //   # a
-    //   b
-    // )
-    if (stmts.comments) {
-        return false;
-    }
-    const stmt = stmts.body[0];
-    // return (a or b)
-    if (stmt.type === "binary" && ["and", "or"].includes(stmt.op)) {
-        return false;
-    }
-    // return (not a)
-    if (stmt.type === "not") {
-        return false;
-    }
-    return true;
-}
-const printReturn = (path, opts, print) => {
-    const node = path.getValue();
-    let parts = "";
-    let joining = false;
-    if (node.args.type === "args_add_block") {
-        const args = node.args.args;
-        const steps = ["args", "args"];
-        if (args.type === "args" && args.parts.length === 1 && args.parts[0]) {
-            // This is the first and only argument being passed to the return keyword.
-            let arg = args.parts[0];
-            steps.push("parts", 0);
-            // If the body of the return contains parens, then just skip directly to
-            // the content of the parens so that we can skip printing parens if we
-            // don't want them.
-            if (arg.type === "paren") {
-                // If we can't skip over the parentheses, then we know we can just bail
-                // out here and print the only argument as normal since it's a paren.
-                if (!canSkipParens(arg)) {
-                    return ["return", path.call(print, "args")];
-                }
-                arg = arg.cnts.body[0];
-                steps.push("cnts", "body", 0);
-            }
-            // If we're returning an array literal that isn't a special array that has
-            // at least 2 elements, then we want to grab the arguments so that we can
-            // print them out as if they were normal return arguments.
-            if (arg.type === "array" && arg.cnts) {
-                const contents = arg.cnts;
-                if (contents.type === "args" && contents.parts.length > 1) {
-                    // If we have just regular arguments and we have more than 1.
-                    steps.push("cnts");
-                }
-            }
-        }
-        // We're doing this weird dance with the steps variable because it's
-        // possible that you're printing an array nested under some parentheses, in
-        // which case we still want to descend down that far. For example,
-        // return([1, 2, 3]) should print as return 1, 2, 3.
-        parts = path.call((targetPath) => {
-            const target = targetPath.getValue();
-            joining = target.type === "args" || target.type === "args_add_block";
-            return print(targetPath);
-        }, ...steps);
-    }
-    // If we didn't hit any of our special cases, then just print out the
-    // arguments normally here.
-    if (parts === "") {
-        parts = path.call(print, "args");
-        joining = true;
-    }
-    const useBrackets = Array.isArray(parts) && parts.length > 1;
-    const value = joining ? join([",", line], parts) : parts;
-    return group([
-        "return",
-        ifBreak(useBrackets ? " [" : "(", " "),
-        indent([softline, value]),
-        softline,
-        ifBreak(useBrackets ? "]" : ")", "")
-    ]);
-};
-exports.printReturn = printReturn;
-const printReturn0 = (path) => path.getValue().value;
-exports.printReturn0 = printReturn0;

data/dist/ruby/nodes/statements.js

@@ -1,110 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printStatements = exports.printProgram = exports.printComment = exports.printEndContent = exports.printParen = exports.printBodyStmt = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const location_1 = require("../location");
-const { breakParent, dedent, group, hardline, indent, join, line, literalline, softline, trim } = prettier_1.default;
-const printBodyStmt = (path, opts, print) => {
-    const node = path.getValue();
-    const parts = [];
-    if (!(0, utils_1.isEmptyStmts)(node.stmts)) {
-        parts.push(path.call(print, "stmts"));
-    }
-    if (node.rsc) {
-        parts.push(dedent([hardline, path.call(print, "rsc")]));
-    }
-    if (node.els) {
-        // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
-        /* istanbul ignore next */
-        const stmts = node.els.type === "else"
-            ? path.call(print, "els", "body", 0)
-            : path.call(print, "els");
-        parts.push([dedent([hardline, "else"]), hardline, stmts]);
-    }
-    if (node.ens) {
-        parts.push(dedent([hardline, path.call(print, "ens")]));
-    }
-    return group(parts);
-};
-exports.printBodyStmt = printBodyStmt;
-const argNodeTypes = ["args", "args_add_block"];
-const printParen = (path, opts, print) => {
-    const contentNode = path.getValue().cnts;
-    if (!contentNode) {
-        return [path.call(print, "lparen"), ")"];
-    }
-    let contentDoc = path.call(print, "cnts");
-    // If the content is params, we're going to let it handle its own parentheses
-    // so that it breaks nicely.
-    if (contentNode.type === "params") {
-        return contentDoc;
-    }
-    // If we have an arg type node as the contents, then it's going to return an
-    // array, so we need to explicitly join that content here.
-    if (argNodeTypes.includes(contentNode.type)) {
-        contentDoc = join([",", line], contentDoc);
-    }
-    return group([
-        path.call(print, "lparen"),
-        indent([softline, contentDoc]),
-        softline,
-        ")"
-    ]);
-};
-exports.printParen = printParen;
-const printEndContent = (path) => {
-    const node = path.getValue();
-    return [trim, "__END__", literalline, node.value];
-};
-exports.printEndContent = printEndContent;
-const printComment = (path, opts) => {
-    return opts.printer.printComment(path, opts);
-};
-exports.printComment = printComment;
-const printProgram = (path, opts, print) => [path.call(print, "stmts"), hardline];
-exports.printProgram = printProgram;
-const printStatements = (path, opts, print) => {
-    const stmts = path.getValue().body;
-    // This is a special case where we have only comments inside a statement
-    // list. In this case we want to avoid doing any kind of line number
-    // tracking and just print out the comments.
-    if (stmts.length === 1 &&
-        stmts[0].type === "void_stmt" &&
-        stmts[0].comments) {
-        const nodePath = path;
-        const comments = nodePath.map((commentPath) => {
-            commentPath.getValue().printed = true;
-            return opts.printer.printComment(commentPath, opts);
-        }, "body", 0, "comments");
-        return [breakParent, join(hardline, comments)];
-    }
-    const parts = [];
-    let lineNo = null;
-    stmts.forEach((stmt, index) => {
-        if (stmt.type === "void_stmt") {
-            return;
-        }
-        const printed = path.call(print, "body", index);
-        if (lineNo === null) {
-            parts.push(printed);
-        }
-        else if ((0, location_1.getStartLine)(stmt.loc) - lineNo > 1 ||
-            [stmt.type, stmts[index - 1].type].includes("access_ctrl")) {
-            parts.push(hardline, hardline, printed);
-        }
-        else if ((0, location_1.getStartLine)(stmt.loc) !== lineNo ||
-            path.getParentNode().type !== "string_embexpr") {
-            parts.push(hardline, printed);
-        }
-        else {
-            parts.push("; ", printed);
-        }
-        lineNo = (0, location_1.getEndLine)(stmt.loc);
-    });
-    return parts;
-};
-exports.printStatements = printStatements;

data/dist/ruby/nodes/strings.js

@@ -1,220 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printXStringLiteral = exports.printSymbolLiteral = exports.printStringLiteral = exports.printStringEmbExpr = exports.printStringDVar = exports.printStringConcat = exports.printDynaSymbol = exports.printChar = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const location_1 = require("../location");
-const { group, hardline, indent, literalline, removeLines, softline, join } = prettier_1.default;
-// If there is some part of this string that matches an escape sequence or that
-// contains the interpolation pattern ("#{"), then we are locked into whichever
-// quote the user chose. (If they chose single quotes, then double quoting
-// would activate the escape sequence, and if they chose double quotes, then
-// single quotes would deactivate it.)
-function isQuoteLocked(node) {
-    return node.parts.some((part) => part.type === "tstring_content" &&
-        (part.value.includes("#{") || part.value.includes("\\")));
-}
-// A string is considered to be able to use single quotes if it contains only
-// plain string content and that content does not contain a single quote.
-function isSingleQuotable(node) {
-    return node.parts.every((part) => part.type === "tstring_content" && !part.value.includes("'"));
-}
-const quotePattern = new RegExp("\\\\([\\s\\S])|(['\"])", "g");
-function normalizeQuotes(content, enclosingQuote) {
-    // Escape and unescape single and double quotes as needed to be able to
-    // enclose `content` with `enclosingQuote`.
-    return content.replace(quotePattern, (match, escaped, quote) => {
-        if (quote === enclosingQuote) {
-            return `\\${quote}`;
-        }
-        if (quote) {
-            return quote;
-        }
-        return `\\${escaped}`;
-    });
-}
-const quotePairs = {
-    "(": ")",
-    "[": "]",
-    "{": "}",
-    "<": ">"
-};
-function getClosingQuote(quote) {
-    if (!quote.startsWith("%")) {
-        return quote;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const boundary = /%[Qq]?(.)/.exec(quote)[1];
-    if (boundary in quotePairs) {
-        return quotePairs[boundary];
-    }
-    return boundary;
-}
-// Prints a @CHAR node. @CHAR nodes are special character strings that usually
-// are strings of length 1. If they're any longer than we'll try to apply the
-// correct quotes.
-const printChar = (path, opts) => {
-    const { value } = path.getValue();
-    if (value.length !== 2) {
-        return value;
-    }
-    const quote = opts.rubySingleQuote ? "'" : '"';
-    return [quote, value.slice(1), quote];
-};
-exports.printChar = printChar;
-const printPercentSDynaSymbol = (path, opts, print) => {
-    const node = path.getValue();
-    const parts = [];
-    // Push on the quote, which includes the opening character.
-    parts.push(node.quote);
-    path.each((childPath) => {
-        const childNode = childPath.getValue();
-        if (childNode.type !== "tstring_content") {
-            // Here we are printing an embedded variable or expression.
-            parts.push(print(childPath));
-        }
-        else {
-            // Here we are printing plain string content.
-            parts.push(join(literalline, childNode.value.split("\n")));
-        }
-    }, "parts");
-    // Push on the closing character, which is the opposite of the third
-    // character from the opening.
-    parts.push(quotePairs[node.quote[2]]);
-    return parts;
-};
-// We don't actually want to print %s symbols, as they're much more rarely seen
-// in the wild. But we're going to be forced into it if it's a multi-line symbol
-// or if the quoting would get super complicated.
-function shouldPrintPercentSDynaSymbol(node) {
-    // We shouldn't print a %s dyna symbol if it was not already that way in the
-    // original source.
-    if (node.quote[0] !== "%") {
-        return false;
-    }
-    // Here we're going to check if there is a closing character, a new line, or a
-    // quote in the content of the dyna symbol. If there is, then quoting could
-    // get weird, so just bail out and stick to the original bounds in the source.
-    const closing = quotePairs[node.quote[2]];
-    return node.parts.some((child) => child.type === "tstring_content" &&
-        (child.value.includes("\n") ||
-            child.value.includes(closing) ||
-            child.value.includes("'") ||
-            child.value.includes('"')));
-}
-// Prints a dynamic symbol. Assumes there's a quote property attached to the
-// node that will tell us which quote to use when printing. We're just going to
-// use whatever quote was provided.
-//
-// In the case of a plain dyna symbol, node.quote will be either :" or :'
-// For %s dyna symbols, node.quote will be %s[, %s(, %s{, or %s<
-const printDynaSymbol = (path, opts, print) => {
-    const node = path.getValue();
-    if (shouldPrintPercentSDynaSymbol(node)) {
-        return printPercentSDynaSymbol(path, opts, print);
-    }
-    const parts = [];
-    let quote;
-    if (isQuoteLocked(node)) {
-        if (node.quote.startsWith("%")) {
-            quote = opts.rubySingleQuote ? "'" : '"';
-        }
-        else if (node.quote.startsWith(":")) {
-            quote = node.quote.slice(1);
-        }
-        else {
-            quote = node.quote;
-        }
-    }
-    else {
-        quote = opts.rubySingleQuote && isSingleQuotable(node) ? "'" : '"';
-    }
-    parts.push(quote);
-    path.each((childPath) => {
-        const child = childPath.getValue();
-        if (child.type !== "tstring_content") {
-            parts.push(print(childPath));
-        }
-        else {
-            parts.push(join(literalline, normalizeQuotes(child.value, quote).split("\n")));
-        }
-    }, "parts");
-    parts.push(quote);
-    // If we're inside of an assoc_new node as the key, then it will handle
-    // printing the : on its own since it could change sides.
-    const parentNode = path.getParentNode();
-    if (parentNode.type !== "assoc" || parentNode.key !== node) {
-        parts.unshift(":");
-    }
-    return parts;
-};
-exports.printDynaSymbol = printDynaSymbol;
-const printStringConcat = (path, opts, print) => {
-    return group([
-        path.call(print, "left"),
-        " \\",
-        indent([hardline, path.call(print, "right")])
-    ]);
-};
-exports.printStringConcat = printStringConcat;
-// Prints out an interpolated variable in the string by converting it into an
-// embedded expression.
-const printStringDVar = (path, opts, print) => ["#{", path.call(print, "var"), "}"];
-exports.printStringDVar = printStringDVar;
-const printStringEmbExpr = (path, opts, print) => {
-    const node = path.getValue();
-    const doc = path.call(print, "stmts");
-    // If the contents of this embedded expression were originally on the same
-    // line in the source, then we're going to leave them in place and assume
-    // that's the way the developer wanted this expression represented.
-    if ((0, location_1.getStartLine)(node.loc) === (0, location_1.getEndLine)(node.loc)) {
-        return ["#{", removeLines(doc), "}"];
-    }
-    return group(["#{", indent([softline, doc]), [softline, "}"]]);
-};
-exports.printStringEmbExpr = printStringEmbExpr;
-// Prints out a literal string. This function does its best to respect the
-// wishes of the user with regards to single versus double quotes, but if the
-// string contains any escape expressions then it will just keep the original
-// quotes.
-const printStringLiteral = (path, { rubySingleQuote }, print) => {
-    const node = path.getValue();
-    // If the string is empty, it will not have any parts, so just print out the
-    // quotes corresponding to the config
-    if (node.parts.length === 0) {
-        return rubySingleQuote ? "''" : '""';
-    }
-    // Determine the quote that should enclose the new string
-    let quote;
-    if (isQuoteLocked(node)) {
-        quote = node.quote;
-    }
-    else {
-        quote = rubySingleQuote && isSingleQuotable(node) ? "'" : '"';
-    }
-    const parts = path.map((partPath) => {
-        const part = partPath.getValue();
-        // In this case, the part of the string is an embedded expression
-        if (part.type !== "tstring_content") {
-            return print(partPath);
-        }
-        // In this case, the part of the string is just regular string content
-        return join(literalline, normalizeQuotes(part.value, quote).split("\n"));
-    }, "parts");
-    return [quote, ...parts, getClosingQuote(quote)];
-};
-exports.printStringLiteral = printStringLiteral;
-// Prints out a symbol literal. Its child will always be the ident that
-// represents the string content of the symbol.
-const printSymbolLiteral = (path, opts, print) => {
-    return [":", path.call(print, "value")];
-};
-exports.printSymbolLiteral = printSymbolLiteral;
-// Prints out an xstring literal. Its child is an array of string parts,
-// including plain string content and interpolated content.
-const printXStringLiteral = (path, opts, print) => {
-    return ["`", ...path.map(print, "parts"), "`"];
-};
-exports.printXStringLiteral = printXStringLiteral;

data/dist/ruby/nodes/super.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printZSuper = exports.printSuper = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { align, group, join, line } = prettier_1.default;
-const printSuper = (path, opts, print) => {
-    const { args } = path.getValue();
-    if (args.type === "arg_paren") {
-        // In case there are explicitly no arguments but they are using parens,
-        // we assume they are attempting to override a parent method and pass no
-        // arguments up.
-        return args.args === null ? "super()" : ["super", path.call(print, "args")];
-    }
-    const keyword = "super ";
-    return group([
-        keyword,
-        align(keyword.length, group(join([",", line], path.call(print, "args"))))
-    ]);
-};
-exports.printSuper = printSuper;
-// Version of super without any parens or args.
-const printZSuper = (path) => path.getValue().value;
-exports.printZSuper = printZSuper;

data/dist/ruby/nodes/undef.js

@@ -1,31 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printUndef = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { addTrailingComment, align, group, join, line } = prettier_1.default;
-const printUndef = (path, opts, print) => {
-    const symsDocs = path.map((symbolPath) => {
-        const symbolNode = symbolPath.getValue();
-        // If we're not printing a symbol literal then it's a dyna symbol, so
-        // we're just going to print that node on its own.
-        if (symbolNode.type !== "symbol_literal") {
-            return print(symbolPath);
-        }
-        // We need to make sure we copy over any comments before we do the
-        // printing so they get printed as well.
-        if (symbolNode.comments) {
-            symbolNode.comments.forEach((comment) => {
-                addTrailingComment(symbolNode.value, comment);
-            });
-        }
-        // If we're printing a symbol literal, then we want to descend into it and
-        // just print the underlying contents so that it prints as a bare word.
-        return symbolPath.call(print, "value");
-    }, "syms");
-    const keyword = "undef ";
-    return group([keyword, align(keyword.length, join([",", line], symsDocs))]);
-};
-exports.printUndef = printUndef;

data/dist/ruby/nodes.js

@@ -1,177 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const alias_1 = require("./nodes/alias");
-const aref_1 = require("./nodes/aref");
-const args_1 = require("./nodes/args");
-const arrays_1 = require("./nodes/arrays");
-const assign_1 = require("./nodes/assign");
-const blocks_1 = require("./nodes/blocks");
-const calls_1 = require("./nodes/calls");
-const case_1 = require("./nodes/case");
-const class_1 = require("./nodes/class");
-const commands_1 = require("./nodes/commands");
-const conditionals_1 = require("./nodes/conditionals");
-const constants_1 = require("./nodes/constants");
-const flow_1 = require("./nodes/flow");
-const hashes_1 = require("./nodes/hashes");
-const heredocs_1 = require("./nodes/heredocs");
-const hooks_1 = require("./nodes/hooks");
-const ints_1 = require("./nodes/ints");
-const lambdas_1 = require("./nodes/lambdas");
-const loops_1 = require("./nodes/loops");
-const massign_1 = require("./nodes/massign");
-const methods_1 = require("./nodes/methods");
-const operators_1 = require("./nodes/operators");
-const params_1 = require("./nodes/params");
-const patterns_1 = require("./nodes/patterns");
-const regexp_1 = require("./nodes/regexp");
-const rescue_1 = require("./nodes/rescue");
-const return_1 = require("./nodes/return");
-const statements_1 = require("./nodes/statements");
-const strings_1 = require("./nodes/strings");
-const super_1 = require("./nodes/super");
-const undef_1 = require("./nodes/undef");
-const printToken = (path) => path.getValue().value;
-const printVoidStmt = () => "";
-const nodes = {
-    BEGIN: hooks_1.printBEGIN,
-    CHAR: strings_1.printChar,
-    END: hooks_1.printEND,
-    __end__: statements_1.printEndContent,
-    access_ctrl: methods_1.printAccessControl,
-    alias: alias_1.printAlias,
-    aref: aref_1.printAref,
-    aref_field: aref_1.printArefField,
-    arg_paren: args_1.printArgParen,
-    args: args_1.printArgs,
-    args_add_block: args_1.printArgsAddBlock,
-    args_forward: params_1.printArgsForward,
-    arg_star: args_1.printArgStar,
-    array: arrays_1.printArray,
-    aryptn: patterns_1.printAryPtn,
-    assign: assign_1.printAssign,
-    assoc: hashes_1.printAssoc,
-    assoc_splat: hashes_1.printAssocSplat,
-    assoclist_from_args: hashes_1.printHashContents,
-    backref: printToken,
-    backtick: printToken,
-    bare_assoc_hash: hashes_1.printHashContents,
-    begin: rescue_1.printBegin,
-    binary: operators_1.printBinary,
-    block_var: blocks_1.printBlockVar,
-    blockarg: args_1.printBlockArg,
-    bodystmt: statements_1.printBodyStmt,
-    brace_block: blocks_1.printBraceBlock,
-    break: flow_1.printBreak,
-    call: calls_1.printCall,
-    case: case_1.printCase,
-    class: class_1.printClass,
-    command: commands_1.printCommand,
-    command_call: commands_1.printCommandCall,
-    comment: statements_1.printComment,
-    const: printToken,
-    const_path_field: constants_1.printConstPath,
-    const_path_ref: constants_1.printConstPath,
-    const_ref: constants_1.printConstRef,
-    cvar: printToken,
-    def: methods_1.printDef,
-    def_endless: methods_1.printDefEndless,
-    defined: constants_1.printDefined,
-    defs: methods_1.printDef,
-    do_block: blocks_1.printDoBlock,
-    dot2: operators_1.printDot2,
-    dot3: operators_1.printDot3,
-    dyna_symbol: strings_1.printDynaSymbol,
-    else: conditionals_1.printElse,
-    elsif: conditionals_1.printElsif,
-    embdoc: statements_1.printComment,
-    ensure: rescue_1.printEnsure,
-    excessed_comma: params_1.printExcessedComma,
-    fcall: calls_1.printCallContainer,
-    field: constants_1.printField,
-    float: printToken,
-    fndptn: patterns_1.printFndPtn,
-    for: loops_1.printFor,
-    gvar: printToken,
-    hash: hashes_1.printHash,
-    heredoc: heredocs_1.printHeredoc,
-    heredoc_beg: printToken,
-    hshptn: patterns_1.printHshPtn,
-    ident: printToken,
-    if: conditionals_1.printIf,
-    if_mod: conditionals_1.printIfModifier,
-    ifop: conditionals_1.printTernary,
-    imaginary: printToken,
-    in: patterns_1.printIn,
-    int: ints_1.printInt,
-    ivar: printToken,
-    kw: printToken,
-    kwrest_param: params_1.printKeywordRestParam,
-    label: printToken,
-    lambda: lambdas_1.printLambda,
-    lbrace: printToken,
-    lparen: printToken,
-    massign: massign_1.printMAssign,
-    method_add_arg: calls_1.printMethodAddArg,
-    method_add_block: calls_1.printMethodAddBlock,
-    mlhs: massign_1.printMLHS,
-    mlhs_paren: massign_1.printMLHSParen,
-    module: class_1.printModule,
-    mrhs: massign_1.printMRHS,
-    mrhs_add_star: massign_1.printMRHSAddStar,
-    mrhs_new_from_args: massign_1.printMRHSNewFromArgs,
-    next: flow_1.printNext,
-    not: operators_1.printNot,
-    op: printToken,
-    opassign: assign_1.printOpAssign,
-    params: params_1.printParams,
-    paren: statements_1.printParen,
-    period: printToken,
-    program: statements_1.printProgram,
-    qsymbols: arrays_1.printQsymbols,
-    qwords: arrays_1.printQwords,
-    rassign: patterns_1.printRAssign,
-    rational: printToken,
-    redo: rescue_1.printRedo,
-    regexp_literal: regexp_1.printRegexpLiteral,
-    rescue: rescue_1.printRescue,
-    rescue_ex: rescue_1.printRescueEx,
-    rescue_mod: rescue_1.printRescueMod,
-    rest_param: params_1.printRestParam,
-    retry: rescue_1.printRetry,
-    return0: return_1.printReturn0,
-    return: return_1.printReturn,
-    sclass: class_1.printSClass,
-    statements: statements_1.printStatements,
-    string_concat: strings_1.printStringConcat,
-    string_dvar: strings_1.printStringDVar,
-    string_embexpr: strings_1.printStringEmbExpr,
-    string_literal: strings_1.printStringLiteral,
-    super: super_1.printSuper,
-    symbol_literal: strings_1.printSymbolLiteral,
-    symbols: arrays_1.printSymbols,
-    top_const_field: constants_1.printTopConst,
-    top_const_ref: constants_1.printTopConst,
-    tstring_content: printToken,
-    unary: operators_1.printUnary,
-    undef: undef_1.printUndef,
-    unless: conditionals_1.printUnless,
-    unless_mod: conditionals_1.printUnlessModifier,
-    until: loops_1.printUntil,
-    until_mod: loops_1.printUntil,
-    var_alias: alias_1.printAlias,
-    var_field: assign_1.printVarField,
-    var_ref: assign_1.printVarRef,
-    vcall: calls_1.printCallContainer,
-    void_stmt: printVoidStmt,
-    when: case_1.printWhen,
-    while: loops_1.printWhile,
-    while_mod: loops_1.printWhile,
-    word: arrays_1.printWord,
-    words: arrays_1.printWords,
-    xstring_literal: strings_1.printXStringLiteral,
-    yield0: flow_1.printYield0,
-    yield: flow_1.printYield,
-    zsuper: super_1.printZSuper
-};
-exports.default = nodes;