prettier 2.0.0.pre.rc4 → 3.0.0

data/dist/ruby/embed.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 });
-const prettier_1 = __importDefault(require("../prettier"));
-const utils_1 = require("../utils");
-const { group, indent, dedent, lineSuffix, mapDoc, markAsRoot, stripTrailingHardline } = prettier_1.default;
-const parsers = {
-    css: "css",
-    javascript: "babel",
-    js: "babel",
-    less: "less",
-    markdown: "markdown",
-    ruby: "ruby",
-    scss: "scss"
-};
-// This function is in here because it handles embedded parser values. I don't
-// have a test that exercises it because I'm not sure for which parser it is
-// necessary, but since it's in prettier core I'm keeping it here.
-/* istanbul ignore next */
-function replaceNewlines(doc) {
-    return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" && currentDoc.includes("\n")
-        ? currentDoc
-            .split(/(\n)/g)
-            .map((v, i) => (i % 2 === 0 ? v : utils_1.literallineWithoutBreakParent))
-        : currentDoc);
-}
-// Returns a number that represents the minimum amount of leading whitespace
-// that is present on every line in the given string. So for example if you have
-// the following heredoc:
-//
-//     <<~HERE
-//       my
-//       content
-//       here
-//     HERE
-//
-// then the return value of this function would be 2. If you indented every line
-// of the inner content 2 more spaces then this function would return 4.
-function getCommonLeadingWhitespace(content) {
-    const pattern = /^\s+/;
-    return content
-        .split("\n")
-        .slice(0, -1)
-        .filter((line) => line.trim().length > 0)
-        .reduce((minimum, line) => {
-        const matched = pattern.exec(line);
-        const length = matched ? matched[0].length : 0;
-        return minimum === null ? length : Math.min(minimum, length);
-    }, content.length);
-}
-// Returns a new string with the common whitespace stripped out. Effectively it
-// emulates what a squiggly heredoc does in Ruby.
-function stripCommonLeadingWhitespace(content) {
-    const lines = content.split("\n");
-    const minimum = getCommonLeadingWhitespace(content);
-    return lines.map((line) => line.slice(minimum)).join("\n");
-}
-const embed = (path, print, textToDoc) => {
-    const node = path.getValue();
-    // Currently we only support embedded formatting on heredoc nodes
-    if (node.type !== "heredoc") {
-        return null;
-    }
-    // First, ensure that we don't have any interpolation
-    const { beging, body, ending } = node;
-    const isSquiggly = beging.body[2] === "~";
-    if (body.some((part) => part.type !== "@tstring_content")) {
-        return null;
-    }
-    // Next, find the parser associated with this heredoc (if there is one). For
-    // example, if you use <<~CSS, we'd hook it up to the css parser.
-    const parser = parsers[beging.body.slice(3).toLowerCase()];
-    if (!parser) {
-        return null;
-    }
-    // Get the content as if it were a source string.
-    let content = body.map((part) => part.body).join("");
-    // If we're using a squiggly heredoc, then we're going to manually strip off
-    // the leading whitespace of each line up to the minimum leading whitespace so
-    // that the embedded parser can handle that for us.
-    if (isSquiggly) {
-        content = stripCommonLeadingWhitespace(content);
-    }
-    // Pass that content into the embedded parser. Get back the doc node.
-    const formatted = [
-        utils_1.literallineWithoutBreakParent,
-        replaceNewlines(stripTrailingHardline(textToDoc(content, { parser })))
-    ];
-    // If we're using a squiggly heredoc, then we can properly handle indentation
-    // ourselves.
-    if (isSquiggly) {
-        return [
-            path.call(print, "beging"),
-            lineSuffix(dedent([
-                indent(markAsRoot(formatted)),
-                { type: "line", hard: true },
-                ending.trim()
-            ]))
-        ];
-    }
-    // Otherwise, we need to just assume it's formatted correctly and return the
-    // content as it is.
-    return markAsRoot([
-        path.call(print, "beging"),
-        lineSuffix(group([formatted, utils_1.literallineWithoutBreakParent, ending.trim()]))
-    ]);
-};
-exports.default = embed;

data/dist/ruby/nodes/alias.js

@@ -1,59 +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.printAlias = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { addTrailingComment, align, group, hardline, line } = prettier_1.default;
-// The `alias` keyword is used to make a method respond to another name as well
-// as the current one. For example, to get the method `foo` to also respond to
-// `bar`, you would:
-//
-//     alias bar foo
-//
-// Now, in the current context you can call `bar` and it will execute the `foo`
-// method.
-//
-// When you're aliasing two methods, you can either provide bare words (like the
-// example above) or you can provide symbols (note that this includes dynamic
-// symbols like :"foo-#{bar}-baz"). In general, to be consistent with the ruby
-// style guide, we prefer bare words:
-//
-//     https://github.com/rubocop-hq/ruby-style-guide#alias-method-lexically
-//
-// The `alias` node contains two children. The left and right align with the
-// arguments passed to the keyword. So, for the above example the left would be
-// the symbol literal `bar` and the right could be the symbol literal `foo`.
-const printAlias = (path, opts, print) => {
-    const keyword = "alias ";
-    // In general, return the printed doc of the argument at the provided index.
-    // Special handling is given for symbol literals that are not bare words, as
-    // we convert those into bare words by just pulling out the ident node.
-    const printAliasArg = (argPath) => {
-        const argNode = argPath.getValue();
-        if (argNode.type === "symbol_literal") {
-            // If 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 (argNode.comments) {
-                argNode.comments.forEach((comment) => {
-                    addTrailingComment(argNode.body[0], comment);
-                });
-            }
-            return argPath.call(print, "body", 0);
-        }
-        return print(argPath);
-    };
-    return group([
-        keyword,
-        path.call(printAliasArg, "body", 0),
-        group(align(keyword.length, [
-            // If the left child has any comments, then we need to explicitly break
-            // this into two lines
-            path.getValue().body[0].comments ? hardline : line,
-            path.call(printAliasArg, "body", 1)
-        ]))
-    ]);
-};
-exports.printAlias = printAlias;

data/dist/ruby/nodes/aref.js

@@ -1,53 +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.printArefField = exports.printAref = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { group, indent, join, line, softline } = prettier_1.default;
-// `aref` nodes are when you're pulling a value out of a collection at a
-// specific index. Put another way, it's any time you're calling the method
-// `#[]`.
-//
-// The nodes usually contains two children, details below in the
-// `printArefField` function. In some cases, you don't necessarily have the
-// second child node, because you can call procs with a pretty esoteric syntax.
-// In the following example, you wouldn't have a second child, and `"foo"` would
-// be the first child.
-//
-//     foo[]
-//
-const printAref = (path, opts, print) => {
-    const indexNode = path.getValue().body[1];
-    if (!indexNode) {
-        return [path.call(print, "body", 0), "[]"];
-    }
-    return (0, exports.printArefField)(path, opts, print);
-};
-exports.printAref = printAref;
-// `aref_field` nodes are for assigning values into collections at specific
-// indices. Put another way, it's any time you're calling the method `#[]=`.
-// The `aref_field` node itself is just the left side of the assignment, and
-// they're always wrapped in `assign` nodes.
-//
-// The nodes always contain two children, the name of the array (usually a
-// `vcall` node and the index (usually an `args_add_block` node). The
-// `args_add_block` is one of a couple nodes that has special handling where its
-// printed form is actually an array to make joining easier.
-//
-// So in the following example, `"foo"` is the array and `["bar"]` is the index.
-//
-//     foo[bar] = baz
-//
-const printArefField = (path, opts, print) => {
-    const [printedArray, printedIndex] = path.map(print, "body");
-    return group([
-        printedArray,
-        "[",
-        indent([softline, join([",", line], printedIndex)]),
-        softline,
-        "]"
-    ]);
-};
-exports.printArefField = printArefField;

data/dist/ruby/nodes/args.js

@@ -1,165 +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.printBlockArg = exports.printArgsAddStar = exports.printArgsAddBlock = exports.printArgs = exports.printArgParen = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const toProc_1 = __importDefault(require("../toProc"));
-const { group, ifBreak, indent, join, line, softline } = prettier_1.default;
-const noTrailingComma = ["command", "command_call"];
-function getArgParenTrailingComma(node) {
-    // If we have a block, then we don't want to add a trailing comma.
-    if (node.type === "args_add_block" && node.body[1]) {
-        return "";
-    }
-    // If we only have one argument and that first argument necessitates that we
-    // skip putting a comma (because it would interfere with parsing the argument)
-    // then we don't want to add a trailing comma.
-    if (node.body.length === 1 && noTrailingComma.includes(node.body[0].type)) {
-        return "";
-    }
-    return ifBreak(",", "");
-}
-const printArgParen = (path, opts, print) => {
-    const argsNode = path.getValue().body[0];
-    if (argsNode === null) {
-        return "";
-    }
-    // Here we can skip the entire rest of the method by just checking if it's
-    // an args_forward node, as we're guaranteed that there are no other arg
-    // nodes.
-    if (argsNode.type === "args_forward") {
-        return group([
-            "(",
-            indent([softline, path.call(print, "body", 0)]),
-            softline,
-            ")"
-        ]);
-    }
-    // Now here we return a doc that represents the whole grouped expression,
-    // including the surrouding parentheses.
-    return group([
-        "(",
-        indent([
-            softline,
-            join([",", line], path.call(print, "body", 0)),
-            (0, utils_1.getTrailingComma)(opts) ? getArgParenTrailingComma(argsNode) : ""
-        ]),
-        softline,
-        ")"
-    ]);
-};
-exports.printArgParen = printArgParen;
-const printArgs = (path, { rubyToProc }, print) => {
-    const args = path.map(print, "body");
-    // Don't bother trying to do any kind of fancy toProc transform if the
-    // option is disabled.
-    if (rubyToProc) {
-        let blockNode = null;
-        // Look up the chain to see if these arguments are contained within a
-        // method_add_block node, and if they are that that node has a block
-        // associated with it. If it does, we're going to attempt to transform it
-        // into the to_proc shorthand and add it to the list of arguments.
-        [1, 2, 3].find((parent) => {
-            const parentNode = path.getParentNode(parent);
-            blockNode =
-                parentNode &&
-                    parentNode.type === "method_add_block" &&
-                    parentNode.body[1];
-            return blockNode;
-        });
-        const proc = blockNode && (0, toProc_1.default)(path, blockNode);
-        // If we have a successful to_proc transformation, but we're part of an
-        // aref node, that means it's something to the effect of
-        //
-        //     foo[:bar].each(&:to_s)
-        //
-        // In this case we need to just return regular arguments, otherwise we
-        // would end up putting &:to_s inside the brackets accidentally.
-        if (proc && path.getParentNode(1).type !== "aref") {
-            args.push(proc);
-        }
-    }
-    return args;
-};
-exports.printArgs = printArgs;
-const printArgsAddBlock = (path, opts, print) => {
-    const node = path.getValue();
-    const blockNode = node.body[1];
-    const parts = path.call(print, "body", 0);
-    if (blockNode) {
-        let blockDoc = path.call(print, "body", 1);
-        if (!(blockNode.comments || []).some(({ leading }) => leading)) {
-            // If we don't have any leading comments, we can just prepend the
-            // operator.
-            blockDoc = ["&", blockDoc];
-        }
-        else {
-            // If we have a method call like:
-            //
-            //     foo(
-            //       # comment
-            //       &block
-            //     )
-            //
-            // then we need to make sure we don't accidentally prepend the operator
-            // before the comment.
-            //
-            // In prettier >= 2.3.0, the comments are printed as an array before the
-            // content. I don't love this kind of reflection, but it's the simplest
-            // way at the moment to get this right.
-            blockDoc = blockDoc[0].concat(["&", blockDoc[1]], blockDoc.slice(2));
-        }
-        parts.push(blockDoc);
-    }
-    return parts;
-};
-exports.printArgsAddBlock = printArgsAddBlock;
-const printArgsAddStar = (path, opts, print) => {
-    let docs = [];
-    path.each((argPath, argIndex) => {
-        const doc = print(argPath);
-        // If it's the first child, then it's an array of args, so we're going to
-        // concat that onto the existing docs if there are any.
-        if (argIndex === 0) {
-            if (doc.length > 0) {
-                docs = docs.concat(doc);
-            }
-            return;
-        }
-        // If it's after the splat, then it's an individual arg, so we're just going
-        // to push it onto the array.
-        if (argIndex !== 1) {
-            docs.push(doc);
-            return;
-        }
-        // If we don't have any leading comments, we can just prepend the operator.
-        const argsNode = argPath.getValue();
-        if (!(argsNode.comments || []).some(({ leading }) => leading)) {
-            docs.push(["*", doc]);
-            return;
-        }
-        // If we have an array like:
-        //
-        //     [
-        //       # comment
-        //       *values
-        //     ]
-        //
-        // then we need to make sure we don't accidentally prepend the operator
-        // before the comment(s).
-        //
-        // In prettier >= 2.3.0, the comments are printed as an array before the
-        // content. I don't love this kind of reflection, but it's the simplest way
-        // at the moment to get this right.
-        docs.push(doc[0].concat(["*", doc[1]], doc.slice(2)));
-    }, "body");
-    return docs;
-};
-exports.printArgsAddStar = printArgsAddStar;
-const printBlockArg = (path, opts, print) => {
-    return ["&", path.call(print, "body", 0)];
-};
-exports.printBlockArg = printBlockArg;

data/dist/ruby/nodes/arrays.js

@@ -1,126 +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.printArray = exports.printWord = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { group, ifBreak, indent, join, line, softline } = prettier_1.default;
-// Checks that every argument within this args node is a string_literal node
-// that has no spaces or interpolations. This means we're dealing with an array
-// that looks something like:
-//
-//     ['a', 'b', 'c']
-//
-function isStringArray(args) {
-    return (args.body.length > 1 &&
-        args.body.every((arg) => {
-            // We want to verify that every node inside of this array is a string
-            // literal. We also want to make sure none of them have comments attached.
-            if (arg.type !== "string_literal" || arg.comments) {
-                return false;
-            }
-            // If the string has multiple parts (meaning plain string content but also
-            // interpolated content) then we know it's not a simple string.
-            if (arg.body.length !== 1) {
-                return false;
-            }
-            const part = arg.body[0];
-            // If the only part of this string is not @tstring_content then it's
-            // interpolated, so again we can return false.
-            if (part.type !== "@tstring_content") {
-                return false;
-            }
-            // Finally, verify that the string doesn't contain a space, an escape
-            // character, or brackets so that we know it can be put into a string
-            // literal array.
-            return !/[\s\\[\]]/.test(part.body);
-        }));
-}
-// Checks that every argument within this args node is a symbol_literal node (as
-// opposed to a dyna_symbol) so it has no interpolation. This means we're
-// dealing with an array that looks something like:
-//
-//     [:a, :b, :c]
-//
-function isSymbolArray(args) {
-    return (args.body.length > 1 &&
-        args.body.every((arg) => arg.type === "symbol_literal" && !arg.comments));
-}
-// Prints out a word that is a part of a special array literal that accepts
-// interpolation. The body is an array of either plain strings or interpolated
-// expressions.
-const printWord = (path, opts, print) => {
-    return path.map(print, "body");
-};
-exports.printWord = printWord;
-// Prints out a special array literal. Accepts the parts of the array literal as
-// an argument, where the first element of the parts array is a string that
-// contains the special start.
-function printArrayLiteral(start, parts) {
-    return group([
-        start,
-        "[",
-        indent([softline, join(line, parts)]),
-        softline,
-        "]"
-    ]);
-}
-const arrayLiteralStarts = {
-    qsymbols: "%i",
-    qwords: "%w",
-    symbols: "%I",
-    words: "%W"
-};
-// An array node is any literal array in Ruby. This includes all of the special
-// array literals as well as regular arrays. If it is a special array literal
-// then it will have one child that represents the special array, otherwise it
-// will have one child that contains all of the elements of the array.
-const printArray = (path, opts, print) => {
-    const array = path.getValue();
-    const args = array.body[0];
-    // If there is no inner arguments node, then we're dealing with an empty
-    // array, so we can go ahead and return.
-    if (args === null) {
-        return (0, utils_1.printEmptyCollection)(path, opts, "[", "]");
-    }
-    // If we don't have a regular args node at this point then we have a special
-    // array literal. In that case we're going to print out the body (which will
-    // return to us an array with the first one being the start of the array) and
-    // send that over to the printArrayLiteral function.
-    if (args.type !== "args" && args.type !== "args_add_star") {
-        return path.call((arrayPath) => printArrayLiteral(arrayLiteralStarts[args.type], arrayPath.map(print, "body")), "body", 0);
-    }
-    if (opts.rubyArrayLiteral) {
-        // If we have an array that contains only simple string literals with no
-        // spaces or interpolation, then we're going to print a %w array.
-        if (isStringArray(args)) {
-            const printString = (stringPath) => stringPath.call(print, "body", 0);
-            const nodePath = path;
-            const parts = nodePath.map(printString, "body", 0, "body");
-            return printArrayLiteral("%w", parts);
-        }
-        // If we have an array that contains only simple symbol literals with no
-        // interpolation, then we're going to print a %i array.
-        if (isSymbolArray(args)) {
-            const printSymbol = (symbolPath) => symbolPath.call(print, "body", 0);
-            const nodePath = path;
-            const parts = nodePath.map(printSymbol, "body", 0, "body");
-            return printArrayLiteral("%i", parts);
-        }
-    }
-    // Here we have a normal array of any type of object with no special literal
-    // types or anything.
-    return group([
-        "[",
-        indent([
-            softline,
-            join([",", line], path.call(print, "body", 0)),
-            (0, utils_1.getTrailingComma)(opts) ? ifBreak(",", "") : ""
-        ]),
-        softline,
-        "]"
-    ]);
-};
-exports.printArray = printArray;

data/dist/ruby/nodes/assign.js

@@ -1,41 +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.printVarRef = exports.printVarField = exports.printOpAssign = exports.printAssign = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { group, indent, join, line } = prettier_1.default;
-const printAssign = (path, opts, print) => {
-    const [, valueNode] = path.getValue().body;
-    const [targetDoc, valueDoc] = path.map(print, "body");
-    let rightSideDoc = valueDoc;
-    // If the right side of this assignment is a multiple assignment, then we need
-    // to join it together with commas.
-    if (["mrhs_add_star", "mrhs_new_from_args"].includes(valueNode.type)) {
-        rightSideDoc = group(join([",", line], valueDoc));
-    }
-    if ((0, utils_1.skipAssignIndent)(valueNode)) {
-        return group([targetDoc, " = ", rightSideDoc]);
-    }
-    return group([targetDoc, " =", indent([line, rightSideDoc])]);
-};
-exports.printAssign = printAssign;
-const printOpAssign = (path, opts, print) => {
-    return group([
-        path.call(print, "body", 0),
-        " ",
-        path.call(print, "body", 1),
-        indent([line, path.call(print, "body", 2)])
-    ]);
-};
-exports.printOpAssign = printOpAssign;
-const printVarField = (path, opts, print) => {
-    return path.getValue().body ? path.call(print, "body", 0) : "";
-};
-exports.printVarField = printVarField;
-const printVarRef = (path, opts, print) => {
-    return path.call(print, "body", 0);
-};
-exports.printVarRef = printVarRef;

data/dist/ruby/nodes/blocks.js

@@ -1,87 +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.printDoBlock = exports.printBraceBlock = exports.printBlockVar = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { breakParent, group, ifBreak, indent, join, removeLines, softline } = prettier_1.default;
-const printBlockVar = (path, opts, print) => {
-    const parts = ["|", removeLines(path.call(print, "body", 0))];
-    // The second part of this node is a list of optional block-local variables
-    if (path.getValue().body[1]) {
-        parts.push("; ", join(", ", path.map(print, "body", 1)));
-    }
-    parts.push("| ");
-    return parts;
-};
-exports.printBlockVar = printBlockVar;
-// You have to go through the main print function if you could potentially have
-// comments attached. So we're doing this weird reflection on the printed docs
-// to retroactively change the printed keyword depending on if we're using
-// braces or not. Ideally we wouldn't do this, we would instead do this
-// reflection in the child printer, but this keeps the logic to just this file
-// and contains it, so keeping it here for now.
-function printBlockBeging(path, print, useBraces) {
-    let docs = print(path);
-    const doc = useBraces ? "{" : "do";
-    if (Array.isArray(docs)) {
-        docs[1] = doc;
-    }
-    else {
-        docs = doc;
-    }
-    return docs;
-}
-function printBlock(braces) {
-    return function printBlockWithBraces(path, opts, print) {
-        const [variables, statements] = path.getValue().body;
-        const stmts = statements.type === "stmts" ? statements.body : statements.body[0].body;
-        let doBlockBody = "";
-        if (stmts.length !== 1 ||
-            stmts[0].type !== "void_stmt" ||
-            stmts[0].comments) {
-            doBlockBody = indent([softline, path.call(print, "body", 1)]);
-        }
-        // If this block is nested underneath a command or command_call node, then
-        // we can't use `do...end` because that will get associated with the parent
-        // node as opposed to the current node (because of the difference in
-        // operator precedence). Instead, we still use a multi-line format but
-        // switch to using braces instead.
-        const useBraces = braces && (0, utils_1.hasAncestor)(path, ["command", "command_call"]);
-        const doBlock = [
-            " ",
-            path.call((begingPath) => printBlockBeging(begingPath, print, useBraces), "beging"),
-            variables ? [" ", path.call(print, "body", 0)] : "",
-            doBlockBody,
-            [softline, useBraces ? "}" : "end"]
-        ];
-        // We can hit this next pattern if within the block the only statement is a
-        // comment.
-        if (stmts.length === 1 &&
-            stmts[0].type === "void_stmt" &&
-            stmts[0].comments) {
-            return [breakParent, doBlock];
-        }
-        const blockReceiver = path.getParentNode().body[0];
-        // If the parent node is a command node, then there are no parentheses
-        // around the arguments to that command, so we need to break the block
-        if (["command", "command_call"].includes(blockReceiver.type)) {
-            return [breakParent, doBlock];
-        }
-        const hasBody = stmts.some(({ type }) => type !== "void_stmt");
-        const braceBlock = [
-            " ",
-            path.call((begingPath) => printBlockBeging(begingPath, print, true), "beging"),
-            hasBody || variables ? " " : "",
-            variables ? path.call(print, "body", 0) : "",
-            path.call(print, "body", 1),
-            hasBody ? " " : "",
-            "}"
-        ];
-        return group(ifBreak(doBlock, braceBlock));
-    };
-}
-exports.printBraceBlock = printBlock(true);
-exports.printDoBlock = printBlock(false);