prettier 2.0.0 → 3.1.0

data/dist/ruby/nodes/loops.js

@@ -1,73 +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.printUntilModifer = exports.printUntil = exports.printWhileModifier = exports.printWhile = exports.printFor = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { align, breakParent, group, hardline, ifBreak, indent, join, softline } = prettier_1.default;
-function printLoop(keyword, modifier) {
-    return function printLoopWithOptions(path, { rubyModifier }, print) {
-        const [, stmts] = path.getValue().body;
-        // If the only statement inside this while loop is a void statement, then we
-        // can shorten to just displaying the predicate and then a semicolon.
-        if ((0, utils_1.isEmptyStmts)(stmts)) {
-            return group([
-                group([keyword, " ", path.call(print, "body", 0)]),
-                hardline,
-                "end"
-            ]);
-        }
-        const inlineLoop = (0, utils_1.inlineEnsureParens)(path, [
-            path.call(print, "body", 1),
-            ` ${keyword} `,
-            path.call(print, "body", 0)
-        ]);
-        // If we're in the modifier form and we're modifying a `begin`, then this is
-        // a special case where we need to explicitly use the modifier form because
-        // otherwise the semantic meaning changes. This looks like:
-        //
-        //     begin
-        //       foo
-        //     end while bar
-        //
-        // The above is effectively a `do...while` loop (which we don't have in
-        // ruby).
-        if (modifier && path.getValue().body[1].type === "begin") {
-            return inlineLoop;
-        }
-        const blockLoop = [
-            [`${keyword} `, align(keyword.length + 1, path.call(print, "body", 0))],
-            indent([softline, path.call(print, "body", 1)]),
-            softline,
-            "end"
-        ];
-        // If we're disallowing inline loops or if the predicate of the loop
-        // contains an assignment (in which case we can't know for certain that that
-        // assignment doesn't impact the statements inside the loop) then we can't
-        // use the modifier form and we must use the block form.
-        if (!rubyModifier || (0, utils_1.containsAssignment)(path.getValue().body[0])) {
-            return [breakParent, blockLoop];
-        }
-        return group(ifBreak(blockLoop, inlineLoop));
-    };
-}
-const printFor = (path, opts, print) => {
-    const [varDoc, rangeDoc, stmtsDoc] = path.map(print, "body");
-    const varsDoc = path.getValue().body[0].type === "mlhs" ? join(", ", varDoc) : varDoc;
-    return group([
-        "for ",
-        varsDoc,
-        " in ",
-        rangeDoc,
-        indent([hardline, stmtsDoc]),
-        hardline,
-        "end"
-    ]);
-};
-exports.printFor = printFor;
-exports.printWhile = printLoop("while", false);
-exports.printWhileModifier = printLoop("while", true);
-exports.printUntil = printLoop("until", false);
-exports.printUntilModifer = printLoop("until", true);

data/dist/ruby/nodes/massign.js

@@ -1,73 +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.printMRHSNewFromArgs = exports.printMRHSAddStar = exports.printMRHS = exports.printMLHSParen = exports.printMLHSAddStar = exports.printMLHSAddPost = exports.printMLHS = exports.printMAssign = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { group, indent, join, line, softline } = prettier_1.default;
-const printMAssign = (path, opts, print) => {
-    let right = path.call(print, "body", 1);
-    if (["mrhs_add_star", "mrhs_new_from_args"].includes(path.getValue().body[1].type)) {
-        right = group(join([",", line], right));
-    }
-    const parts = [join([",", line], path.call(print, "body", 0))];
-    if (path.getValue().body[0].comma) {
-        parts.push(",");
-    }
-    return group([group(parts), " =", indent([line, right])]);
-};
-exports.printMAssign = printMAssign;
-const printMLHS = (path, opts, print) => {
-    return path.map(print, "body");
-};
-exports.printMLHS = printMLHS;
-const printMLHSAddPost = (path, opts, print) => {
-    return [
-        ...path.call(print, "body", 0),
-        ...path.call(print, "body", 1)
-    ];
-};
-exports.printMLHSAddPost = printMLHSAddPost;
-const printMLHSAddStar = (path, opts, print) => {
-    const parts = ["*"];
-    if (path.getValue().body[1]) {
-        parts.push(path.call(print, "body", 1));
-    }
-    return [...path.call(print, "body", 0), parts];
-};
-exports.printMLHSAddStar = printMLHSAddStar;
-const printMLHSParen = (path, opts, print) => {
-    if (["massign", "mlhs_paren"].includes(path.getParentNode().type)) {
-        // If we're nested in brackets as part of the left hand side of an
-        // assignment, i.e., (a, b, c) = 1, 2, 3
-        // ignore the current node and just go straight to the content
-        return path.call(print, "body", 0);
-    }
-    const parts = [
-        softline,
-        join([",", line], path.call(print, "body", 0))
-    ];
-    if (path.getValue().body[0].comma) {
-        parts.push(",");
-    }
-    return group(["(", indent(parts), [softline, ")"]]);
-};
-exports.printMLHSParen = printMLHSParen;
-const printMRHS = (path, opts, print) => {
-    return path.map(print, "body");
-};
-exports.printMRHS = printMRHS;
-const printMRHSAddStar = (path, opts, print) => {
-    const [leftDoc, rightDoc] = path.map(print, "body");
-    return [...leftDoc, ["*", rightDoc]];
-};
-exports.printMRHSAddStar = printMRHSAddStar;
-const printMRHSNewFromArgs = (path, opts, print) => {
-    const parts = path.call(print, "body", 0);
-    if (path.getValue().body[1]) {
-        parts.push(path.call(print, "body", 1));
-    }
-    return parts;
-};
-exports.printMRHSNewFromArgs = printMRHSNewFromArgs;

data/dist/ruby/nodes/methods.js

@@ -1,70 +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.printAccessControl = exports.printSingleLineMethod = exports.printDef = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { group, hardline, indent, line } = prettier_1.default;
-const printDef = (path, opts, print) => {
-    const node = path.getValue();
-    const declaration = ["def "];
-    let paramsNode;
-    let bodystmtNode;
-    let nameDoc;
-    let paramsDoc;
-    let bodystmtDoc;
-    if (node.type === "def") {
-        paramsNode = node.body[1];
-        bodystmtNode = node.body[2];
-        nameDoc = path.call(print, "body", 0);
-        paramsDoc = path.call(print, "body", 1);
-        bodystmtDoc = path.call(print, "body", 2);
-    }
-    else {
-        // In this case, we're printing a method that's defined as a singleton, so
-        // we need to include the target and the operator
-        declaration.push(path.call(print, "body", 0), path.call(print, "body", 1));
-        paramsNode = node.body[3];
-        bodystmtNode = node.body[4];
-        nameDoc = path.call(print, "body", 2);
-        paramsDoc = path.call(print, "body", 3);
-        bodystmtDoc = path.call(print, "body", 4);
-    }
-    // In case there are no parens but there are arguments
-    const parens = paramsNode.type === "params" && paramsNode.body.some((type) => type);
-    declaration.push(nameDoc, parens ? "(" : "", paramsDoc, parens ? ")" : "");
-    if ((0, utils_1.isEmptyBodyStmt)(bodystmtNode)) {
-        return group([...declaration, "; end"]);
-    }
-    return group([
-        group(declaration),
-        indent([hardline, bodystmtDoc]),
-        hardline,
-        "end"
-    ]);
-};
-exports.printDef = printDef;
-const printSingleLineMethod = (path, opts, print) => {
-    const parensNode = path.getValue().body[1];
-    let paramsDoc = "";
-    if (parensNode) {
-        const paramsNode = parensNode.body[0];
-        if (paramsNode.body.some((type) => type)) {
-            paramsDoc = path.call(print, "body", 1);
-        }
-    }
-    return group([
-        "def ",
-        path.call(print, "body", 0),
-        paramsDoc,
-        " =",
-        indent(group([line, path.call(print, "body", 2)]))
-    ]);
-};
-exports.printSingleLineMethod = printSingleLineMethod;
-const printAccessControl = (path, opts, print) => {
-    return path.call(print, "body", 0);
-};
-exports.printAccessControl = printAccessControl;

data/dist/ruby/nodes/operators.js

@@ -1,70 +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.printUnary = exports.printDot3 = exports.printDot2 = exports.printBinary = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { group, indent, line, softline } = prettier_1.default;
-const printBinary = (path, opts, print) => {
-    const [, operator, rightNode] = path.getValue().body;
-    const space = operator === "**" ? "" : " ";
-    if (utils_1.noIndent.includes(rightNode.type)) {
-        return group([
-            group(path.call(print, "body", 0)),
-            space,
-            operator,
-            space,
-            group(path.call(print, "body", 2))
-        ]);
-    }
-    return group([
-        group(path.call(print, "body", 0)),
-        space,
-        group(indent([
-            operator,
-            space === "" ? softline : line,
-            path.call(print, "body", 2)
-        ]))
-    ]);
-};
-exports.printBinary = printBinary;
-// dot2 nodes are used with ranges (or flip-flops). They can optionally drop
-// their left side for beginless ranges or their right side for endless ranges.
-const printDot2 = (path, opts, print) => {
-    const [leftNode, rightNode] = path.getValue().body;
-    return [
-        leftNode ? path.call(print, "body", 0) : "",
-        "..",
-        rightNode ? path.call(print, "body", 1) : ""
-    ];
-};
-exports.printDot2 = printDot2;
-// dot3 nodes are used with ranges (or flip-flops). They can optionally drop
-// their left side for beginless ranges or their right side for endless ranges.
-const printDot3 = (path, opts, print) => {
-    const [leftNode, rightNode] = path.getValue().body;
-    return [
-        leftNode ? path.call(print, "body", 0) : "",
-        "...",
-        rightNode ? path.call(print, "body", 1) : ""
-    ];
-};
-exports.printDot3 = printDot3;
-const printUnary = (path, opts, print) => {
-    const node = path.getValue();
-    const contentsDoc = path.call(print, "body", 0);
-    if (node.oper === "not") {
-        // Here we defer to the original source, as it's kind of difficult to
-        // determine if we can actually remove the parentheses being used.
-        if (node.paren) {
-            return ["not", "(", contentsDoc, ")"];
-        }
-        else {
-            return ["not", " ", contentsDoc];
-        }
-    }
-    return [node.oper, contentsDoc];
-};
-exports.printUnary = printUnary;

data/dist/ruby/nodes/params.js

@@ -1,89 +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.printRestParam = exports.printKeywordRestParam = exports.printArgsForward = exports.printParams = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { group, hardline, join, indent, line, lineSuffix, softline } = prettier_1.default;
-function printRestParamSymbol(symbol) {
-    return function printRestParamWithSymbol(path, opts, print) {
-        return path.getValue().body[0]
-            ? [symbol, path.call(print, "body", 0)]
-            : symbol;
-    };
-}
-const printParams = (path, opts, print) => {
-    const [reqs, optls, rest, post, kwargs, kwargRest, block] = path.getValue().body;
-    let parts = [];
-    if (reqs) {
-        path.each((reqPath) => {
-            // For some very strange reason, if you have a comment attached to a
-            // rest_param, it shows up here in the list of required params.
-            if (reqPath.getValue().type !== "rest_param") {
-                parts.push(print(reqPath));
-            }
-        }, "body", 0);
-    }
-    if (optls) {
-        parts = parts.concat(path.map((optlPath) => join(" = ", optlPath.map(print)), "body", 1));
-    }
-    if (rest && rest.type !== "excessed_comma") {
-        parts.push(path.call(print, "body", 2));
-    }
-    if (post) {
-        parts = parts.concat(path.map(print, "body", 3));
-    }
-    if (kwargs) {
-        parts = parts.concat(path.map((kwargPath) => {
-            if (!kwargPath.getValue()[1]) {
-                return kwargPath.call(print, 0);
-            }
-            return group(join(" ", kwargPath.map(print)));
-        }, "body", 4));
-    }
-    if (kwargRest) {
-        parts.push(kwargRest === "nil" ? "**nil" : path.call(print, "body", 5));
-    }
-    if (block) {
-        parts.push(path.call(print, "body", 6));
-    }
-    const contents = [join([",", line], parts)];
-    // You can put an extra comma at the end of block args between pipes to
-    // change what it does. Below is the difference:
-    //
-    // [[1, 2], [3, 4]].each { |x| p x } # prints [1, 2] then [3, 4]
-    // [[1, 2], [3, 4]].each { |x,| p x } # prints 1 then 3
-    //
-    // In ruby 2.5, the excessed comma is indicated by having a 0 in the rest
-    // param position. In ruby 2.6+ it's indicated by having an "excessed_comma"
-    // node in the rest position. Seems odd, but it's true.
-    if (rest === 0 || (rest && rest.type === "excessed_comma")) {
-        contents.push(",");
-    }
-    // If the parent node is a paren then we skipped printing the parentheses so
-    // that we could handle them here and get nicer formatting.
-    const parentNode = path.getParentNode();
-    if (["lambda", "paren"].includes(parentNode.type)) {
-        const parts = ["("];
-        // If the parent node is a paren and the paren has comments that are
-        // attached to the left paren, then we need to print those out explicitly
-        // here.
-        if (parentNode.type === "paren" && parentNode.lparen.comments) {
-            const comments = [];
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            parentNode.lparen.comments.forEach((comment, index) => {
-                comment.printed = true;
-                comments.push(lineSuffix(`${index === 0 ? " " : ""}#${comment.value}`));
-            });
-            parts.push(join(hardline, comments));
-        }
-        return group([...parts, indent([softline, ...contents]), softline, ")"]);
-    }
-    return group(contents);
-};
-exports.printParams = printParams;
-exports.printArgsForward = (0, utils_1.literal)("...");
-exports.printKeywordRestParam = printRestParamSymbol("**");
-exports.printRestParam = printRestParamSymbol("*");

data/dist/ruby/nodes/patterns.js

@@ -1,122 +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.printRAssign = exports.printIn = exports.printHshPtn = exports.printFndPtn = exports.printAryPtn = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { align, group, hardline, indent, join, line } = prettier_1.default;
-const patterns = ["aryptn", "binary", "fndptn", "hshptn", "rassign"];
-const printPatternArg = (path, opts, print) => {
-    // Pinning is a really special syntax in pattern matching that's not really
-    // all that well supported in ripper. Here we're just going to the original
-    // source to see if the variable is pinned.
-    if (opts.originalText &&
-        opts.originalText[opts.locStart(path.getValue()) - 1] === "^") {
-        return ["^", path.call(print)];
-    }
-    return path.call(print);
-};
-const printAryPtn = (path, opts, print) => {
-    const [constant, preargs, splatarg, postargs] = path.getValue().body;
-    let argDocs = [];
-    if (preargs) {
-        argDocs = argDocs.concat(path.map((argPath) => printPatternArg(argPath, opts, print), "body", 1));
-    }
-    if (splatarg) {
-        argDocs.push(["*", path.call(print, "body", 2)]);
-    }
-    if (postargs) {
-        argDocs = argDocs.concat(path.map(print, "body", 3));
-    }
-    let argDoc = group(join([",", line], argDocs));
-    // There are a couple of cases where we _must_ use brackets. They include:
-    //
-    // * When the number of arguments inside the array pattern is one 1, then we
-    //   have to include them, otherwise it matches the whole array. Consider the
-    //   difference between `in [elem]` and `in elem`.
-    // * If we have a wrapping constant, then we definitely need the brackets.
-    //   Consider the difference between `in Const[elem]` and `in Const elem`
-    // * If we're nested inside a parent pattern, then we have to have brackets.
-    //   Consider the difference between `in key: first, second` and
-    //   `in key: [first, second]`.
-    if (argDocs.length === 1 ||
-        constant ||
-        patterns.includes(path.getParentNode().type)) {
-        argDoc = ["[", argDoc, "]"];
-    }
-    if (constant) {
-        return [path.call(print, "body", 0), argDoc];
-    }
-    return argDoc;
-};
-exports.printAryPtn = printAryPtn;
-const printFndPtn = (path, opts, print) => {
-    const [constant] = path.getValue().body;
-    const docs = [
-        "[",
-        group(join([",", line], [
-            ["*", path.call(print, "body", 1)],
-            ...path.map(print, "body", 2),
-            ["*", path.call(print, "body", 3)]
-        ])),
-        "]"
-    ];
-    if (constant) {
-        return [path.call(print, "body", 0), docs];
-    }
-    return docs;
-};
-exports.printFndPtn = printFndPtn;
-const printHshPtn = (path, opts, print) => {
-    const [constant, keyValuePairs, keyValueRest] = path.getValue().body;
-    let args = [];
-    if (keyValuePairs.length > 0) {
-        const printPair = (pairPath) => {
-            const parts = [pairPath.call(print, 0)];
-            if (pairPath.getValue()[1]) {
-                parts.push(" ", pairPath.call((pairValuePath) => printPatternArg(pairValuePath, opts, print), 1));
-            }
-            return parts;
-        };
-        args = args.concat(path.map(printPair, "body", 1));
-    }
-    if (keyValueRest) {
-        args.push(["**", path.call(print, "body", 2)]);
-    }
-    args = group(join([",", line], args));
-    if (constant) {
-        args = ["[", args, "]"];
-    }
-    else if (patterns.includes(path.getParentNode().type)) {
-        args = ["{ ", args, " }"];
-    }
-    if (constant) {
-        return [path.call(print, "body", 0), args];
-    }
-    return args;
-};
-exports.printHshPtn = printHshPtn;
-const printIn = (path, opts, print) => {
-    const keyword = "in ";
-    const parts = [
-        keyword,
-        align(keyword.length, path.call((valuePath) => printPatternArg(valuePath, opts, print), "body", 0)),
-        indent([hardline, path.call(print, "body", 1)])
-    ];
-    if (path.getValue().body[2]) {
-        parts.push(hardline, path.call(print, "body", 2));
-    }
-    return group(parts);
-};
-exports.printIn = printIn;
-const printRAssign = (path, opts, print) => {
-    const { keyword } = path.getValue();
-    const [leftDoc, rightDoc] = path.map(print, "body");
-    return group([
-        leftDoc,
-        keyword ? " in" : " =>",
-        group(indent([line, rightDoc]))
-    ]);
-};
-exports.printRAssign = printRAssign;

data/dist/ruby/nodes/regexp.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printRegexpLiteral = void 0;
-const utils_1 = require("../../utils");
-function hasContent(node, pattern) {
-    return node.body.some((child) => child.type === "@tstring_content" && pattern.test(child.body));
-}
-// If the first part of this regex is plain string content, we have a space
-// or an =, and we're contained within a command or command_call node, then we
-// want to use braces because otherwise we could end up with an ambiguous
-// operator, e.g. foo / bar/ or foo /=bar/
-function forwardSlashIsAmbiguous(path) {
-    const node = path.getValue();
-    const firstChildNode = node.body[0];
-    return (firstChildNode &&
-        firstChildNode.type === "@tstring_content" &&
-        [" ", "="].includes(firstChildNode.body[0]) &&
-        (0, utils_1.hasAncestor)(path, ["command", "command_call"]));
-}
-// This function is responsible for printing out regexp_literal nodes. They can
-// either use the special %r literal syntax or they can use forward slashes. At
-// the end of either of those they can have modifiers like m or x that have
-// special meaning for the regex engine.
-//
-// We favor the use of forward slashes unless the regex contains a forward slash
-// itself. In that case we switch over to using %r with braces.
-const printRegexpLiteral = (path, opts, print) => {
-    const node = path.getValue();
-    const docs = path.map(print, "body");
-    // We should use braces if using a forward slash would be ambiguous in the
-    // current context or if there's a forward slash in the content of the regexp.
-    const useBraces = forwardSlashIsAmbiguous(path) || hasContent(node, /\//);
-    // If we should be using braces but we have braces in the body of the regexp,
-    // then we're just going to resort to using whatever the original content was.
-    if (useBraces && hasContent(node, /[{}]/)) {
-        return [node.beging, ...docs, node.ending];
-    }
-    return [
-        useBraces ? "%r{" : "/",
-        ...docs,
-        useBraces ? "}" : "/",
-        node.ending.slice(1)
-    ];
-};
-exports.printRegexpLiteral = printRegexpLiteral;

data/dist/ruby/nodes/rescue.js

@@ -1,85 +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.printRetry = exports.printRedo = exports.printRescueMod = exports.printRescueEx = exports.printRescue = exports.printEnsure = exports.printBegin = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { align, group, hardline, indent, join, line } = prettier_1.default;
-const printBegin = (path, opts, print) => {
-    return [
-        "begin",
-        indent([hardline, path.map(print, "body")]),
-        hardline,
-        "end"
-    ];
-};
-exports.printBegin = printBegin;
-const printEnsure = (path, opts, print) => {
-    return [
-        path.call(print, "body", 0),
-        indent([hardline, path.call(print, "body", 1)])
-    ];
-};
-exports.printEnsure = printEnsure;
-const printRescue = (path, opts, print) => {
-    const parts = ["rescue"];
-    if (path.getValue().body[0]) {
-        parts.push(align("rescue ".length, path.call(print, "body", 0)));
-    }
-    else {
-        // If you don't specify an error to rescue in a `begin/rescue` block, then
-        // implicitly you're rescuing from `StandardError`. In this case, we're
-        // just going to explicitly add it.
-        parts.push(" StandardError");
-    }
-    const bodystmt = path.call(print, "body", 1);
-    if (bodystmt.length > 0) {
-        parts.push(indent([hardline, bodystmt]));
-    }
-    // This is the next clause on the `begin` statement, either another
-    // `rescue`, and `ensure`, or an `else` clause.
-    if (path.getValue().body[2]) {
-        parts.push([hardline, path.call(print, "body", 2)]);
-    }
-    return group(parts);
-};
-exports.printRescue = printRescue;
-// This is a container node that we're adding into the AST that isn't present in
-// Ripper solely so that we have a nice place to attach inline comments.
-const printRescueEx = (path, opts, print) => {
-    const [exception, variable] = path.getValue().body;
-    const parts = [];
-    if (exception) {
-        // If there's just one exception being rescued, then it's just going to be a
-        // single doc node.
-        let exceptionDoc = path.call(print, "body", 0);
-        // If there are multiple exceptions being rescued, then we're going to have
-        // multiple doc nodes returned as an array that we need to join together.
-        if (["mrhs_add_star", "mrhs_new_from_args"].includes(exception.type)) {
-            exceptionDoc = group(join([",", line], exceptionDoc));
-        }
-        parts.push(" ", exceptionDoc);
-    }
-    if (variable) {
-        parts.push(" => ", path.call(print, "body", 1));
-    }
-    return group(parts);
-};
-exports.printRescueEx = printRescueEx;
-const printRescueMod = (path, opts, print) => {
-    const [statementDoc, valueDoc] = path.map(print, "body");
-    return [
-        "begin",
-        indent([hardline, statementDoc]),
-        hardline,
-        "rescue StandardError",
-        indent([hardline, valueDoc]),
-        hardline,
-        "end"
-    ];
-};
-exports.printRescueMod = printRescueMod;
-exports.printRedo = (0, utils_1.literal)("redo");
-exports.printRetry = (0, utils_1.literal)("retry");