prettier 2.0.0 → 3.1.0

data/dist/ruby/nodes/return.js

@@ -1,75 +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 utils_1 = require("../../utils");
-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(args) {
-    const stmts = args.body[0].body[0];
-    // 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.body[1])) {
-        return false;
-    }
-    // return (not a)
-    if (stmt.type === "unary" && stmt.oper === "not") {
-        return false;
-    }
-    return true;
-}
-const printReturn = (path, opts, print) => {
-    let args = path.getValue().body[0].body[0];
-    let steps = ["body", 0, "body", 0];
-    if (args.body.length === 1) {
-        // 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 (args.body[0] && args.body[0].type === "paren" && canSkipParens(args)) {
-            args = args.body[0].body[0];
-            steps = steps.concat("body", 0, "body", 0);
-        }
-        // If we're returning an array literal that isn't a special array, single
-        // element array, or an empty array, then we want to grab the arguments so
-        // that we can print them out as if they were normal return arguments.
-        if (args.body[0] &&
-            args.body[0].type === "array" &&
-            args.body[0].body[0] &&
-            args.body[0].body[0].body.length > 1 &&
-            ["args", "args_add_star"].includes(args.body[0].body[0].type)) {
-            steps = steps.concat("body", 0, "body", 0);
-        }
-    }
-    // Now that we've established which actual node is the arguments to return,
-    // we grab it out of the path by diving down the steps that we've set up.
-    const parts = path.call(print, ...steps);
-    const useBrackets = Array.isArray(parts) && parts.length > 1;
-    // If we got the value straight out of the parens, then `parts` would only
-    // be a singular doc as opposed to an array.
-    const value = Array.isArray(parts) ? join([",", line], parts) : parts;
-    // We only get here if we have comments somewhere that would prevent us from
-    // skipping the parentheses.
-    if (args.body.length === 1 && args.body[0].type === "paren") {
-        return ["return", value];
-    }
-    return group([
-        "return",
-        ifBreak(useBrackets ? " [" : "(", " "),
-        indent([softline, value]),
-        softline,
-        ifBreak(useBrackets ? "]" : ")", "")
-    ]);
-};
-exports.printReturn = printReturn;
-exports.printReturn0 = (0, utils_1.literal)("return");

data/dist/ruby/nodes/statements.js

@@ -1,111 +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.printStmts = exports.printProgram = exports.printComment = exports.printEndContent = exports.printParen = exports.printBodyStmt = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { breakParent, dedent, group, hardline, indent, join, line, literalline, softline, trim } = prettier_1.default;
-const printBodyStmt = (path, opts, print) => {
-    const [stmts, rescue, elseClause, ensure] = path.getValue().body;
-    const parts = [];
-    if (!(0, utils_1.isEmptyStmts)(stmts)) {
-        parts.push(path.call(print, "body", 0));
-    }
-    if (rescue) {
-        parts.push(dedent([hardline, path.call(print, "body", 1)]));
-    }
-    if (elseClause) {
-        // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
-        /* istanbul ignore next */
-        const stmts = elseClause.type === "else"
-            ? path.call(print, "body", 2, "body", 0)
-            : path.call(print, "body", 2);
-        parts.push([dedent([hardline, "else"]), hardline, stmts]);
-    }
-    if (ensure) {
-        parts.push(dedent([hardline, path.call(print, "body", 3)]));
-    }
-    return group(parts);
-};
-exports.printBodyStmt = printBodyStmt;
-const argNodeTypes = ["args", "args_add_star", "args_add_block"];
-const printParen = (path, opts, print) => {
-    const contentNode = path.getValue().body[0];
-    if (!contentNode) {
-        return [path.call(print, "lparen"), ")"];
-    }
-    let contentDoc = path.call(print, "body", 0);
-    // 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 { body } = path.getValue();
-    return [trim, "__END__", literalline, body];
-};
-exports.printEndContent = printEndContent;
-const printComment = (path, opts) => {
-    return opts.printer.printComment(path, opts);
-};
-exports.printComment = printComment;
-const printProgram = (path, opts, print) => {
-    return [join(hardline, path.map(print, "body")), hardline];
-};
-exports.printProgram = printProgram;
-const printStmts = (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 (stmt.sl - lineNo > 1 ||
-            [stmt.type, stmts[index - 1].type].includes("access_ctrl")) {
-            parts.push(hardline, hardline, printed);
-        }
-        else if (stmt.sl !== lineNo ||
-            path.getParentNode().type !== "string_embexpr") {
-            parts.push(hardline, printed);
-        }
-        else {
-            parts.push("; ", printed);
-        }
-        lineNo = stmt.el;
-    });
-    return parts;
-};
-exports.printStmts = printStmts;

data/dist/ruby/nodes/strings.js

@@ -1,218 +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 { 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.body.some((part) => part.type === "@tstring_content" &&
-        (part.body.includes("#{") || part.body.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.body.every((part) => part.type === "@tstring_content" && !part.body.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 { body } = path.getValue();
-    if (body.length !== 2) {
-        return body;
-    }
-    const quote = opts.rubySingleQuote ? "'" : '"';
-    return [quote, body.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.body.split("\n")));
-        }
-    }, "body");
-    // 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.body.some((child) => child.type === "@tstring_content" &&
-        (child.body.includes("\n") ||
-            child.body.includes(closing) ||
-            child.body.includes("'") ||
-            child.body.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.body, quote).split("\n")));
-        }
-    }, "body");
-    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_new" || parentNode.body[0] !== node) {
-        parts.unshift(":");
-    }
-    return parts;
-};
-exports.printDynaSymbol = printDynaSymbol;
-const printStringConcat = (path, opts, print) => {
-    const [leftDoc, rightDoc] = path.map(print, "body");
-    return group([leftDoc, " \\", indent([hardline, rightDoc])]);
-};
-exports.printStringConcat = printStringConcat;
-// Prints out an interpolated variable in the string by converting it into an
-// embedded expression.
-const printStringDVar = (path, opts, print) => {
-    return ["#{", path.call(print, "body", 0), "}"];
-};
-exports.printStringDVar = printStringDVar;
-const printStringEmbExpr = (path, opts, print) => {
-    const node = path.getValue();
-    const parts = path.call(print, "body", 0);
-    // 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 (node.sl === node.el) {
-        return ["#{", removeLines(parts), "}"];
-    }
-    return group(["#{", indent([softline, parts]), [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.body.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.body, quote).split("\n"));
-    }, "body");
-    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, "body", 0)];
-};
-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, "body"), "`"];
-};
-exports.printXStringLiteral = printXStringLiteral;

data/dist/ruby/nodes/super.js

@@ -1,30 +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 utils_1 = require("../../utils");
-const { align, group, join, line } = prettier_1.default;
-const printSuper = (path, opts, print) => {
-    const args = path.getValue().body[0];
-    if (args.type === "arg_paren") {
-        // In case there are explicitly no arguments but they are using parens,
-        // we assume they are attempting to override the initializer and pass no
-        // arguments up.
-        if (args.body[0] === null) {
-            return "super()";
-        }
-        return ["super", path.call(print, "body", 0)];
-    }
-    const keyword = "super ";
-    const argsDocs = path.call(print, "body", 0);
-    return group([
-        keyword,
-        align(keyword.length, group(join([",", line], argsDocs)))
-    ]);
-};
-exports.printSuper = printSuper;
-// Version of super without any parens or args.
-exports.printZSuper = (0, utils_1.literal)("super");

data/dist/ruby/nodes/undef.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.printUndef = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { addTrailingComment, align, group, join, line } = prettier_1.default;
-const printUndefSymbol = (path, opts, print) => {
-    const node = path.getValue();
-    // Since we're going to descend into the symbol literal to grab out the ident
-    // node, then we need to make sure we copy over any comments as well,
-    // otherwise we could accidentally skip printing them.
-    if (node.comments) {
-        node.comments.forEach((comment) => {
-            addTrailingComment(node.body[0], comment);
-        });
-    }
-    return path.call(print, "body", 0);
-};
-const printUndef = (path, opts, print) => {
-    const keyword = "undef ";
-    const argNodes = path.map((symbolPath) => printUndefSymbol(symbolPath, opts, print), "body");
-    return group([keyword, align(keyword.length, join([",", line], argNodes))]);
-};
-exports.printUndef = printUndef;

data/dist/ruby/nodes.js

@@ -1,151 +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 nodes = {
-    "@__end__": statements_1.printEndContent,
-    "@CHAR": strings_1.printChar,
-    "@comment": statements_1.printComment,
-    "@int": ints_1.printInt,
-    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_add_star: args_1.printArgsAddStar,
-    args_forward: params_1.printArgsForward,
-    array: arrays_1.printArray,
-    aryptn: patterns_1.printAryPtn,
-    assign: assign_1.printAssign,
-    assoc_new: hashes_1.printAssocNew,
-    assoc_splat: hashes_1.printAssocSplat,
-    assoclist_from_args: hashes_1.printHashContents,
-    bare_assoc_hash: hashes_1.printHashContents,
-    BEGIN: hooks_1.printBEGIN,
-    begin: rescue_1.printBegin,
-    binary: operators_1.printBinary,
-    blockarg: args_1.printBlockArg,
-    block_var: blocks_1.printBlockVar,
-    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,
-    const_path_field: constants_1.printConstPath,
-    const_path_ref: constants_1.printConstPath,
-    const_ref: constants_1.printConstRef,
-    def: methods_1.printDef,
-    defs: methods_1.printDef,
-    defsl: methods_1.printSingleLineMethod,
-    defined: constants_1.printDefined,
-    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,
-    END: hooks_1.printEND,
-    ensure: rescue_1.printEnsure,
-    fcall: calls_1.printCallContainer,
-    fndptn: patterns_1.printFndPtn,
-    field: constants_1.printField,
-    for: loops_1.printFor,
-    hash: hashes_1.printHash,
-    heredoc: heredocs_1.printHeredoc,
-    hshptn: patterns_1.printHshPtn,
-    if: conditionals_1.printIf,
-    ifop: conditionals_1.printTernary,
-    if_mod: conditionals_1.printIfModifier,
-    in: patterns_1.printIn,
-    kwrest_param: params_1.printKeywordRestParam,
-    lambda: lambdas_1.printLambda,
-    massign: massign_1.printMAssign,
-    method_add_arg: calls_1.printMethodAddArg,
-    method_add_block: calls_1.printMethodAddBlock,
-    mlhs: massign_1.printMLHS,
-    mlhs_add_post: massign_1.printMLHSAddPost,
-    mlhs_add_star: massign_1.printMLHSAddStar,
-    mlhs_paren: massign_1.printMLHSParen,
-    mrhs: massign_1.printMRHS,
-    mrhs_add_star: massign_1.printMRHSAddStar,
-    mrhs_new_from_args: massign_1.printMRHSNewFromArgs,
-    module: class_1.printModule,
-    next: flow_1.printNext,
-    opassign: assign_1.printOpAssign,
-    params: params_1.printParams,
-    paren: statements_1.printParen,
-    program: statements_1.printProgram,
-    rassign: patterns_1.printRAssign,
-    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,
-    return: return_1.printReturn,
-    return0: return_1.printReturn0,
-    sclass: class_1.printSClass,
-    stmts: statements_1.printStmts,
-    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,
-    top_const_field: constants_1.printTopConst,
-    top_const_ref: constants_1.printTopConst,
-    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.printUntilModifer,
-    var_alias: alias_1.printAlias,
-    var_field: assign_1.printVarField,
-    var_ref: assign_1.printVarRef,
-    vcall: calls_1.printCallContainer,
-    when: case_1.printWhen,
-    while: loops_1.printWhile,
-    while_mod: loops_1.printWhileModifier,
-    word: arrays_1.printWord,
-    xstring_literal: strings_1.printXStringLiteral,
-    yield: flow_1.printYield,
-    yield0: flow_1.printYield0,
-    zsuper: super_1.printZSuper
-};
-exports.default = nodes;

data/dist/ruby/parser.js

@@ -1,34 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const parseSync_1 = __importDefault(require("../parser/parseSync"));
-const parser = {
-    // This function is responsible for taking an input string of text and
-    // returning to prettier a JavaScript object that is the equivalent AST that
-    // represents the code stored in that string. We accomplish this by spawning a
-    // new Ruby process of parser.rb and reading JSON off STDOUT.
-    parse(text) {
-        return (0, parseSync_1.default)("ruby", text);
-    },
-    astFormat: "ruby",
-    // This function handles checking whether or not the source string has the
-    // pragma for prettier. This is an optional workflow for incremental adoption.
-    hasPragma(text) {
-        return /^\s*#[^\S\n]*@(?:prettier|format)\s*?(?:\n|$)/m.test(text);
-    },
-    // This function is critical for comments and cursor support, and is
-    // responsible for returning the index of the character within the source
-    // string that is the beginning of the given node.
-    locStart(node) {
-        return node.sc;
-    },
-    // This function is critical for comments and cursor support, and is
-    // responsible for returning the index of the character within the source
-    // string that is the ending of the given node.
-    locEnd(node) {
-        return node.ec;
-    }
-};
-exports.default = parser;