prettier 2.1.1 → 2.1.2

package/index.js

@@ -21,7 +21,7 @@ var stream__default = /*#__PURE__*/_interopDefaultLegacy(stream$6);
 var events__default = /*#__PURE__*/_interopDefaultLegacy(events$1);
 
 var name = "prettier";
-var version = "2.1.1";
+var version = "2.1.2";
 var description = "Prettier is an opinionated code formatter";
 var bin = "./bin/prettier.js";
 var repository = "prettier/prettier";
@@ -101,7 +101,7 @@ var dependencies = {
 	"unicode-regex": "3.0.0",
 	unified: "9.2.0",
 	vnopts: "1.0.2",
-	"yaml-unist-parser": "1.3.0"
+	"yaml-unist-parser": "1.3.1"
 };
 var devDependencies = {
 	"@babel/core": "7.11.4",
@@ -136,7 +136,7 @@ var devDependencies = {
 	"jest-snapshot-serializer-raw": "1.1.0",
 	"jest-watch-typeahead": "0.6.0",
 	"npm-run-all": "4.1.5",
-	prettier: "2.1.0",
+	prettier: "2.1.1",
 	rimraf: "3.0.2",
 	rollup: "2.26.5",
 	"rollup-plugin-node-globals": "1.4.0",
@@ -4619,6 +4619,11 @@ var docPrinter = {
   printDocToString
 };
 
+const {
+  literalline: literalline$1,
+  concat: concat$2
+} = docBuilders; // Using a unique object to compare by reference.
+
 const traverseDocOnExitStackMarker = {};
 
 function traverseDoc(doc, onEnter, onExit, shouldTraverseConditionalGroups) {
@@ -4895,6 +4900,10 @@ function normalizeDoc(doc) {
   });
 }
 
+function replaceNewlinesWithLiterallines(doc) {
+  return mapDoc(doc, currentDoc => typeof currentDoc === "string" && currentDoc.includes("\n") ? concat$2(currentDoc.split(/(\n)/g).map((v, i) => i % 2 === 0 ? v : literalline$1)) : currentDoc);
+}
+
 var docUtils = {
   isEmpty,
   willBreak,
@@ -4906,7 +4915,8 @@ var docUtils = {
   removeLines,
   stripTrailingHardline,
   normalizeParts,
-  normalizeDoc
+  normalizeDoc,
+  replaceNewlinesWithLiterallines
 };
 
 function flattenDoc(doc) {
@@ -13791,7 +13801,7 @@ var massageAst = massageAST;
 
 
 const {
-  concat: concat$2,
+  concat: concat$3,
   line: line$1,
   hardline: hardline$1,
   breakParent: breakParent$1,
@@ -14139,10 +14149,10 @@ function printLeadingComment(commentPath, options) {
     const lineBreak = hasNewline$1(options.originalText, options.locEnd(comment)) ? hasNewline$1(options.originalText, options.locStart(comment), {
       backwards: true
     }) ? hardline$1 : line$1 : " ";
-    return concat$2([contents, lineBreak]);
+    return concat$3([contents, lineBreak]);
   }
 
-  return concat$2([contents, hardline$1]);
+  return concat$3([contents, hardline$1]);
 }
 
 function printTrailingComment(commentPath, options) {
@@ -14176,13 +14186,13 @@ function printTrailingComment(commentPath, options) {
     // if this a comment on its own line; normal trailing comments are
     // always at the end of another expression.
     const isLineBeforeEmpty = isPreviousLineEmpty$1(originalText, comment, locStart);
-    return lineSuffix$1(concat$2([hardline$1, isLineBeforeEmpty ? hardline$1 : "", contents]));
+    return lineSuffix$1(concat$3([hardline$1, isLineBeforeEmpty ? hardline$1 : "", contents]));
   }
 
-  let printed = concat$2([" ", contents]); // Trailing block comments never need a newline
+  let printed = concat$3([" ", contents]); // Trailing block comments never need a newline
 
   if (!isBlock) {
-    printed = concat$2([lineSuffix$1(printed), breakParent$1]);
+    printed = concat$3([lineSuffix$1(printed), breakParent$1]);
   }
 
   return printed;
@@ -14212,12 +14222,12 @@ function printDanglingComments(path, options, sameIndent, filter) {
     return join$1(hardline$1, parts);
   }
 
-  return indent$1(concat$2([hardline$1, join$1(hardline$1, parts)]));
+  return indent$1(concat$3([hardline$1, join$1(hardline$1, parts)]));
 }
 
 function prependCursorPlaceholder(path, options, printed) {
   if (path.getNode() === options.cursorNode && path.getValue()) {
-    return concat$2([cursor$2, printed, cursor$2]);
+    return concat$3([cursor$2, printed, cursor$2]);
   }
 
   return printed;
@@ -14260,7 +14270,7 @@ function printComments(path, print, options, needsSemi) {
       trailingParts.push(printTrailingComment(commentPath, options));
     }
   }, "comments");
-  return prependCursorPlaceholder(path, options, concat$2(leadingParts.concat(trailingParts)));
+  return prependCursorPlaceholder(path, options, concat$3(leadingParts.concat(trailingParts)));
 }
 
 function ensureAllCommentsPrinted(astComments) {
@@ -14538,7 +14548,7 @@ var multiparser = {
 const doc = document;
 const docBuilders$1 = doc.builders;
 const {
-  concat: concat$3,
+  concat: concat$4,
   hardline: hardline$2,
   addAlignmentToDoc: addAlignmentToDoc$1
 } = docBuilders$1;
@@ -14608,7 +14618,7 @@ function printAstToDoc(ast, options, alignmentSize = 0) {
   if (alignmentSize > 0) {
     // Add a hardline to make the indents take effect
     // It should be removed in index.js format()
-    doc = addAlignmentToDoc$1(concat$3([hardline$2, doc]), alignmentSize, options.tabWidth);
+    doc = addAlignmentToDoc$1(concat$4([hardline$2, doc]), alignmentSize, options.tabWidth);
   }
 
   docUtils$1.propagateBreaks(doc);
@@ -37733,13 +37743,14 @@ const {
     line: line$3,
     hardline: hardline$3,
     softline: softline$1,
-    literalline: literalline$1,
-    concat: concat$4,
+    literalline: literalline$2,
+    concat: concat$5,
     group: group$1,
     dedentToRoot: dedentToRoot$1
   },
   utils: {
-    mapDoc: mapDoc$1
+    mapDoc: mapDoc$1,
+    replaceNewlinesWithLiterallines: replaceNewlinesWithLiterallines$1
   }
 } = document;
 const {
@@ -37843,11 +37854,11 @@ function embed(path, print, textToDoc, options) {
             }
 
             if (expressionDoc) {
-              parts.push(concat$4(["${", expressionDoc, "}"]));
+              parts.push(concat$5(["${", expressionDoc, "}"]));
             }
           }
 
-          return concat$4(["`", indent$2(concat$4([hardline$3, join$2(hardline$3, parts)])), hardline$3, "`"]);
+          return concat$5(["`", indent$2(concat$5([hardline$3, join$2(hardline$3, parts)])), hardline$3, "`"]);
         }
 
         const htmlParser = isHtml(path) ? "html" : isAngularComponentTemplate(path) ? "angular" : undefined;
@@ -37869,7 +37880,7 @@ function embed(path, print, textToDoc, options) {
           const text = parent.quasis[0].value.raw.replace(/((?:\\\\)*)\\`/g, (_, backslashes) => "\\".repeat(backslashes.length / 2) + "`");
           const indentation = getIndentation(text);
           const hasIndent = indentation !== "";
-          return concat$4([hasIndent ? indent$2(concat$4([softline$1, printMarkdown(text.replace(new RegExp(`^${indentation}`, "gm"), ""))])) : concat$4([literalline$1, dedentToRoot$1(printMarkdown(text))]), softline$1]);
+          return concat$5([hasIndent ? indent$2(concat$5([softline$1, printMarkdown(text.replace(new RegExp(`^${indentation}`, "gm"), ""))])) : concat$5([literalline$2, dedentToRoot$1(printMarkdown(text))]), softline$1]);
         }
 
         break;
@@ -37931,7 +37942,7 @@ function transformCssDoc(quasisDoc, path, print) {
     throw new Error("Couldn't insert all the expressions");
   }
 
-  return concat$4(["`", indent$2(concat$4([hardline$3, newDoc])), softline$1, "`"]);
+  return concat$5(["`", indent$2(concat$5([hardline$3, newDoc])), softline$1, "`"]);
 } // Search all the placeholders in the quasisDoc tree
 // and replace them with the expression docs one by one
 // returns a new doc with all the placeholders replaced,
@@ -37975,7 +37986,7 @@ function replacePlaceholders(quasisDoc, expressionDocs) {
       part.split(/@prettier-placeholder-(\d+)-id/).forEach((component, idx) => {
         // The placeholder is always at odd indices
         if (idx % 2 === 0) {
-          replacedParts.push(component);
+          replacedParts.push(replaceNewlinesWithLiterallines$1(component));
           return;
         } // The component will always be a number at odd index
 
@@ -38004,7 +38015,7 @@ function printGraphqlComments(lines) {
     if (array[i - 1] === "" && seenComment) {
       // If a non-first comment is preceded by a blank (whitespace only) line,
       // add in a blank line.
-      parts.push(concat$4([hardline$3, textLine]));
+      parts.push(concat$5([hardline$3, textLine]));
     } else {
       parts.push(textLine);
     }
@@ -38200,20 +38211,20 @@ function printHtmlTemplateLiteral(path, print, textToDoc, parser, options) {
       }
 
       const placeholderIndex = +component;
-      parts.push(concat$4(["${", group$1(expressionDocs[placeholderIndex]), "}"]));
+      parts.push(concat$5(["${", group$1(expressionDocs[placeholderIndex]), "}"]));
     }
 
-    return concat$4(parts);
+    return concat$5(parts);
   });
   const leadingWhitespace = /^\s/.test(text) ? " " : "";
   const trailingWhitespace = /\s$/.test(text) ? " " : "";
   const linebreak = options.htmlWhitespaceSensitivity === "ignore" ? hardline$3 : leadingWhitespace && trailingWhitespace ? line$3 : null;
 
   if (linebreak) {
-    return group$1(concat$4(["`", indent$2(concat$4([linebreak, group$1(contentDoc)])), linebreak, "`"]));
+    return group$1(concat$5(["`", indent$2(concat$5([linebreak, group$1(contentDoc)])), linebreak, "`"]));
   }
 
-  return group$1(concat$4(["`", leadingWhitespace, topLevelCount > 1 ? indent$2(group$1(contentDoc)) : group$1(contentDoc), trailingWhitespace, "`"]));
+  return group$1(concat$5(["`", leadingWhitespace, topLevelCount > 1 ? indent$2(group$1(contentDoc)) : group$1(contentDoc), trailingWhitespace, "`"]));
 }
 
 var embed_1 = embed;
@@ -40985,7 +40996,7 @@ var needsParens_1 = needsParens;
 
 const {
   builders: {
-    concat: concat$5,
+    concat: concat$6,
     join: join$3,
     line: line$4
   }
@@ -41007,12 +41018,12 @@ function printHtmlBinding(path, options, print) {
       const {
         params
       } = functionDeclarationPath.getValue();
-      return concat$5([params.length > 1 ? "(" : "", join$3(concat$5([",", line$4]), functionDeclarationPath.map(print, "params")), params.length > 1 ? ")" : ""]);
+      return concat$6([params.length > 1 ? "(" : "", join$3(concat$6([",", line$4]), functionDeclarationPath.map(print, "params")), params.length > 1 ? ")" : ""]);
     }, "program", "body", 0);
   }
 
   if (options.__isVueSlotScope) {
-    return path.call(functionDeclarationPath => join$3(concat$5([",", line$4]), functionDeclarationPath.map(print, "params")), "program", "body", 0);
+    return path.call(functionDeclarationPath => join$3(concat$6([",", line$4]), functionDeclarationPath.map(print, "params")), "program", "body", 0);
   }
 } // based on https://github.com/prettier/prettier/blob/master/src/language-html/syntax-vue.js isVueEventBindingExpression()
 
@@ -41078,7 +41089,7 @@ const {
 } = utils$6;
 const {
   builders: {
-    concat: concat$6,
+    concat: concat$7,
     line: line$5,
     hardline: hardline$4,
     softline: softline$2,
@@ -41099,14 +41110,14 @@ function printCallArguments(path, options, print) {
   const args = isDynamicImport ? [node.source] : node.arguments;
 
   if (args.length === 0) {
-    return concat$6(["(", comments.printDanglingComments(path, options,
+    return concat$7(["(", comments.printDanglingComments(path, options,
     /* sameIndent */
     true), ")"]);
   } // useEffect(() => { ... }, [foo, bar, baz])
 
 
   if (args.length === 2 && args[0].type === "ArrowFunctionExpression" && args[0].params.length === 0 && args[0].body.type === "BlockStatement" && args[1].type === "ArrayExpression" && !args.some(arg => arg.comments)) {
-    return concat$6(["(", path.call(print, "arguments", 0), ", ", path.call(print, "arguments", 1), ")"]);
+    return concat$7(["(", path.call(print, "arguments", 0), ", ", path.call(print, "arguments", 1), ")"]);
   } // func(
   //   ({
   //     a,
@@ -41123,7 +41134,7 @@ function printCallArguments(path, options, print) {
 
     let shouldBreak = false;
     argPath.each(paramPath => {
-      const printed = concat$6([print(paramPath)]);
+      const printed = concat$7([print(paramPath)]);
       shouldBreak = shouldBreak || willBreak$1(printed);
     }, "params");
     return shouldBreak;
@@ -41150,7 +41161,7 @@ function printCallArguments(path, options, print) {
     }
 
     shouldBreakForArrowFunction = shouldBreakForArrowFunctionInArguments(arg, argPath);
-    return concat$6(parts);
+    return concat$7(parts);
   };
 
   const printedArguments = isDynamicImport ? [path.call(path => printArgument(path, 0), "source")] : path.map(printArgument, "arguments");
@@ -41158,7 +41169,7 @@ function printCallArguments(path, options, print) {
   !(isDynamicImport || node.callee && node.callee.type === "Import") && shouldPrintComma$1(options, "all") ? "," : "";
 
   function allArgsBrokenOut() {
-    return group$2(concat$6(["(", indent$3(concat$6([line$5, concat$6(printedArguments)])), maybeTrailingComma, line$5, ")"]), {
+    return group$2(concat$7(["(", indent$3(concat$7([line$5, concat$7(printedArguments)])), maybeTrailingComma, line$5, ")"]), {
       shouldBreak: true
     });
   }
@@ -41178,7 +41189,7 @@ function printCallArguments(path, options, print) {
 
     const printArgument = argPath => {
       if (shouldGroupFirst && i === 0) {
-        printedExpanded = [concat$6([argPath.call(p => print(p, {
+        printedExpanded = [concat$7([argPath.call(p => print(p, {
           expandFirstArg: true
         })), printedArguments.length > 1 ? "," : "", hasEmptyLineFollowingFirstArg ? hardline$4 : line$5, hasEmptyLineFollowingFirstArg ? hardline$4 : ""])].concat(printedArguments.slice(1));
       }
@@ -41199,17 +41210,17 @@ function printCallArguments(path, options, print) {
     }
 
     const somePrintedArgumentsWillBreak = printedArguments.some(willBreak$1);
-    const simpleConcat = concat$6(["(", concat$6(printedExpanded), ")"]);
-    return concat$6([somePrintedArgumentsWillBreak ? breakParent$2 : "", conditionalGroup$1([!somePrintedArgumentsWillBreak && !node.typeArguments && !node.typeParameters ? simpleConcat : ifBreak$1(allArgsBrokenOut(), simpleConcat), shouldGroupFirst ? concat$6(["(", group$2(printedExpanded[0], {
+    const simpleConcat = concat$7(["(", concat$7(printedExpanded), ")"]);
+    return concat$7([somePrintedArgumentsWillBreak ? breakParent$2 : "", conditionalGroup$1([!somePrintedArgumentsWillBreak && !node.typeArguments && !node.typeParameters ? simpleConcat : ifBreak$1(allArgsBrokenOut(), simpleConcat), shouldGroupFirst ? concat$7(["(", group$2(printedExpanded[0], {
       shouldBreak: true
-    }), concat$6(printedExpanded.slice(1)), ")"]) : concat$6(["(", concat$6(printedArguments.slice(0, -1)), group$2(getLast$3(printedExpanded), {
+    }), concat$7(printedExpanded.slice(1)), ")"]) : concat$7(["(", concat$7(printedArguments.slice(0, -1)), group$2(getLast$3(printedExpanded), {
       shouldBreak: true
     }), ")"]), allArgsBrokenOut()], {
       shouldBreak
     })]);
   }
 
-  const contents = concat$6(["(", indent$3(concat$6([softline$2, concat$6(printedArguments)])), ifBreak$1(maybeTrailingComma), softline$2, ")"]);
+  const contents = concat$7(["(", indent$3(concat$7([softline$2, concat$7(printedArguments)])), ifBreak$1(maybeTrailingComma), softline$2, ")"]);
 
   if (isLongCurriedCallExpression$1(path)) {
     // By not wrapping the arguments in a group, the printer prioritizes
@@ -41261,7 +41272,7 @@ const {
 } = utils$6;
 const {
   builders: {
-    concat: concat$7,
+    concat: concat$8,
     softline: softline$3,
     group: group$3,
     indent: indent$4
@@ -41304,18 +41315,18 @@ function printMemberLookup(path, options, print) {
   const optional = printOptionalToken(path);
 
   if (!n.computed) {
-    return concat$7([optional, ".", property]);
+    return concat$8([optional, ".", property]);
   }
 
   if (!n.property || isNumericLiteral$1(n.property)) {
-    return concat$7([optional, "[", property, "]"]);
+    return concat$8([optional, "[", property, "]"]);
   }
 
-  return group$3(concat$7([optional, "[", indent$4(concat$7([softline$3, property])), softline$3, "]"]));
+  return group$3(concat$8([optional, "[", indent$4(concat$8([softline$3, property])), softline$3, "]"]));
 }
 
 function printBindExpressionCallee(path, options, print) {
-  return concat$7(["::", path.call(print, "callee")]);
+  return concat$8(["::", path.call(print, "callee")]);
 }
 
 var misc = {
@@ -41343,7 +41354,7 @@ const {
 } = utils$6;
 const {
   builders: {
-    concat: concat$8,
+    concat: concat$9,
     join: join$4,
     hardline: hardline$5,
     group: group$4,
@@ -41406,7 +41417,7 @@ function printMemberChain(path, options, print) {
     if (isCallOrOptionalCallExpression$1(node) && (isMemberish$1(node.callee) || isCallOrOptionalCallExpression$1(node.callee))) {
       printedNodes.unshift({
         node,
-        printed: concat$8([comments.printComments(path, () => concat$8([printOptionalToken$1(path), printFunctionTypeParameters$1(path, options, print), callArguments(path, options, print)]), options), shouldInsertEmptyLineAfter(node) ? hardline$5 : ""])
+        printed: concat$9([comments.printComments(path, () => concat$9([printOptionalToken$1(path), printFunctionTypeParameters$1(path, options, print), callArguments(path, options, print)]), options), shouldInsertEmptyLineAfter(node) ? hardline$5 : ""])
       });
       path.call(callee => rec(callee), "callee");
     } else if (isMemberish$1(node)) {
@@ -41436,7 +41447,7 @@ function printMemberChain(path, options, print) {
   const node = path.getValue();
   printedNodes.unshift({
     node,
-    printed: concat$8([printOptionalToken$1(path), printFunctionTypeParameters$1(path, options, print), callArguments(path, options, print)])
+    printed: concat$9([printOptionalToken$1(path), printFunctionTypeParameters$1(path, options, print), callArguments(path, options, print)])
   });
 
   if (node.callee) {
@@ -41573,10 +41584,10 @@ function printMemberChain(path, options, print) {
     // accordingly
 
     if (printedGroup.length > 0 && printedGroup[printedGroup.length - 1].needsParens) {
-      return concat$8(["(", ...printed, ")"]);
+      return concat$9(["(", ...printed, ")"]);
     }
 
-    return concat$8(printed);
+    return concat$9(printed);
   }
 
   function printIndentedGroup(groups) {
@@ -41585,11 +41596,11 @@ function printMemberChain(path, options, print) {
       return "";
     }
 
-    return indent$5(group$4(concat$8([hardline$5, join$4(hardline$5, groups.map(printGroup))])));
+    return indent$5(group$4(concat$9([hardline$5, join$4(hardline$5, groups.map(printGroup))])));
   }
 
   const printedGroups = groups.map(printGroup);
-  const oneLine = concat$8(printedGroups);
+  const oneLine = concat$9(printedGroups);
   const cutoff = shouldMerge ? 3 : 2;
   const flatGroups = flatten_1(groups);
   const hasComment = flatGroups.slice(1, -1).some(node => hasLeadingComment$4(node.node)) || flatGroups.slice(0, -1).some(node => hasTrailingComment$2(node.node)) || groups[cutoff] && hasLeadingComment$4(groups[cutoff][0].node); // If we only have a single `.`, we shouldn't do anything fancy and just
@@ -41607,7 +41618,7 @@ function printMemberChain(path, options, print) {
 
   const lastNodeBeforeIndent = getLast$4(groups[shouldMerge ? 1 : 0]).node;
   const shouldHaveEmptyLineBeforeIndent = !isCallOrOptionalCallExpression$1(lastNodeBeforeIndent) && shouldInsertEmptyLineAfter(lastNodeBeforeIndent);
-  const expanded = concat$8([printGroup(groups[0]), shouldMerge ? concat$8(groups.slice(1, 2).map(printGroup)) : "", shouldHaveEmptyLineBeforeIndent ? hardline$5 : "", printIndentedGroup(groups.slice(shouldMerge ? 2 : 1))]);
+  const expanded = concat$9([printGroup(groups[0]), shouldMerge ? concat$9(groups.slice(1, 2).map(printGroup)) : "", shouldHaveEmptyLineBeforeIndent ? hardline$5 : "", printIndentedGroup(groups.slice(shouldMerge ? 2 : 1))]);
   const callExpressions = printedNodes.map(({
     node
   }) => node).filter(isCallOrOptionalCallExpression$1);
@@ -41628,7 +41639,7 @@ function printMemberChain(path, options, print) {
     return group$4(expanded);
   }
 
-  return concat$8([// We only need to check `oneLine` because if `expanded` is chosen
+  return concat$9([// We only need to check `oneLine` because if `expanded` is chosen
   // that means that the parent group has already been broken
   // naturally
   willBreak$2(oneLine) || shouldHaveEmptyLineBeforeIndent ? breakParent$3 : "", conditionalGroup$2([oneLine, expanded])]);
@@ -41638,7 +41649,7 @@ var memberChain = printMemberChain;
 
 const {
   builders: {
-    concat: concat$9,
+    concat: concat$a,
     softline: softline$4,
     group: group$5,
     indent: indent$6,
@@ -41656,7 +41667,7 @@ const {
 
 function printModuleSource(path, options, print) {
   const node = path.getValue();
-  return node.source ? concat$9([" from ", path.call(print, "source")]) : "";
+  return node.source ? concat$a([" from ", path.call(print, "source")]) : "";
 }
 
 function printModuleSpecifiers(path, options, print) {
@@ -41690,16 +41701,16 @@ function printModuleSpecifiers(path, options, print) {
       const canBreak = groupedSpecifiers.length > 1 || standalonesSpecifiers.length > 0 || node.specifiers.some(node => node.comments);
 
       if (canBreak) {
-        parts.push(group$5(concat$9(["{", indent$6(concat$9([options.bracketSpacing ? line$6 : softline$4, join$5(concat$9([",", line$6]), groupedSpecifiers)])), ifBreak$2(shouldPrintComma$2(options) ? "," : ""), options.bracketSpacing ? line$6 : softline$4, "}"])));
+        parts.push(group$5(concat$a(["{", indent$6(concat$a([options.bracketSpacing ? line$6 : softline$4, join$5(concat$a([",", line$6]), groupedSpecifiers)])), ifBreak$2(shouldPrintComma$2(options) ? "," : ""), options.bracketSpacing ? line$6 : softline$4, "}"])));
       } else {
-        parts.push(concat$9(["{", options.bracketSpacing ? " " : "", concat$9(groupedSpecifiers), options.bracketSpacing ? " " : "", "}"]));
+        parts.push(concat$a(["{", options.bracketSpacing ? " " : "", concat$a(groupedSpecifiers), options.bracketSpacing ? " " : "", "}"]));
       }
     }
   } else {
     parts.push("{}");
   }
 
-  return concat$9(parts);
+  return concat$a(parts);
 }
 
 var module$2 = {
@@ -41715,7 +41726,7 @@ const {
 } = util;
 const {
   builders: {
-    concat: concat$a,
+    concat: concat$b,
     line: line$7,
     softline: softline$5,
     group: group$6,
@@ -41881,7 +41892,7 @@ function printTernaryOperator(path, options, print, operatorOptions) {
     // parens when using ?: within JSX, because the parens are analogous to
     // curly braces in an if statement.
 
-    const wrap = doc => concat$a([ifBreak$3("(", ""), indent$7(concat$a([softline$5, doc])), softline$5, ifBreak$3(")", "")]); // The only things we don't wrap are:
+    const wrap = doc => concat$b([ifBreak$3("(", ""), indent$7(concat$b([softline$5, doc])), softline$5, ifBreak$3(")", "")]); // The only things we don't wrap are:
     // * Nested conditional expressions in alternates
     // * null
     // * undefined
@@ -41892,7 +41903,7 @@ function printTernaryOperator(path, options, print, operatorOptions) {
     parts.push(" ? ", isNil(consequentNode) ? path.call(print, operatorOptions.consequentNodePropertyName) : wrap(path.call(print, operatorOptions.consequentNodePropertyName)), " : ", alternateNode.type === operatorOptions.conditionalNodeType || isNil(alternateNode) ? path.call(print, operatorOptions.alternateNodePropertyName) : wrap(path.call(print, operatorOptions.alternateNodePropertyName)));
   } else {
     // normal mode
-    const part = concat$a([line$7, "? ", consequentNode.type === operatorOptions.conditionalNodeType ? ifBreak$3("", "(") : "", align$1(2, path.call(print, operatorOptions.consequentNodePropertyName)), consequentNode.type === operatorOptions.conditionalNodeType ? ifBreak$3("", ")") : "", line$7, ": ", alternateNode.type === operatorOptions.conditionalNodeType ? path.call(print, operatorOptions.alternateNodePropertyName) : align$1(2, path.call(print, operatorOptions.alternateNodePropertyName))]);
+    const part = concat$b([line$7, "? ", consequentNode.type === operatorOptions.conditionalNodeType ? ifBreak$3("", "(") : "", align$1(2, path.call(print, operatorOptions.consequentNodePropertyName)), consequentNode.type === operatorOptions.conditionalNodeType ? ifBreak$3("", ")") : "", line$7, ": ", alternateNode.type === operatorOptions.conditionalNodeType ? path.call(print, operatorOptions.alternateNodePropertyName) : align$1(2, path.call(print, operatorOptions.alternateNodePropertyName))]);
     parts.push(parent.type !== operatorOptions.conditionalNodeType || parent[operatorOptions.alternateNodePropertyName] === node || isParentTest ? part : options.useTabs ? dedent$1(indent$7(part)) : align$1(Math.max(0, options.tabWidth - 2), part));
   } // We want a whole chain of ConditionalExpressions to all
   // break if any of them break. That means we should only group around the
@@ -41904,7 +41915,7 @@ function printTernaryOperator(path, options, print, operatorOptions) {
 
   const maybeGroup = doc => parent === firstNonConditionalParent ? group$6(doc, {
     shouldBreak
-  }) : shouldBreak ? concat$a([doc, breakParent$4]) : doc; // Break the closing paren to keep the chain right after it:
+  }) : shouldBreak ? concat$b([doc, breakParent$4]) : doc; // Break the closing paren to keep the chain right after it:
   // (a
   //   ? b
   //   : c
@@ -41912,7 +41923,7 @@ function printTernaryOperator(path, options, print, operatorOptions) {
 
 
   const breakClosingParen = !jsxMode && (parent.type === "MemberExpression" || parent.type === "OptionalMemberExpression" || parent.type === "NGPipeExpression" && parent.left === node) && !parent.computed;
-  const result = maybeGroup(concat$a([].concat((testDoc =>
+  const result = maybeGroup(concat$b([].concat((testDoc =>
   /**
    *     a
    *       ? b
@@ -41923,8 +41934,8 @@ function printTernaryOperator(path, options, print, operatorOptions) {
    *       ? d
    *       : e
    */
-  parent.type === operatorOptions.conditionalNodeType && parent[operatorOptions.alternateNodePropertyName] === node ? align$1(2, testDoc) : testDoc)(concat$a(operatorOptions.beforeParts())), forceNoIndent ? concat$a(parts) : indent$7(concat$a(parts)), operatorOptions.afterParts(breakClosingParen))));
-  return isParentTest ? group$6(concat$a([indent$7(concat$a([softline$5, result])), softline$5])) : result;
+  parent.type === operatorOptions.conditionalNodeType && parent[operatorOptions.alternateNodePropertyName] === node ? align$1(2, testDoc) : testDoc)(concat$b(operatorOptions.beforeParts())), forceNoIndent ? concat$b(parts) : indent$7(concat$b(parts)), operatorOptions.afterParts(breakClosingParen))));
+  return isParentTest ? group$6(concat$b([indent$7(concat$b([softline$5, result])), softline$5])) : result;
 }
 
 var ternary = printTernaryOperator;
@@ -41954,12 +41965,12 @@ const {
 } = utilShared;
 const {
   builders: {
-    concat: concat$b,
+    concat: concat$c,
     join: join$6,
     line: line$8,
     hardline: hardline$6,
     softline: softline$6,
-    literalline: literalline$2,
+    literalline: literalline$3,
     group: group$7,
     indent: indent$8,
     align: align$2,
@@ -42130,15 +42141,15 @@ function genericPrint(path, options, printPath, args) {
   }
 
   if (decorators.length > 0) {
-    return group$7(concat$b(decorators.concat(parts)));
+    return group$7(concat$c(decorators.concat(parts)));
   }
 
-  return concat$b(parts);
+  return concat$c(parts);
 }
 
 function printDecorators(path, options, print) {
   const node = path.getValue();
-  return group$7(concat$b([join$6(line$8, path.map(print, "decorators")), hasNewlineBetweenOrAfterDecorators$1(node, options) ? hardline$6 : line$8]));
+  return group$7(concat$c([join$6(line$8, path.map(print, "decorators")), hasNewlineBetweenOrAfterDecorators$1(node, options) ? hardline$6 : line$8]));
 }
 
 function printPathNoParens(path, options, print, args) {
@@ -42168,7 +42179,7 @@ function printPathNoParens(path, options, print, args) {
       return path.call(print, "node");
 
     case "JsonRoot":
-      return concat$b([path.call(print, "node"), hardline$6]);
+      return concat$c([path.call(print, "node"), hardline$6]);
 
     case "File":
       // Print @babel/parser's InterpreterDirective here so that
@@ -42178,7 +42189,7 @@ function printPathNoParens(path, options, print, args) {
       }
 
       parts.push(path.call(print, "program"));
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "Program":
       {
@@ -42208,7 +42219,7 @@ function printPathNoParens(path, options, print, args) {
           parts.push(hardline$6);
         }
 
-        return concat$b(parts);
+        return concat$c(parts);
       }
     // Babel extension.
 
@@ -42218,19 +42229,19 @@ function printPathNoParens(path, options, print, args) {
     case "ExpressionStatement":
       // Detect Flow and TypeScript directives
       if (n.directive) {
-        return concat$b([nodeStr(n.expression, options, true), semi]);
+        return concat$c([nodeStr(n.expression, options, true), semi]);
       }
 
       if (options.parser === "__vue_event_binding") {
         const parent = path.getParentNode();
 
         if (parent.type === "Program" && parent.body.length === 1 && parent.body[0] === n) {
-          return concat$b([path.call(print, "expression"), isVueEventBindingExpression$1(n.expression) ? ";" : ""]);
+          return concat$c([path.call(print, "expression"), isVueEventBindingExpression$1(n.expression) ? ";" : ""]);
         }
       } // Do not append semicolon after the only JSX element in a program
 
 
-      return concat$b([path.call(print, "expression"), isTheOnlyJSXElementInMarkdown$1(options, path) ? "" : semi]);
+      return concat$c([path.call(print, "expression"), isTheOnlyJSXElementInMarkdown$1(options, path) ? "" : semi]);
     // Babel non-standard node. Used for Closure-style type casts. See postprocess.js.
 
     case "ParenthesizedExpression":
@@ -42238,14 +42249,14 @@ function printPathNoParens(path, options, print, args) {
         const shouldHug = !n.expression.comments;
 
         if (shouldHug) {
-          return concat$b(["(", path.call(print, "expression"), ")"]);
+          return concat$c(["(", path.call(print, "expression"), ")"]);
         }
 
-        return group$7(concat$b(["(", indent$8(concat$b([softline$6, path.call(print, "expression")])), softline$6, ")"]));
+        return group$7(concat$c(["(", indent$8(concat$c([softline$6, path.call(print, "expression")])), softline$6, ")"]));
       }
 
     case "AssignmentExpression":
-      return printAssignment(n.left, path.call(print, "left"), concat$b([" ", n.operator]), n.right, path.call(print, "right"), options);
+      return printAssignment(n.left, path.call(print, "left"), concat$c([" ", n.operator]), n.right, path.call(print, "right"), options);
 
     case "BinaryExpression":
     case "LogicalExpression":
@@ -42268,7 +42279,7 @@ function printPathNoParens(path, options, print, args) {
         //   ) {
 
         if (isInsideParenthesis) {
-          return concat$b(parts);
+          return concat$c(parts);
         } // Break between the parens in
         // unaries or in a member or specific call expression, i.e.
         //
@@ -42280,7 +42291,7 @@ function printPathNoParens(path, options, print, args) {
 
 
         if ((parent.type === "CallExpression" || parent.type === "OptionalCallExpression") && parent.callee === n || parent.type === "UnaryExpression" || (parent.type === "MemberExpression" || parent.type === "OptionalMemberExpression") && !parent.computed) {
-          return group$7(concat$b([indent$8(concat$b([softline$6, concat$b(parts)])), softline$6]));
+          return group$7(concat$c([indent$8(concat$c([softline$6, concat$c(parts)])), softline$6]));
         } // Avoid indenting sub-expressions in some cases where the first sub-expression is already
         // indented accordingly. We should indent sub-expressions where the first case isn't indented.
 
@@ -42290,7 +42301,7 @@ function printPathNoParens(path, options, print, args) {
         const samePrecedenceSubExpression = isBinaryish$1(n.left) && shouldFlatten$2(n.operator, n.left.operator);
 
         if (shouldNotIndent || shouldInlineLogicalExpression(n) && !samePrecedenceSubExpression || !shouldInlineLogicalExpression(n) && shouldIndentIfInlining) {
-          return group$7(concat$b(parts));
+          return group$7(concat$c(parts));
         }
 
         if (parts.length === 0) {
@@ -42309,9 +42320,9 @@ function printPathNoParens(path, options, print, args) {
         const firstGroupIndex = parts.findIndex(part => typeof part !== "string" && part.type === "group"); // Separate the leftmost expression, possibly with its leading comments.
 
         const headParts = parts.slice(0, firstGroupIndex === -1 ? 1 : firstGroupIndex + 1);
-        const rest = concat$b(parts.slice(headParts.length, hasJSX ? -1 : undefined));
+        const rest = concat$c(parts.slice(headParts.length, hasJSX ? -1 : undefined));
         const groupId = Symbol("logicalChain-" + ++uid);
-        const chain = group$7(concat$b([// Don't include the initial expression in the indentation
+        const chain = group$7(concat$c([// Don't include the initial expression in the indentation
         // level. The first item is guaranteed to be the first
         // left-most expression.
         ...headParts, indent$8(rest)]), {
@@ -42323,27 +42334,27 @@ function printPathNoParens(path, options, print, args) {
         }
 
         const jsxPart = getLast$5(parts);
-        return group$7(concat$b([chain, ifBreak$4(indent$8(jsxPart), jsxPart, {
+        return group$7(concat$c([chain, ifBreak$4(indent$8(jsxPart), jsxPart, {
           groupId
         })]));
       }
 
     case "AssignmentPattern":
-      return concat$b([path.call(print, "left"), " = ", path.call(print, "right")]);
+      return concat$c([path.call(print, "left"), " = ", path.call(print, "right")]);
 
     case "TSTypeAssertion":
       {
         const shouldBreakAfterCast = !(n.expression.type === "ArrayExpression" || n.expression.type === "ObjectExpression");
-        const castGroup = group$7(concat$b(["<", indent$8(concat$b([softline$6, path.call(print, "typeAnnotation")])), softline$6, ">"]));
-        const exprContents = concat$b([ifBreak$4("("), indent$8(concat$b([softline$6, path.call(print, "expression")])), softline$6, ifBreak$4(")")]);
+        const castGroup = group$7(concat$c(["<", indent$8(concat$c([softline$6, path.call(print, "typeAnnotation")])), softline$6, ">"]));
+        const exprContents = concat$c([ifBreak$4("("), indent$8(concat$c([softline$6, path.call(print, "expression")])), softline$6, ifBreak$4(")")]);
 
         if (shouldBreakAfterCast) {
-          return conditionalGroup$3([concat$b([castGroup, path.call(print, "expression")]), concat$b([castGroup, group$7(exprContents, {
+          return conditionalGroup$3([concat$c([castGroup, path.call(print, "expression")]), concat$c([castGroup, group$7(exprContents, {
             shouldBreak: true
-          })]), concat$b([castGroup, path.call(print, "expression")])]);
+          })]), concat$c([castGroup, path.call(print, "expression")])]);
         }
 
-        return group$7(concat$b([castGroup, path.call(print, "expression")]));
+        return group$7(concat$c([castGroup, path.call(print, "expression")]));
       }
 
     case "OptionalMemberExpression":
@@ -42359,27 +42370,27 @@ function printPathNoParens(path, options, print, args) {
         } while (firstNonMemberParent && (firstNonMemberParent.type === "MemberExpression" || firstNonMemberParent.type === "OptionalMemberExpression" || firstNonMemberParent.type === "TSNonNullExpression"));
 
         const shouldInline = firstNonMemberParent && (firstNonMemberParent.type === "NewExpression" || firstNonMemberParent.type === "BindExpression" || firstNonMemberParent.type === "VariableDeclarator" && firstNonMemberParent.id.type !== "Identifier" || firstNonMemberParent.type === "AssignmentExpression" && firstNonMemberParent.left.type !== "Identifier") || n.computed || n.object.type === "Identifier" && n.property.type === "Identifier" && parent.type !== "MemberExpression" && parent.type !== "OptionalMemberExpression";
-        return concat$b([path.call(print, "object"), shouldInline ? printMemberLookup$2(path, options, print) : group$7(indent$8(concat$b([softline$6, printMemberLookup$2(path, options, print)])))]);
+        return concat$c([path.call(print, "object"), shouldInline ? printMemberLookup$2(path, options, print) : group$7(indent$8(concat$c([softline$6, printMemberLookup$2(path, options, print)])))]);
       }
 
     case "MetaProperty":
-      return concat$b([path.call(print, "meta"), ".", path.call(print, "property")]);
+      return concat$c([path.call(print, "meta"), ".", path.call(print, "property")]);
 
     case "BindExpression":
       if (n.object) {
         parts.push(path.call(print, "object"));
       }
 
-      parts.push(group$7(indent$8(concat$b([softline$6, printBindExpressionCallee$2(path, options, print)]))));
-      return concat$b(parts);
+      parts.push(group$7(indent$8(concat$c([softline$6, printBindExpressionCallee$2(path, options, print)]))));
+      return concat$c(parts);
 
     case "Identifier":
       {
-        return concat$b([n.name, printOptionalToken$2(path), printTypeAnnotation(path, options, print)]);
+        return concat$c([n.name, printOptionalToken$2(path), printTypeAnnotation(path, options, print)]);
       }
 
     case "V8IntrinsicIdentifier":
-      return concat$b(["%", n.name]);
+      return concat$c(["%", n.name]);
 
     case "SpreadElement":
     case "SpreadElementPattern":
@@ -42387,7 +42398,7 @@ function printPathNoParens(path, options, print, args) {
     case "SpreadPropertyPattern":
     case "RestElement":
     case "ObjectTypeSpreadProperty":
-      return concat$b(["...", path.call(print, "argument"), printTypeAnnotation(path, options, print)]);
+      return concat$c(["...", path.call(print, "argument"), printTypeAnnotation(path, options, print)]);
 
     case "FunctionDeclaration":
     case "FunctionExpression":
@@ -42397,7 +42408,7 @@ function printPathNoParens(path, options, print, args) {
         parts.push(semi);
       }
 
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "ArrowFunctionExpression":
       {
@@ -42408,7 +42419,7 @@ function printPathNoParens(path, options, print, args) {
         if (shouldPrintParamsWithoutParens(path, options)) {
           parts.push(path.call(print, "params", 0));
         } else {
-          parts.push(group$7(concat$b([printFunctionParams(path, print, options,
+          parts.push(group$7(concat$c([printFunctionParams(path, print, options,
           /* expandLast */
           args && (args.expandLastArg || args.expandFirstArg),
           /* printTypeParams */
@@ -42431,13 +42442,13 @@ function printPathNoParens(path, options, print, args) {
         // as the arrow.
 
         if (!hasLeadingOwnLineComment$1(options.originalText, n.body, options) && (n.body.type === "ArrayExpression" || n.body.type === "ObjectExpression" || n.body.type === "BlockStatement" || isJSXNode$3(n.body) || isTemplateOnItsOwnLine$1(n.body, options.originalText, options) || n.body.type === "ArrowFunctionExpression" || n.body.type === "DoExpression")) {
-          return group$7(concat$b([concat$b(parts), " ", body]));
+          return group$7(concat$c([concat$c(parts), " ", body]));
         } // We handle sequence expressions as the body of arrows specially,
         // so that the required parentheses end up on their own lines.
 
 
         if (n.body.type === "SequenceExpression") {
-          return group$7(concat$b([concat$b(parts), group$7(concat$b([" (", indent$8(concat$b([softline$6, body])), softline$6, ")"]))]));
+          return group$7(concat$c([concat$c(parts), group$7(concat$c([" (", indent$8(concat$c([softline$6, body])), softline$6, ")"]))]));
         } // if the arrow function is expanded as last argument, we are adding a
         // level of indentation and need to add a softline to align the closing )
         // with the opening (, or if it's inside a JSXExpression (e.g. an attribute)
@@ -42452,7 +42463,7 @@ function printPathNoParens(path, options, print, args) {
         const shouldAddParens = n.body.type === "ConditionalExpression" && !startsWithNoLookaheadToken$2(n.body,
         /* forbidFunctionAndClass */
         false);
-        return group$7(concat$b([concat$b(parts), group$7(concat$b([indent$8(concat$b([line$8, shouldAddParens ? ifBreak$4("", "(") : "", body, shouldAddParens ? ifBreak$4("", ")") : ""])), shouldAddSoftLine ? concat$b([ifBreak$4(printTrailingComma ? "," : ""), softline$6]) : ""]))]));
+        return group$7(concat$c([concat$c(parts), group$7(concat$c([indent$8(concat$c([line$8, shouldAddParens ? ifBreak$4("", "(") : "", body, shouldAddParens ? ifBreak$4("", ")") : ""])), shouldAddSoftLine ? concat$c([ifBreak$4(printTrailingComma ? "," : ""), softline$6]) : ""]))]));
       }
 
     case "YieldExpression":
@@ -42466,7 +42477,7 @@ function printPathNoParens(path, options, print, args) {
         parts.push(" ", path.call(print, "argument"));
       }
 
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "AwaitExpression":
       {
@@ -42479,10 +42490,10 @@ function printPathNoParens(path, options, print, args) {
         const parent = path.getParentNode();
 
         if ((parent.type === "CallExpression" || parent.type === "OptionalCallExpression") && parent.callee === n || (parent.type === "MemberExpression" || parent.type === "OptionalMemberExpression") && parent.object === n) {
-          return group$7(concat$b([indent$8(concat$b([softline$6, concat$b(parts)])), softline$6]));
+          return group$7(concat$c([indent$8(concat$c([softline$6, concat$c(parts)])), softline$6]));
         }
 
-        return concat$b(parts);
+        return concat$c(parts);
       }
 
     case "ImportSpecifier":
@@ -42496,7 +42507,7 @@ function printPathNoParens(path, options, print, args) {
         parts.push(" as ", path.call(print, "local"));
       }
 
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "ExportSpecifier":
       parts.push(path.call(print, "local"));
@@ -42505,25 +42516,25 @@ function printPathNoParens(path, options, print, args) {
         parts.push(" as ", path.call(print, "exported"));
       }
 
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "ImportNamespaceSpecifier":
       parts.push("* as ");
       parts.push(path.call(print, "local"));
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "ImportDefaultSpecifier":
       return path.call(print, "local");
 
     case "TSExportAssignment":
-      return concat$b(["export = ", path.call(print, "expression"), semi]);
+      return concat$c(["export = ", path.call(print, "expression"), semi]);
 
     case "ExportDefaultDeclaration":
     case "ExportNamedDeclaration":
       return printExportDeclaration(path, options, print);
 
     case "DeclareExportDeclaration":
-      return concat$b(["declare ", printExportDeclaration(path, options, print)]);
+      return concat$c(["declare ", printExportDeclaration(path, options, print)]);
 
     case "ExportAllDeclaration":
       parts.push("export");
@@ -42539,10 +42550,10 @@ function printPathNoParens(path, options, print, args) {
       }
 
       parts.push(printModuleSource$1(path, options, print), semi);
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "ExportNamespaceSpecifier":
-      return concat$b(["* as ", path.call(print, "exported")]);
+      return concat$c(["* as ", path.call(print, "exported")]);
 
     case "ExportDefaultSpecifier":
       return path.call(print, "exported");
@@ -42566,15 +42577,15 @@ function printPathNoParens(path, options, print, args) {
         }
 
         if (Array.isArray(n.attributes) && n.attributes.length !== 0) {
-          parts.push(" with ", concat$b(path.map(print, "attributes")));
+          parts.push(" with ", concat$c(path.map(print, "attributes")));
         }
 
         parts.push(semi);
-        return concat$b(parts);
+        return concat$c(parts);
       }
 
     case "ImportAttribute":
-      return concat$b([path.call(print, "key"), ": ", path.call(print, "value")]);
+      return concat$c([path.call(print, "key"), ": ", path.call(print, "value")]);
 
     case "Import":
       return "import";
@@ -42598,7 +42609,7 @@ function printPathNoParens(path, options, print, args) {
 
         if (hasDirectives) {
           path.each(childPath => {
-            parts.push(indent$8(concat$b([hardline$6, print(childPath), semi])));
+            parts.push(indent$8(concat$c([hardline$6, print(childPath), semi])));
 
             if (isNextLineEmpty$4(options.originalText, childPath.getValue(), options.locEnd)) {
               parts.push(hardline$6);
@@ -42607,16 +42618,16 @@ function printPathNoParens(path, options, print, args) {
         }
 
         if (hasContent) {
-          parts.push(indent$8(concat$b([hardline$6, naked])));
+          parts.push(indent$8(concat$c([hardline$6, naked])));
         }
 
         parts.push(comments.printDanglingComments(path, options));
         parts.push(hardline$6, "}");
-        return concat$b(parts);
+        return concat$c(parts);
       }
 
     case "ReturnStatement":
-      return concat$b(["return", printReturnAndThrowArgument(path, options, print)]);
+      return concat$c(["return", printReturnAndThrowArgument(path, options, print)]);
 
     case "NewExpression":
     case "ImportExpression":
@@ -42635,7 +42646,7 @@ function printPathNoParens(path, options, print, args) {
         args.length === 1 && isTemplateOnItsOwnLine$1(args[0], options.originalText, options) || // Keep test declarations on a single line
         // e.g. `it('long name', () => {`
         !isNew && isTestCall$1(n, path.getParentNode())) {
-          return concat$b([isNew ? "new " : "", path.call(print, "callee"), optional, printFunctionTypeParameters$2(path, options, print), concat$b(["(", isDynamicImport ? path.call(print, "source") : join$6(", ", path.map(print, "arguments")), ")"])]);
+          return concat$c([isNew ? "new " : "", path.call(print, "callee"), optional, printFunctionTypeParameters$2(path, options, print), concat$c(["(", isDynamicImport ? path.call(print, "source") : join$6(", ", path.map(print, "arguments")), ")"])]);
         } // Inline Flow annotation comments following Identifiers in Call nodes need to
         // stay with the Identifier. For example:
         //
@@ -42656,7 +42667,7 @@ function printPathNoParens(path, options, print, args) {
           return memberChain(path, options, print);
         }
 
-        const contents = concat$b([isNew ? "new " : "", isDynamicImport ? "import" : path.call(print, "callee"), optional, isIdentifierWithFlowAnnotation ? `/*:: ${n.callee.trailingComments[0].value.slice(2).trim()} */` : "", printFunctionTypeParameters$2(path, options, print), callArguments(path, options, print)]); // We group here when the callee is itself a call expression.
+        const contents = concat$c([isNew ? "new " : "", isDynamicImport ? "import" : path.call(print, "callee"), optional, isIdentifierWithFlowAnnotation ? `/*:: ${n.callee.trailingComments[0].value.slice(2).trim()} */` : "", printFunctionTypeParameters$2(path, options, print), callArguments(path, options, print)]); // We group here when the callee is itself a call expression.
         // See `isLongCurriedCallExpression` for more info.
 
         if (isDynamicImport || isCallOrOptionalCallExpression$2(n.callee)) {
@@ -42667,7 +42678,7 @@ function printPathNoParens(path, options, print, args) {
       }
 
     case "ObjectTypeInternalSlot":
-      return concat$b([n.static ? "static " : "", "[[", path.call(print, "id"), "]]", printOptionalToken$2(path), n.method ? "" : ": ", path.call(print, "value")]);
+      return concat$c([n.static ? "static " : "", "[[", path.call(print, "id"), "]]", printOptionalToken$2(path), n.method ? "" : ": ", path.call(print, "value")]);
 
     case "ObjectExpression":
     case "ObjectPattern":
@@ -42717,7 +42728,7 @@ function printPathNoParens(path, options, print, args) {
         });
         let separatorParts = [];
         const props = propsAndLoc.sort((a, b) => a.loc - b.loc).map(prop => {
-          const result = concat$b(separatorParts.concat(group$7(prop.printed)));
+          const result = concat$c(separatorParts.concat(group$7(prop.printed)));
           separatorParts = [separator, line$8];
 
           if ((prop.node.type === "TSPropertySignature" || prop.node.type === "TSMethodSignature" || prop.node.type === "TSConstructSignatureDeclaration") && hasNodeIgnoreComment$2(prop.node)) {
@@ -42739,12 +42750,12 @@ function printPathNoParens(path, options, print, args) {
             const printedDanglingComments = comments.printDanglingComments(path, options,
             /* sameIndent */
             true);
-            printed = concat$b([printedDanglingComments, hasLineComments || hasNewline$5(options.originalText, options.locEnd(n.comments[n.comments.length - 1])) ? hardline$6 : line$8, "..."]);
+            printed = concat$c([printedDanglingComments, hasLineComments || hasNewline$5(options.originalText, options.locEnd(n.comments[n.comments.length - 1])) ? hardline$6 : line$8, "..."]);
           } else {
             printed = "...";
           }
 
-          props.push(concat$b(separatorParts.concat(printed)));
+          props.push(concat$c(separatorParts.concat(printed)));
         }
 
         const lastElem = getLast$5(n[propertiesField]);
@@ -42753,12 +42764,12 @@ function printPathNoParens(path, options, print, args) {
 
         if (props.length === 0) {
           if (!hasDanglingComments$1(n)) {
-            return concat$b([leftBrace, rightBrace, printTypeAnnotation(path, options, print)]);
+            return concat$c([leftBrace, rightBrace, printTypeAnnotation(path, options, print)]);
           }
 
-          content = group$7(concat$b([leftBrace, comments.printDanglingComments(path, options), softline$6, rightBrace, printOptionalToken$2(path), printTypeAnnotation(path, options, print)]));
+          content = group$7(concat$c([leftBrace, comments.printDanglingComments(path, options), softline$6, rightBrace, printOptionalToken$2(path), printTypeAnnotation(path, options, print)]));
         } else {
-          content = concat$b([leftBrace, indent$8(concat$b([options.bracketSpacing ? line$8 : softline$6, concat$b(props)])), ifBreak$4(canHaveTrailingSeparator && (separator !== "," || shouldPrintComma$3(options)) ? separator : ""), concat$b([options.bracketSpacing ? line$8 : softline$6, rightBrace]), printOptionalToken$2(path), printTypeAnnotation(path, options, print)]);
+          content = concat$c([leftBrace, indent$8(concat$c([options.bracketSpacing ? line$8 : softline$6, concat$c(props)])), ifBreak$4(canHaveTrailingSeparator && (separator !== "," || shouldPrintComma$3(options)) ? separator : ""), concat$c([options.bracketSpacing ? line$8 : softline$6, rightBrace]), printOptionalToken$2(path), printTypeAnnotation(path, options, print)]);
         } // If we inline the object as first argument of the parent, we don't want
         // to create another group so that the object breaks before the return
         // type
@@ -42787,7 +42798,7 @@ function printPathNoParens(path, options, print, args) {
         parts.push(printAssignment(n.key, printPropertyKey(path, options, print), ":", n.value, path.call(print, "value"), options));
       }
 
-      return concat$b(parts);
+      return concat$c(parts);
     // Babel 6
 
     case "ClassMethod":
@@ -42812,13 +42823,13 @@ function printPathNoParens(path, options, print, args) {
       }
 
       parts.push(printMethod(path, options, print));
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "ObjectMethod":
       return printMethod(path, options, print);
 
     case "Decorator":
-      return concat$b(["@", path.call(print, "expression"), path.call(print, "callee")]);
+      return concat$c(["@", path.call(print, "expression"), path.call(print, "callee")]);
 
     case "ArrayExpression":
     case "ArrayPattern":
@@ -42831,7 +42842,7 @@ function printPathNoParens(path, options, print, args) {
           if (!hasDanglingComments$1(n)) {
             parts.push(openBracket, closeBracket);
           } else {
-            parts.push(group$7(concat$b([openBracket, comments.printDanglingComments(path, options), softline$6, closeBracket])));
+            parts.push(group$7(concat$c([openBracket, comments.printDanglingComments(path, options), softline$6, closeBracket])));
           }
         } else {
           const lastElem = getLast$5(n.elements);
@@ -42863,7 +42874,7 @@ function printPathNoParens(path, options, print, args) {
             const itemsKey = elementType === "ArrayExpression" ? "elements" : "properties";
             return element[itemsKey] && element[itemsKey].length > 1;
           });
-          parts.push(group$7(concat$b([openBracket, indent$8(concat$b([softline$6, printArrayItems(path, options, "elements", print)])), needsForcedTrailingComma ? "," : "", ifBreak$4(canHaveTrailingComma && !needsForcedTrailingComma && shouldPrintComma$3(options) ? "," : ""), comments.printDanglingComments(path, options,
+          parts.push(group$7(concat$c([openBracket, indent$8(concat$c([softline$6, printArrayItems(path, options, "elements", print)])), needsForcedTrailingComma ? "," : "", ifBreak$4(canHaveTrailingComma && !needsForcedTrailingComma && shouldPrintComma$3(options) ? "," : ""), comments.printDanglingComments(path, options,
           /* sameIndent */
           true), softline$6, closeBracket]), {
             shouldBreak
@@ -42871,7 +42882,7 @@ function printPathNoParens(path, options, print, args) {
         }
 
         parts.push(printOptionalToken$2(path), printTypeAnnotation(path, options, print));
-        return concat$b(parts);
+        return concat$c(parts);
       }
 
     case "SequenceExpression":
@@ -42887,13 +42898,13 @@ function printPathNoParens(path, options, print, args) {
             if (p.getName() === 0) {
               parts.push(print(p));
             } else {
-              parts.push(",", indent$8(concat$b([line$8, print(p)])));
+              parts.push(",", indent$8(concat$c([line$8, print(p)])));
             }
           }, "expressions");
-          return group$7(concat$b(parts));
+          return group$7(concat$c(parts));
         }
 
-        return group$7(concat$b([join$6(concat$b([",", line$8]), path.map(print, "expressions"))]));
+        return group$7(concat$c([join$6(concat$c([",", line$8]), path.map(print, "expressions"))]));
       }
 
     case "ThisExpression":
@@ -42960,12 +42971,12 @@ function printPathNoParens(path, options, print, args) {
       }
 
       if (n.argument.comments && n.argument.comments.length > 0) {
-        parts.push(group$7(concat$b(["(", indent$8(concat$b([softline$6, path.call(print, "argument")])), softline$6, ")"])));
+        parts.push(group$7(concat$c(["(", indent$8(concat$c([softline$6, path.call(print, "argument")])), softline$6, ")"])));
       } else {
         parts.push(path.call(print, "argument"));
       }
 
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "UpdateExpression":
       parts.push(path.call(print, "argument"), n.operator);
@@ -42974,7 +42985,7 @@ function printPathNoParens(path, options, print, args) {
         parts.reverse();
       }
 
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "ConditionalExpression":
       return ternary(path, options, print, {
@@ -43006,13 +43017,13 @@ function printPathNoParens(path, options, print, args) {
           firstVariable = indent$8(printed[0]);
         }
 
-        parts = [n.declare ? "declare " : "", n.kind, firstVariable ? concat$b([" ", firstVariable]) : "", indent$8(concat$b(printed.slice(1).map(p => concat$b([",", hasValue && !isParentForLoop ? hardline$6 : line$8, p]))))];
+        parts = [n.declare ? "declare " : "", n.kind, firstVariable ? concat$c([" ", firstVariable]) : "", indent$8(concat$c(printed.slice(1).map(p => concat$c([",", hasValue && !isParentForLoop ? hardline$6 : line$8, p]))))];
 
         if (!(isParentForLoop && parentNode.body !== n)) {
           parts.push(semi);
         }
 
-        return group$7(concat$b(parts));
+        return group$7(concat$c(parts));
       }
 
     case "TSTypeAliasDeclaration":
@@ -43023,19 +43034,19 @@ function printPathNoParens(path, options, print, args) {
 
         const printed = printAssignmentRight(n.id, n.typeAnnotation, n.typeAnnotation && path.call(print, "typeAnnotation"), options);
         parts.push("type ", path.call(print, "id"), path.call(print, "typeParameters"), " =", printed, semi);
-        return group$7(concat$b(parts));
+        return group$7(concat$c(parts));
       }
 
     case "VariableDeclarator":
       return printAssignment(n.id, path.call(print, "id"), " =", n.init, n.init && path.call(print, "init"), options);
 
     case "WithStatement":
-      return group$7(concat$b(["with (", path.call(print, "object"), ")", adjustClause(n.body, path.call(print, "body"))]));
+      return group$7(concat$c(["with (", path.call(print, "object"), ")", adjustClause(n.body, path.call(print, "body"))]));
 
     case "IfStatement":
       {
         const con = adjustClause(n.consequent, path.call(print, "consequent"));
-        const opening = group$7(concat$b(["if (", group$7(concat$b([indent$8(concat$b([softline$6, path.call(print, "test")])), softline$6])), ")", con]));
+        const opening = group$7(concat$c(["if (", group$7(concat$c([indent$8(concat$c([softline$6, path.call(print, "test")])), softline$6])), ")", con]));
         parts.push(opening);
 
         if (n.alternate) {
@@ -43050,7 +43061,7 @@ function printPathNoParens(path, options, print, args) {
           parts.push("else", group$7(adjustClause(n.alternate, path.call(print, "alternate"), n.alternate.type === "IfStatement")));
         }
 
-        return concat$b(parts);
+        return concat$c(parts);
       }
 
     case "ForStatement":
@@ -43062,29 +43073,29 @@ function printPathNoParens(path, options, print, args) {
         const dangling = comments.printDanglingComments(path, options,
         /* sameLine */
         true);
-        const printedComments = dangling ? concat$b([dangling, softline$6]) : "";
+        const printedComments = dangling ? concat$c([dangling, softline$6]) : "";
 
         if (!n.init && !n.test && !n.update) {
-          return concat$b([printedComments, group$7(concat$b(["for (;;)", body]))]);
+          return concat$c([printedComments, group$7(concat$c(["for (;;)", body]))]);
         }
 
-        return concat$b([printedComments, group$7(concat$b(["for (", group$7(concat$b([indent$8(concat$b([softline$6, path.call(print, "init"), ";", line$8, path.call(print, "test"), ";", line$8, path.call(print, "update")])), softline$6])), ")", body]))]);
+        return concat$c([printedComments, group$7(concat$c(["for (", group$7(concat$c([indent$8(concat$c([softline$6, path.call(print, "init"), ";", line$8, path.call(print, "test"), ";", line$8, path.call(print, "update")])), softline$6])), ")", body]))]);
       }
 
     case "WhileStatement":
-      return group$7(concat$b(["while (", group$7(concat$b([indent$8(concat$b([softline$6, path.call(print, "test")])), softline$6])), ")", adjustClause(n.body, path.call(print, "body"))]));
+      return group$7(concat$c(["while (", group$7(concat$c([indent$8(concat$c([softline$6, path.call(print, "test")])), softline$6])), ")", adjustClause(n.body, path.call(print, "body"))]));
 
     case "ForInStatement":
       // Note: esprima can't actually parse "for each (".
-      return group$7(concat$b([n.each ? "for each (" : "for (", path.call(print, "left"), " in ", path.call(print, "right"), ")", adjustClause(n.body, path.call(print, "body"))]));
+      return group$7(concat$c([n.each ? "for each (" : "for (", path.call(print, "left"), " in ", path.call(print, "right"), ")", adjustClause(n.body, path.call(print, "body"))]));
 
     case "ForOfStatement":
-      return group$7(concat$b(["for", n.await ? " await" : "", " (", path.call(print, "left"), " of ", path.call(print, "right"), ")", adjustClause(n.body, path.call(print, "body"))]));
+      return group$7(concat$c(["for", n.await ? " await" : "", " (", path.call(print, "left"), " of ", path.call(print, "right"), ")", adjustClause(n.body, path.call(print, "body"))]));
 
     case "DoWhileStatement":
       {
         const clause = adjustClause(n.body, path.call(print, "body"));
-        const doBody = group$7(concat$b(["do", clause]));
+        const doBody = group$7(concat$c(["do", clause]));
         parts = [doBody];
 
         if (n.body.type === "BlockStatement") {
@@ -43094,12 +43105,12 @@ function printPathNoParens(path, options, print, args) {
         }
 
         parts.push("while (");
-        parts.push(group$7(concat$b([indent$8(concat$b([softline$6, path.call(print, "test")])), softline$6])), ")", semi);
-        return concat$b(parts);
+        parts.push(group$7(concat$c([indent$8(concat$c([softline$6, path.call(print, "test")])), softline$6])), ")", semi);
+        return concat$c(parts);
       }
 
     case "DoExpression":
-      return concat$b(["do ", path.call(print, "body")]);
+      return concat$c(["do ", path.call(print, "body")]);
 
     case "BreakStatement":
       parts.push("break");
@@ -43109,7 +43120,7 @@ function printPathNoParens(path, options, print, args) {
       }
 
       parts.push(semi);
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "ContinueStatement":
       parts.push("continue");
@@ -43119,17 +43130,17 @@ function printPathNoParens(path, options, print, args) {
       }
 
       parts.push(semi);
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "LabeledStatement":
       if (n.body.type === "EmptyStatement") {
-        return concat$b([path.call(print, "label"), ":;"]);
+        return concat$c([path.call(print, "label"), ":;"]);
       }
 
-      return concat$b([path.call(print, "label"), ": ", path.call(print, "body")]);
+      return concat$c([path.call(print, "label"), ": ", path.call(print, "body")]);
 
     case "TryStatement":
-      return concat$b(["try ", path.call(print, "block"), n.handler ? concat$b([" ", path.call(print, "handler")]) : "", n.finalizer ? concat$b([" finally ", path.call(print, "finalizer")]) : ""]);
+      return concat$c(["try ", path.call(print, "block"), n.handler ? concat$c([" ", path.call(print, "handler")]) : "", n.finalizer ? concat$c([" finally ", path.call(print, "finalizer")]) : ""]);
 
     case "CatchClause":
       if (n.param) {
@@ -43137,19 +43148,19 @@ function printPathNoParens(path, options, print, args) {
           backwards: true
         }));
         const param = path.call(print, "param");
-        return concat$b(["catch ", hasComments ? concat$b(["(", indent$8(concat$b([softline$6, param])), softline$6, ") "]) : concat$b(["(", param, ") "]), path.call(print, "body")]);
+        return concat$c(["catch ", hasComments ? concat$c(["(", indent$8(concat$c([softline$6, param])), softline$6, ") "]) : concat$c(["(", param, ") "]), path.call(print, "body")]);
       }
 
-      return concat$b(["catch ", path.call(print, "body")]);
+      return concat$c(["catch ", path.call(print, "body")]);
 
     case "ThrowStatement":
-      return concat$b(["throw", printReturnAndThrowArgument(path, options, print)]);
+      return concat$c(["throw", printReturnAndThrowArgument(path, options, print)]);
     // Note: ignoring n.lexical because it has no printing consequences.
 
     case "SwitchStatement":
-      return concat$b([group$7(concat$b(["switch (", indent$8(concat$b([softline$6, path.call(print, "discriminant")])), softline$6, ")"])), " {", n.cases.length > 0 ? indent$8(concat$b([hardline$6, join$6(hardline$6, path.map(casePath => {
+      return concat$c([group$7(concat$c(["switch (", indent$8(concat$c([softline$6, path.call(print, "discriminant")])), softline$6, ")"])), " {", n.cases.length > 0 ? indent$8(concat$c([hardline$6, join$6(hardline$6, path.map(casePath => {
         const caseNode = casePath.getValue();
-        return concat$b([casePath.call(print), n.cases.indexOf(caseNode) !== n.cases.length - 1 && isNextLineEmpty$4(options.originalText, caseNode, options.locEnd) ? hardline$6 : ""]);
+        return concat$c([casePath.call(print), n.cases.indexOf(caseNode) !== n.cases.length - 1 && isNextLineEmpty$4(options.originalText, caseNode, options.locEnd) ? hardline$6 : ""]);
       }, "cases"))])) : "", hardline$6, "}"]);
 
     case "SwitchCase":
@@ -43166,15 +43177,15 @@ function printPathNoParens(path, options, print, args) {
           const cons = path.call(consequentPath => {
             return printStatementSequence(consequentPath, options, print);
           }, "consequent");
-          parts.push(consequent.length === 1 && consequent[0].type === "BlockStatement" ? concat$b([" ", cons]) : indent$8(concat$b([hardline$6, cons])));
+          parts.push(consequent.length === 1 && consequent[0].type === "BlockStatement" ? concat$c([" ", cons]) : indent$8(concat$c([hardline$6, cons])));
         }
 
-        return concat$b(parts);
+        return concat$c(parts);
       }
     // JSX extensions below.
 
     case "DebuggerStatement":
-      return concat$b(["debugger", semi]);
+      return concat$c(["debugger", semi]);
 
     case "JSXAttribute":
       parts.push(path.call(print, "name"));
@@ -43189,7 +43200,7 @@ function printPathNoParens(path, options, print, args) {
           const quote = getPreferredQuote$1(final, options.jsxSingleQuote ? "'" : '"');
           const escape = quote === "'" ? "&apos;" : "&quot;";
           final = final.slice(1, -1).replace(new RegExp(quote, "g"), escape);
-          res = concat$b([quote, final, quote]);
+          res = concat$c([quote, final, quote]);
         } else {
           res = path.call(print, "value");
         }
@@ -43197,7 +43208,7 @@ function printPathNoParens(path, options, print, args) {
         parts.push("=", res);
       }
 
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "JSXIdentifier":
       return "" + n.name;
@@ -43214,15 +43225,15 @@ function printPathNoParens(path, options, print, args) {
     case "JSXSpreadAttribute":
     case "JSXSpreadChild":
       {
-        return concat$b(["{", path.call(p => {
-          const printed = concat$b(["...", print(p)]);
+        return concat$c(["{", path.call(p => {
+          const printed = concat$c(["...", print(p)]);
           const n = p.getValue();
 
           if (!n.comments || !n.comments.length || !willPrintOwnComments(p)) {
             return printed;
           }
 
-          return concat$b([indent$8(concat$b([softline$6, comments.printComments(p, () => printed, options)])), softline$6]);
+          return concat$c([indent$8(concat$c([softline$6, comments.printComments(p, () => printed, options)])), softline$6]);
         }, n.type === "JSXSpreadAttribute" ? "argument" : "expression"), "}"]);
       }
 
@@ -43233,10 +43244,10 @@ function printPathNoParens(path, options, print, args) {
         const shouldInline = n.expression.type === "JSXEmptyExpression" || !hasComments && (n.expression.type === "ArrayExpression" || n.expression.type === "ObjectExpression" || n.expression.type === "ArrowFunctionExpression" || n.expression.type === "CallExpression" || n.expression.type === "OptionalCallExpression" || n.expression.type === "FunctionExpression" || n.expression.type === "TemplateLiteral" || n.expression.type === "TaggedTemplateExpression" || n.expression.type === "DoExpression" || isJSXNode$3(parent) && (n.expression.type === "ConditionalExpression" || isBinaryish$1(n.expression)));
 
         if (shouldInline) {
-          return group$7(concat$b(["{", path.call(print, "expression"), lineSuffixBoundary$1, "}"]));
+          return group$7(concat$c(["{", path.call(print, "expression"), lineSuffixBoundary$1, "}"]));
         }
 
-        return group$7(concat$b(["{", indent$8(concat$b([softline$6, path.call(print, "expression")])), softline$6, lineSuffixBoundary$1, "}"]));
+        return group$7(concat$c(["{", indent$8(concat$c([softline$6, path.call(print, "expression")])), softline$6, lineSuffixBoundary$1, "}"]));
       }
 
     case "JSXFragment":
@@ -43252,7 +43263,7 @@ function printPathNoParens(path, options, print, args) {
         const nameHasComments = n.name && n.name.comments && n.name.comments.length > 0 || n.typeParameters && n.typeParameters.comments && n.typeParameters.comments.length > 0; // Don't break self-closing elements with no attributes and no comments
 
         if (n.selfClosing && !n.attributes.length && !nameHasComments) {
-          return concat$b(["<", path.call(print, "name"), path.call(print, "typeParameters"), " />"]);
+          return concat$c(["<", path.call(print, "name"), path.call(print, "typeParameters"), " />"]);
         } // don't break up opening elements with a single long text attribute
 
 
@@ -43266,7 +43277,7 @@ function printPathNoParens(path, options, print, args) {
         //   // comment
         // >
         !nameHasComments && (!n.attributes[0].comments || !n.attributes[0].comments.length)) {
-          return group$7(concat$b(["<", path.call(print, "name"), path.call(print, "typeParameters"), " ", concat$b(path.map(print, "attributes")), n.selfClosing ? " />" : ">"]));
+          return group$7(concat$c(["<", path.call(print, "name"), path.call(print, "typeParameters"), " ", concat$c(path.map(print, "attributes")), n.selfClosing ? " />" : ">"]));
         }
 
         const lastAttrHasTrailingComments = n.attributes.length && hasTrailingComment$3(getLast$5(n.attributes));
@@ -43283,13 +43294,13 @@ function printPathNoParens(path, options, print, args) {
         // string literal with newlines
 
         const shouldBreak = n.attributes && n.attributes.some(attr => attr.value && isStringLiteral$1(attr.value) && attr.value.value.includes("\n"));
-        return group$7(concat$b(["<", path.call(print, "name"), path.call(print, "typeParameters"), concat$b([indent$8(concat$b(path.map(attr => concat$b([line$8, print(attr)]), "attributes"))), n.selfClosing ? line$8 : bracketSameLine ? ">" : softline$6]), n.selfClosing ? "/>" : bracketSameLine ? "" : ">"]), {
+        return group$7(concat$c(["<", path.call(print, "name"), path.call(print, "typeParameters"), concat$c([indent$8(concat$c(path.map(attr => concat$c([line$8, print(attr)]), "attributes"))), n.selfClosing ? line$8 : bracketSameLine ? ">" : softline$6]), n.selfClosing ? "/>" : bracketSameLine ? "" : ">"]), {
           shouldBreak
         });
       }
 
     case "JSXClosingElement":
-      return concat$b(["</", path.call(print, "name"), ">"]);
+      return concat$c(["</", path.call(print, "name"), ">"]);
 
     case "JSXOpeningFragment":
     case "JSXClosingFragment":
@@ -43297,7 +43308,7 @@ function printPathNoParens(path, options, print, args) {
         const hasComment = n.comments && n.comments.length;
         const hasOwnLineComment = hasComment && !n.comments.every(comments$1.isBlockComment);
         const isOpeningFragment = n.type === "JSXOpeningFragment";
-        return concat$b([isOpeningFragment ? "<" : "</", indent$8(concat$b([hasOwnLineComment ? hardline$6 : hasComment && !isOpeningFragment ? " " : "", comments.printDanglingComments(path, options, true)])), hasOwnLineComment ? hardline$6 : "", ">"]);
+        return concat$c([isOpeningFragment ? "<" : "</", indent$8(concat$c([hasOwnLineComment ? hardline$6 : hasComment && !isOpeningFragment ? " " : "", comments.printDanglingComments(path, options, true)])), hasOwnLineComment ? hardline$6 : "", ">"]);
       }
 
     case "JSXText":
@@ -43307,7 +43318,7 @@ function printPathNoParens(path, options, print, args) {
     case "JSXEmptyExpression":
       {
         const requiresHardline = n.comments && !n.comments.every(comments$1.isBlockComment);
-        return concat$b([comments.printDanglingComments(path, options,
+        return concat$c([comments.printDanglingComments(path, options,
         /* sameIndent */
         !requiresHardline), requiresHardline ? hardline$6 : ""]);
       }
@@ -43317,7 +43328,7 @@ function printPathNoParens(path, options, print, args) {
         return "{}";
       }
 
-      return concat$b(["{", n.body.length > 0 ? indent$8(concat$b([hardline$6, path.call(bodyPath => {
+      return concat$c(["{", n.body.length > 0 ? indent$8(concat$c([hardline$6, path.call(bodyPath => {
         return printStatementSequence(bodyPath, options, print);
       }, "body")])) : comments.printDanglingComments(path, options), hardline$6, "}"]);
 
@@ -43362,7 +43373,7 @@ function printPathNoParens(path, options, print, args) {
         }
 
         parts.push(semi);
-        return group$7(concat$b(parts));
+        return group$7(concat$c(parts));
       }
 
     case "ClassDeclaration":
@@ -43371,8 +43382,8 @@ function printPathNoParens(path, options, print, args) {
         parts.push("declare ");
       }
 
-      parts.push(concat$b(printClass(path, options, print)));
-      return concat$b(parts);
+      parts.push(concat$c(printClass(path, options, print)));
+      return concat$c(parts);
 
     case "TSInterfaceHeritage":
     case "TSExpressionWithTypeArguments":
@@ -43383,10 +43394,10 @@ function printPathNoParens(path, options, print, args) {
         parts.push(path.call(print, "typeParameters"));
       }
 
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "TemplateElement":
-      return join$6(literalline$2, n.value.raw.split(/\r?\n/g));
+      return join$6(literalline$3, n.value.raw.split(/\r?\n/g));
 
     case "TemplateLiteral":
       {
@@ -43437,20 +43448,20 @@ function printPathNoParens(path, options, print, args) {
               // Breaks at the template element boundaries (${ and }) are preferred to breaking
               // in the middle of a MemberExpression
               if (n.expressions[i].comments && n.expressions[i].comments.length || n.expressions[i].type === "MemberExpression" || n.expressions[i].type === "OptionalMemberExpression" || n.expressions[i].type === "ConditionalExpression" || n.expressions[i].type === "SequenceExpression" || n.expressions[i].type === "TSAsExpression" || isBinaryish$1(n.expressions[i])) {
-                printed = concat$b([indent$8(concat$b([softline$6, printed])), softline$6]);
+                printed = concat$c([indent$8(concat$c([softline$6, printed])), softline$6]);
               }
             }
 
             const aligned = indentSize === 0 && quasi.value.raw.endsWith("\n") ? align$2(-Infinity, printed) : addAlignmentToDoc$2(printed, indentSize, tabWidth);
-            parts.push(group$7(concat$b(["${", aligned, lineSuffixBoundary$1, "}"])));
+            parts.push(group$7(concat$c(["${", aligned, lineSuffixBoundary$1, "}"])));
           }
         }, "quasis");
         parts.push("`");
-        return concat$b(parts);
+        return concat$c(parts);
       }
 
     case "TaggedTemplateExpression":
-      return concat$b([path.call(print, "tag"), path.call(print, "typeParameters"), path.call(print, "quasi")]);
+      return concat$c([path.call(print, "tag"), path.call(print, "typeParameters"), path.call(print, "quasi")]);
     // These types are unprintable because they serve as abstract
     // supertypes for other (printable) types.
 
@@ -43485,14 +43496,14 @@ function printPathNoParens(path, options, print, args) {
       return "";
 
     case "TSNamedTupleMember":
-      return concat$b([path.call(print, "label"), n.optional ? "?" : "", ": ", path.call(print, "elementType")]);
+      return concat$c([path.call(print, "label"), n.optional ? "?" : "", ": ", path.call(print, "elementType")]);
 
     case "TSTupleType":
     case "TupleTypeAnnotation":
       {
         const typesField = n.type === "TSTupleType" ? "elementTypes" : "types";
         const hasRest = n[typesField].length > 0 && getLast$5(n[typesField]).type === "TSRestType";
-        return group$7(concat$b(["[", indent$8(concat$b([softline$6, printArrayItems(path, options, typesField, print)])), ifBreak$4(shouldPrintComma$3(options, "all") && !hasRest ? "," : ""), comments.printDanglingComments(path, options,
+        return group$7(concat$c(["[", indent$8(concat$c([softline$6, printArrayItems(path, options, typesField, print)])), ifBreak$4(shouldPrintComma$3(options, "all") && !hasRest ? "," : ""), comments.printDanglingComments(path, options,
         /* sameIndent */
         true), softline$6, "]"]));
       }
@@ -43510,7 +43521,7 @@ function printPathNoParens(path, options, print, args) {
       return "mixed";
 
     case "ArrayTypeAnnotation":
-      return concat$b([path.call(print, "elementType"), "[]"]);
+      return concat$c([path.call(print, "elementType"), "[]"]);
 
     case "BooleanTypeAnnotation":
       return "boolean";
@@ -43524,7 +43535,7 @@ function printPathNoParens(path, options, print, args) {
     case "TSDeclareFunction":
       // For TypeScript the TSDeclareFunction node shares the AST
       // structure with FunctionDeclaration
-      return concat$b([n.declare ? "declare " : "", printFunctionDeclaration(path, print, options), semi]);
+      return concat$c([n.declare ? "declare " : "", printFunctionDeclaration(path, print, options), semi]);
 
     case "DeclareFunction":
       return printFlowDeclaration(path, ["function ", path.call(print, "id"), n.predicate ? " " : "", path.call(print, "predicate"), semi]);
@@ -43539,7 +43550,7 @@ function printPathNoParens(path, options, print, args) {
       return printFlowDeclaration(path, ["var ", path.call(print, "id"), semi]);
 
     case "DeclareExportAllDeclaration":
-      return concat$b(["declare export *", printModuleSource$1(path, options, print)]);
+      return concat$c(["declare export *", printModuleSource$1(path, options, print)]);
 
     case "DeclareOpaqueType":
     case "OpaqueType":
@@ -43560,11 +43571,11 @@ function printPathNoParens(path, options, print, args) {
           return printFlowDeclaration(path, parts);
         }
 
-        return concat$b(parts);
+        return concat$c(parts);
       }
 
     case "EnumDeclaration":
-      return concat$b(["enum ", path.call(print, "id"), " ", path.call(print, "body")]);
+      return concat$c(["enum ", path.call(print, "id"), " ", path.call(print, "body")]);
 
     case "EnumBooleanBody":
     case "EnumNumberBody":
@@ -43596,20 +43607,20 @@ function printPathNoParens(path, options, print, args) {
         }
 
         if (n.members.length === 0) {
-          parts.push(group$7(concat$b(["{", comments.printDanglingComments(path, options), softline$6, "}"])));
+          parts.push(group$7(concat$c(["{", comments.printDanglingComments(path, options), softline$6, "}"])));
         } else {
-          parts.push(group$7(concat$b(["{", indent$8(concat$b([hardline$6, printArrayItems(path, options, "members", print), shouldPrintComma$3(options) ? "," : ""])), comments.printDanglingComments(path, options,
+          parts.push(group$7(concat$c(["{", indent$8(concat$c([hardline$6, printArrayItems(path, options, "members", print), shouldPrintComma$3(options) ? "," : ""])), comments.printDanglingComments(path, options,
           /* sameIndent */
           true), hardline$6, "}"])));
         }
 
-        return concat$b(parts);
+        return concat$c(parts);
       }
 
     case "EnumBooleanMember":
     case "EnumNumberMember":
     case "EnumStringMember":
-      return concat$b([path.call(print, "id"), " = ", typeof n.init === "object" ? path.call(print, "init") : String(n.init)]);
+      return concat$c([path.call(print, "id"), " = ", typeof n.init === "object" ? path.call(print, "init") : String(n.init)]);
 
     case "EnumDefaultedMember":
       return path.call(print, "id");
@@ -43654,20 +43665,20 @@ function printPathNoParens(path, options, print, args) {
           parts.push(")");
         }
 
-        return group$7(concat$b(parts));
+        return group$7(concat$c(parts));
       }
 
     case "TSRestType":
-      return concat$b(["...", path.call(print, "typeAnnotation")]);
+      return concat$c(["...", path.call(print, "typeAnnotation")]);
 
     case "TSOptionalType":
-      return concat$b([path.call(print, "typeAnnotation"), "?"]);
+      return concat$c([path.call(print, "typeAnnotation"), "?"]);
 
     case "FunctionTypeParam":
-      return concat$b([path.call(print, "name"), printOptionalToken$2(path), n.name ? ": " : "", path.call(print, "typeAnnotation")]);
+      return concat$c([path.call(print, "name"), printOptionalToken$2(path), n.name ? ": " : "", path.call(print, "typeAnnotation")]);
 
     case "GenericTypeAnnotation":
-      return concat$b([path.call(print, "id"), path.call(print, "typeParameters")]);
+      return concat$c([path.call(print, "id"), path.call(print, "typeParameters")]);
 
     case "DeclareInterface":
     case "InterfaceDeclaration":
@@ -43695,31 +43706,31 @@ function printPathNoParens(path, options, print, args) {
         if (n.extends && n.extends.length !== 0) {
           extendsParts.push(shouldIndentOnlyHeritageClauses ? ifBreak$4(" ", line$8, {
             groupId: getTypeParametersGroupId(n.typeParameters)
-          }) : line$8, "extends ", (n.extends.length === 1 ? identity$2 : indent$8)(join$6(concat$b([",", line$8]), path.map(print, "extends"))));
+          }) : line$8, "extends ", (n.extends.length === 1 ? identity$2 : indent$8)(join$6(concat$c([",", line$8]), path.map(print, "extends"))));
         }
 
         if (n.id && hasTrailingComment$3(n.id) || n.extends && n.extends.length !== 0) {
-          const printedExtends = concat$b(extendsParts);
+          const printedExtends = concat$c(extendsParts);
 
           if (shouldIndentOnlyHeritageClauses) {
-            parts.push(group$7(concat$b(partsGroup.concat(ifBreak$4(indent$8(printedExtends), printedExtends)))));
+            parts.push(group$7(concat$c(partsGroup.concat(ifBreak$4(indent$8(printedExtends), printedExtends)))));
           } else {
-            parts.push(group$7(indent$8(concat$b(partsGroup.concat(printedExtends)))));
+            parts.push(group$7(indent$8(concat$c(partsGroup.concat(printedExtends)))));
           }
         } else {
           parts.push(...partsGroup, ...extendsParts);
         }
 
         parts.push(" ", path.call(print, "body"));
-        return group$7(concat$b(parts));
+        return group$7(concat$c(parts));
       }
 
     case "ClassImplements":
     case "InterfaceExtends":
-      return concat$b([path.call(print, "id"), path.call(print, "typeParameters")]);
+      return concat$c([path.call(print, "id"), path.call(print, "typeParameters")]);
 
     case "TSClassImplements":
-      return concat$b([path.call(print, "expression"), path.call(print, "typeParameters")]);
+      return concat$c([path.call(print, "expression"), path.call(print, "typeParameters")]);
 
     case "TSIntersectionType":
     case "IntersectionTypeAnnotation":
@@ -43733,10 +43744,10 @@ function printPathNoParens(path, options, print, args) {
             result.push(types[i]);
           } else if (isObjectType$1(n.types[i - 1]) && isObjectType$1(n.types[i])) {
             // If both are objects, don't indent
-            result.push(concat$b([" & ", wasIndented ? indent$8(types[i]) : types[i]]));
+            result.push(concat$c([" & ", wasIndented ? indent$8(types[i]) : types[i]]));
           } else if (!isObjectType$1(n.types[i - 1]) && !isObjectType$1(n.types[i])) {
             // If no object is involved, go to the next line if it breaks
-            result.push(indent$8(concat$b([" &", line$8, types[i]])));
+            result.push(indent$8(concat$c([" &", line$8, types[i]])));
           } else {
             // If you go from object to non-object or vis-versa, then inline it
             if (i > 1) {
@@ -43747,7 +43758,7 @@ function printPathNoParens(path, options, print, args) {
           }
         }
 
-        return group$7(concat$b(result));
+        return group$7(concat$c(result));
       }
 
     case "TSUnionType":
@@ -43786,21 +43797,21 @@ function printPathNoParens(path, options, print, args) {
         }
 
         const shouldAddStartLine = shouldIndent && !hasLeadingOwnLineComment$1(options.originalText, n, options);
-        const code = concat$b([ifBreak$4(concat$b([shouldAddStartLine ? line$8 : "", "| "])), join$6(concat$b([line$8, "| "]), printed)]);
+        const code = concat$c([ifBreak$4(concat$c([shouldAddStartLine ? line$8 : "", "| "])), join$6(concat$c([line$8, "| "]), printed)]);
 
         if (needsParens_1(path, options)) {
-          return group$7(concat$b([indent$8(code), softline$6]));
+          return group$7(concat$c([indent$8(code), softline$6]));
         }
 
         if (parent.type === "TupleTypeAnnotation" && parent.types.length > 1 || parent.type === "TSTupleType" && parent.elementTypes.length > 1) {
-          return group$7(concat$b([indent$8(concat$b([ifBreak$4(concat$b(["(", softline$6])), code])), softline$6, ifBreak$4(")")]));
+          return group$7(concat$c([indent$8(concat$c([ifBreak$4(concat$c(["(", softline$6])), code])), softline$6, ifBreak$4(")")]));
         }
 
         return group$7(shouldIndent ? indent$8(code) : code);
       }
 
     case "NullableTypeAnnotation":
-      return concat$b(["?", path.call(print, "typeAnnotation")]);
+      return concat$c(["?", path.call(print, "typeAnnotation")]);
 
     case "TSNullKeyword":
     case "NullLiteralTypeAnnotation":
@@ -43821,12 +43832,12 @@ function printPathNoParens(path, options, print, args) {
       }
 
       parts.push(path.call(print, "value"));
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "ObjectTypeIndexer":
       {
         const variance = getFlowVariance$1(n);
-        return concat$b([variance || "", "[", path.call(print, "id"), n.id ? ": " : "", path.call(print, "key"), "]: ", path.call(print, "value")]);
+        return concat$c([variance || "", "[", path.call(print, "id"), n.id ? ": " : "", path.call(print, "key"), "]: ", path.call(print, "value")]);
       }
 
     case "ObjectTypeProperty":
@@ -43840,11 +43851,11 @@ function printPathNoParens(path, options, print, args) {
           modifier = "static ";
         }
 
-        return concat$b([modifier, isGetterOrSetter$1(n) ? n.kind + " " : "", variance || "", printPropertyKey(path, options, print), printOptionalToken$2(path), isFunctionNotation$1(n, options) ? "" : ": ", path.call(print, "value")]);
+        return concat$c([modifier, isGetterOrSetter$1(n) ? n.kind + " " : "", variance || "", printPropertyKey(path, options, print), printOptionalToken$2(path), isFunctionNotation$1(n, options) ? "" : ": ", path.call(print, "value")]);
       }
 
     case "QualifiedTypeIdentifier":
-      return concat$b([path.call(print, "qualification"), ".", path.call(print, "id")]);
+      return concat$c([path.call(print, "qualification"), ".", path.call(print, "id")]);
 
     case "StringLiteralTypeAnnotation":
       return nodeStr(n, options);
@@ -43870,12 +43881,12 @@ function printPathNoParens(path, options, print, args) {
 
         const printed = printAssignmentRight(n.id, n.right, path.call(print, "right"), options);
         parts.push("type ", path.call(print, "id"), path.call(print, "typeParameters"), " =", printed, semi);
-        return group$7(concat$b(parts));
+        return group$7(concat$c(parts));
       }
 
     case "TypeCastExpression":
       {
-        return concat$b(["(", path.call(print, "expression"), printTypeAnnotation(path, options, print), ")"]);
+        return concat$c(["(", path.call(print, "expression"), printTypeAnnotation(path, options, print), ")"]);
       }
 
     case "TypeParameterDeclaration":
@@ -43888,7 +43899,7 @@ function printPathNoParens(path, options, print, args) {
         const commentSyntax = commentStart >= 0 && options.originalText.slice(commentStart).match(/^\/\*\s*::/);
 
         if (commentSyntax) {
-          return concat$b(["/*:: ", printTypeParameters(path, options, print, "params"), " */"]);
+          return concat$c(["/*:: ", printTypeParameters(path, options, print, "params"), " */"]);
         }
 
         return printTypeParameters(path, options, print, "params");
@@ -43911,7 +43922,7 @@ function printPathNoParens(path, options, print, args) {
           }
 
           parts.push("]");
-          return concat$b(parts);
+          return concat$c(parts);
         }
 
         const variance = getFlowVariance$1(n);
@@ -43944,11 +43955,11 @@ function printPathNoParens(path, options, print, args) {
           parts.push(",");
         }
 
-        return concat$b(parts);
+        return concat$c(parts);
       }
 
     case "TypeofTypeAnnotation":
-      return concat$b(["typeof ", path.call(print, "argument")]);
+      return concat$c(["typeof ", path.call(print, "argument")]);
 
     case "VoidTypeAnnotation":
       return "void";
@@ -43960,7 +43971,7 @@ function printPathNoParens(path, options, print, args) {
     // supported by the pretty-printer.
 
     case "DeclaredPredicate":
-      return concat$b(["%checks(", path.call(print, "value"), ")"]);
+      return concat$c(["%checks(", path.call(print, "value"), ")"]);
 
     case "TSAbstractKeyword":
       return "abstract";
@@ -44026,10 +44037,10 @@ function printPathNoParens(path, options, print, args) {
       return "void";
 
     case "TSAsExpression":
-      return concat$b([path.call(print, "expression"), " as ", path.call(print, "typeAnnotation")]);
+      return concat$c([path.call(print, "expression"), " as ", path.call(print, "typeAnnotation")]);
 
     case "TSArrayType":
-      return concat$b([path.call(print, "elementType"), "[]"]);
+      return concat$c([path.call(print, "elementType"), "[]"]);
 
     case "TSPropertySignature":
       {
@@ -44061,7 +44072,7 @@ function printPathNoParens(path, options, print, args) {
           parts.push(" = ", path.call(print, "initializer"));
         }
 
-        return concat$b(parts);
+        return concat$c(parts);
       }
 
     case "TSParameterProperty":
@@ -44082,13 +44093,13 @@ function printPathNoParens(path, options, print, args) {
       }
 
       parts.push(path.call(print, "parameter"));
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "TSTypeReference":
-      return concat$b([path.call(print, "typeName"), printTypeParameters(path, options, print, "typeParameters")]);
+      return concat$c([path.call(print, "typeName"), printTypeParameters(path, options, print, "typeParameters")]);
 
     case "TSTypeQuery":
-      return concat$b(["typeof ", path.call(print, "exprName")]);
+      return concat$c(["typeof ", path.call(print, "exprName")]);
 
     case "TSIndexSignature":
       {
@@ -44098,27 +44109,27 @@ function printPathNoParens(path, options, print, args) {
         // So we leave off the trailing comma when there's just one parameter.
 
         const trailingComma = n.parameters.length > 1 ? ifBreak$4(shouldPrintComma$3(options) ? "," : "") : "";
-        const parametersGroup = group$7(concat$b([indent$8(concat$b([softline$6, join$6(concat$b([", ", softline$6]), path.map(print, "parameters"))])), trailingComma, softline$6]));
-        return concat$b([n.export ? "export " : "", n.accessibility ? concat$b([n.accessibility, " "]) : "", n.static ? "static " : "", n.readonly ? "readonly " : "", "[", n.parameters ? parametersGroup : "", n.typeAnnotation ? "]: " : "]", n.typeAnnotation ? path.call(print, "typeAnnotation") : "", parent.type === "ClassBody" ? semi : ""]);
+        const parametersGroup = group$7(concat$c([indent$8(concat$c([softline$6, join$6(concat$c([", ", softline$6]), path.map(print, "parameters"))])), trailingComma, softline$6]));
+        return concat$c([n.export ? "export " : "", n.accessibility ? concat$c([n.accessibility, " "]) : "", n.static ? "static " : "", n.readonly ? "readonly " : "", "[", n.parameters ? parametersGroup : "", n.typeAnnotation ? "]: " : "]", n.typeAnnotation ? path.call(print, "typeAnnotation") : "", parent.type === "ClassBody" ? semi : ""]);
       }
 
     case "TSTypePredicate":
-      return concat$b([n.asserts ? "asserts " : "", path.call(print, "parameterName"), n.typeAnnotation ? concat$b([" is ", path.call(print, "typeAnnotation")]) : ""]);
+      return concat$c([n.asserts ? "asserts " : "", path.call(print, "parameterName"), n.typeAnnotation ? concat$c([" is ", path.call(print, "typeAnnotation")]) : ""]);
 
     case "TSNonNullExpression":
-      return concat$b([path.call(print, "expression"), "!"]);
+      return concat$c([path.call(print, "expression"), "!"]);
 
     case "TSThisType":
       return "this";
 
     case "TSImportType":
-      return concat$b([!n.isTypeOf ? "" : "typeof ", "import(", path.call(print, n.parameter ? "parameter" : "argument"), ")", !n.qualifier ? "" : concat$b([".", path.call(print, "qualifier")]), printTypeParameters(path, options, print, "typeParameters")]);
+      return concat$c([!n.isTypeOf ? "" : "typeof ", "import(", path.call(print, n.parameter ? "parameter" : "argument"), ")", !n.qualifier ? "" : concat$c([".", path.call(print, "qualifier")]), printTypeParameters(path, options, print, "typeParameters")]);
 
     case "TSLiteralType":
       return path.call(print, "literal");
 
     case "TSIndexedAccessType":
-      return concat$b([path.call(print, "objectType"), "[", path.call(print, "indexType"), "]"]);
+      return concat$c([path.call(print, "objectType"), "[", path.call(print, "indexType"), "]"]);
 
     case "TSConstructSignatureDeclaration":
     case "TSCallSignatureDeclaration":
@@ -44139,16 +44150,16 @@ function printPathNoParens(path, options, print, args) {
           parts.push(isType ? " => " : ": ", path.call(print, "returnType"), path.call(print, "typeAnnotation"));
         }
 
-        return concat$b(parts);
+        return concat$c(parts);
       }
 
     case "TSTypeOperator":
-      return concat$b([n.operator, " ", path.call(print, "typeAnnotation")]);
+      return concat$c([n.operator, " ", path.call(print, "typeAnnotation")]);
 
     case "TSMappedType":
       {
         const shouldBreak = hasNewlineInRange$5(options.originalText, options.locStart(n), options.locEnd(n));
-        return group$7(concat$b(["{", indent$8(concat$b([options.bracketSpacing ? line$8 : softline$6, n.readonly ? concat$b([getTypeScriptMappedTypeModifier$1(n.readonly, "readonly"), " "]) : "", printTypeScriptModifiers(path, options, print), path.call(print, "typeParameter"), n.optional ? getTypeScriptMappedTypeModifier$1(n.optional, "?") : "", n.typeAnnotation ? ": " : "", path.call(print, "typeAnnotation"), ifBreak$4(semi, "")])), comments.printDanglingComments(path, options,
+        return group$7(concat$c(["{", indent$8(concat$c([options.bracketSpacing ? line$8 : softline$6, n.readonly ? concat$c([getTypeScriptMappedTypeModifier$1(n.readonly, "readonly"), " "]) : "", printTypeScriptModifiers(path, options, print), path.call(print, "typeParameter"), n.optional ? getTypeScriptMappedTypeModifier$1(n.optional, "?") : "", n.typeAnnotation ? ": " : "", path.call(print, "typeAnnotation"), ifBreak$4(semi, "")])), comments.printDanglingComments(path, options,
         /* sameIndent */
         true), options.bracketSpacing ? line$8 : softline$6, "}"]), {
           shouldBreak
@@ -44156,7 +44167,7 @@ function printPathNoParens(path, options, print, args) {
       }
 
     case "TSMethodSignature":
-      parts.push(n.accessibility ? concat$b([n.accessibility, " "]) : "", n.export ? "export " : "", n.static ? "static " : "", n.readonly ? "readonly " : "", n.computed ? "[" : "", path.call(print, "key"), n.computed ? "]" : "", printOptionalToken$2(path), printFunctionParams(path, print, options,
+      parts.push(n.accessibility ? concat$c([n.accessibility, " "]) : "", n.export ? "export " : "", n.static ? "static " : "", n.readonly ? "readonly " : "", n.computed ? "[" : "", path.call(print, "key"), n.computed ? "]" : "", printOptionalToken$2(path), printFunctionParams(path, print, options,
       /* expandArg */
       false,
       /* printTypeParams */
@@ -44166,7 +44177,7 @@ function printPathNoParens(path, options, print, args) {
         parts.push(": ", path.call(print, "returnType"), path.call(print, "typeAnnotation"));
       }
 
-      return group$7(concat$b(parts));
+      return group$7(concat$c(parts));
 
     case "TSNamespaceExportDeclaration":
       parts.push("export as namespace ", path.call(print, "id"));
@@ -44175,7 +44186,7 @@ function printPathNoParens(path, options, print, args) {
         parts.push(";");
       }
 
-      return group$7(concat$b(parts));
+      return group$7(concat$c(parts));
 
     case "TSEnumDeclaration":
       if (n.declare) {
@@ -44193,14 +44204,14 @@ function printPathNoParens(path, options, print, args) {
       parts.push("enum ", path.call(print, "id"), " ");
 
       if (n.members.length === 0) {
-        parts.push(group$7(concat$b(["{", comments.printDanglingComments(path, options), softline$6, "}"])));
+        parts.push(group$7(concat$c(["{", comments.printDanglingComments(path, options), softline$6, "}"])));
       } else {
-        parts.push(group$7(concat$b(["{", indent$8(concat$b([hardline$6, printArrayItems(path, options, "members", print), shouldPrintComma$3(options, "es5") ? "," : ""])), comments.printDanglingComments(path, options,
+        parts.push(group$7(concat$c(["{", indent$8(concat$c([hardline$6, printArrayItems(path, options, "members", print), shouldPrintComma$3(options, "es5") ? "," : ""])), comments.printDanglingComments(path, options,
         /* sameIndent */
         true), hardline$6, "}"])));
       }
 
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "TSEnumMember":
       parts.push(path.call(print, "id"));
@@ -44209,7 +44220,7 @@ function printPathNoParens(path, options, print, args) {
         parts.push(" = ", path.call(print, "initializer"));
       }
 
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "TSImportEqualsDeclaration":
       if (n.isExport) {
@@ -44222,10 +44233,10 @@ function printPathNoParens(path, options, print, args) {
         parts.push(";");
       }
 
-      return group$7(concat$b(parts));
+      return group$7(concat$c(parts));
 
     case "TSExternalModuleReference":
-      return concat$b(["require(", path.call(print, "expression"), ")"]);
+      return concat$c(["require(", path.call(print, "expression"), ")"]);
 
     case "TSModuleDeclaration":
       {
@@ -44262,11 +44273,11 @@ function printPathNoParens(path, options, print, args) {
           parts.push(semi);
         }
 
-        return concat$b(parts);
+        return concat$c(parts);
       }
 
     case "PrivateName":
-      return concat$b(["#", path.call(print, "id")]);
+      return concat$c(["#", path.call(print, "id")]);
     // TODO: Temporary auto-generated node type. To remove when typescript-estree has proper support for private fields.
 
     case "TSPrivateIdentifier":
@@ -44284,7 +44295,7 @@ function printPathNoParens(path, options, print, args) {
       });
 
     case "TSInferType":
-      return concat$b(["infer", " ", path.call(print, "typeParameter")]);
+      return concat$c(["infer", " ", path.call(print, "typeParameter")]);
 
     case "InterpreterDirective":
       parts.push("#!", n.value, hardline$6);
@@ -44293,42 +44304,42 @@ function printPathNoParens(path, options, print, args) {
         parts.push(hardline$6);
       }
 
-      return concat$b(parts);
+      return concat$c(parts);
 
     case "NGRoot":
-      return concat$b([].concat(path.call(print, "node"), !n.node.comments || n.node.comments.length === 0 ? [] : concat$b([" //", n.node.comments[0].value.trimEnd()])));
+      return concat$c([].concat(path.call(print, "node"), !n.node.comments || n.node.comments.length === 0 ? [] : concat$c([" //", n.node.comments[0].value.trimEnd()])));
 
     case "NGChainedExpression":
-      return group$7(join$6(concat$b([";", line$8]), path.map(childPath => hasNgSideEffect$1(childPath) ? print(childPath) : concat$b(["(", print(childPath), ")"]), "expressions")));
+      return group$7(join$6(concat$c([";", line$8]), path.map(childPath => hasNgSideEffect$1(childPath) ? print(childPath) : concat$c(["(", print(childPath), ")"]), "expressions")));
 
     case "NGEmptyExpression":
       return "";
 
     case "NGQuotedExpression":
-      return concat$b([n.prefix, ": ", n.value.trim()]);
+      return concat$c([n.prefix, ": ", n.value.trim()]);
 
     case "NGMicrosyntax":
-      return concat$b(path.map((childPath, index) => concat$b([index === 0 ? "" : isNgForOf$1(childPath.getValue(), index, n) ? " " : concat$b([";", line$8]), print(childPath)]), "body"));
+      return concat$c(path.map((childPath, index) => concat$c([index === 0 ? "" : isNgForOf$1(childPath.getValue(), index, n) ? " " : concat$c([";", line$8]), print(childPath)]), "body"));
 
     case "NGMicrosyntaxKey":
       return /^[$_a-z][\w$]*(-[$_a-z][\w$])*$/i.test(n.name) ? n.name : JSON.stringify(n.name);
 
     case "NGMicrosyntaxExpression":
-      return concat$b([path.call(print, "expression"), n.alias === null ? "" : concat$b([" as ", path.call(print, "alias")])]);
+      return concat$c([path.call(print, "expression"), n.alias === null ? "" : concat$c([" as ", path.call(print, "alias")])]);
 
     case "NGMicrosyntaxKeyedExpression":
       {
         const index = path.getName();
         const parentNode = path.getParentNode();
         const shouldNotPrintColon = isNgForOf$1(n, index, parentNode) || (index === 1 && (n.key.name === "then" || n.key.name === "else") || index === 2 && n.key.name === "else" && parentNode.body[index - 1].type === "NGMicrosyntaxKeyedExpression" && parentNode.body[index - 1].key.name === "then") && parentNode.body[0].type === "NGMicrosyntaxExpression";
-        return concat$b([path.call(print, "key"), shouldNotPrintColon ? " " : ": ", path.call(print, "expression")]);
+        return concat$c([path.call(print, "key"), shouldNotPrintColon ? " " : ": ", path.call(print, "expression")]);
       }
 
     case "NGMicrosyntaxLet":
-      return concat$b(["let ", path.call(print, "key"), n.value === null ? "" : concat$b([" = ", path.call(print, "value")])]);
+      return concat$c(["let ", path.call(print, "key"), n.value === null ? "" : concat$c([" = ", path.call(print, "value")])]);
 
     case "NGMicrosyntaxAs":
-      return concat$b([path.call(print, "key"), " as ", path.call(print, "alias")]);
+      return concat$c([path.call(print, "key"), " as ", path.call(print, "alias")]);
 
     case "PipelineBareFunction":
       return path.call(print, "callee");
@@ -44339,7 +44350,7 @@ function printPathNoParens(path, options, print, args) {
     case "PipelinePrimaryTopicReference":
       {
         parts.push("#");
-        return concat$b(parts);
+        return concat$c(parts);
       }
 
     case "ArgumentPlaceholder":
@@ -44353,13 +44364,13 @@ function printPathNoParens(path, options, print, args) {
       return "?";
 
     case "TSJSDocNullableType":
-      return concat$b(["?", path.call(print, "typeAnnotation")]);
+      return concat$c(["?", path.call(print, "typeAnnotation")]);
 
     case "TSJSDocNonNullableType":
-      return concat$b(["!", path.call(print, "typeAnnotation")]);
+      return concat$c(["!", path.call(print, "typeAnnotation")]);
 
     case "TSJSDocFunctionType":
-      return concat$b(["function(", // The parameters could be here, but typescript-estree doesn't convert them anyway (throws an error).
+      return concat$c(["function(", // The parameters could be here, but typescript-estree doesn't convert them anyway (throws an error).
       "): ", path.call(print, "typeAnnotation")]);
 
     default:
@@ -44421,7 +44432,7 @@ function printStatementSequence(path, options, print) {
       parts.push(hardline$6);
     }
 
-    printed.push(concat$b(parts));
+    printed.push(concat$c(parts));
   });
   return join$6(hardline$6, printed);
 }
@@ -44430,7 +44441,7 @@ function printPropertyKey(path, options, print) {
   const node = path.getNode();
 
   if (node.computed) {
-    return concat$b(["[", path.call(print, "key"), "]"]);
+    return concat$c(["[", path.call(print, "key"), "]"]);
   }
 
   const parent = path.getParentNode();
@@ -44440,7 +44451,7 @@ function printPropertyKey(path, options, print) {
 
   if (node.type === "ClassPrivateProperty" && // flow has `Identifier` key, and babel has `PrivateName` key
   key.type === "Identifier") {
-    return concat$b(["#", path.call(print, "key")]);
+    return concat$c(["#", path.call(print, "key")]);
   }
 
   if (options.quoteProps === "consistent" && !needsQuoteProps.has(parent)) {
@@ -44491,11 +44502,11 @@ function printMethod(path, options, print) {
   }
 
   parts.push(printPropertyKey(path, options, print), node.optional || node.key.optional ? "?" : "", node === value ? printMethodInternal(path, options, print) : path.call(path => printMethodInternal(path, options, print), "value"));
-  return concat$b(parts);
+  return concat$c(parts);
 }
 
 function printMethodInternal(path, options, print) {
-  const parts = [printFunctionTypeParameters$2(path, options, print), group$7(concat$b([printFunctionParams(path, print, options), printReturnType(path, print, options)]))];
+  const parts = [printFunctionTypeParameters$2(path, options, print), group$7(concat$c([printFunctionParams(path, print, options), printReturnType(path, print, options)]))];
 
   if (path.getNode().body) {
     parts.push(" ", path.call(print, "body"));
@@ -44503,7 +44514,7 @@ function printMethodInternal(path, options, print) {
     parts.push(options.semi ? ";" : "");
   }
 
-  return concat$b(parts);
+  return concat$c(parts);
 }
 
 function printJestEachTemplateLiteral(path, options, print) {
@@ -44563,8 +44574,8 @@ function printJestEachTemplateLiteral(path, options, print) {
       });
     }
 
-    parts.push(lineSuffixBoundary$1, "`", indent$8(concat$b([hardline$6, join$6(hardline$6, table.map(row => join$6(" | ", row.cells.map((cell, index) => row.hasLineBreak ? cell : cell + " ".repeat(maxColumnWidths[index] - getStringWidth$3(cell))))))])), hardline$6, "`");
-    return concat$b(parts);
+    parts.push(lineSuffixBoundary$1, "`", indent$8(concat$c([hardline$6, join$6(hardline$6, table.map(row => join$6(" | ", row.cells.map((cell, index) => row.hasLineBreak ? cell : cell + " ".repeat(maxColumnWidths[index] - getStringWidth$3(cell))))))])), hardline$6, "`");
+    return concat$c(parts);
   }
 }
 
@@ -44580,10 +44591,10 @@ function printTypeAnnotation(path, options, print) {
   const isFunctionDeclarationIdentifier = parentNode.type === "DeclareFunction" && parentNode.id === node;
 
   if (isFlowAnnotationComment$1(options.originalText, node.typeAnnotation, options)) {
-    return concat$b([" /*: ", path.call(print, "typeAnnotation"), " */"]);
+    return concat$c([" /*: ", path.call(print, "typeAnnotation"), " */"]);
   }
 
-  return concat$b([isFunctionDeclarationIdentifier ? "" : isDefinite ? "!: " : ": ", path.call(print, "typeAnnotation")]);
+  return concat$c([isFunctionDeclarationIdentifier ? "" : isDefinite ? "!: " : ": ", path.call(print, "typeAnnotation")]);
 }
 
 function printFunctionParams(path, print, options, expandArg, printTypeParams) {
@@ -44615,16 +44626,16 @@ function printFunctionParams(path, print, options, expandArg, printTypeParams) {
         parts.push(",", line$8);
       }
 
-      return concat$b(parts);
+      return concat$c(parts);
     }, paramsField);
   }
 
   if (fun.rest) {
-    printed.push(concat$b(["...", path.call(print, "rest")]));
+    printed.push(concat$c(["...", path.call(print, "rest")]));
   }
 
   if (printed.length === 0) {
-    return concat$b([typeParams, "(", comments.printDanglingComments(path, options,
+    return concat$c([typeParams, "(", comments.printDanglingComments(path, options,
     /* sameIndent */
     true, comment => getNextNonSpaceNonCommentCharacter$2(options.originalText, comment, options.locEnd) === ")"), ")"]);
   }
@@ -44641,7 +44652,7 @@ function printFunctionParams(path, print, options, expandArg, printTypeParams) {
   //                         })
 
   if (shouldExpandParameters) {
-    return group$7(concat$b([removeLines$1(typeParams), "(", concat$b(printed.map(removeLines$1)), ")"]));
+    return group$7(concat$c([removeLines$1(typeParams), "(", concat$c(printed.map(removeLines$1)), ")"]));
   } // Single object destructuring should hug
   //
   // function({
@@ -44654,26 +44665,26 @@ function printFunctionParams(path, print, options, expandArg, printTypeParams) {
   const hasNotParameterDecorator = fun[paramsField].every(param => !param.decorators);
 
   if (shouldHugParameters && hasNotParameterDecorator) {
-    return concat$b([typeParams, "(", concat$b(printed), ")"]);
+    return concat$c([typeParams, "(", concat$c(printed), ")"]);
   } // don't break in specs, eg; `it("should maintain parens around done even when long", (done) => {})`
 
 
   if (isParametersInTestCall) {
-    return concat$b([typeParams, "(", concat$b(printed), ")"]);
+    return concat$c([typeParams, "(", concat$c(printed), ")"]);
   }
 
   const isFlowShorthandWithOneArg = (isObjectTypePropertyAFunction$1(parent, options) || isTypeAnnotationAFunction$1(parent, options) || parent.type === "TypeAlias" || parent.type === "UnionTypeAnnotation" || parent.type === "TSUnionType" || parent.type === "IntersectionTypeAnnotation" || parent.type === "FunctionTypeAnnotation" && parent.returnType === fun) && fun[paramsField].length === 1 && fun[paramsField][0].name === null && fun[paramsField][0].typeAnnotation && fun.typeParameters === null && isSimpleFlowType$1(fun[paramsField][0].typeAnnotation) && !fun.rest;
 
   if (isFlowShorthandWithOneArg) {
     if (options.arrowParens === "always") {
-      return concat$b(["(", concat$b(printed), ")"]);
+      return concat$c(["(", concat$c(printed), ")"]);
     }
 
-    return concat$b(printed);
+    return concat$c(printed);
   }
 
   const canHaveTrailingComma = !(lastParam && lastParam.type === "RestElement") && !fun.rest;
-  return concat$b([typeParams, "(", indent$8(concat$b([softline$6, concat$b(printed)])), ifBreak$4(canHaveTrailingComma && shouldPrintComma$3(options, "all") ? "," : ""), softline$6, ")"]);
+  return concat$c([typeParams, "(", indent$8(concat$c([softline$6, concat$c(printed)])), ifBreak$4(canHaveTrailingComma && shouldPrintComma$3(options, "all") ? "," : ""), softline$6, ")"]);
 }
 
 function shouldPrintParamsWithoutParens(path, options) {
@@ -44714,8 +44725,8 @@ function printFunctionDeclaration(path, print, options) {
     parts.push(path.call(print, "id"));
   }
 
-  parts.push(printFunctionTypeParameters$2(path, options, print), group$7(concat$b([printFunctionParams(path, print, options), printReturnType(path, print, options)])), n.body ? " " : "", path.call(print, "body"));
-  return concat$b(parts);
+  parts.push(printFunctionTypeParameters$2(path, options, print), group$7(concat$c([printFunctionParams(path, print, options), printReturnType(path, print, options)])), n.body ? " " : "", path.call(print, "body"));
+  return concat$c(parts);
 }
 
 function printReturnType(path, print, options) {
@@ -44723,7 +44734,7 @@ function printReturnType(path, print, options) {
   const returnType = path.call(print, "returnType");
 
   if (n.returnType && isFlowAnnotationComment$1(options.originalText, n.returnType, options)) {
-    return concat$b([" /*: ", returnType, " */"]);
+    return concat$c([" /*: ", returnType, " */"]);
   }
 
   const parts = [returnType]; // prepend colon to TypeScript type annotation
@@ -44738,7 +44749,7 @@ function printReturnType(path, print, options) {
     parts.push(n.returnType ? " " : ": ", path.call(print, "predicate"));
   }
 
-  return concat$b(parts);
+  return concat$c(parts);
 }
 
 function printExportDeclaration(path, options, print) {
@@ -44774,7 +44785,7 @@ function printExportDeclaration(path, options, print) {
     parts.push(semi);
   }
 
-  return concat$b(parts);
+  return concat$c(parts);
 }
 
 function printFlowDeclaration(path, parts) {
@@ -44789,7 +44800,7 @@ function printFlowDeclaration(path, parts) {
     parts.unshift("declare ");
   }
 
-  return concat$b(parts);
+  return concat$c(parts);
 }
 
 function printTypeScriptModifiers(path, options, print) {
@@ -44799,7 +44810,7 @@ function printTypeScriptModifiers(path, options, print) {
     return "";
   }
 
-  return concat$b([join$6(" ", path.map(print, "modifiers")), " "]);
+  return concat$c([join$6(" ", path.map(print, "modifiers")), " "]);
 }
 
 const typeParametersGroupIds = new WeakMap();
@@ -44845,14 +44856,14 @@ function printTypeParameters(path, options, print, paramsKey) {
       return printed;
     }
 
-    return concat$b([printed, hardline$6]);
+    return concat$c([printed, hardline$6]);
   }
 
   if (shouldInline) {
-    return concat$b(["<", join$6(", ", path.map(print, paramsKey)), printDanglingCommentsForInline(n), ">"]);
+    return concat$c(["<", join$6(", ", path.map(print, paramsKey)), printDanglingCommentsForInline(n), ">"]);
   }
 
-  return group$7(concat$b(["<", indent$8(concat$b([softline$6, join$6(concat$b([",", line$8]), path.map(print, paramsKey))])), ifBreak$4(options.parser !== "typescript" && options.parser !== "babel-ts" && shouldPrintComma$3(options, "all") ? "," : ""), softline$6, ">"]), {
+  return group$7(concat$c(["<", indent$8(concat$c([softline$6, join$6(concat$c([",", line$8]), path.map(print, paramsKey))])), ifBreak$4(options.parser !== "typescript" && options.parser !== "babel-ts" && shouldPrintComma$3(options, "all") ? "," : ""), softline$6, ">"]), {
     id: getTypeParametersGroupId(n)
   });
 }
@@ -44890,12 +44901,12 @@ function printClass(path, options, print) {
       }) => marker === listName);
       extendsParts.push(shouldIndentOnlyHeritageClauses ? ifBreak$4(" ", line$8, {
         groupId: getTypeParametersGroupId(n.typeParameters)
-      }) : line$8, printedLeadingComments, printedLeadingComments && hardline$6, listName, group$7(indent$8(concat$b([line$8, join$6(concat$b([",", line$8]), path.map(print, listName))]))));
+      }) : line$8, printedLeadingComments, printedLeadingComments && hardline$6, listName, group$7(indent$8(concat$c([line$8, join$6(concat$c([",", line$8]), path.map(print, listName))]))));
     }
   }
 
   if (n.superClass) {
-    const printed = concat$b(["extends ", path.call(print, "superClass"), path.call(print, "superTypeParameters")]);
+    const printed = concat$c(["extends ", path.call(print, "superClass"), path.call(print, "superTypeParameters")]);
     const printedWithComments = path.call(superClass => comments.printComments(superClass, () => printed, options), "superClass");
 
     if (groupMode) {
@@ -44911,12 +44922,12 @@ function printClass(path, options, print) {
   printList("implements");
 
   if (groupMode) {
-    const printedExtends = concat$b(extendsParts);
+    const printedExtends = concat$c(extendsParts);
 
     if (shouldIndentOnlyHeritageClauses) {
-      parts.push(group$7(concat$b(partsGroup.concat(ifBreak$4(indent$8(printedExtends), printedExtends)))));
+      parts.push(group$7(concat$c(partsGroup.concat(ifBreak$4(indent$8(printedExtends), printedExtends)))));
     } else {
-      parts.push(group$7(indent$8(concat$b(partsGroup.concat(printedExtends)))));
+      parts.push(group$7(indent$8(concat$c(partsGroup.concat(printedExtends)))));
     }
   } else {
     parts.push(...partsGroup, ...extendsParts);
@@ -45067,14 +45078,14 @@ function printJSXElement(path, options, print) {
   const n = path.getValue();
 
   if (n.type === "JSXElement" && isEmptyJSXElement$1(n)) {
-    return concat$b([path.call(print, "openingElement"), path.call(print, "closingElement")]);
+    return concat$c([path.call(print, "openingElement"), path.call(print, "closingElement")]);
   }
 
   const openingLines = n.type === "JSXElement" ? path.call(print, "openingElement") : path.call(print, "openingFragment");
   const closingLines = n.type === "JSXElement" ? path.call(print, "closingElement") : path.call(print, "closingFragment");
 
   if (n.children.length === 1 && n.children[0].type === "JSXExpressionContainer" && (n.children[0].expression.type === "TemplateLiteral" || n.children[0].expression.type === "TaggedTemplateExpression")) {
-    return concat$b([openingLines, concat$b(path.map(print, "children")), closingLines]);
+    return concat$c([openingLines, concat$c(path.map(print, "children")), closingLines]);
   } // Convert `{" "}` to text nodes containing a space.
   // This makes it easy to turn them into `jsxWhitespace` which
   // can then print as either a space or `{" "}` when breaking.
@@ -45098,7 +45109,7 @@ function printJSXElement(path, options, print) {
   let forcedBreak = willBreak$3(openingLines) || containsTag || containsMultipleAttributes || containsMultipleExpressions;
   const isMdxBlock = path.getParentNode().rootMarker === "mdx";
   const rawJsxWhitespace = options.singleQuote ? "{' '}" : '{" "}';
-  const jsxWhitespace = isMdxBlock ? concat$b([" "]) : ifBreak$4(concat$b([rawJsxWhitespace, softline$6]), " ");
+  const jsxWhitespace = isMdxBlock ? concat$c([" "]) : ifBreak$4(concat$c([rawJsxWhitespace, softline$6]), " ");
   const isFacebookTranslationTag = n.openingElement && n.openingElement.name && n.openingElement.name.name === "fbt";
   const children = printJSXChildren(path, options, print, jsxWhitespace, isFacebookTranslationTag);
   const containsText = n.children.some(child => isMeaningfulJSXText$1(child)); // We can end up we multiple whitespace elements with empty string
@@ -45147,7 +45158,7 @@ function printJSXElement(path, options, print) {
         } // Leading whitespace
 
 
-        multilineChildren.push(concat$b([rawJsxWhitespace, hardline$6]));
+        multilineChildren.push(concat$c([rawJsxWhitespace, hardline$6]));
         return;
       } else if (i === children.length - 1) {
         // Trailing whitespace
@@ -45169,7 +45180,7 @@ function printJSXElement(path, options, print) {
   // When there is no text (just tags and expressions) we use `group`
   // to output each on a separate line.
 
-  const content = containsText ? fill$3(multilineChildren) : group$7(concat$b(multilineChildren), {
+  const content = containsText ? fill$3(multilineChildren) : group$7(concat$c(multilineChildren), {
     shouldBreak: true
   });
 
@@ -45177,13 +45188,13 @@ function printJSXElement(path, options, print) {
     return content;
   }
 
-  const multiLineElem = group$7(concat$b([openingLines, indent$8(concat$b([hardline$6, content])), hardline$6, closingLines]));
+  const multiLineElem = group$7(concat$c([openingLines, indent$8(concat$c([hardline$6, content])), hardline$6, closingLines]));
 
   if (forcedBreak) {
     return multiLineElem;
   }
 
-  return conditionalGroup$3([group$7(concat$b([openingLines, concat$b(children), closingLines])), multiLineElem]);
+  return conditionalGroup$3([group$7(concat$c([openingLines, concat$c(children), closingLines])), multiLineElem]);
 }
 
 function maybeWrapJSXElementInParens(path, elem, options) {
@@ -45213,7 +45224,7 @@ function maybeWrapJSXElementInParens(path, elem, options) {
 
   const shouldBreak = path.match(undefined, node => node.type === "ArrowFunctionExpression", isCallOrOptionalCallExpression$2, node => node.type === "JSXExpressionContainer");
   const needsParens = needsParens_1(path, options);
-  return group$7(concat$b([needsParens ? "" : ifBreak$4("("), indent$8(concat$b([softline$6, elem])), softline$6, needsParens ? "" : ifBreak$4(")")]), {
+  return group$7(concat$c([needsParens ? "" : ifBreak$4("("), indent$8(concat$c([softline$6, elem])), softline$6, needsParens ? "" : ifBreak$4(")")]), {
     shouldBreak
   });
 }
@@ -45273,8 +45284,8 @@ function printBinaryishExpressions(path, print, options, isNested, isInsideParen
     const shouldInline = shouldInlineLogicalExpression(node);
     const lineBeforeOperator = (node.operator === "|>" || node.type === "NGPipeExpression" || node.operator === "|" && options.parser === "__vue_expression") && !hasLeadingOwnLineComment$1(options.originalText, node.right, options);
     const operator = node.type === "NGPipeExpression" ? "|" : node.operator;
-    const rightSuffix = node.type === "NGPipeExpression" && node.arguments.length !== 0 ? group$7(indent$8(concat$b([softline$6, ": ", join$6(concat$b([softline$6, ":", ifBreak$4(" ")]), path.map(print, "arguments").map(arg => align$2(2, group$7(arg))))]))) : "";
-    const right = shouldInline ? concat$b([operator, " ", path.call(print, "right"), rightSuffix]) : concat$b([lineBeforeOperator ? line$8 : "", operator, lineBeforeOperator ? " " : line$8, path.call(print, "right"), rightSuffix]); // If there's only a single binary expression, we want to create a group
+    const rightSuffix = node.type === "NGPipeExpression" && node.arguments.length !== 0 ? group$7(indent$8(concat$c([softline$6, ": ", join$6(concat$c([softline$6, ":", ifBreak$4(" ")]), path.map(print, "arguments").map(arg => align$2(2, group$7(arg))))]))) : "";
+    const right = shouldInline ? concat$c([operator, " ", path.call(print, "right"), rightSuffix]) : concat$c([lineBeforeOperator ? line$8 : "", operator, lineBeforeOperator ? " " : line$8, path.call(print, "right"), rightSuffix]); // If there's only a single binary expression, we want to create a group
     // in order to avoid having a small right part like -1 be on its own line.
 
     const parent = path.getParentNode();
@@ -45287,7 +45298,7 @@ function printBinaryishExpressions(path, print, options, isNested, isInsideParen
     // only for the left and right parts
 
     if (isNested && node.comments) {
-      parts = normalizeParts$1(comments.printComments(path, () => concat$b(parts), options).parts);
+      parts = normalizeParts$1(comments.printComments(path, () => concat$c(parts), options).parts);
     }
   } else {
     // Our stopping case. Simply print the node normally.
@@ -45299,17 +45310,17 @@ function printBinaryishExpressions(path, print, options, isNested, isInsideParen
 
 function printAssignmentRight(leftNode, rightNode, printedRight, options) {
   if (hasLeadingOwnLineComment$1(options.originalText, rightNode, options)) {
-    return indent$8(concat$b([line$8, printedRight]));
+    return indent$8(concat$c([line$8, printedRight]));
   }
 
   const canBreak = isBinaryish$1(rightNode) && !shouldInlineLogicalExpression(rightNode) || rightNode.type === "ConditionalExpression" && isBinaryish$1(rightNode.test) && !shouldInlineLogicalExpression(rightNode.test) || rightNode.type === "StringLiteralTypeAnnotation" || rightNode.type === "ClassExpression" && rightNode.decorators && rightNode.decorators.length || (leftNode.type === "Identifier" || isStringLiteral$1(leftNode) || leftNode.type === "MemberExpression") && (isStringLiteral$1(rightNode) || isMemberExpressionChain$1(rightNode)) && // do not put values on a separate line from the key in json
   options.parser !== "json" && options.parser !== "json5" || rightNode.type === "SequenceExpression";
 
   if (canBreak) {
-    return group$7(indent$8(concat$b([line$8, printedRight])));
+    return group$7(indent$8(concat$c([line$8, printedRight])));
   }
 
-  return concat$b([" ", printedRight]);
+  return concat$c([" ", printedRight]);
 }
 
 function printAssignment(leftNode, printedLeft, operator, rightNode, printedRight, options) {
@@ -45318,7 +45329,7 @@ function printAssignment(leftNode, printedLeft, operator, rightNode, printedRigh
   }
 
   const printed = printAssignmentRight(leftNode, rightNode, printedRight, options);
-  return group$7(concat$b([printedLeft, operator, printed]));
+  return group$7(concat$c([printedLeft, operator, printed]));
 }
 
 function adjustClause(node, clause, forceSpace) {
@@ -45327,10 +45338,10 @@ function adjustClause(node, clause, forceSpace) {
   }
 
   if (node.type === "BlockStatement" || forceSpace) {
-    return concat$b([" ", clause]);
+    return concat$c([" ", clause]);
   }
 
-  return indent$8(concat$b([line$8, clause]));
+  return indent$8(concat$c([line$8, clause]));
 }
 
 function nodeStr(node, options, isFlowOrTypeScriptDirectiveLiteral) {
@@ -45406,7 +45417,7 @@ function printArrayItems(path, options, printPath, print) {
   const printedElements = [];
   let separatorParts = [];
   path.each(childPath => {
-    printedElements.push(concat$b(separatorParts));
+    printedElements.push(concat$c(separatorParts));
     printedElements.push(group$7(print(childPath)));
     separatorParts = [",", line$8];
 
@@ -45414,7 +45425,7 @@ function printArrayItems(path, options, printPath, print) {
       separatorParts.push(softline$6);
     }
   }, printPath);
-  return concat$b(printedElements);
+  return concat$c(printedElements);
 }
 
 function printReturnAndThrowArgument(path, options, print) {
@@ -45424,9 +45435,9 @@ function printReturnAndThrowArgument(path, options, print) {
 
   if (node.argument) {
     if (returnArgumentHasLeadingComment$1(options, node.argument)) {
-      parts.push(concat$b([" (", indent$8(concat$b([hardline$6, path.call(print, "argument")])), hardline$6, ")"]));
+      parts.push(concat$c([" (", indent$8(concat$c([hardline$6, path.call(print, "argument")])), hardline$6, ")"]));
     } else if (isBinaryish$1(node.argument) || node.argument.type === "SequenceExpression") {
-      parts.push(group$7(concat$b([ifBreak$4(" (", " "), indent$8(concat$b([softline$6, path.call(print, "argument")])), softline$6, ifBreak$4(")")])));
+      parts.push(group$7(concat$c([ifBreak$4(" (", " "), indent$8(concat$c([softline$6, path.call(print, "argument")])), softline$6, ifBreak$4(")")])));
     } else {
       parts.push(" ", path.call(print, "argument"));
     }
@@ -45449,7 +45460,7 @@ function printReturnAndThrowArgument(path, options, print) {
     parts.push(semi);
   }
 
-  return concat$b(parts);
+  return concat$c(parts);
 }
 
 function willPrintOwnComments(path
@@ -45479,7 +45490,7 @@ function printComment$1(commentPath, options) {
           if (comment.trailing && !hasNewline$5(options.originalText, options.locStart(comment), {
             backwards: true
           })) {
-            return concat$b([hardline$6, printed]);
+            return concat$c([hardline$6, printed]);
           }
 
           return printed;
@@ -45512,7 +45523,7 @@ function isIndentableBlockComment(comment) {
 
 function printIndentableBlockComment(comment) {
   const lines = comment.value.split("\n");
-  return concat$b(["/*", join$6(hardline$6, lines.map((line, index) => index === 0 ? line.trimEnd() : " " + (index < lines.length - 1 ? line.trim() : line.trimStart()))), "*/"]);
+  return concat$c(["/*", join$6(hardline$6, lines.map((line, index) => index === 0 ? line.trimEnd() : " " + (index < lines.length - 1 ? line.trim() : line.trimStart()))), "*/"]);
 }
 
 var printerEstree = {
@@ -45536,7 +45547,7 @@ var printerEstree = {
 };
 
 const {
-  concat: concat$c,
+  concat: concat$d,
   hardline: hardline$7,
   indent: indent$9,
   join: join$7
@@ -45547,19 +45558,19 @@ function genericPrint$1(path, options, print) {
 
   switch (node.type) {
     case "JsonRoot":
-      return concat$c([path.call(print, "node"), hardline$7]);
+      return concat$d([path.call(print, "node"), hardline$7]);
 
     case "ArrayExpression":
-      return node.elements.length === 0 ? "[]" : concat$c(["[", indent$9(concat$c([hardline$7, join$7(concat$c([",", hardline$7]), path.map(print, "elements"))])), hardline$7, "]"]);
+      return node.elements.length === 0 ? "[]" : concat$d(["[", indent$9(concat$d([hardline$7, join$7(concat$d([",", hardline$7]), path.map(print, "elements"))])), hardline$7, "]"]);
 
     case "ObjectExpression":
-      return node.properties.length === 0 ? "{}" : concat$c(["{", indent$9(concat$c([hardline$7, join$7(concat$c([",", hardline$7]), path.map(print, "properties"))])), hardline$7, "}"]);
+      return node.properties.length === 0 ? "{}" : concat$d(["{", indent$9(concat$d([hardline$7, join$7(concat$d([",", hardline$7]), path.map(print, "properties"))])), hardline$7, "}"]);
 
     case "ObjectProperty":
-      return concat$c([path.call(print, "key"), ": ", path.call(print, "value")]);
+      return concat$d([path.call(print, "key"), ": ", path.call(print, "value")]);
 
     case "UnaryExpression":
-      return concat$c([node.operator === "+" ? "" : node.operator, path.call(print, "argument")]);
+      return concat$d([node.operator === "+" ? "" : node.operator, path.call(print, "argument")]);
 
     case "NullLiteral":
       return "null";
@@ -46386,7 +46397,7 @@ var clean_1$1 = clean$2;
 const {
   builders: {
     hardline: hardline$8,
-    concat: concat$d,
+    concat: concat$e,
     markAsRoot: markAsRoot$1
   }
 } = document;
@@ -46433,7 +46444,7 @@ function print$1(node, textToDoc) {
     }, {
       stripTrailingHardline: true
     }) : "";
-    return markAsRoot$1(concat$d(["---", hardline$8, doc, doc ? hardline$8 : "", "---"]));
+    return markAsRoot$1(concat$e(["---", hardline$8, doc, doc ? hardline$8 : "", "---"]));
   }
 }
 
@@ -46445,7 +46456,7 @@ var frontMatter = {
 const {
   builders: {
     hardline: hardline$9,
-    concat: concat$e
+    concat: concat$f
   }
 } = document;
 const {
@@ -46459,7 +46470,7 @@ function embed$1(path, print, textToDoc
 
   if (node.type === "front-matter") {
     const doc = printFrontMatter(node, textToDoc);
-    return doc ? concat$e([doc, hardline$9]) : "";
+    return doc ? concat$f([doc, hardline$9]) : "";
   }
 }
 
@@ -46867,7 +46878,7 @@ const {
 } = util;
 const {
   builders: {
-    concat: concat$f,
+    concat: concat$g,
     join: join$8,
     line: line$9,
     hardline: hardline$a,
@@ -46950,13 +46961,13 @@ function genericPrint$2(path, options, print) {
 
   switch (node.type) {
     case "front-matter":
-      return concat$f([node.raw, hardline$a]);
+      return concat$g([node.raw, hardline$a]);
 
     case "css-root":
       {
         const nodes = printNodeSequence(path, options, print);
         const after = node.raws.after.trim();
-        return concat$f([nodes, after ? ` ${after}` : "", nodes.parts.length && !options.__isHTMLStyleAttribute ? hardline$a : ""]);
+        return concat$g([nodes, after ? ` ${after}` : "", nodes.parts.length && !options.__isHTMLStyleAttribute ? hardline$a : ""]);
       }
 
     case "css-comment":
@@ -46968,7 +46979,7 @@ function genericPrint$2(path, options, print) {
 
     case "css-rule":
       {
-        return concat$f([path.call(print, "selector"), node.important ? " !important" : "", node.nodes ? concat$f([node.selector && node.selector.type === "selector-unknown" && lastLineHasInlineComment$1(node.selector.value) ? line$9 : " ", "{", node.nodes.length > 0 ? indent$a(concat$f([hardline$a, printNodeSequence(path, options, print)])) : "", hardline$a, "}", isDetachedRulesetDeclarationNode$1(node) ? ";" : ""]) : ";"]);
+        return concat$g([path.call(print, "selector"), node.important ? " !important" : "", node.nodes ? concat$g([node.selector && node.selector.type === "selector-unknown" && lastLineHasInlineComment$1(node.selector.value) ? line$9 : " ", "{", node.nodes.length > 0 ? indent$a(concat$g([hardline$a, printNodeSequence(path, options, print)])) : "", hardline$a, "}", isDetachedRulesetDeclarationNode$1(node) ? ";" : ""]) : ";"]);
       }
 
     case "css-decl":
@@ -46982,10 +46993,10 @@ function genericPrint$2(path, options, print) {
         let value = hasComposesNode$1(node) ? removeLines$2(path.call(print, "value")) : path.call(print, "value");
 
         if (!isColon && lastLineHasInlineComment$1(trimmedBetween)) {
-          value = indent$a(concat$f([hardline$a, dedent$2(value)]));
+          value = indent$a(concat$g([hardline$a, dedent$2(value)]));
         }
 
-        return concat$f([node.raws.before.replace(/[\s;]/g, ""), insideICSSRuleNode$1(path) ? node.prop : maybeToLowerCase$1(node.prop), trimmedBetween.startsWith("//") ? " " : "", trimmedBetween, node.extend ? "" : " ", isLessParser$1(options) && node.extend && node.selector ? concat$f(["extend(", path.call(print, "selector"), ")"]) : "", value, node.raws.important ? node.raws.important.replace(/\s*!\s*important/i, " !important") : node.important ? " !important" : "", node.raws.scssDefault ? node.raws.scssDefault.replace(/\s*!default/i, " !default") : node.scssDefault ? " !default" : "", node.raws.scssGlobal ? node.raws.scssGlobal.replace(/\s*!global/i, " !global") : node.scssGlobal ? " !global" : "", node.nodes ? concat$f([" {", indent$a(concat$f([softline$7, printNodeSequence(path, options, print)])), softline$7, "}"]) : isTemplatePropNode$1(node) && !parentNode.raws.semicolon && options.originalText[options.locEnd(node) - 1] !== ";" ? "" : options.__isHTMLStyleAttribute && isLastNode$1(path, node) ? ifBreak$5(";", "") : ";"]);
+        return concat$g([node.raws.before.replace(/[\s;]/g, ""), insideICSSRuleNode$1(path) ? node.prop : maybeToLowerCase$1(node.prop), trimmedBetween.startsWith("//") ? " " : "", trimmedBetween, node.extend ? "" : " ", isLessParser$1(options) && node.extend && node.selector ? concat$g(["extend(", path.call(print, "selector"), ")"]) : "", value, node.raws.important ? node.raws.important.replace(/\s*!\s*important/i, " !important") : node.important ? " !important" : "", node.raws.scssDefault ? node.raws.scssDefault.replace(/\s*!default/i, " !default") : node.scssDefault ? " !default" : "", node.raws.scssGlobal ? node.raws.scssGlobal.replace(/\s*!global/i, " !global") : node.scssGlobal ? " !global" : "", node.nodes ? concat$g([" {", indent$a(concat$g([softline$7, printNodeSequence(path, options, print)])), softline$7, "}"]) : isTemplatePropNode$1(node) && !parentNode.raws.semicolon && options.originalText[options.locEnd(node) - 1] !== ";" ? "" : options.__isHTMLStyleAttribute && isLastNode$1(path, node) ? ifBreak$5(";", "") : ";"]);
       }
 
     case "css-atrule":
@@ -46995,22 +47006,22 @@ function genericPrint$2(path, options, print) {
 
         if (isLessParser$1(options)) {
           if (node.mixin) {
-            return concat$f([path.call(print, "selector"), node.important ? " !important" : "", isTemplatePlaceholderNodeWithoutSemiColon ? "" : ";"]);
+            return concat$g([path.call(print, "selector"), node.important ? " !important" : "", isTemplatePlaceholderNodeWithoutSemiColon ? "" : ";"]);
           }
 
           if (node.function) {
-            return concat$f([node.name, concat$f([path.call(print, "params")]), isTemplatePlaceholderNodeWithoutSemiColon ? "" : ";"]);
+            return concat$g([node.name, concat$g([path.call(print, "params")]), isTemplatePlaceholderNodeWithoutSemiColon ? "" : ";"]);
           }
 
           if (node.variable) {
-            return concat$f(["@", node.name, ": ", node.value ? concat$f([path.call(print, "value")]) : "", node.raws.between.trim() ? node.raws.between.trim() + " " : "", node.nodes ? concat$f(["{", indent$a(concat$f([node.nodes.length > 0 ? softline$7 : "", printNodeSequence(path, options, print)])), softline$7, "}"]) : "", isTemplatePlaceholderNodeWithoutSemiColon ? "" : ";"]);
+            return concat$g(["@", node.name, ": ", node.value ? concat$g([path.call(print, "value")]) : "", node.raws.between.trim() ? node.raws.between.trim() + " " : "", node.nodes ? concat$g(["{", indent$a(concat$g([node.nodes.length > 0 ? softline$7 : "", printNodeSequence(path, options, print)])), softline$7, "}"]) : "", isTemplatePlaceholderNodeWithoutSemiColon ? "" : ";"]);
           }
         }
 
-        return concat$f(["@", // If a Less file ends up being parsed with the SCSS parser, Less
+        return concat$g(["@", // If a Less file ends up being parsed with the SCSS parser, Less
         // variable declarations will be parsed as at-rules with names ending
         // with a colon, so keep the original case then.
-        isDetachedRulesetCallNode$1(node) || node.name.endsWith(":") ? node.name : maybeToLowerCase$1(node.name), node.params ? concat$f([isDetachedRulesetCallNode$1(node) ? "" : isTemplatePlaceholderNode$1(node) ? node.raws.afterName === "" ? "" : node.name.endsWith(":") ? " " : /^\s*\n\s*\n/.test(node.raws.afterName) ? concat$f([hardline$a, hardline$a]) : /^\s*\n/.test(node.raws.afterName) ? hardline$a : " " : " ", path.call(print, "params")]) : "", node.selector ? indent$a(concat$f([" ", path.call(print, "selector")])) : "", node.value ? group$b(concat$f([" ", path.call(print, "value"), isSCSSControlDirectiveNode$1(node) ? hasParensAroundNode$1(node) ? " " : line$9 : ""])) : node.name === "else" ? " " : "", node.nodes ? concat$f([isSCSSControlDirectiveNode$1(node) ? "" : node.selector && !node.selector.nodes && typeof node.selector.value === "string" && lastLineHasInlineComment$1(node.selector.value) || !node.selector && typeof node.params === "string" && lastLineHasInlineComment$1(node.params) ? line$9 : " ", "{", indent$a(concat$f([node.nodes.length > 0 ? softline$7 : "", printNodeSequence(path, options, print)])), softline$7, "}"]) : isTemplatePlaceholderNodeWithoutSemiColon ? "" : ";"]);
+        isDetachedRulesetCallNode$1(node) || node.name.endsWith(":") ? node.name : maybeToLowerCase$1(node.name), node.params ? concat$g([isDetachedRulesetCallNode$1(node) ? "" : isTemplatePlaceholderNode$1(node) ? node.raws.afterName === "" ? "" : node.name.endsWith(":") ? " " : /^\s*\n\s*\n/.test(node.raws.afterName) ? concat$g([hardline$a, hardline$a]) : /^\s*\n/.test(node.raws.afterName) ? hardline$a : " " : " ", path.call(print, "params")]) : "", node.selector ? indent$a(concat$g([" ", path.call(print, "selector")])) : "", node.value ? group$b(concat$g([" ", path.call(print, "value"), isSCSSControlDirectiveNode$1(node) ? hasParensAroundNode$1(node) ? " " : line$9 : ""])) : node.name === "else" ? " " : "", node.nodes ? concat$g([isSCSSControlDirectiveNode$1(node) ? "" : node.selector && !node.selector.nodes && typeof node.selector.value === "string" && lastLineHasInlineComment$1(node.selector.value) || !node.selector && typeof node.params === "string" && lastLineHasInlineComment$1(node.params) ? line$9 : " ", "{", indent$a(concat$g([node.nodes.length > 0 ? softline$7 : "", printNodeSequence(path, options, print)])), softline$7, "}"]) : isTemplatePlaceholderNodeWithoutSemiColon ? "" : ";"]);
       }
     // postcss-media-query-parser
 
@@ -47031,7 +47042,7 @@ function genericPrint$2(path, options, print) {
 
     case "media-query":
       {
-        return concat$f([join$8(" ", path.map(print, "nodes")), isLastNode$1(path, node) ? "" : ","]);
+        return concat$g([join$8(" ", path.map(print, "nodes")), isLastNode$1(path, node) ? "" : ","]);
       }
 
     case "media-type":
@@ -47045,7 +47056,7 @@ function genericPrint$2(path, options, print) {
           return node.value;
         }
 
-        return concat$f(["(", concat$f(path.map(print, "nodes")), ")"]);
+        return concat$g(["(", concat$g(path.map(print, "nodes")), ")"]);
       }
 
     case "media-feature":
@@ -47055,7 +47066,7 @@ function genericPrint$2(path, options, print) {
 
     case "media-colon":
       {
-        return concat$f([node.value, " "]);
+        return concat$g([node.value, " "]);
       }
 
     case "media-value":
@@ -47081,12 +47092,12 @@ function genericPrint$2(path, options, print) {
 
     case "selector-root":
       {
-        return group$b(concat$f([insideAtRuleNode$1(path, "custom-selector") ? concat$f([getAncestorNode$1(path, "css-atrule").customSelector, line$9]) : "", join$8(concat$f([",", insideAtRuleNode$1(path, ["extend", "custom-selector", "nest"]) ? line$9 : hardline$a]), path.map(print, "nodes"))]));
+        return group$b(concat$g([insideAtRuleNode$1(path, "custom-selector") ? concat$g([getAncestorNode$1(path, "css-atrule").customSelector, line$9]) : "", join$8(concat$g([",", insideAtRuleNode$1(path, ["extend", "custom-selector", "nest"]) ? line$9 : hardline$a]), path.map(print, "nodes"))]));
       }
 
     case "selector-selector":
       {
-        return group$b(indent$a(concat$f(path.map(print, "nodes"))));
+        return group$b(indent$a(concat$g(path.map(print, "nodes"))));
       }
 
     case "selector-comment":
@@ -47104,22 +47115,22 @@ function genericPrint$2(path, options, print) {
         const parentNode = path.getParentNode();
         const index = parentNode && parentNode.nodes.indexOf(node);
         const prevNode = index && parentNode.nodes[index - 1];
-        return concat$f([node.namespace ? concat$f([node.namespace === true ? "" : node.namespace.trim(), "|"]) : "", prevNode.type === "selector-nesting" ? node.value : adjustNumbers(isKeyframeAtRuleKeywords$1(path, node.value) ? node.value.toLowerCase() : node.value)]);
+        return concat$g([node.namespace ? concat$g([node.namespace === true ? "" : node.namespace.trim(), "|"]) : "", prevNode.type === "selector-nesting" ? node.value : adjustNumbers(isKeyframeAtRuleKeywords$1(path, node.value) ? node.value.toLowerCase() : node.value)]);
       }
 
     case "selector-id":
       {
-        return concat$f(["#", node.value]);
+        return concat$g(["#", node.value]);
       }
 
     case "selector-class":
       {
-        return concat$f([".", adjustNumbers(adjustStrings(node.value, options))]);
+        return concat$g([".", adjustNumbers(adjustStrings(node.value, options))]);
       }
 
     case "selector-attribute":
       {
-        return concat$f(["[", node.namespace ? concat$f([node.namespace === true ? "" : node.namespace.trim(), "|"]) : "", node.attribute.trim(), node.operator ? node.operator : "", node.value ? quoteAttributeValue(adjustStrings(node.value.trim(), options), options) : "", node.insensitive ? " i" : "", "]"]);
+        return concat$g(["[", node.namespace ? concat$g([node.namespace === true ? "" : node.namespace.trim(), "|"]) : "", node.attribute.trim(), node.operator ? node.operator : "", node.value ? quoteAttributeValue(adjustStrings(node.value.trim(), options), options) : "", node.insensitive ? " i" : "", "]"]);
       }
 
     case "selector-combinator":
@@ -47127,22 +47138,22 @@ function genericPrint$2(path, options, print) {
         if (node.value === "+" || node.value === ">" || node.value === "~" || node.value === ">>>") {
           const parentNode = path.getParentNode();
           const leading = parentNode.type === "selector-selector" && parentNode.nodes[0] === node ? "" : line$9;
-          return concat$f([leading, node.value, isLastNode$1(path, node) ? "" : " "]);
+          return concat$g([leading, node.value, isLastNode$1(path, node) ? "" : " "]);
         }
 
         const leading = node.value.trim().startsWith("(") ? line$9 : "";
         const value = adjustNumbers(adjustStrings(node.value.trim(), options)) || line$9;
-        return concat$f([leading, value]);
+        return concat$g([leading, value]);
       }
 
     case "selector-universal":
       {
-        return concat$f([node.namespace ? concat$f([node.namespace === true ? "" : node.namespace.trim(), "|"]) : "", node.value]);
+        return concat$g([node.namespace ? concat$g([node.namespace === true ? "" : node.namespace.trim(), "|"]) : "", node.value]);
       }
 
     case "selector-pseudo":
       {
-        return concat$f([maybeToLowerCase$1(node.value), node.nodes && node.nodes.length > 0 ? concat$f(["(", join$8(", ", path.map(print, "nodes")), ")"]) : ""]);
+        return concat$g([maybeToLowerCase$1(node.value), node.nodes && node.nodes.length > 0 ? concat$g(["(", join$8(", ", path.map(print, "nodes")), ")"]) : ""]);
       }
 
     case "selector-nesting":
@@ -47174,7 +47185,7 @@ function genericPrint$2(path, options, print) {
           const start = options.locStart(parentNode.open) + 1;
           const end = options.locEnd(parentNode.close) - 1;
           const selector = options.originalText.slice(start, end).trim();
-          return lastLineHasInlineComment$1(selector) ? concat$f([breakParent$5, selector]) : selector;
+          return lastLineHasInlineComment$1(selector) ? concat$g([breakParent$5, selector]) : selector;
         }
 
         return node.value;
@@ -47373,7 +47384,7 @@ function genericPrint$2(path, options, print) {
         }
 
         if (isControlDirective) {
-          return group$b(indent$a(concat$f(parts)));
+          return group$b(indent$a(concat$g(parts)));
         } // Indent is not needed for import url when url is very long
         // and node has two groups
         // when type is value-comma_group
@@ -47392,7 +47403,7 @@ function genericPrint$2(path, options, print) {
         const parentNode = path.getParentNode();
 
         if (parentNode && isURLFunctionNode$1(parentNode) && (node.groups.length === 1 || node.groups.length > 0 && node.groups[0].type === "value-comma_group" && node.groups[0].groups.length > 0 && node.groups[0].groups[0].type === "value-word" && node.groups[0].groups[0].value.startsWith("data:"))) {
-          return concat$f([node.open ? path.call(print, "open") : "", join$8(",", path.map(print, "groups")), node.close ? path.call(print, "close") : ""]);
+          return concat$g([node.open ? path.call(print, "open") : "", join$8(",", path.map(print, "groups")), node.close ? path.call(print, "close") : ""]);
         }
 
         if (!node.open) {
@@ -47401,7 +47412,7 @@ function genericPrint$2(path, options, print) {
 
           for (let i = 0; i < printed.length; i++) {
             if (i !== 0) {
-              res.push(concat$f([",", line$9]));
+              res.push(concat$g([",", line$9]));
             }
 
             res.push(printed[i]);
@@ -47413,7 +47424,7 @@ function genericPrint$2(path, options, print) {
         const isSCSSMapItem = isSCSSMapItemNode$1(path);
         const lastItem = node.groups[node.groups.length - 1];
         const isLastItemComment = lastItem && lastItem.type === "value-comment";
-        return group$b(concat$f([node.open ? path.call(print, "open") : "", indent$a(concat$f([softline$7, join$8(concat$f([",", line$9]), path.map(childPath => {
+        return group$b(concat$g([node.open ? path.call(print, "open") : "", indent$a(concat$g([softline$7, join$8(concat$g([",", line$9]), path.map(childPath => {
           const node = childPath.getValue();
           const printed = print(childPath); // Key/Value pair in open paren already indented
 
@@ -47430,7 +47441,7 @@ function genericPrint$2(path, options, print) {
 
     case "value-func":
       {
-        return concat$f([node.value, insideAtRuleNode$1(path, "supports") && isMediaAndSupportsKeywords$1(node) ? " " : "", path.call(print, "group")]);
+        return concat$g([node.value, insideAtRuleNode$1(path, "supports") && isMediaAndSupportsKeywords$1(node) ? " " : "", path.call(print, "group")]);
       }
 
     case "value-paren":
@@ -47440,7 +47451,7 @@ function genericPrint$2(path, options, print) {
 
     case "value-number":
       {
-        return concat$f([printCssNumber(node.value), maybeToLowerCase$1(node.unit)]);
+        return concat$g([printCssNumber(node.value), maybeToLowerCase$1(node.unit)]);
       }
 
     case "value-operator":
@@ -47462,7 +47473,7 @@ function genericPrint$2(path, options, print) {
         const parentNode = path.getParentNode();
         const index = parentNode && parentNode.groups.indexOf(node);
         const prevNode = index && parentNode.groups[index - 1];
-        return concat$f([node.value, // Don't add spaces on escaped colon `:`, e.g: grid-template-rows: [row-1-00\:00] auto;
+        return concat$g([node.value, // Don't add spaces on escaped colon `:`, e.g: grid-template-rows: [row-1-00\:00] auto;
         prevNode && prevNode.value[prevNode.value.length - 1] === "\\" || // Don't add spaces on `:` in `url` function (i.e. `url(fbglyph: cross-outline, fig-white)`)
         insideValueFunctionNode$1(path, "url") ? "" : line$9]);
       }
@@ -47472,7 +47483,7 @@ function genericPrint$2(path, options, print) {
 
     case "value-comma":
       {
-        return concat$f([node.value, " "]);
+        return concat$g([node.value, " "]);
       }
 
     case "value-string":
@@ -47482,7 +47493,7 @@ function genericPrint$2(path, options, print) {
 
     case "value-atword":
       {
-        return concat$f(["@", node.value]);
+        return concat$g(["@", node.value]);
       }
 
     case "value-unicode-range":
@@ -47531,7 +47542,7 @@ function printNodeSequence(path, options, print) {
 
     i++;
   }, "nodes");
-  return concat$f(parts);
+  return concat$g(parts);
 }
 
 const STRING_REGEX$3 = /(["'])(?:(?!\1)[^\\]|\\[\S\s])*\1/g;
@@ -47887,7 +47898,7 @@ var utils$8 = {
 };
 
 const {
-  concat: concat$g,
+  concat: concat$h,
   group: group$f,
   hardline: hardline$b,
   ifBreak: ifBreak$6,
@@ -47929,7 +47940,7 @@ function print$2(path, options, print) {
     case "Program":
     case "Template":
       {
-        return group$f(concat$g(path.map(print, "body")));
+        return group$f(concat$h(path.map(print, "body")));
       }
 
     case "ElementNode":
@@ -47938,11 +47949,11 @@ function print$2(path, options, print) {
         const bim = isNextNodeOfSomeType$1(path, ["ElementNode"]) ? hardline$b : "";
 
         if (isVoid$1(n)) {
-          return concat$g([group$f(printStartingTag(path, print)), bim]);
+          return concat$h([group$f(printStartingTag(path, print)), bim]);
         }
 
         const isWhitespaceOnly = n.children.every(n => isWhitespaceNode$1(n));
-        return concat$g([group$f(printStartingTag(path, print)), group$f(concat$g([isWhitespaceOnly ? "" : indent$b(printChildren(path, options, print)), n.children.length ? hardline$b : "", concat$g(["</", n.tag, ">"])])), bim]);
+        return concat$h([group$f(printStartingTag(path, print)), group$f(concat$h([isWhitespaceOnly ? "" : indent$b(printChildren(path, options, print)), n.children.length ? hardline$b : "", concat$h(["</", n.tag, ">"])])), bim]);
       }
 
     case "BlockStatement":
@@ -47951,15 +47962,15 @@ function print$2(path, options, print) {
         const isElseIf = pp && pp.inverse && pp.inverse.body.length === 1 && pp.inverse.body[0] === n && pp.inverse.body[0].path.parts[0] === "if";
 
         if (isElseIf) {
-          return concat$g([printElseIfBlock(path, print), printProgram(path, print), printInverse(path, print)]);
+          return concat$h([printElseIfBlock(path, print), printProgram(path, print), printInverse(path, print)]);
         }
 
-        return concat$g([printOpenBlock(path, print), group$f(concat$g([printProgram(path, print), printInverse(path, print), printCloseBlock(path, print)]))]);
+        return concat$h([printOpenBlock(path, print), group$f(concat$h([printProgram(path, print), printInverse(path, print), printCloseBlock(path, print)]))]);
       }
 
     case "ElementModifierStatement":
       {
-        return group$f(concat$g(["{{", printPathAndParams(path, print), softline$8, "}}"]));
+        return group$f(concat$h(["{{", printPathAndParams(path, print), softline$8, "}}"]));
       }
 
     case "MustacheStatement":
@@ -47967,12 +47978,12 @@ function print$2(path, options, print) {
         const isParentOfSpecifiedTypes = isParentOfSomeType$1(path, ["AttrNode", "ConcatStatement"]);
         const isChildOfElementNodeAndDoesNotHaveParams = isParentOfSomeType$1(path, ["ElementNode"]) && doesNotHaveHashParams(n) && doesNotHavePositionalParams(n);
         const shouldBreakOpeningMustache = isParentOfSpecifiedTypes || isChildOfElementNodeAndDoesNotHaveParams;
-        return group$f(concat$g([printOpeningMustache(n), shouldBreakOpeningMustache ? indent$b(softline$8) : "", printPathAndParams(path, print), softline$8, printClosingMustache(n)]));
+        return group$f(concat$h([printOpeningMustache(n), shouldBreakOpeningMustache ? indent$b(softline$8) : "", printPathAndParams(path, print), softline$8, printClosingMustache(n)]));
       }
 
     case "SubExpression":
       {
-        return group$f(concat$g(["(", printSubExpressionPathAndParams(path, print), softline$8, ")"]));
+        return group$f(concat$h(["(", printSubExpressionPathAndParams(path, print), softline$8, ")"]));
       }
 
     case "AttrNode":
@@ -47985,28 +47996,28 @@ function print$2(path, options, print) {
         const isEmptyValue = isEmptyText && n.value.loc.start.column === n.value.loc.end.column;
 
         if (isEmptyValue) {
-          return concat$g([n.name]);
+          return concat$h([n.name]);
         }
 
         const value = path.call(print, "value");
         const quotedValue = isText ? printStringLiteral(value.parts.join(), options) : value;
-        return concat$g([n.name, "=", quotedValue]);
+        return concat$h([n.name, "=", quotedValue]);
       }
 
     case "ConcatStatement":
       {
         const quote = options.singleQuote ? "'" : '"';
-        return concat$g([quote, ...path.map(partPath => print(partPath), "parts"), quote]);
+        return concat$h([quote, ...path.map(partPath => print(partPath), "parts"), quote]);
       }
 
     case "Hash":
       {
-        return concat$g([join$9(line$a, path.map(print, "pairs"))]);
+        return concat$h([join$9(line$a, path.map(print, "pairs"))]);
       }
 
     case "HashPair":
       {
-        return concat$g([n.key, "=", path.call(print, "value")]);
+        return concat$h([n.key, "=", path.call(print, "value")]);
       }
 
     case "TextNode":
@@ -48042,7 +48053,7 @@ function print$2(path, options, print) {
           // TODO: format style and srcset attributes
           // and cleanup concat that is not necessary
           if (!isInAttributeOfName(path, "class")) {
-            return concat$g([n.chars]);
+            return concat$h([n.chars]);
           }
 
           let leadingSpace = "";
@@ -48058,7 +48069,7 @@ function print$2(path, options, print) {
             }
           }
 
-          return concat$g([...generateHardlines(leadingLineBreaksCount, maxLineBreaksToPreserve), n.chars.replace(/^\s+/g, leadingSpace).replace(/\s+$/, trailingSpace), ...generateHardlines(trailingLineBreaksCount, maxLineBreaksToPreserve)]);
+          return concat$h([...generateHardlines(leadingLineBreaksCount, maxLineBreaksToPreserve), n.chars.replace(/^\s+/g, leadingSpace).replace(/\s+$/, trailingSpace), ...generateHardlines(trailingLineBreaksCount, maxLineBreaksToPreserve)]);
         }
 
         let leadingSpace = "";
@@ -48092,13 +48103,13 @@ function print$2(path, options, print) {
           text = "\\" + text;
         }
 
-        return concat$g([...generateHardlines(leadingLineBreaksCount, maxLineBreaksToPreserve), text.replace(/^\s+/g, leadingSpace).replace(/\s+$/, trailingSpace), ...generateHardlines(trailingLineBreaksCount, maxLineBreaksToPreserve)]);
+        return concat$h([...generateHardlines(leadingLineBreaksCount, maxLineBreaksToPreserve), text.replace(/^\s+/g, leadingSpace).replace(/\s+$/, trailingSpace), ...generateHardlines(trailingLineBreaksCount, maxLineBreaksToPreserve)]);
       }
 
     case "MustacheCommentStatement":
       {
         const dashes = n.value.includes("}}") ? "--" : "";
-        return concat$g(["{{!", dashes, n.value, dashes, "}}"]);
+        return concat$h(["{{!", dashes, n.value, dashes, "}}"]);
       }
 
     case "PathExpression":
@@ -48113,7 +48124,7 @@ function print$2(path, options, print) {
 
     case "CommentStatement":
       {
-        return concat$g(["<!--", n.value, "-->"]);
+        return concat$h(["<!--", n.value, "-->"]);
       }
 
     case "StringLiteral":
@@ -48147,18 +48158,18 @@ function print$2(path, options, print) {
 
 function printStartingTag(path, print) {
   const node = path.getValue();
-  return concat$g(["<", node.tag, printAttributesLike(path, print), printBlockParams(node), printStartingTagEndMarker(node)]);
+  return concat$h(["<", node.tag, printAttributesLike(path, print), printBlockParams(node), printStartingTagEndMarker(node)]);
 }
 
 function printAttributesLike(path, print) {
   const node = path.getValue();
-  return indent$b(concat$g([node.attributes.length ? line$a : "", join$9(line$a, path.map(print, "attributes")), node.modifiers.length ? line$a : "", join$9(line$a, path.map(print, "modifiers")), node.comments.length ? line$a : "", join$9(line$a, path.map(print, "comments"))]));
+  return indent$b(concat$h([node.attributes.length ? line$a : "", join$9(line$a, path.map(print, "attributes")), node.modifiers.length ? line$a : "", join$9(line$a, path.map(print, "modifiers")), node.comments.length ? line$a : "", join$9(line$a, path.map(print, "comments"))]));
 }
 
 function printChildren(path, options, print) {
-  return concat$g(path.map((childPath, childIndex) => {
+  return concat$h(path.map((childPath, childIndex) => {
     if (childIndex === 0) {
-      return concat$g([softline$8, print(childPath, options, print)]);
+      return concat$h([softline$8, print(childPath, options, print)]);
     }
 
     return print(childPath, options, print);
@@ -48167,10 +48178,10 @@ function printChildren(path, options, print) {
 
 function printStartingTagEndMarker(node) {
   if (isVoid$1(node)) {
-    return ifBreak$6(concat$g([softline$8, "/>"]), concat$g([" />", softline$8]));
+    return ifBreak$6(concat$h([softline$8, "/>"]), concat$h([" />", softline$8]));
   }
 
-  return ifBreak$6(concat$g([softline$8, ">"]), ">");
+  return ifBreak$6(concat$h([softline$8, ">"]), ">");
 }
 /* MustacheStatement print helpers */
 
@@ -48178,13 +48189,13 @@ function printStartingTagEndMarker(node) {
 function printOpeningMustache(node) {
   const mustache = node.escaped === false ? "{{{" : "{{";
   const strip = node.strip && node.strip.open ? "~" : "";
-  return concat$g([mustache, strip]);
+  return concat$h([mustache, strip]);
 }
 
 function printClosingMustache(node) {
   const mustache = node.escaped === false ? "}}}" : "}}";
   const strip = node.strip && node.strip.close ? "~" : "";
-  return concat$g([strip, mustache]);
+  return concat$h([strip, mustache]);
 }
 /* BlockStatement print helpers */
 
@@ -48192,56 +48203,56 @@ function printClosingMustache(node) {
 function printOpeningBlockOpeningMustache(node) {
   const opening = printOpeningMustache(node);
   const strip = node.openStrip.open ? "~" : "";
-  return concat$g([opening, strip, "#"]);
+  return concat$h([opening, strip, "#"]);
 }
 
 function printOpeningBlockClosingMustache(node) {
   const closing = printClosingMustache(node);
   const strip = node.openStrip.close ? "~" : "";
-  return concat$g([strip, closing]);
+  return concat$h([strip, closing]);
 }
 
 function printClosingBlockOpeningMustache(node) {
   const opening = printOpeningMustache(node);
   const strip = node.closeStrip.open ? "~" : "";
-  return concat$g([opening, strip, "/"]);
+  return concat$h([opening, strip, "/"]);
 }
 
 function printClosingBlockClosingMustache(node) {
   const closing = printClosingMustache(node);
   const strip = node.closeStrip.close ? "~" : "";
-  return concat$g([strip, closing]);
+  return concat$h([strip, closing]);
 }
 
 function printInverseBlockOpeningMustache(node) {
   const opening = printOpeningMustache(node);
   const strip = node.inverseStrip.open ? "~" : "";
-  return concat$g([opening, strip]);
+  return concat$h([opening, strip]);
 }
 
 function printInverseBlockClosingMustache(node) {
   const closing = printClosingMustache(node);
   const strip = node.inverseStrip.close ? "~" : "";
-  return concat$g([strip, closing]);
+  return concat$h([strip, closing]);
 }
 
 function printOpenBlock(path, print) {
   const node = path.getValue();
-  return group$f(concat$g([printOpeningBlockOpeningMustache(node), printPathAndParams(path, print), printBlockParams(node.program), softline$8, printOpeningBlockClosingMustache(node)]));
+  return group$f(concat$h([printOpeningBlockOpeningMustache(node), printPathAndParams(path, print), printBlockParams(node.program), softline$8, printOpeningBlockClosingMustache(node)]));
 }
 
 function printElseBlock(node) {
-  return concat$g([hardline$b, printInverseBlockOpeningMustache(node), "else", printInverseBlockClosingMustache(node)]);
+  return concat$h([hardline$b, printInverseBlockOpeningMustache(node), "else", printInverseBlockClosingMustache(node)]);
 }
 
 function printElseIfBlock(path, print) {
   const parentNode = path.getParentNode(1);
-  return concat$g([printInverseBlockOpeningMustache(parentNode), "else ", printPathAndParams(path, print), printInverseBlockClosingMustache(parentNode)]);
+  return concat$h([printInverseBlockOpeningMustache(parentNode), "else ", printPathAndParams(path, print), printInverseBlockClosingMustache(parentNode)]);
 }
 
 function printCloseBlock(path, print) {
   const node = path.getValue();
-  return concat$g([blockStatementHasOnlyWhitespaceInProgram(node) ? softline$8 : hardline$b, printClosingBlockOpeningMustache(node), path.call(print, "path"), printClosingBlockClosingMustache(node)]);
+  return concat$h([blockStatementHasOnlyWhitespaceInProgram(node) ? softline$8 : hardline$b, printClosingBlockOpeningMustache(node), path.call(print, "path"), printClosingBlockClosingMustache(node)]);
 }
 
 function blockStatementHasOnlyWhitespaceInProgram(node) {
@@ -48264,20 +48275,20 @@ function printProgram(path, print) {
   }
 
   const program = path.call(print, "program");
-  return indent$b(concat$g([hardline$b, program]));
+  return indent$b(concat$h([hardline$b, program]));
 }
 
 function printInverse(path, print) {
   const node = path.getValue();
   const inverse = path.call(print, "inverse");
-  const parts = concat$g([hardline$b, inverse]);
+  const parts = concat$h([hardline$b, inverse]);
 
   if (blockStatementHasElseIf(node)) {
     return parts;
   }
 
   if (blockStatementHasElse(node)) {
-    return concat$g([printElseBlock(node), indent$b(parts)]);
+    return concat$h([printElseBlock(node), indent$b(parts)]);
   }
 
   return "";
@@ -48348,7 +48359,7 @@ function printStringLiteral(stringLiteral, options) {
 
   const enclosingQuote = shouldUseAlternateQuote ? alternate : preferred;
   const escapedStringLiteral = stringLiteral.replace(enclosingQuote.regex, `\\${enclosingQuote.quote}`);
-  return concat$g([enclosingQuote.quote, escapedStringLiteral, enclosingQuote.quote]);
+  return concat$h([enclosingQuote.quote, escapedStringLiteral, enclosingQuote.quote]);
 }
 /* SubExpression print helpers */
 
@@ -48361,7 +48372,7 @@ function printSubExpressionPathAndParams(path, print) {
     return p;
   }
 
-  return indent$b(concat$g([p, line$a, group$f(params)]));
+  return indent$b(concat$h([p, line$a, group$f(params)]));
 }
 /* misc. print helpers */
 
@@ -48374,7 +48385,7 @@ function printPathAndParams(path, print) {
     return p;
   }
 
-  return indent$b(group$f(concat$g([p, line$a, params])));
+  return indent$b(group$f(concat$h([p, line$a, params])));
 }
 
 function printPath(path, print) {
@@ -48407,7 +48418,7 @@ function printBlockParams(node) {
     return "";
   }
 
-  return concat$g([" as |", node.blockParams.join(" "), "|"]);
+  return concat$h([" as |", node.blockParams.join(" "), "|"]);
 }
 /* istanbul ignore next
    https://github.com/glimmerjs/glimmer-vm/blob/master/packages/%40glimmer/compiler/lib/location.ts#L5-L29
@@ -48532,7 +48543,7 @@ var pragma$2 = {
 };
 
 const {
-  concat: concat$h,
+  concat: concat$i,
   join: join$a,
   hardline: hardline$c,
   line: line$b,
@@ -48565,7 +48576,7 @@ function genericPrint$3(path, options, print) {
       {
         const parts = [];
         path.map((pathChild, index) => {
-          parts.push(concat$h([pathChild.call(print)]));
+          parts.push(concat$i([pathChild.call(print)]));
 
           if (index !== n.definitions.length - 1) {
             parts.push(hardline$c);
@@ -48575,29 +48586,29 @@ function genericPrint$3(path, options, print) {
             }
           }
         }, "definitions");
-        return concat$h([concat$h(parts), hardline$c]);
+        return concat$i([concat$i(parts), hardline$c]);
       }
 
     case "OperationDefinition":
       {
         const hasOperation = options.originalText[options.locStart(n)] !== "{";
         const hasName = !!n.name;
-        return concat$h([hasOperation ? n.operation : "", hasOperation && hasName ? concat$h([" ", path.call(print, "name")]) : "", n.variableDefinitions && n.variableDefinitions.length ? group$h(concat$h(["(", indent$c(concat$h([softline$9, join$a(concat$h([ifBreak$7("", ", "), softline$9]), path.map(print, "variableDefinitions"))])), softline$9, ")"])) : "", printDirectives(path, print, n), n.selectionSet ? !hasOperation && !hasName ? "" : " " : "", path.call(print, "selectionSet")]);
+        return concat$i([hasOperation ? n.operation : "", hasOperation && hasName ? concat$i([" ", path.call(print, "name")]) : "", n.variableDefinitions && n.variableDefinitions.length ? group$h(concat$i(["(", indent$c(concat$i([softline$9, join$a(concat$i([ifBreak$7("", ", "), softline$9]), path.map(print, "variableDefinitions"))])), softline$9, ")"])) : "", printDirectives(path, print, n), n.selectionSet ? !hasOperation && !hasName ? "" : " " : "", path.call(print, "selectionSet")]);
       }
 
     case "FragmentDefinition":
       {
-        return concat$h(["fragment ", path.call(print, "name"), n.variableDefinitions && n.variableDefinitions.length ? group$h(concat$h(["(", indent$c(concat$h([softline$9, join$a(concat$h([ifBreak$7("", ", "), softline$9]), path.map(print, "variableDefinitions"))])), softline$9, ")"])) : "", " on ", path.call(print, "typeCondition"), printDirectives(path, print, n), " ", path.call(print, "selectionSet")]);
+        return concat$i(["fragment ", path.call(print, "name"), n.variableDefinitions && n.variableDefinitions.length ? group$h(concat$i(["(", indent$c(concat$i([softline$9, join$a(concat$i([ifBreak$7("", ", "), softline$9]), path.map(print, "variableDefinitions"))])), softline$9, ")"])) : "", " on ", path.call(print, "typeCondition"), printDirectives(path, print, n), " ", path.call(print, "selectionSet")]);
       }
 
     case "SelectionSet":
       {
-        return concat$h(["{", indent$c(concat$h([hardline$c, join$a(hardline$c, path.call(selectionsPath => printSequence(selectionsPath, options, print), "selections"))])), hardline$c, "}"]);
+        return concat$i(["{", indent$c(concat$i([hardline$c, join$a(hardline$c, path.call(selectionsPath => printSequence(selectionsPath, options, print), "selections"))])), hardline$c, "}"]);
       }
 
     case "Field":
       {
-        return group$h(concat$h([n.alias ? concat$h([path.call(print, "alias"), ": "]) : "", path.call(print, "name"), n.arguments.length > 0 ? group$h(concat$h(["(", indent$c(concat$h([softline$9, join$a(concat$h([ifBreak$7("", ", "), softline$9]), path.call(argsPath => printSequence(argsPath, options, print), "arguments"))])), softline$9, ")"])) : "", printDirectives(path, print, n), n.selectionSet ? " " : "", path.call(print, "selectionSet")]));
+        return group$h(concat$i([n.alias ? concat$i([path.call(print, "alias"), ": "]) : "", path.call(print, "name"), n.arguments.length > 0 ? group$h(concat$i(["(", indent$c(concat$i([softline$9, join$a(concat$i([ifBreak$7("", ", "), softline$9]), path.call(argsPath => printSequence(argsPath, options, print), "arguments"))])), softline$9, ")"])) : "", printDirectives(path, print, n), n.selectionSet ? " " : "", path.call(print, "selectionSet")]));
       }
 
     case "Name":
@@ -48608,10 +48619,10 @@ function genericPrint$3(path, options, print) {
     case "StringValue":
       {
         if (n.block) {
-          return concat$h(['"""', hardline$c, join$a(hardline$c, n.value.replace(/"""/g, "\\$&").split("\n")), hardline$c, '"""']);
+          return concat$i(['"""', hardline$c, join$a(hardline$c, n.value.replace(/"""/g, "\\$&").split("\n")), hardline$c, '"""']);
         }
 
-        return concat$h(['"', n.value.replace(/["\\]/g, "\\$&").replace(/\n/g, "\\n"), '"']);
+        return concat$i(['"', n.value.replace(/["\\]/g, "\\$&").replace(/\n/g, "\\n"), '"']);
       }
 
     case "IntValue":
@@ -48633,28 +48644,28 @@ function genericPrint$3(path, options, print) {
 
     case "Variable":
       {
-        return concat$h(["$", path.call(print, "name")]);
+        return concat$i(["$", path.call(print, "name")]);
       }
 
     case "ListValue":
       {
-        return group$h(concat$h(["[", indent$c(concat$h([softline$9, join$a(concat$h([ifBreak$7("", ", "), softline$9]), path.map(print, "values"))])), softline$9, "]"]));
+        return group$h(concat$i(["[", indent$c(concat$i([softline$9, join$a(concat$i([ifBreak$7("", ", "), softline$9]), path.map(print, "values"))])), softline$9, "]"]));
       }
 
     case "ObjectValue":
       {
-        return group$h(concat$h(["{", options.bracketSpacing && n.fields.length > 0 ? " " : "", indent$c(concat$h([softline$9, join$a(concat$h([ifBreak$7("", ", "), softline$9]), path.map(print, "fields"))])), softline$9, ifBreak$7("", options.bracketSpacing && n.fields.length > 0 ? " " : ""), "}"]));
+        return group$h(concat$i(["{", options.bracketSpacing && n.fields.length > 0 ? " " : "", indent$c(concat$i([softline$9, join$a(concat$i([ifBreak$7("", ", "), softline$9]), path.map(print, "fields"))])), softline$9, ifBreak$7("", options.bracketSpacing && n.fields.length > 0 ? " " : ""), "}"]));
       }
 
     case "ObjectField":
     case "Argument":
       {
-        return concat$h([path.call(print, "name"), ": ", path.call(print, "value")]);
+        return concat$i([path.call(print, "name"), ": ", path.call(print, "value")]);
       }
 
     case "Directive":
       {
-        return concat$h(["@", path.call(print, "name"), n.arguments.length > 0 ? group$h(concat$h(["(", indent$c(concat$h([softline$9, join$a(concat$h([ifBreak$7("", ", "), softline$9]), path.call(argsPath => printSequence(argsPath, options, print), "arguments"))])), softline$9, ")"])) : ""]);
+        return concat$i(["@", path.call(print, "name"), n.arguments.length > 0 ? group$h(concat$i(["(", indent$c(concat$i([softline$9, join$a(concat$i([ifBreak$7("", ", "), softline$9]), path.call(argsPath => printSequence(argsPath, options, print), "arguments"))])), softline$9, ")"])) : ""]);
       }
 
     case "NamedType":
@@ -48664,93 +48675,93 @@ function genericPrint$3(path, options, print) {
 
     case "VariableDefinition":
       {
-        return concat$h([path.call(print, "variable"), ": ", path.call(print, "type"), n.defaultValue ? concat$h([" = ", path.call(print, "defaultValue")]) : "", printDirectives(path, print, n)]);
+        return concat$i([path.call(print, "variable"), ": ", path.call(print, "type"), n.defaultValue ? concat$i([" = ", path.call(print, "defaultValue")]) : "", printDirectives(path, print, n)]);
       }
 
     case "ObjectTypeExtension":
     case "ObjectTypeDefinition":
       {
-        return concat$h([path.call(print, "description"), n.description ? hardline$c : "", n.kind === "ObjectTypeExtension" ? "extend " : "", "type ", path.call(print, "name"), n.interfaces.length > 0 ? concat$h([" implements ", concat$h(printInterfaces(path, options, print))]) : "", printDirectives(path, print, n), n.fields.length > 0 ? concat$h([" {", indent$c(concat$h([hardline$c, join$a(hardline$c, path.call(fieldsPath => printSequence(fieldsPath, options, print), "fields"))])), hardline$c, "}"]) : ""]);
+        return concat$i([path.call(print, "description"), n.description ? hardline$c : "", n.kind === "ObjectTypeExtension" ? "extend " : "", "type ", path.call(print, "name"), n.interfaces.length > 0 ? concat$i([" implements ", concat$i(printInterfaces(path, options, print))]) : "", printDirectives(path, print, n), n.fields.length > 0 ? concat$i([" {", indent$c(concat$i([hardline$c, join$a(hardline$c, path.call(fieldsPath => printSequence(fieldsPath, options, print), "fields"))])), hardline$c, "}"]) : ""]);
       }
 
     case "FieldDefinition":
       {
-        return concat$h([path.call(print, "description"), n.description ? hardline$c : "", path.call(print, "name"), n.arguments.length > 0 ? group$h(concat$h(["(", indent$c(concat$h([softline$9, join$a(concat$h([ifBreak$7("", ", "), softline$9]), path.call(argsPath => printSequence(argsPath, options, print), "arguments"))])), softline$9, ")"])) : "", ": ", path.call(print, "type"), printDirectives(path, print, n)]);
+        return concat$i([path.call(print, "description"), n.description ? hardline$c : "", path.call(print, "name"), n.arguments.length > 0 ? group$h(concat$i(["(", indent$c(concat$i([softline$9, join$a(concat$i([ifBreak$7("", ", "), softline$9]), path.call(argsPath => printSequence(argsPath, options, print), "arguments"))])), softline$9, ")"])) : "", ": ", path.call(print, "type"), printDirectives(path, print, n)]);
       }
 
     case "DirectiveDefinition":
       {
-        return concat$h([path.call(print, "description"), n.description ? hardline$c : "", "directive ", "@", path.call(print, "name"), n.arguments.length > 0 ? group$h(concat$h(["(", indent$c(concat$h([softline$9, join$a(concat$h([ifBreak$7("", ", "), softline$9]), path.call(argsPath => printSequence(argsPath, options, print), "arguments"))])), softline$9, ")"])) : "", n.repeatable ? " repeatable" : "", concat$h([" on ", join$a(" | ", path.map(print, "locations"))])]);
+        return concat$i([path.call(print, "description"), n.description ? hardline$c : "", "directive ", "@", path.call(print, "name"), n.arguments.length > 0 ? group$h(concat$i(["(", indent$c(concat$i([softline$9, join$a(concat$i([ifBreak$7("", ", "), softline$9]), path.call(argsPath => printSequence(argsPath, options, print), "arguments"))])), softline$9, ")"])) : "", n.repeatable ? " repeatable" : "", concat$i([" on ", join$a(" | ", path.map(print, "locations"))])]);
       }
 
     case "EnumTypeExtension":
     case "EnumTypeDefinition":
       {
-        return concat$h([path.call(print, "description"), n.description ? hardline$c : "", n.kind === "EnumTypeExtension" ? "extend " : "", "enum ", path.call(print, "name"), printDirectives(path, print, n), n.values.length > 0 ? concat$h([" {", indent$c(concat$h([hardline$c, join$a(hardline$c, path.call(valuesPath => printSequence(valuesPath, options, print), "values"))])), hardline$c, "}"]) : ""]);
+        return concat$i([path.call(print, "description"), n.description ? hardline$c : "", n.kind === "EnumTypeExtension" ? "extend " : "", "enum ", path.call(print, "name"), printDirectives(path, print, n), n.values.length > 0 ? concat$i([" {", indent$c(concat$i([hardline$c, join$a(hardline$c, path.call(valuesPath => printSequence(valuesPath, options, print), "values"))])), hardline$c, "}"]) : ""]);
       }
 
     case "EnumValueDefinition":
       {
-        return concat$h([path.call(print, "description"), n.description ? hardline$c : "", path.call(print, "name"), printDirectives(path, print, n)]);
+        return concat$i([path.call(print, "description"), n.description ? hardline$c : "", path.call(print, "name"), printDirectives(path, print, n)]);
       }
 
     case "InputValueDefinition":
       {
-        return concat$h([path.call(print, "description"), n.description ? n.description.block ? hardline$c : line$b : "", path.call(print, "name"), ": ", path.call(print, "type"), n.defaultValue ? concat$h([" = ", path.call(print, "defaultValue")]) : "", printDirectives(path, print, n)]);
+        return concat$i([path.call(print, "description"), n.description ? n.description.block ? hardline$c : line$b : "", path.call(print, "name"), ": ", path.call(print, "type"), n.defaultValue ? concat$i([" = ", path.call(print, "defaultValue")]) : "", printDirectives(path, print, n)]);
       }
 
     case "InputObjectTypeExtension":
     case "InputObjectTypeDefinition":
       {
-        return concat$h([path.call(print, "description"), n.description ? hardline$c : "", n.kind === "InputObjectTypeExtension" ? "extend " : "", "input ", path.call(print, "name"), printDirectives(path, print, n), n.fields.length > 0 ? concat$h([" {", indent$c(concat$h([hardline$c, join$a(hardline$c, path.call(fieldsPath => printSequence(fieldsPath, options, print), "fields"))])), hardline$c, "}"]) : ""]);
+        return concat$i([path.call(print, "description"), n.description ? hardline$c : "", n.kind === "InputObjectTypeExtension" ? "extend " : "", "input ", path.call(print, "name"), printDirectives(path, print, n), n.fields.length > 0 ? concat$i([" {", indent$c(concat$i([hardline$c, join$a(hardline$c, path.call(fieldsPath => printSequence(fieldsPath, options, print), "fields"))])), hardline$c, "}"]) : ""]);
       }
 
     case "SchemaDefinition":
       {
-        return concat$h(["schema", printDirectives(path, print, n), " {", n.operationTypes.length > 0 ? indent$c(concat$h([hardline$c, join$a(hardline$c, path.call(opsPath => printSequence(opsPath, options, print), "operationTypes"))])) : "", hardline$c, "}"]);
+        return concat$i(["schema", printDirectives(path, print, n), " {", n.operationTypes.length > 0 ? indent$c(concat$i([hardline$c, join$a(hardline$c, path.call(opsPath => printSequence(opsPath, options, print), "operationTypes"))])) : "", hardline$c, "}"]);
       }
 
     case "OperationTypeDefinition":
       {
-        return concat$h([path.call(print, "operation"), ": ", path.call(print, "type")]);
+        return concat$i([path.call(print, "operation"), ": ", path.call(print, "type")]);
       }
 
     case "InterfaceTypeExtension":
     case "InterfaceTypeDefinition":
       {
-        return concat$h([path.call(print, "description"), n.description ? hardline$c : "", n.kind === "InterfaceTypeExtension" ? "extend " : "", "interface ", path.call(print, "name"), n.interfaces.length > 0 ? concat$h([" implements ", concat$h(printInterfaces(path, options, print))]) : "", printDirectives(path, print, n), n.fields.length > 0 ? concat$h([" {", indent$c(concat$h([hardline$c, join$a(hardline$c, path.call(fieldsPath => printSequence(fieldsPath, options, print), "fields"))])), hardline$c, "}"]) : ""]);
+        return concat$i([path.call(print, "description"), n.description ? hardline$c : "", n.kind === "InterfaceTypeExtension" ? "extend " : "", "interface ", path.call(print, "name"), n.interfaces.length > 0 ? concat$i([" implements ", concat$i(printInterfaces(path, options, print))]) : "", printDirectives(path, print, n), n.fields.length > 0 ? concat$i([" {", indent$c(concat$i([hardline$c, join$a(hardline$c, path.call(fieldsPath => printSequence(fieldsPath, options, print), "fields"))])), hardline$c, "}"]) : ""]);
       }
 
     case "FragmentSpread":
       {
-        return concat$h(["...", path.call(print, "name"), printDirectives(path, print, n)]);
+        return concat$i(["...", path.call(print, "name"), printDirectives(path, print, n)]);
       }
 
     case "InlineFragment":
       {
-        return concat$h(["...", n.typeCondition ? concat$h([" on ", path.call(print, "typeCondition")]) : "", printDirectives(path, print, n), " ", path.call(print, "selectionSet")]);
+        return concat$i(["...", n.typeCondition ? concat$i([" on ", path.call(print, "typeCondition")]) : "", printDirectives(path, print, n), " ", path.call(print, "selectionSet")]);
       }
 
     case "UnionTypeExtension":
     case "UnionTypeDefinition":
       {
-        return group$h(concat$h([path.call(print, "description"), n.description ? hardline$c : "", group$h(concat$h([n.kind === "UnionTypeExtension" ? "extend " : "", "union ", path.call(print, "name"), printDirectives(path, print, n), n.types.length > 0 ? concat$h([" =", ifBreak$7("", " "), indent$c(concat$h([ifBreak$7(concat$h([line$b, "  "])), join$a(concat$h([line$b, "| "]), path.map(print, "types"))]))]) : ""]))]));
+        return group$h(concat$i([path.call(print, "description"), n.description ? hardline$c : "", group$h(concat$i([n.kind === "UnionTypeExtension" ? "extend " : "", "union ", path.call(print, "name"), printDirectives(path, print, n), n.types.length > 0 ? concat$i([" =", ifBreak$7("", " "), indent$c(concat$i([ifBreak$7(concat$i([line$b, "  "])), join$a(concat$i([line$b, "| "]), path.map(print, "types"))]))]) : ""]))]));
       }
 
     case "ScalarTypeExtension":
     case "ScalarTypeDefinition":
       {
-        return concat$h([path.call(print, "description"), n.description ? hardline$c : "", n.kind === "ScalarTypeExtension" ? "extend " : "", "scalar ", path.call(print, "name"), printDirectives(path, print, n)]);
+        return concat$i([path.call(print, "description"), n.description ? hardline$c : "", n.kind === "ScalarTypeExtension" ? "extend " : "", "scalar ", path.call(print, "name"), printDirectives(path, print, n)]);
       }
 
     case "NonNullType":
       {
-        return concat$h([path.call(print, "type"), "!"]);
+        return concat$i([path.call(print, "type"), "!"]);
       }
 
     case "ListType":
       {
-        return concat$h(["[", path.call(print, "type"), "]"]);
+        return concat$i(["[", path.call(print, "type"), "]"]);
       }
 
     default:
@@ -48764,7 +48775,13 @@ function printDirectives(path, print, n) {
     return "";
   }
 
-  return group$h(concat$h([line$b, join$a(line$b, path.map(print, "directives"))]));
+  const printed = join$a(line$b, path.map(print, "directives"));
+
+  if (n.kind === "FragmentDefinition" || n.kind === "OperationDefinition") {
+    return group$h(concat$i([line$b, printed]));
+  }
+
+  return concat$i([" ", group$h(indent$c(concat$i([softline$9, printed])))]);
 }
 
 function printSequence(sequencePath, options, print) {
@@ -48773,7 +48790,7 @@ function printSequence(sequencePath, options, print) {
     const printed = print(path);
 
     if (isNextLineEmpty$6(options.originalText, path.getValue(), options.locEnd) && i < count - 1) {
-      return concat$h([printed, hardline$c]);
+      return concat$i([printed, hardline$c]);
     }
 
     return printed;
@@ -49095,12 +49112,11 @@ const {
 const {
   builders: {
     hardline: hardline$d,
-    literalline: literalline$3,
-    concat: concat$i,
+    concat: concat$j,
     markAsRoot: markAsRoot$2
   },
   utils: {
-    mapDoc: mapDoc$2
+    replaceNewlinesWithLiterallines: replaceNewlinesWithLiterallines$2
   }
 } = document;
 const {
@@ -49127,7 +49143,7 @@ function embed$2(path, print, textToDoc, options) {
       }, {
         stripTrailingHardline: true
       });
-      return markAsRoot$2(concat$i([style, node.lang, node.meta ? " " + node.meta : "", hardline$d, replaceNewlinesWithLiterallines(doc), hardline$d, style]));
+      return markAsRoot$2(concat$j([style, node.lang, node.meta ? " " + node.meta : "", hardline$d, replaceNewlinesWithLiterallines$2(doc), hardline$d, style]));
     }
   }
 
@@ -49137,7 +49153,7 @@ function embed$2(path, print, textToDoc, options) {
     // MDX
 
     case "importExport":
-      return concat$i([textToDoc(node.value, {
+      return concat$j([textToDoc(node.value, {
         parser: "babel"
       }, {
         stripTrailingHardline: true
@@ -49153,10 +49169,6 @@ function embed$2(path, print, textToDoc, options) {
   }
 
   return null;
-
-  function replaceNewlinesWithLiterallines(doc) {
-    return mapDoc$2(doc, currentDoc => typeof currentDoc === "string" && currentDoc.includes("\n") ? concat$i(currentDoc.split(/(\n)/g).map((v, i) => i % 2 === 0 ? v : literalline$3)) : currentDoc);
-  }
 }
 
 var embed_1$2 = embed$2;
@@ -49455,7 +49467,7 @@ const {
 const {
   builders: {
     breakParent: breakParent$6,
-    concat: concat$j,
+    concat: concat$k,
     join: join$b,
     line: line$c,
     literalline: literalline$4,
@@ -49496,7 +49508,7 @@ function genericPrint$4(path, options, print) {
   const node = path.getValue();
 
   if (shouldRemainTheSameContent(path)) {
-    return concat$j(splitText$2(options.originalText.slice(node.position.start.offset, node.position.end.offset), options).map(node => node.type === "word" ? node.value : node.value === "" ? "" : printLine(path, node.value, options)));
+    return concat$k(splitText$2(options.originalText.slice(node.position.start.offset, node.position.end.offset), options).map(node => node.type === "word" ? node.value : node.value === "" ? "" : printLine(path, node.value, options)));
   }
 
   switch (node.type) {
@@ -49508,7 +49520,7 @@ function genericPrint$4(path, options, print) {
         return "";
       }
 
-      return concat$j([normalizeDoc$1(printRoot(path, options, print)), !TRAILING_HARDLINE_NODES.has(getLastDescendantNode(node).type) ? hardline$e : ""]);
+      return concat$k([normalizeDoc$1(printRoot(path, options, print)), !TRAILING_HARDLINE_NODES.has(getLastDescendantNode(node).type) ? hardline$e : ""]);
 
     case "paragraph":
       return printChildren$1(path, options, print, {
@@ -49563,21 +49575,21 @@ function genericPrint$4(path, options, print) {
           style = hasPrevOrNextWord || getAncestorNode$2(path, "emphasis") ? "*" : "_";
         }
 
-        return concat$j([style, printChildren$1(path, options, print), style]);
+        return concat$k([style, printChildren$1(path, options, print), style]);
       }
 
     case "strong":
-      return concat$j(["**", printChildren$1(path, options, print), "**"]);
+      return concat$k(["**", printChildren$1(path, options, print), "**"]);
 
     case "delete":
-      return concat$j(["~~", printChildren$1(path, options, print), "~~"]);
+      return concat$k(["~~", printChildren$1(path, options, print), "~~"]);
 
     case "inlineCode":
       {
         const backtickCount = getMinNotPresentContinuousCount$1(node.value, "`");
         const style = "`".repeat(backtickCount || 1);
         const gap = backtickCount && !/^\s/.test(node.value) ? " " : "";
-        return concat$j([style, gap, node.value, gap, style]);
+        return concat$k([style, gap, node.value, gap, style]);
       }
 
     case "link":
@@ -49587,37 +49599,37 @@ function genericPrint$4(path, options, print) {
             const mailto = "mailto:";
             const url = // <hello@example.com> is parsed as { url: "mailto:hello@example.com" }
             node.url.startsWith(mailto) && options.originalText.slice(node.position.start.offset + 1, node.position.start.offset + 1 + mailto.length) !== mailto ? node.url.slice(mailto.length) : node.url;
-            return concat$j(["<", url, ">"]);
+            return concat$k(["<", url, ">"]);
           }
 
         case "[":
-          return concat$j(["[", printChildren$1(path, options, print), "](", printUrl(node.url, ")"), printTitle(node.title, options), ")"]);
+          return concat$k(["[", printChildren$1(path, options, print), "](", printUrl(node.url, ")"), printTitle(node.title, options), ")"]);
 
         default:
           return options.originalText.slice(node.position.start.offset, node.position.end.offset);
       }
 
     case "image":
-      return concat$j(["![", node.alt || "", "](", printUrl(node.url, ")"), printTitle(node.title, options), ")"]);
+      return concat$k(["![", node.alt || "", "](", printUrl(node.url, ")"), printTitle(node.title, options), ")"]);
 
     case "blockquote":
-      return concat$j(["> ", align$3("> ", printChildren$1(path, options, print))]);
+      return concat$k(["> ", align$3("> ", printChildren$1(path, options, print))]);
 
     case "heading":
-      return concat$j(["#".repeat(node.depth) + " ", printChildren$1(path, options, print)]);
+      return concat$k(["#".repeat(node.depth) + " ", printChildren$1(path, options, print)]);
 
     case "code":
       {
         if (node.isIndented) {
           // indented code block
           const alignment = " ".repeat(4);
-          return align$3(alignment, concat$j([alignment, concat$j(replaceEndOfLineWith$1(node.value, hardline$e))]));
+          return align$3(alignment, concat$k([alignment, concat$k(replaceEndOfLineWith$1(node.value, hardline$e))]));
         } // fenced code block
 
 
         const styleUnit = options.__inJsTemplate ? "~" : "`";
         const style = styleUnit.repeat(Math.max(3, getMaxContinuousCount$3(node.value, styleUnit) + 1));
-        return concat$j([style, node.lang || "", node.meta ? " " + node.meta : "", hardline$e, concat$j(replaceEndOfLineWith$1(getFencedCodeBlockValue$2(node, options.originalText), hardline$e)), hardline$e, style]);
+        return concat$k([style, node.lang || "", node.meta ? " " + node.meta : "", hardline$e, concat$k(replaceEndOfLineWith$1(getFencedCodeBlockValue$2(node, options.originalText), hardline$e)), hardline$e, style]);
       }
 
     case "html":
@@ -49625,7 +49637,7 @@ function genericPrint$4(path, options, print) {
         const parentNode = path.getParentNode();
         const value = parentNode.type === "root" && getLast$7(parentNode.children) === node ? node.value.trimEnd() : node.value;
         const isHtmlComment = /^<!--[\S\s]*-->$/.test(value);
-        return concat$j(replaceEndOfLineWith$1(value, isHtmlComment ? hardline$e : markAsRoot$3(literalline$4)));
+        return concat$k(replaceEndOfLineWith$1(value, isHtmlComment ? hardline$e : markAsRoot$3(literalline$4)));
       }
 
     case "list":
@@ -49638,10 +49650,10 @@ function genericPrint$4(path, options, print) {
             const childNode = childPath.getValue();
 
             if (childNode.children.length === 2 && childNode.children[1].type === "html" && childNode.children[0].position.start.column !== childNode.children[1].position.start.column) {
-              return concat$j([prefix, printListItem(childPath, options, print, prefix)]);
+              return concat$k([prefix, printListItem(childPath, options, print, prefix)]);
             }
 
-            return concat$j([prefix, align$3(" ".repeat(prefix.length), printListItem(childPath, options, print, prefix))]);
+            return concat$k([prefix, align$3(" ".repeat(prefix.length), printListItem(childPath, options, print, prefix))]);
 
             function getPrefix() {
               const rawPrefix = node.ordered ? (index === 0 ? node.start : isGitDiffFriendlyOrderedList ? 1 : node.start + index) + (nthSiblingIndex % 2 === 0 ? ". " : ") ") : nthSiblingIndex % 2 === 0 ? "- " : "* ";
@@ -49666,21 +49678,21 @@ function genericPrint$4(path, options, print) {
       }
 
     case "linkReference":
-      return concat$j(["[", printChildren$1(path, options, print), "]", node.referenceType === "full" ? concat$j(["[", node.identifier, "]"]) : node.referenceType === "collapsed" ? "[]" : ""]);
+      return concat$k(["[", printChildren$1(path, options, print), "]", node.referenceType === "full" ? concat$k(["[", node.identifier, "]"]) : node.referenceType === "collapsed" ? "[]" : ""]);
 
     case "imageReference":
       switch (node.referenceType) {
         case "full":
-          return concat$j(["![", node.alt || "", "][", node.identifier, "]"]);
+          return concat$k(["![", node.alt || "", "][", node.identifier, "]"]);
 
         default:
-          return concat$j(["![", node.alt, "]", node.referenceType === "collapsed" ? "[]" : ""]);
+          return concat$k(["![", node.alt, "]", node.referenceType === "collapsed" ? "[]" : ""]);
       }
 
     case "definition":
       {
         const lineOrSpace = options.proseWrap === "always" ? line$c : " ";
-        return group$i(concat$j([concat$j(["[", node.identifier, "]:"]), indent$d(concat$j([lineOrSpace, printUrl(node.url), node.title === null ? "" : concat$j([lineOrSpace, printTitle(node.title, options, false)])]))]));
+        return group$i(concat$k([concat$k(["[", node.identifier, "]:"]), indent$d(concat$k([lineOrSpace, printUrl(node.url), node.title === null ? "" : concat$k([lineOrSpace, printTitle(node.title, options, false)])]))]));
       }
     // `footnote` requires `.use(footnotes, {inlineNotes: true})`, we are not using this option
     // https://github.com/remarkjs/remark-footnotes#optionsinlinenotes
@@ -49688,18 +49700,18 @@ function genericPrint$4(path, options, print) {
     /* istanbul ignore next */
 
     case "footnote":
-      return concat$j(["[^", printChildren$1(path, options, print), "]"]);
+      return concat$k(["[^", printChildren$1(path, options, print), "]"]);
 
     case "footnoteReference":
-      return concat$j(["[^", node.identifier, "]"]);
+      return concat$k(["[^", node.identifier, "]"]);
 
     case "footnoteDefinition":
       {
         const nextNode = path.getParentNode().children[path.getName() + 1];
         const shouldInlineFootnote = node.children.length === 1 && node.children[0].type === "paragraph" && (options.proseWrap === "never" || options.proseWrap === "preserve" && node.children[0].position.start.line === node.children[0].position.end.line);
-        return concat$j(["[^", node.identifier, "]: ", shouldInlineFootnote ? printChildren$1(path, options, print) : group$i(concat$j([align$3(" ".repeat(4), printChildren$1(path, options, print, {
+        return concat$k(["[^", node.identifier, "]: ", shouldInlineFootnote ? printChildren$1(path, options, print) : group$i(concat$k([align$3(" ".repeat(4), printChildren$1(path, options, print, {
           processor: (childPath, index) => {
-            return index === 0 ? group$i(concat$j([softline$a, childPath.call(print)])) : childPath.call(print);
+            return index === 0 ? group$i(concat$k([softline$a, childPath.call(print)])) : childPath.call(print);
           }
         })), nextNode && nextNode.type === "footnoteDefinition" ? softline$a : ""]))]);
       }
@@ -49711,20 +49723,20 @@ function genericPrint$4(path, options, print) {
       return printChildren$1(path, options, print);
 
     case "break":
-      return /\s/.test(options.originalText[node.position.start.offset]) ? concat$j(["  ", markAsRoot$3(literalline$4)]) : concat$j(["\\", hardline$e]);
+      return /\s/.test(options.originalText[node.position.start.offset]) ? concat$k(["  ", markAsRoot$3(literalline$4)]) : concat$k(["\\", hardline$e]);
 
     case "liquidNode":
-      return concat$j(replaceEndOfLineWith$1(node.value, hardline$e));
+      return concat$k(replaceEndOfLineWith$1(node.value, hardline$e));
     // MDX
 
     case "importExport":
     case "jsx":
       // fallback to the original text if multiparser failed
       // or `embeddedLanguageFormatting: "off"`
-      return concat$j([node.value, hardline$e]);
+      return concat$k([node.value, hardline$e]);
 
     case "math":
-      return concat$j(["$$", hardline$e, node.value ? concat$j([concat$j(replaceEndOfLineWith$1(node.value, hardline$e)), hardline$e]) : "", "$$"]);
+      return concat$k(["$$", hardline$e, node.value ? concat$k([concat$k(replaceEndOfLineWith$1(node.value, hardline$e)), hardline$e]) : "", "$$"]);
 
     case "inlineMath":
       {
@@ -49746,7 +49758,7 @@ function genericPrint$4(path, options, print) {
 function printListItem(path, options, print, listPrefix) {
   const node = path.getValue();
   const prefix = node.checked === null ? "" : node.checked ? "[x] " : "[ ] ";
-  return concat$j([prefix, printChildren$1(path, options, print, {
+  return concat$k([prefix, printChildren$1(path, options, print, {
     processor: (childPath, index) => {
       if (index === 0 && childPath.getValue().type !== "list") {
         return align$3(" ".repeat(prefix.length), childPath.call(print));
@@ -49754,7 +49766,7 @@ function printListItem(path, options, print, listPrefix) {
 
       const alignment = " ".repeat(clamp(options.tabWidth - listPrefix.length, 0, 3) // 4+ will cause indented code block
       );
-      return concat$j([alignment, align$3(alignment, childPath.call(print))]);
+      return concat$k([alignment, align$3(alignment, childPath.call(print))]);
     }
   })]);
 }
@@ -49838,7 +49850,7 @@ function printTable(path, options, print) {
   const alignedTable = join$b(hardlineWithoutBreakParent, [printRow(contents[0]), printSeparator(), join$b(hardlineWithoutBreakParent, contents.slice(1).map(rowContents => printRow(rowContents)))]);
 
   if (options.proseWrap !== "never") {
-    return concat$j([breakParent$6, alignedTable]);
+    return concat$k([breakParent$6, alignedTable]);
   } // Only if the --prose-wrap never is set and it exceeds the print width.
 
 
@@ -49849,10 +49861,10 @@ function printTable(path, options, print) {
   true), join$b(hardlineWithoutBreakParent, contents.slice(1).map(rowContents => printRow(rowContents,
   /* isCompact */
   true)))]);
-  return concat$j([breakParent$6, group$i(ifBreak$8(compactTable, alignedTable))]);
+  return concat$k([breakParent$6, group$i(ifBreak$8(compactTable, alignedTable))]);
 
   function printSeparator(isCompact) {
-    return concat$j(["| ", join$b(" | ", columnMaxWidths.map((width, index) => {
+    return concat$k(["| ", join$b(" | ", columnMaxWidths.map((width, index) => {
       const spaces = isCompact ? 3 : width;
 
       switch (node.align[index]) {
@@ -49872,7 +49884,7 @@ function printTable(path, options, print) {
   }
 
   function printRow(rowContents, isCompact) {
-    return concat$j(["| ", join$b(" | ", isCompact ? rowContents : rowContents.map((rowContent, columnIndex) => {
+    return concat$k(["| ", join$b(" | ", isCompact ? rowContents : rowContents.map((rowContent, columnIndex) => {
       switch (node.align[columnIndex]) {
         case "right":
           return alignRight(rowContent, columnMaxWidths[columnIndex]);
@@ -49888,19 +49900,19 @@ function printTable(path, options, print) {
 
   function alignLeft(text, width) {
     const spaces = width - getStringWidth$4(text);
-    return concat$j([text, " ".repeat(spaces)]);
+    return concat$k([text, " ".repeat(spaces)]);
   }
 
   function alignRight(text, width) {
     const spaces = width - getStringWidth$4(text);
-    return concat$j([" ".repeat(spaces), text]);
+    return concat$k([" ".repeat(spaces), text]);
   }
 
   function alignCenter(text, width) {
     const spaces = width - getStringWidth$4(text);
     const left = Math.floor(spaces / 2);
     const right = spaces - left;
-    return concat$j([" ".repeat(left), text, " ".repeat(right)]);
+    return concat$k([" ".repeat(left), text, " ".repeat(right)]);
   }
 }
 
@@ -49948,7 +49960,7 @@ function printRoot(path, options, print) {
         const ignoreRange = ignoreRanges[0];
 
         if (index === ignoreRange.start.index) {
-          return concat$j([children[ignoreRange.start.index].value, options.originalText.slice(ignoreRange.start.offset, ignoreRange.end.offset), children[ignoreRange.end.index].value]);
+          return concat$k([children[ignoreRange.start.index].value, options.originalText.slice(ignoreRange.start.offset, ignoreRange.end.offset), children[ignoreRange.end.index].value]);
         }
 
         if (ignoreRange.start.index < index && index < ignoreRange.end.index) {
@@ -49968,7 +49980,7 @@ function printRoot(path, options, print) {
 
 function printChildren$1(path, options, print, events) {
   events = events || {};
-  const postprocessor = events.postprocessor || concat$j;
+  const postprocessor = events.postprocessor || concat$k;
 
   const processor = events.processor || (childPath => childPath.call(print));
 
@@ -52259,7 +52271,7 @@ var pragma$4 = {
 
 const {
   builders: {
-    concat: concat$k,
+    concat: concat$l,
     group: group$j
   }
 } = document;
@@ -52276,7 +52288,7 @@ function printVueFor(value, textToDoc) {
     operator,
     right
   } = parseVueFor(value);
-  return concat$k([group$j(textToDoc(`function _(${left}) {}`, {
+  return concat$l([group$j(textToDoc(`function _(${left}) {}`, {
     parser: "babel",
     __isVueForBindingLeft: true
   })), " ", operator, " ", textToDoc(right, {
@@ -52668,7 +52680,7 @@ var parseSrcset = createCommonjsModule(function (module) {
 
 const {
   builders: {
-    concat: concat$l,
+    concat: concat$m,
     ifBreak: ifBreak$9,
     join: join$c,
     line: line$d
@@ -52711,7 +52723,7 @@ function printImgSrcset(value) {
     return index === -1 ? descriptor.length : index;
   });
   const maxDescriptorLeftLength = getMax(descriptorLeftLengths);
-  return join$c(concat$l([",", line$d]), urls.map((url, index) => {
+  return join$c(concat$m([",", line$d]), urls.map((url, index) => {
     const parts = [url];
     const descriptor = descriptors[index];
 
@@ -52722,7 +52734,7 @@ function printImgSrcset(value) {
       parts.push(ifBreak$9(alignment, " "), descriptor + unit);
     }
 
-    return concat$l(parts);
+    return concat$m(parts);
   }));
 }
 
@@ -52738,7 +52750,7 @@ var syntaxAttribute = {
 const {
   builders,
   utils: {
-    mapDoc: mapDoc$3,
+    mapDoc: mapDoc$2,
     normalizeParts: normalizeParts$2
   }
 } = document;
@@ -52797,7 +52809,7 @@ const {
   printClassNames: printClassNames$1
 } = syntaxAttribute;
 
-function concat$m(parts) {
+function concat$n(parts) {
   const newParts = normalizeParts$2(parts);
   return newParts.length === 0 ? "" : newParts.length === 1 ? newParts[0] : builders.concat(newParts);
 }
@@ -52833,7 +52845,7 @@ function embed$4(path, print, textToDoc, options) {
             isEmpty = doc === "";
           }
 
-          return concat$m([printOpeningTagPrefix(node, options), group$k(printOpeningTag(path, options, print)), isEmpty ? "" : hardline$f, doc, isEmpty ? "" : hardline$f, printClosingTag(node, options), printClosingTagSuffix(node, options)]);
+          return concat$n([printOpeningTagPrefix(node, options), group$k(printOpeningTag(path, options, print)), isEmpty ? "" : hardline$f, doc, isEmpty ? "" : hardline$f, printClosingTag(node, options), printClosingTagSuffix(node, options)]);
         }
 
         break;
@@ -52863,12 +52875,12 @@ function embed$4(path, print, textToDoc, options) {
               textToDocOptions.__babelSourceType = sourceType;
             }
 
-            return builders.concat([concat$m([breakParent$7, printOpeningTagPrefix(node, options), textToDoc(value, textToDocOptions, {
+            return builders.concat([concat$n([breakParent$7, printOpeningTagPrefix(node, options), textToDoc(value, textToDocOptions, {
               stripTrailingHardline: true
             }), printClosingTagSuffix(node, options)])]);
           }
         } else if (node.parent.type === "interpolation") {
-          return concat$m([indent$e(concat$m([line$e, textToDoc(node.value, Object.assign({
+          return concat$n([indent$e(concat$n([line$e, textToDoc(node.value, Object.assign({
             __isInHtmlInterpolation: true
           }, options.parser === "angular" ? {
             parser: "__ng_interpolation",
@@ -52893,7 +52905,7 @@ function embed$4(path, print, textToDoc, options) {
 
 
         if (/^PRETTIER_HTML_PLACEHOLDER_\d+_\d+_IN_JS$/.test(options.originalText.slice(node.valueSpan.start.offset, node.valueSpan.end.offset))) {
-          return concat$m([node.rawName, "=", node.value]);
+          return concat$n([node.rawName, "=", node.value]);
         } // lwc: html`<my-element data-for={value}></my-element>`
 
 
@@ -52901,7 +52913,7 @@ function embed$4(path, print, textToDoc, options) {
           const interpolationRegex = /^{[\S\s]*}$/;
 
           if (interpolationRegex.test(options.originalText.slice(node.valueSpan.start.offset, node.valueSpan.end.offset))) {
-            return concat$m([node.rawName, "=", node.value]);
+            return concat$n([node.rawName, "=", node.value]);
           }
         }
 
@@ -52913,7 +52925,7 @@ function embed$4(path, print, textToDoc, options) {
         }), options);
 
         if (embeddedAttributeValueDoc) {
-          return concat$m([node.rawName, '="', group$k(mapDoc$3(embeddedAttributeValueDoc, doc => typeof doc === "string" ? doc.replace(/"/g, "&quot;") : doc)), '"']);
+          return concat$n([node.rawName, '="', group$k(mapDoc$2(embeddedAttributeValueDoc, doc => typeof doc === "string" ? doc.replace(/"/g, "&quot;") : doc)), '"']);
         }
 
         break;
@@ -52929,7 +52941,7 @@ function genericPrint$5(path, options, print) {
 
   switch (node.type) {
     case "front-matter":
-      return concat$m(replaceEndOfLineWith$2(node.raw, literalline$5));
+      return concat$n(replaceEndOfLineWith$2(node.raw, literalline$5));
 
     case "root":
       if (options.__onHtmlRoot) {
@@ -52943,7 +52955,7 @@ function genericPrint$5(path, options, print) {
     case "ieConditionalComment":
       {
         if (shouldPreserveContent$1(node, options)) {
-          return concat$m([].concat(printOpeningTagPrefix(node, options), group$k(printOpeningTag(path, options, print)), replaceEndOfLineWith$2(getNodeContent(node, options), literalline$5), printClosingTag(node, options), printClosingTagSuffix(node, options)));
+          return concat$n([].concat(printOpeningTagPrefix(node, options), group$k(printOpeningTag(path, options, print)), replaceEndOfLineWith$2(getNodeContent(node, options), literalline$5), printClosingTag(node, options), printClosingTagSuffix(node, options)));
         }
         /**
          * do not break:
@@ -52969,11 +52981,11 @@ function genericPrint$5(path, options, print) {
 
         const shouldHugContent = node.children.length === 1 && node.firstChild.type === "interpolation" && node.firstChild.isLeadingSpaceSensitive && !node.firstChild.hasLeadingSpaces && node.lastChild.isTrailingSpaceSensitive && !node.lastChild.hasTrailingSpaces;
         const attrGroupId = Symbol("element-attr-group-id");
-        return concat$m([group$k(concat$m([group$k(printOpeningTag(path, options, print), {
+        return concat$n([group$k(concat$n([group$k(printOpeningTag(path, options, print), {
           id: attrGroupId
-        }), node.children.length === 0 ? node.hasDanglingSpaces && node.isDanglingSpaceSensitive ? line$e : "" : concat$m([forceBreakContent$1(node) ? breakParent$7 : "", (childrenDoc => shouldHugContent ? ifBreak$a(indent$e(childrenDoc), childrenDoc, {
+        }), node.children.length === 0 ? node.hasDanglingSpaces && node.isDanglingSpaceSensitive ? line$e : "" : concat$n([forceBreakContent$1(node) ? breakParent$7 : "", (childrenDoc => shouldHugContent ? ifBreak$a(indent$e(childrenDoc), childrenDoc, {
           groupId: attrGroupId
-        }) : (isScriptLikeTag$1(node) || isVueCustomBlock$1(node, options)) && node.parent.type === "root" && options.parser === "vue" && !options.vueIndentScriptAndStyle ? childrenDoc : indent$e(childrenDoc))(concat$m([shouldHugContent ? ifBreak$a(softline$b, "", {
+        }) : (isScriptLikeTag$1(node) || isVueCustomBlock$1(node, options)) && node.parent.type === "root" && options.parser === "vue" && !options.vueIndentScriptAndStyle ? childrenDoc : indent$e(childrenDoc))(concat$n([shouldHugContent ? ifBreak$a(softline$b, "", {
           groupId: attrGroupId
         }) : node.firstChild.hasLeadingSpaces && node.firstChild.isLeadingSpaceSensitive ? line$e : node.firstChild.type === "text" && node.isWhitespaceSensitive && node.isIndentationSensitive ? dedentToRoot$2(softline$b) : softline$b, printChildren$2(path, options, print)])), (node.next ? needsToBorrowPrevClosingTagEndMarker(node.next) : needsToBorrowLastChildClosingTagEndMarker(node.parent)) ? node.lastChild.hasTrailingSpaces && node.lastChild.isTrailingSpaceSensitive ? " " : "" : shouldHugContent ? ifBreak$a(softline$b, "", {
           groupId: attrGroupId
@@ -52991,10 +53003,10 @@ function genericPrint$5(path, options, print) {
 
     case "ieConditionalStartComment":
     case "ieConditionalEndComment":
-      return concat$m([printOpeningTagStart(node), printClosingTagEnd(node)]);
+      return concat$n([printOpeningTagStart(node), printClosingTagEnd(node)]);
 
     case "interpolation":
-      return concat$m([printOpeningTagStart(node, options), concat$m(path.map(print, "children")), printClosingTagEnd(node, options)]);
+      return concat$n([printOpeningTagStart(node, options), concat$n(path.map(print, "children")), printClosingTagEnd(node, options)]);
 
     case "text":
       {
@@ -53003,18 +53015,18 @@ function genericPrint$5(path, options, print) {
           const trailingNewlineRegex = /\n[^\S\n]*?$/;
           const hasTrailingNewline = trailingNewlineRegex.test(node.value);
           const value = hasTrailingNewline ? node.value.replace(trailingNewlineRegex, "") : node.value;
-          return concat$m([concat$m(replaceEndOfLineWith$2(value, literalline$5)), hasTrailingNewline ? hardline$f : ""]);
+          return concat$n([concat$n(replaceEndOfLineWith$2(value, literalline$5)), hasTrailingNewline ? hardline$f : ""]);
         }
 
         return fill$6(normalizeParts$2([].concat(printOpeningTagPrefix(node, options), getTextValueParts(node), printClosingTagSuffix(node, options))));
       }
 
     case "docType":
-      return concat$m([group$k(concat$m([printOpeningTagStart(node, options), " ", node.value.replace(/^html\b/i, "html").replace(/\s+/g, " ")])), printClosingTagEnd(node, options)]);
+      return concat$n([group$k(concat$n([printOpeningTagStart(node, options), " ", node.value.replace(/^html\b/i, "html").replace(/\s+/g, " ")])), printClosingTagEnd(node, options)]);
 
     case "comment":
       {
-        return concat$m([printOpeningTagPrefix(node, options), concat$m(replaceEndOfLineWith$2(options.originalText.slice(options.locStart(node), options.locEnd(node)), literalline$5)), printClosingTagSuffix(node, options)]);
+        return concat$n([printOpeningTagPrefix(node, options), concat$n(replaceEndOfLineWith$2(options.originalText.slice(options.locStart(node), options.locEnd(node)), literalline$5)), printClosingTagSuffix(node, options)]);
       }
 
     case "attribute":
@@ -53027,7 +53039,7 @@ function genericPrint$5(path, options, print) {
         const singleQuoteCount = countChars$1(value, "'");
         const doubleQuoteCount = countChars$1(value, '"');
         const quote = singleQuoteCount < doubleQuoteCount ? "'" : '"';
-        return concat$m([node.rawName, concat$m(["=", quote, concat$m(replaceEndOfLineWith$2(quote === '"' ? value.replace(/"/g, "&quot;") : value.replace(/'/g, "&apos;"), literalline$5)), quote])]);
+        return concat$n([node.rawName, concat$n(["=", quote, concat$n(replaceEndOfLineWith$2(quote === '"' ? value.replace(/"/g, "&quot;") : value.replace(/'/g, "&apos;"), literalline$5)), quote])]);
       }
 
     default:
@@ -53040,15 +53052,15 @@ function printChildren$2(path, options, print) {
   const node = path.getValue();
 
   if (forceBreakChildren$1(node)) {
-    return concat$m([breakParent$7, concat$m(path.map(childPath => {
+    return concat$n([breakParent$7, concat$n(path.map(childPath => {
       const childNode = childPath.getValue();
       const prevBetweenLine = !childNode.prev ? "" : printBetweenLine(childNode.prev, childNode);
-      return concat$m([!prevBetweenLine ? "" : concat$m([prevBetweenLine, forceNextEmptyLine$1(childNode.prev) ? hardline$f : ""]), printChild(childPath)]);
+      return concat$n([!prevBetweenLine ? "" : concat$n([prevBetweenLine, forceNextEmptyLine$1(childNode.prev) ? hardline$f : ""]), printChild(childPath)]);
     }, "children"))]);
   }
 
   const groupIds = node.children.map(() => Symbol(""));
-  return concat$m(path.map((childPath, childIndex) => {
+  return concat$n(path.map((childPath, childIndex) => {
     const childNode = childPath.getValue();
 
     if (isTextLikeNode$1(childNode)) {
@@ -53057,10 +53069,10 @@ function printChildren$2(path, options, print) {
 
         if (prevBetweenLine) {
           if (forceNextEmptyLine$1(childNode.prev)) {
-            return concat$m([hardline$f, hardline$f, printChild(childPath)]);
+            return concat$n([hardline$f, hardline$f, printChild(childPath)]);
           }
 
-          return concat$m([prevBetweenLine, printChild(childPath)]);
+          return concat$n([prevBetweenLine, printChild(childPath)]);
         }
       }
 
@@ -53104,7 +53116,7 @@ function printChildren$2(path, options, print) {
       }
     }
 
-    return concat$m([].concat(prevParts, group$k(concat$m([concat$m(leadingParts), group$k(concat$m([printChild(childPath), concat$m(trailingParts)]), {
+    return concat$n([].concat(prevParts, group$k(concat$n([concat$n(leadingParts), group$k(concat$n([printChild(childPath), concat$n(trailingParts)]), {
       id: groupIds[childIndex]
     })])), nextParts));
   }, "children"));
@@ -53113,7 +53125,7 @@ function printChildren$2(path, options, print) {
     const child = childPath.getValue();
 
     if (hasPrettierIgnore$6(child)) {
-      return concat$m([].concat(printOpeningTagPrefix(child, options), replaceEndOfLineWith$2(options.originalText.slice(options.locStart(child) + (child.prev && needsToBorrowNextOpeningTagStartMarker(child.prev) ? printOpeningTagStartMarker(child).length : 0), options.locEnd(child) - (child.next && needsToBorrowPrevClosingTagEndMarker(child.next) ? printClosingTagEndMarker(child, options).length : 0)), literalline$5), printClosingTagSuffix(child, options)));
+      return concat$n([].concat(printOpeningTagPrefix(child, options), replaceEndOfLineWith$2(options.originalText.slice(options.locStart(child) + (child.prev && needsToBorrowNextOpeningTagStartMarker(child.prev) ? printOpeningTagStartMarker(child).length : 0), options.locEnd(child) - (child.next && needsToBorrowPrevClosingTagEndMarker(child.next) ? printClosingTagEndMarker(child, options).length : 0)), literalline$5), printClosingTagSuffix(child, options)));
     }
 
     return print(childPath);
@@ -53190,10 +53202,10 @@ function printAttributes(path, options, print) {
   const hasPrettierIgnoreAttribute = typeof ignoreAttributeData === "boolean" ? () => ignoreAttributeData : Array.isArray(ignoreAttributeData) ? attribute => ignoreAttributeData.includes(attribute.rawName) : () => false;
   const printedAttributes = path.map(attributePath => {
     const attribute = attributePath.getValue();
-    return hasPrettierIgnoreAttribute(attribute) ? concat$m(replaceEndOfLineWith$2(options.originalText.slice(options.locStart(attribute), options.locEnd(attribute)), literalline$5)) : print(attributePath);
+    return hasPrettierIgnoreAttribute(attribute) ? concat$n(replaceEndOfLineWith$2(options.originalText.slice(options.locStart(attribute), options.locEnd(attribute)), literalline$5)) : print(attributePath);
   }, "attrs");
   const forceNotToBreakAttrContent = node.type === "element" && node.fullName === "script" && node.attrs.length === 1 && node.attrs[0].fullName === "src" && node.children.length === 0;
-  const parts = [indent$e(concat$m([forceNotToBreakAttrContent ? " " : line$e, join$d(line$e, printedAttributes)]))];
+  const parts = [indent$e(concat$n([forceNotToBreakAttrContent ? " " : line$e, join$d(line$e, printedAttributes)]))];
 
   if (
   /**
@@ -53215,16 +53227,16 @@ function printAttributes(path, options, print) {
     parts.push(node.isSelfClosing ? line$e : softline$b);
   }
 
-  return concat$m(parts);
+  return concat$n(parts);
 }
 
 function printOpeningTag(path, options, print) {
   const node = path.getValue();
-  return concat$m([printOpeningTagStart(node, options), printAttributes(path, options, print), node.isSelfClosing ? "" : printOpeningTagEnd(node)]);
+  return concat$n([printOpeningTagStart(node, options), printAttributes(path, options, print), node.isSelfClosing ? "" : printOpeningTagEnd(node)]);
 }
 
 function printOpeningTagStart(node, options) {
-  return node.prev && needsToBorrowNextOpeningTagStartMarker(node.prev) ? "" : concat$m([printOpeningTagPrefix(node, options), printOpeningTagStartMarker(node)]);
+  return node.prev && needsToBorrowNextOpeningTagStartMarker(node.prev) ? "" : concat$n([printOpeningTagPrefix(node, options), printOpeningTagStartMarker(node)]);
 }
 
 function printOpeningTagEnd(node) {
@@ -53232,15 +53244,15 @@ function printOpeningTagEnd(node) {
 }
 
 function printClosingTag(node, options) {
-  return concat$m([node.isSelfClosing ? "" : printClosingTagStart(node, options), printClosingTagEnd(node, options)]);
+  return concat$n([node.isSelfClosing ? "" : printClosingTagStart(node, options), printClosingTagEnd(node, options)]);
 }
 
 function printClosingTagStart(node, options) {
-  return node.lastChild && needsToBorrowParentClosingTagStartMarker(node.lastChild) ? "" : concat$m([printClosingTagPrefix(node, options), printClosingTagStartMarker(node, options)]);
+  return node.lastChild && needsToBorrowParentClosingTagStartMarker(node.lastChild) ? "" : concat$n([printClosingTagPrefix(node, options), printClosingTagStartMarker(node, options)]);
 }
 
 function printClosingTagEnd(node, options) {
-  return (node.next ? needsToBorrowPrevClosingTagEndMarker(node.next) : needsToBorrowLastChildClosingTagEndMarker(node.parent)) ? "" : concat$m([printClosingTagEndMarker(node, options), printClosingTagSuffix(node, options)]);
+  return (node.next ? needsToBorrowPrevClosingTagEndMarker(node.next) : needsToBorrowLastChildClosingTagEndMarker(node.parent)) ? "" : concat$n([printClosingTagEndMarker(node, options), printClosingTagSuffix(node, options)]);
 }
 
 function needsToBorrowNextOpeningTagStartMarker(node) {
@@ -53435,7 +53447,7 @@ function printEmbeddedAttributeValue(node, originalTextToDoc, options) {
 
   const printHug = doc => group$k(doc);
 
-  const printExpand = (doc, canHaveTrailingWhitespace = true) => group$k(concat$m([indent$e(concat$m([softline$b, doc])), canHaveTrailingWhitespace ? softline$b : ""]));
+  const printExpand = (doc, canHaveTrailingWhitespace = true) => group$k(concat$n([indent$e(concat$n([softline$b, doc])), canHaveTrailingWhitespace ? softline$b : ""]));
 
   const printMaybeHug = doc => shouldHug ? printHug(doc) : printExpand(doc);
 
@@ -53580,20 +53592,20 @@ function printEmbeddedAttributeValue(node, originalTextToDoc, options) {
       const parts = [];
       value.split(interpolationRegex).forEach((part, index) => {
         if (index % 2 === 0) {
-          parts.push(concat$m(replaceEndOfLineWith$2(part, literalline$5)));
+          parts.push(concat$n(replaceEndOfLineWith$2(part, literalline$5)));
         } else {
           try {
-            parts.push(group$k(concat$m(["{{", indent$e(concat$m([line$e, ngTextToDoc(part, {
+            parts.push(group$k(concat$n(["{{", indent$e(concat$n([line$e, ngTextToDoc(part, {
               parser: "__ng_interpolation",
               __isInHtmlInterpolation: true // to avoid unexpected `}}`
 
             })])), line$e, "}}"])));
           } catch (e) {
-            parts.push("{{", concat$m(replaceEndOfLineWith$2(part, literalline$5)), "}}");
+            parts.push("{{", concat$n(replaceEndOfLineWith$2(part, literalline$5)), "}}");
           }
         }
       });
-      return group$k(concat$m(parts));
+      return group$k(concat$n(parts));
     }
   }
 
@@ -54039,7 +54051,7 @@ const docBuilders$2 = document.builders;
 const {
   conditionalGroup: conditionalGroup$4,
   breakParent: breakParent$8,
-  concat: concat$n,
+  concat: concat$o,
   dedent: dedent$3,
   dedentToRoot: dedentToRoot$3,
   fill: fill$7,
@@ -54116,22 +54128,22 @@ function genericPrint$6(path, options, print) {
   const tag = !node.tag ? "" : path.call(print, "tag");
   const anchor = !node.anchor ? "" : path.call(print, "anchor");
   const nextEmptyLine = isNode$1(node, ["mapping", "sequence", "comment", "directive", "mappingItem", "sequenceItem"]) && !isLastDescendantNode$1(path) ? printNextEmptyLine(path, options.originalText) : "";
-  return concat$n([node.type !== "mappingValue" && hasLeadingComments$1(node) ? concat$n([join$e(hardline$g, path.map(print, "leadingComments")), hardline$g]) : "", tag, tag && anchor ? " " : "", anchor, tag || anchor ? isNode$1(node, ["sequence", "mapping"]) && !hasMiddleComments$1(node) ? hardline$g : " " : "", hasMiddleComments$1(node) ? concat$n([node.middleComments.length === 1 ? "" : hardline$g, join$e(hardline$g, path.map(print, "middleComments")), hardline$g]) : "", hasPrettierIgnore$8(path) ? concat$n(replaceEndOfLineWith$3(options.originalText.slice(node.position.start.offset, node.position.end.offset).trimEnd(), literalline$6)) : group$l(_print(node, parentNode, path, options, print)), hasTrailingComment$5(node) && !isNode$1(node, ["document", "documentHead"]) ? lineSuffix$2(concat$n([node.type === "mappingValue" && !node.content ? "" : " ", parentNode.type === "mappingKey" && path.getParentNode(2).type === "mapping" && isInlineNode(node) ? "" : breakParent$8, path.call(print, "trailingComment")])) : "", nextEmptyLine, hasEndComments$1(node) && !isNode$1(node, ["documentHead", "documentBody"]) ? align$4(node.type === "sequenceItem" ? 2 : 0, concat$n([hardline$g, join$e(hardline$g, path.map(path => concat$n([isPreviousLineEmpty$3(options.originalText, path.getValue(), options.locStart) ? hardline$g : "", print(path)]), "endComments"))])) : ""]);
+  return concat$o([node.type !== "mappingValue" && hasLeadingComments$1(node) ? concat$o([join$e(hardline$g, path.map(print, "leadingComments")), hardline$g]) : "", tag, tag && anchor ? " " : "", anchor, tag || anchor ? isNode$1(node, ["sequence", "mapping"]) && !hasMiddleComments$1(node) ? hardline$g : " " : "", hasMiddleComments$1(node) ? concat$o([node.middleComments.length === 1 ? "" : hardline$g, join$e(hardline$g, path.map(print, "middleComments")), hardline$g]) : "", hasPrettierIgnore$8(path) ? concat$o(replaceEndOfLineWith$3(options.originalText.slice(node.position.start.offset, node.position.end.offset).trimEnd(), literalline$6)) : group$l(_print(node, parentNode, path, options, print)), hasTrailingComment$5(node) && !isNode$1(node, ["document", "documentHead"]) ? lineSuffix$2(concat$o([node.type === "mappingValue" && !node.content ? "" : " ", parentNode.type === "mappingKey" && path.getParentNode(2).type === "mapping" && isInlineNode(node) ? "" : breakParent$8, path.call(print, "trailingComment")])) : "", shouldPrintEndComments(node) ? align$4(node.type === "sequenceItem" ? 2 : 0, concat$o([hardline$g, join$e(hardline$g, path.map(path => concat$o([isPreviousLineEmpty$3(options.originalText, path.getValue(), options.locStart) ? hardline$g : "", print(path)]), "endComments"))])) : "", nextEmptyLine]);
 }
 
 function _print(node, parentNode, path, options, print) {
   switch (node.type) {
     case "root":
-      return concat$n([join$e(hardline$g, path.map((childPath, index) => {
+      return concat$o([join$e(hardline$g, path.map((childPath, index) => {
         const document = node.children[index];
         const nextDocument = node.children[index + 1];
-        return concat$n([print(childPath), shouldPrintDocumentEndMarker(document, nextDocument) ? concat$n([hardline$g, "...", hasTrailingComment$5(document) ? concat$n([" ", path.call(print, "trailingComment")]) : ""]) : !nextDocument || hasTrailingComment$5(nextDocument.head) ? "" : concat$n([hardline$g, "---"])]);
+        return concat$o([print(childPath), shouldPrintDocumentEndMarker(document, nextDocument) ? concat$o([hardline$g, "...", hasTrailingComment$5(document) ? concat$o([" ", path.call(print, "trailingComment")]) : ""]) : !nextDocument || hasTrailingComment$5(nextDocument.head) ? "" : concat$o([hardline$g, "---"])]);
       }, "children")), node.children.length === 0 || (lastDescendantNode => isNode$1(lastDescendantNode, ["blockLiteral", "blockFolded"]) && lastDescendantNode.chomping === "keep")(getLastDescendantNode$2(node)) ? "" : hardline$g]);
 
     case "document":
       {
         const nextDocument = parentNode.children[path.getName() + 1];
-        return join$e(hardline$g, [shouldPrintDocumentHeadEndMarker(node, nextDocument, parentNode, options) === "head" ? join$e(hardline$g, [node.head.children.length === 0 && node.head.endComments.length === 0 ? "" : path.call(print, "head"), concat$n(["---", hasTrailingComment$5(node.head) ? concat$n([" ", path.call(print, "head", "trailingComment")]) : ""])].filter(Boolean)) : "", shouldPrintDocumentBody(node) ? path.call(print, "body") : ""].filter(Boolean));
+        return join$e(hardline$g, [shouldPrintDocumentHeadEndMarker(node, nextDocument, parentNode, options) === "head" ? join$e(hardline$g, [node.head.children.length === 0 && node.head.endComments.length === 0 ? "" : path.call(print, "head"), concat$o(["---", hasTrailingComment$5(node.head) ? concat$o([" ", path.call(print, "head", "trailingComment")]) : ""])].filter(Boolean)) : "", shouldPrintDocumentBody(node) ? path.call(print, "body") : ""].filter(Boolean));
       }
 
     case "documentHead":
@@ -54143,24 +54155,24 @@ function _print(node, parentNode, path, options, print) {
         const endComments = join$e(hardline$g, path.map(print, "endComments")).parts;
         const separator = children.length === 0 || endComments.length === 0 ? "" : (lastDescendantNode => isNode$1(lastDescendantNode, ["blockFolded", "blockLiteral"]) ? lastDescendantNode.chomping === "keep" ? // there's already a newline printed at the end of blockValue (chomping=keep, lastDescendant=true)
         "" : // an extra newline for better readability
-        concat$n([hardline$g, hardline$g]) : hardline$g)(getLastDescendantNode$2(node));
-        return concat$n([].concat(children, separator, endComments));
+        concat$o([hardline$g, hardline$g]) : hardline$g)(getLastDescendantNode$2(node));
+        return concat$o([].concat(children, separator, endComments));
       }
 
     case "directive":
-      return concat$n(["%", join$e(" ", [node.name].concat(node.parameters))]);
+      return concat$o(["%", join$e(" ", [node.name].concat(node.parameters))]);
 
     case "comment":
-      return concat$n(["#", node.value]);
+      return concat$o(["#", node.value]);
 
     case "alias":
-      return concat$n(["*", node.value]);
+      return concat$o(["*", node.value]);
 
     case "tag":
       return options.originalText.slice(node.position.start.offset, node.position.end.offset);
 
     case "anchor":
-      return concat$n(["&", node.value]);
+      return concat$o(["&", node.value]);
 
     case "plain":
       return printFlowScalarContent(node.type, options.originalText.slice(node.position.start.offset, node.position.end.offset), options);
@@ -54176,19 +54188,19 @@ function _print(node, parentNode, path, options, print) {
           // only quoteDouble can use escape chars
           // and quoteSingle do not need to escape backslashes
           const originalQuote = node.type === "quoteDouble" ? doubleQuote : singleQuote;
-          return concat$n([originalQuote, printFlowScalarContent(node.type, raw, options), originalQuote]);
+          return concat$o([originalQuote, printFlowScalarContent(node.type, raw, options), originalQuote]);
         } else if (raw.includes(doubleQuote)) {
-          return concat$n([singleQuote, printFlowScalarContent(node.type, node.type === "quoteDouble" ? raw // double quote needs to be escaped by backslash in quoteDouble
+          return concat$o([singleQuote, printFlowScalarContent(node.type, node.type === "quoteDouble" ? raw // double quote needs to be escaped by backslash in quoteDouble
           .replace(/\\"/g, doubleQuote).replace(/'/g, singleQuote.repeat(2)) : raw, options), singleQuote]);
         }
 
         if (raw.includes(singleQuote)) {
-          return concat$n([doubleQuote, printFlowScalarContent(node.type, node.type === "quoteSingle" ? // single quote needs to be escaped by 2 single quotes in quoteSingle
+          return concat$o([doubleQuote, printFlowScalarContent(node.type, node.type === "quoteSingle" ? // single quote needs to be escaped by 2 single quotes in quoteSingle
           raw.replace(/''/g, singleQuote) : raw, options), doubleQuote]);
         }
 
         const quote = options.singleQuote ? singleQuote : doubleQuote;
-        return concat$n([quote, printFlowScalarContent(node.type, raw, options), quote]);
+        return concat$o([quote, printFlowScalarContent(node.type, raw, options), quote]);
       }
 
     case "blockFolded":
@@ -54196,7 +54208,7 @@ function _print(node, parentNode, path, options, print) {
       {
         const parentIndent = getAncestorCount$1(path, ancestorNode => isNode$1(ancestorNode, ["sequence", "mapping"]));
         const isLastDescendant = isLastDescendantNode$1(path);
-        return concat$n([node.type === "blockFolded" ? ">" : "|", node.indent === null ? "" : node.indent.toString(), node.chomping === "clip" ? "" : node.chomping === "keep" ? "+" : "-", hasIndicatorComment$1(node) ? concat$n([" ", path.call(print, "indicatorComment")]) : "", (node.indent === null ? dedent$3 : dedentToRoot$3)(align$4(node.indent === null ? options.tabWidth : node.indent - 1 + parentIndent, concat$n(getBlockValueLineContents$1(node, {
+        return concat$o([node.type === "blockFolded" ? ">" : "|", node.indent === null ? "" : node.indent.toString(), node.chomping === "clip" ? "" : node.chomping === "keep" ? "+" : "-", hasIndicatorComment$1(node) ? concat$o([" ", path.call(print, "indicatorComment")]) : "", (node.indent === null ? dedent$3 : dedentToRoot$3)(align$4(node.indent === null ? options.tabWidth : node.indent - 1 + parentIndent, concat$o(getBlockValueLineContents$1(node, {
           parentIndent,
           isLastDescendant,
           options
@@ -54207,7 +54219,7 @@ function _print(node, parentNode, path, options, print) {
       return join$e(hardline$g, path.map(print, "children"));
 
     case "sequenceItem":
-      return concat$n(["- ", align$4(2, !node.content ? "" : path.call(print, "content"))]);
+      return concat$o(["- ", align$4(2, !node.content ? "" : path.call(print, "content"))]);
 
     case "mappingKey":
       return !node.content ? "" : path.call(print, "content");
@@ -54225,26 +54237,26 @@ function _print(node, parentNode, path, options, print) {
         const isEmptyMappingValue = isEmptyNode$1(node.value);
 
         if (isEmptyMappingKey && isEmptyMappingValue) {
-          return concat$n([": "]);
+          return concat$o([": "]);
         }
 
         const key = path.call(print, "key");
         const value = path.call(print, "value");
 
         if (isEmptyMappingValue) {
-          return node.type === "flowMappingItem" && parentNode.type === "flowMapping" ? key : node.type === "mappingItem" && isAbsolutelyPrintedAsSingleLineNode(node.key.content, options) && !hasTrailingComment$5(node.key.content) && (!parentNode.tag || parentNode.tag.value !== "tag:yaml.org,2002:set") ? concat$n([key, needsSpaceInFrontOfMappingValue(node) ? " " : "", ":"]) : concat$n(["? ", align$4(2, key)]);
+          return node.type === "flowMappingItem" && parentNode.type === "flowMapping" ? key : node.type === "mappingItem" && isAbsolutelyPrintedAsSingleLineNode(node.key.content, options) && !hasTrailingComment$5(node.key.content) && (!parentNode.tag || parentNode.tag.value !== "tag:yaml.org,2002:set") ? concat$o([key, needsSpaceInFrontOfMappingValue(node) ? " " : "", ":"]) : concat$o(["? ", align$4(2, key)]);
         }
 
         if (isEmptyMappingKey) {
-          return concat$n([": ", align$4(2, value)]);
+          return concat$o([": ", align$4(2, value)]);
         }
 
         const groupId = Symbol("mappingKey");
         const forceExplicitKey = hasLeadingComments$1(node.value) || !isInlineNode(node.key.content);
-        return forceExplicitKey ? concat$n(["? ", align$4(2, key), hardline$g, join$e("", path.map(print, "value", "leadingComments").map(comment => concat$n([comment, hardline$g]))), ": ", align$4(2, value)]) : // force singleline
-        isSingleLineNode(node.key.content) && !hasLeadingComments$1(node.key.content) && !hasMiddleComments$1(node.key.content) && !hasTrailingComment$5(node.key.content) && !hasEndComments$1(node.key) && !hasLeadingComments$1(node.value.content) && !hasMiddleComments$1(node.value.content) && !hasEndComments$1(node.value) && isAbsolutelyPrintedAsSingleLineNode(node.value.content, options) ? concat$n([key, needsSpaceInFrontOfMappingValue(node) ? " " : "", ": ", value]) : conditionalGroup$4([concat$n([group$l(concat$n([ifBreak$b("? "), group$l(align$4(2, key), {
+        return forceExplicitKey ? concat$o(["? ", align$4(2, key), hardline$g, join$e("", path.map(print, "value", "leadingComments").map(comment => concat$o([comment, hardline$g]))), ": ", align$4(2, value)]) : // force singleline
+        isSingleLineNode(node.key.content) && !hasLeadingComments$1(node.key.content) && !hasMiddleComments$1(node.key.content) && !hasTrailingComment$5(node.key.content) && !hasEndComments$1(node.key) && !hasLeadingComments$1(node.value.content) && !hasMiddleComments$1(node.value.content) && !hasEndComments$1(node.value) && isAbsolutelyPrintedAsSingleLineNode(node.value.content, options) ? concat$o([key, needsSpaceInFrontOfMappingValue(node) ? " " : "", ": ", value]) : conditionalGroup$4([concat$o([group$l(concat$o([ifBreak$b("? "), group$l(align$4(2, key), {
           id: groupId
-        })])), ifBreak$b(concat$n([hardline$g, ": ", align$4(2, value)]), indent(concat$n([needsSpaceInFrontOfMappingValue(node) ? " " : "", ":", hasLeadingComments$1(node.value.content) || hasEndComments$1(node.value) && node.value.content && !isNode$1(node.value.content, ["mapping", "sequence"]) || parentNode.type === "mapping" && hasTrailingComment$5(node.key.content) && isInlineNode(node.value.content) || isNode$1(node.value.content, ["mapping", "sequence"]) && node.value.content.tag === null && node.value.content.anchor === null ? hardline$g : !node.value.content ? "" : line$f, value])), {
+        })])), ifBreak$b(concat$o([hardline$g, ": ", align$4(2, value)]), indent(concat$o([needsSpaceInFrontOfMappingValue(node) ? " " : "", ":", hasLeadingComments$1(node.value.content) || hasEndComments$1(node.value) && node.value.content && !isNode$1(node.value.content, ["mapping", "sequence"]) || parentNode.type === "mapping" && hasTrailingComment$5(node.key.content) && isInlineNode(node.value.content) || isNode$1(node.value.content, ["mapping", "sequence"]) && node.value.content.tag === null && node.value.content.anchor === null ? hardline$g : !node.value.content ? "" : line$f, value])), {
           groupId
         })])]);
       }
@@ -54258,7 +54270,7 @@ function _print(node, parentNode, path, options, print) {
 
         const isLastItemEmptyMappingItem = node.children.length !== 0 && (lastItem => lastItem.type === "flowMappingItem" && isEmptyNode$1(lastItem.key) && isEmptyNode$1(lastItem.value))(getLast$9(node.children));
 
-        return concat$n([openMarker, indent(concat$n([bracketSpacing, concat$n(path.map((childPath, index) => concat$n([print(childPath), index === node.children.length - 1 ? "" : concat$n([",", line$f, node.children[index].position.start.line !== node.children[index + 1].position.start.line ? printNextEmptyLine(childPath, options.originalText) : ""])]), "children")), ifBreak$b(",", "")])), isLastItemEmptyMappingItem ? "" : bracketSpacing, closeMarker]);
+        return concat$o([openMarker, indent(concat$o([bracketSpacing, concat$o(path.map((childPath, index) => concat$o([print(childPath), index === node.children.length - 1 ? "" : concat$o([",", line$f, node.children[index].position.start.line !== node.children[index + 1].position.start.line ? printNextEmptyLine(childPath, options.originalText) : ""])]), "children")), ifBreak$b(",", "")])), isLastItemEmptyMappingItem ? "" : bracketSpacing, closeMarker]);
       }
 
     case "flowSequenceItem":
@@ -54418,6 +54430,10 @@ function needsSpaceInFrontOfMappingValue(node) {
   return node.key.content && node.key.content.type === "alias";
 }
 
+function shouldPrintEndComments(node) {
+  return hasEndComments$1(node) && !isNode$1(node, ["documentHead", "documentBody"]);
+}
+
 function printNextEmptyLine(path, originalText) {
   const node = path.getValue();
   const root = path.stack[0];
@@ -54426,7 +54442,10 @@ function printNextEmptyLine(path, originalText) {
   if (!root.isNextEmptyLinePrintedChecklist[node.position.end.line]) {
     if (isNextLineEmpty$8(node, originalText)) {
       root.isNextEmptyLinePrintedChecklist[node.position.end.line] = true;
-      return softline$c;
+
+      if (!shouldPrintEndComments(path.getParentNode())) {
+        return softline$c;
+      }
     }
   }