prettier 2.7.1 → 2.8.0

package/index.js

@@ -6378,17 +6378,14 @@ var require_loc = __commonJS2({
   "src/language-js/loc.js"(exports2, module2) {
     "use strict";
     var isNonEmptyArray = require_is_non_empty_array();
-    function locStart(node, opts) {
-      const {
-        ignoreDecorators
-      } = opts || {};
-      if (!ignoreDecorators) {
-        const decorators = node.declaration && node.declaration.decorators || node.decorators;
-        if (isNonEmptyArray(decorators)) {
-          return locStart(decorators[0]);
-        }
+    function locStart(node) {
+      var _node$declaration$dec, _node$declaration;
+      const start = node.range ? node.range[0] : node.start;
+      const decorators = (_node$declaration$dec = (_node$declaration = node.declaration) === null || _node$declaration === void 0 ? void 0 : _node$declaration.decorators) !== null && _node$declaration$dec !== void 0 ? _node$declaration$dec : node.decorators;
+      if (isNonEmptyArray(decorators)) {
+        return Math.min(locStart(decorators[0]), start);
       }
-      return node.range ? node.range[0] : node.start;
+      return start;
     }
     function locEnd(node) {
       return node.range ? node.range[1] : node.end;
@@ -7347,7 +7344,7 @@ var require_parser = __commonJS2({
           error.message += "\n" + error.codeFrame;
           throw error;
         }
-        throw error.stack;
+        throw error;
       }
     }
     module2.exports = {
@@ -8480,6 +8477,9 @@ var require_range_util = __commonJS2({
         } else {
           break;
         }
+        if (resultStartNode === resultEndNode) {
+          break;
+        }
       }
       return {
         startNode: resultStartNode,
@@ -21722,7 +21722,7 @@ var require_utils7 = __commonJS2({
       return typeof result === "boolean" ? result : Object.values(node).some((value) => hasNode(value, fn));
     }
     function hasNakedLeftSide(node) {
-      return node.type === "AssignmentExpression" || node.type === "BinaryExpression" || node.type === "LogicalExpression" || node.type === "NGPipeExpression" || node.type === "ConditionalExpression" || isCallExpression(node) || isMemberExpression(node) || node.type === "SequenceExpression" || node.type === "TaggedTemplateExpression" || node.type === "BindExpression" || node.type === "UpdateExpression" && !node.prefix || node.type === "TSAsExpression" || node.type === "TSNonNullExpression";
+      return node.type === "AssignmentExpression" || node.type === "BinaryExpression" || node.type === "LogicalExpression" || node.type === "NGPipeExpression" || node.type === "ConditionalExpression" || isCallExpression(node) || isMemberExpression(node) || node.type === "SequenceExpression" || node.type === "TaggedTemplateExpression" || node.type === "BindExpression" || node.type === "UpdateExpression" && !node.prefix || isTSTypeExpression(node) || node.type === "TSNonNullExpression";
     }
     function getLeftSide(node) {
       var _ref2, _ref3, _ref4, _ref5, _ref6, _node$left;
@@ -21991,7 +21991,20 @@ var require_utils7 = __commonJS2({
       if (isMemberExpression(node)) {
         return isSimpleCallArgument(node.object, depth) && isSimpleCallArgument(node.property, depth);
       }
-      if (node.type === "UnaryExpression" && (node.operator === "!" || node.operator === "-")) {
+      const targetUnaryExpressionOperators = {
+        "!": true,
+        "-": true,
+        "+": true,
+        "~": true
+      };
+      if (node.type === "UnaryExpression" && targetUnaryExpressionOperators[node.operator]) {
+        return isSimpleCallArgument(node.argument, depth);
+      }
+      const targetUpdateExpressionOperators = {
+        "++": true,
+        "--": true
+      };
+      if (node.type === "UpdateExpression" && targetUpdateExpressionOperators[node.operator]) {
         return isSimpleCallArgument(node.argument, depth);
       }
       if (node.type === "TSNonNullExpression") {
@@ -22043,6 +22056,7 @@ var require_utils7 = __commonJS2({
           return node.object && startsWithNoLookaheadToken(node.object, forbidFunctionClassAndDoExpr);
         case "SequenceExpression":
           return startsWithNoLookaheadToken(node.expressions[0], forbidFunctionClassAndDoExpr);
+        case "TSSatisfiesExpression":
         case "TSAsExpression":
         case "TSNonNullExpression":
           return startsWithNoLookaheadToken(node.expression, forbidFunctionClassAndDoExpr);
@@ -22226,6 +22240,9 @@ var require_utils7 = __commonJS2({
       return Boolean(options.__isUsingHackPipeline);
     }
     var markerForIfWithoutBlockAndSameLineComment = Symbol("ifWithoutBlockAndSameLineComment");
+    function isTSTypeExpression(node) {
+      return node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression";
+    }
     module2.exports = {
       getFunctionParameters,
       iterateFunctionParametersPath,
@@ -22289,7 +22306,8 @@ var require_utils7 = __commonJS2({
       hasComment,
       getComments,
       CommentCheckFlags,
-      markerForIfWithoutBlockAndSameLineComment
+      markerForIfWithoutBlockAndSameLineComment,
+      isTSTypeExpression
     };
   }
 });
@@ -22324,7 +22342,8 @@ var require_template_literal = __commonJS2({
       isJestEachTemplateLiteral,
       isSimpleTemplateLiteral,
       hasComment,
-      isMemberExpression
+      isMemberExpression,
+      isTSTypeExpression
     } = require_utils7();
     function printTemplateLiteral(path, print, options) {
       const node = path.getValue();
@@ -22360,7 +22379,7 @@ var require_template_literal = __commonJS2({
           let printed = expressions[i];
           if (!isSimple) {
             const expression = node[expressionsKey][i];
-            if (hasComment(expression) || isMemberExpression(expression) || expression.type === "ConditionalExpression" || expression.type === "SequenceExpression" || expression.type === "TSAsExpression" || isBinaryish(expression)) {
+            if (hasComment(expression) || isMemberExpression(expression) || expression.type === "ConditionalExpression" || expression.type === "SequenceExpression" || isTSTypeExpression(expression) || isBinaryish(expression)) {
               printed = [indent([softline, printed]), softline];
             }
           }
@@ -22983,7 +23002,7 @@ var require_build = __commonJS2({
       };
     }
     var commentEndRe = /\*\/$/;
-    var commentStartRe = /^\/\*\*/;
+    var commentStartRe = /^\/\*\*?/;
     var docblockRe = /^\s*(\/\*\*?(.|\r?\n)*?\*\/)/;
     var lineCommentRe = /(^|\s+)\/\/([^\r\n]*)/g;
     var ltrimNewlineRe = /^(\r?\n)+/;
@@ -23036,7 +23055,7 @@ var require_build = __commonJS2({
       const start = " *";
       const tail = " */";
       const keys = Object.keys(pragmas);
-      const printedObject = keys.map((key) => printKeyValues(key, pragmas[key])).reduce((arr, next) => arr.concat(next), []).map((keyValue) => start + " " + keyValue + line).join("");
+      const printedObject = keys.map((key) => printKeyValues(key, pragmas[key])).reduce((arr, next) => arr.concat(next), []).map((keyValue) => `${start} ${keyValue}${line}`).join("");
       if (!comments) {
         if (keys.length === 0) {
           return "";
@@ -23708,7 +23727,8 @@ var require_needs_parens = __commonJS2({
       getPrecedence,
       isCallExpression,
       isMemberExpression,
-      isObjectProperty
+      isObjectProperty,
+      isTSTypeExpression
     } = require_utils7();
     function needsParens(path, options) {
       const parent = path.getParentNode();
@@ -23834,12 +23854,14 @@ var require_needs_parens = __commonJS2({
         }
         case "TSTypeAssertion":
         case "TSAsExpression":
+        case "TSSatisfiesExpression":
         case "LogicalExpression":
           switch (parent.type) {
+            case "TSSatisfiesExpression":
             case "TSAsExpression":
-              return node.type !== "TSAsExpression";
+              return !isTSTypeExpression(node);
             case "ConditionalExpression":
-              return node.type === "TSAsExpression";
+              return isTSTypeExpression(node);
             case "CallExpression":
             case "NewExpression":
             case "OptionalCallExpression":
@@ -23863,7 +23885,7 @@ var require_needs_parens = __commonJS2({
               return name === "object";
             case "AssignmentExpression":
             case "AssignmentPattern":
-              return name === "left" && (node.type === "TSTypeAssertion" || node.type === "TSAsExpression");
+              return name === "left" && (node.type === "TSTypeAssertion" || isTSTypeExpression(node));
             case "LogicalExpression":
               if (node.type === "LogicalExpression") {
                 return parent.operator !== node.operator;
@@ -23913,7 +23935,7 @@ var require_needs_parens = __commonJS2({
               return true;
           }
         case "YieldExpression":
-          if (parent.type === "UnaryExpression" || parent.type === "AwaitExpression" || parent.type === "TSAsExpression" || parent.type === "TSNonNullExpression") {
+          if (parent.type === "UnaryExpression" || parent.type === "AwaitExpression" || isTSTypeExpression(parent) || parent.type === "TSNonNullExpression") {
             return true;
           }
         case "AwaitExpression":
@@ -23924,6 +23946,7 @@ var require_needs_parens = __commonJS2({
             case "SpreadElement":
             case "SpreadProperty":
             case "TSAsExpression":
+            case "TSSatisfiesExpression":
             case "TSNonNullExpression":
             case "BindExpression":
               return true;
@@ -23951,6 +23974,12 @@ var require_needs_parens = __commonJS2({
           }
         case "TSFunctionType":
         case "TSConstructorType":
+          if (name === "extendsType" && parent.type === "TSConditionalType") {
+            const returnTypeAnnotation = (node.returnType || node.typeAnnotation).typeAnnotation;
+            if (returnTypeAnnotation.type === "TSInferType" && returnTypeAnnotation.typeParameter.constraint) {
+              return true;
+            }
+          }
           if (name === "checkType" && parent.type === "TSConditionalType") {
             return true;
           }
@@ -24034,6 +24063,7 @@ var require_needs_parens = __commonJS2({
             case "TSTypeAssertion":
             case "TypeCastExpression":
             case "TSAsExpression":
+            case "TSSatisfiesExpression":
             case "TSNonNullExpression":
               return true;
             case "NewExpression":
@@ -24071,6 +24101,7 @@ var require_needs_parens = __commonJS2({
             case "OptionalMemberExpression":
               return name === "object";
             case "TSAsExpression":
+            case "TSSatisfiesExpression":
             case "TSNonNullExpression":
             case "BindExpression":
             case "TaggedTemplateExpression":
@@ -24318,7 +24349,6 @@ var require_binaryish = __commonJS2({
         group,
         indent,
         align,
-        ifBreak,
         indentIfBreak
       },
       utils: {
@@ -24395,7 +24425,7 @@ var require_binaryish = __commonJS2({
       const shouldInline = shouldInlineLogicalExpression(node);
       const lineBeforeOperator = (node.operator === "|>" || node.type === "NGPipeExpression" || node.operator === "|" && options.parser === "__vue_expression") && !hasLeadingOwnLineComment(options.originalText, node.right);
       const operator = node.type === "NGPipeExpression" ? "|" : node.operator;
-      const rightSuffix = node.type === "NGPipeExpression" && node.arguments.length > 0 ? group(indent([softline, ": ", join([softline, ":", ifBreak(" ")], path.map(print, "arguments").map((arg) => align(2, group(arg))))])) : "";
+      const rightSuffix = node.type === "NGPipeExpression" && node.arguments.length > 0 ? group(indent([line, ": ", join([line, ": "], path.map(print, "arguments").map((arg) => align(2, group(arg))))])) : "";
       let right;
       if (shouldInline) {
         right = [operator, " ", print("right"), rightSuffix];
@@ -24794,14 +24824,26 @@ var require_jsx = __commonJS2({
       if (node.attributes && node.attributes.length === 1 && node.attributes[0].value && isStringLiteral(node.attributes[0].value) && !node.attributes[0].value.value.includes("\n") && !nameHasComments && !hasComment(node.attributes[0])) {
         return group(["<", print("name"), print("typeParameters"), " ", ...path.map(print, "attributes"), node.selfClosing ? " />" : ">"]);
       }
-      const lastAttrHasTrailingComments = node.attributes.length > 0 && hasComment(getLast(node.attributes), CommentCheckFlags.Trailing);
-      const bracketSameLine = node.attributes.length === 0 && !nameHasComments || (options.bracketSameLine || options.jsxBracketSameLine) && (!nameHasComments || node.attributes.length > 0) && !lastAttrHasTrailingComments;
       const shouldBreak = node.attributes && node.attributes.some((attr) => attr.value && isStringLiteral(attr.value) && attr.value.value.includes("\n"));
       const attributeLine = options.singleAttributePerLine && node.attributes.length > 1 ? hardline : line;
-      return group(["<", print("name"), print("typeParameters"), indent(path.map(() => [attributeLine, print()], "attributes")), node.selfClosing ? line : bracketSameLine ? ">" : softline, node.selfClosing ? "/>" : bracketSameLine ? "" : ">"], {
+      return group(["<", print("name"), print("typeParameters"), indent(path.map(() => [attributeLine, print()], "attributes")), ...printEndOfOpeningTag(node, options, nameHasComments)], {
         shouldBreak
       });
     }
+    function printEndOfOpeningTag(node, options, nameHasComments) {
+      if (node.selfClosing) {
+        return [line, "/>"];
+      }
+      const bracketSameLine = shouldPrintBracketSameLine(node, options, nameHasComments);
+      if (bracketSameLine) {
+        return [">"];
+      }
+      return [softline, ">"];
+    }
+    function shouldPrintBracketSameLine(node, options, nameHasComments) {
+      const lastAttrHasTrailingComments = node.attributes.length > 0 && hasComment(getLast(node.attributes), CommentCheckFlags.Trailing);
+      return node.attributes.length === 0 && !nameHasComments || (options.bracketSameLine || options.jsxBracketSameLine) && (!nameHasComments || node.attributes.length > 0) && !lastAttrHasTrailingComments;
+    }
     function printJsxClosingElement(path, options, print) {
       const node = path.getValue();
       const parts = [];
@@ -24928,6 +24970,546 @@ var require_jsx = __commonJS2({
     };
   }
 });
+var require_doc_builders = __commonJS2({
+  "src/document/doc-builders.js"(exports2, module2) {
+    "use strict";
+    function concat(parts) {
+      if (false) {
+        for (const part of parts) {
+          assertDoc(part);
+        }
+      }
+      return {
+        type: "concat",
+        parts
+      };
+    }
+    function indent(contents) {
+      if (false) {
+        assertDoc(contents);
+      }
+      return {
+        type: "indent",
+        contents
+      };
+    }
+    function align(widthOrString, contents) {
+      if (false) {
+        assertDoc(contents);
+      }
+      return {
+        type: "align",
+        contents,
+        n: widthOrString
+      };
+    }
+    function group(contents, opts = {}) {
+      if (false) {
+        assertDoc(contents);
+      }
+      return {
+        type: "group",
+        id: opts.id,
+        contents,
+        break: Boolean(opts.shouldBreak),
+        expandedStates: opts.expandedStates
+      };
+    }
+    function dedentToRoot(contents) {
+      return align(Number.NEGATIVE_INFINITY, contents);
+    }
+    function markAsRoot(contents) {
+      return align({
+        type: "root"
+      }, contents);
+    }
+    function dedent(contents) {
+      return align(-1, contents);
+    }
+    function conditionalGroup(states, opts) {
+      return group(states[0], Object.assign(Object.assign({}, opts), {}, {
+        expandedStates: states
+      }));
+    }
+    function fill(parts) {
+      if (false) {
+        for (const part of parts) {
+          assertDoc(part);
+        }
+      }
+      return {
+        type: "fill",
+        parts
+      };
+    }
+    function ifBreak(breakContents, flatContents, opts = {}) {
+      if (false) {
+        if (breakContents) {
+          assertDoc(breakContents);
+        }
+        if (flatContents) {
+          assertDoc(flatContents);
+        }
+      }
+      return {
+        type: "if-break",
+        breakContents,
+        flatContents,
+        groupId: opts.groupId
+      };
+    }
+    function indentIfBreak(contents, opts) {
+      return {
+        type: "indent-if-break",
+        contents,
+        groupId: opts.groupId,
+        negate: opts.negate
+      };
+    }
+    function lineSuffix(contents) {
+      if (false) {
+        assertDoc(contents);
+      }
+      return {
+        type: "line-suffix",
+        contents
+      };
+    }
+    var lineSuffixBoundary = {
+      type: "line-suffix-boundary"
+    };
+    var breakParent = {
+      type: "break-parent"
+    };
+    var trim = {
+      type: "trim"
+    };
+    var hardlineWithoutBreakParent = {
+      type: "line",
+      hard: true
+    };
+    var literallineWithoutBreakParent = {
+      type: "line",
+      hard: true,
+      literal: true
+    };
+    var line = {
+      type: "line"
+    };
+    var softline = {
+      type: "line",
+      soft: true
+    };
+    var hardline = concat([hardlineWithoutBreakParent, breakParent]);
+    var literalline = concat([literallineWithoutBreakParent, breakParent]);
+    var cursor = {
+      type: "cursor",
+      placeholder: Symbol("cursor")
+    };
+    function join(sep, arr) {
+      const res = [];
+      for (let i = 0; i < arr.length; i++) {
+        if (i !== 0) {
+          res.push(sep);
+        }
+        res.push(arr[i]);
+      }
+      return concat(res);
+    }
+    function addAlignmentToDoc(doc2, size, tabWidth) {
+      let aligned = doc2;
+      if (size > 0) {
+        for (let i = 0; i < Math.floor(size / tabWidth); ++i) {
+          aligned = indent(aligned);
+        }
+        aligned = align(size % tabWidth, aligned);
+        aligned = align(Number.NEGATIVE_INFINITY, aligned);
+      }
+      return aligned;
+    }
+    function label(label2, contents) {
+      return {
+        type: "label",
+        label: label2,
+        contents
+      };
+    }
+    module2.exports = {
+      concat,
+      join,
+      line,
+      softline,
+      hardline,
+      literalline,
+      group,
+      conditionalGroup,
+      fill,
+      lineSuffix,
+      lineSuffixBoundary,
+      cursor,
+      breakParent,
+      ifBreak,
+      trim,
+      indent,
+      indentIfBreak,
+      align,
+      addAlignmentToDoc,
+      markAsRoot,
+      dedentToRoot,
+      dedent,
+      hardlineWithoutBreakParent,
+      literallineWithoutBreakParent,
+      label
+    };
+  }
+});
+var require_doc_utils = __commonJS2({
+  "src/document/doc-utils.js"(exports2, module2) {
+    "use strict";
+    var getLast = require_get_last();
+    var {
+      literalline,
+      join
+    } = require_doc_builders();
+    var isConcat = (doc2) => Array.isArray(doc2) || doc2 && doc2.type === "concat";
+    var getDocParts = (doc2) => {
+      if (Array.isArray(doc2)) {
+        return doc2;
+      }
+      if (doc2.type !== "concat" && doc2.type !== "fill") {
+        throw new Error("Expect doc type to be `concat` or `fill`.");
+      }
+      return doc2.parts;
+    };
+    var traverseDocOnExitStackMarker = {};
+    function traverseDoc(doc2, onEnter, onExit, shouldTraverseConditionalGroups) {
+      const docsStack = [doc2];
+      while (docsStack.length > 0) {
+        const doc3 = docsStack.pop();
+        if (doc3 === traverseDocOnExitStackMarker) {
+          onExit(docsStack.pop());
+          continue;
+        }
+        if (onExit) {
+          docsStack.push(doc3, traverseDocOnExitStackMarker);
+        }
+        if (!onEnter || onEnter(doc3) !== false) {
+          if (isConcat(doc3) || doc3.type === "fill") {
+            const parts = getDocParts(doc3);
+            for (let ic = parts.length, i = ic - 1; i >= 0; --i) {
+              docsStack.push(parts[i]);
+            }
+          } else if (doc3.type === "if-break") {
+            if (doc3.flatContents) {
+              docsStack.push(doc3.flatContents);
+            }
+            if (doc3.breakContents) {
+              docsStack.push(doc3.breakContents);
+            }
+          } else if (doc3.type === "group" && doc3.expandedStates) {
+            if (shouldTraverseConditionalGroups) {
+              for (let ic = doc3.expandedStates.length, i = ic - 1; i >= 0; --i) {
+                docsStack.push(doc3.expandedStates[i]);
+              }
+            } else {
+              docsStack.push(doc3.contents);
+            }
+          } else if (doc3.contents) {
+            docsStack.push(doc3.contents);
+          }
+        }
+      }
+    }
+    function mapDoc(doc2, cb) {
+      const mapped = /* @__PURE__ */ new Map();
+      return rec(doc2);
+      function rec(doc3) {
+        if (mapped.has(doc3)) {
+          return mapped.get(doc3);
+        }
+        const result = process2(doc3);
+        mapped.set(doc3, result);
+        return result;
+      }
+      function process2(doc3) {
+        if (Array.isArray(doc3)) {
+          return cb(doc3.map(rec));
+        }
+        if (doc3.type === "concat" || doc3.type === "fill") {
+          const parts = doc3.parts.map(rec);
+          return cb(Object.assign(Object.assign({}, doc3), {}, {
+            parts
+          }));
+        }
+        if (doc3.type === "if-break") {
+          const breakContents = doc3.breakContents && rec(doc3.breakContents);
+          const flatContents = doc3.flatContents && rec(doc3.flatContents);
+          return cb(Object.assign(Object.assign({}, doc3), {}, {
+            breakContents,
+            flatContents
+          }));
+        }
+        if (doc3.type === "group" && doc3.expandedStates) {
+          const expandedStates = doc3.expandedStates.map(rec);
+          const contents = expandedStates[0];
+          return cb(Object.assign(Object.assign({}, doc3), {}, {
+            contents,
+            expandedStates
+          }));
+        }
+        if (doc3.contents) {
+          const contents = rec(doc3.contents);
+          return cb(Object.assign(Object.assign({}, doc3), {}, {
+            contents
+          }));
+        }
+        return cb(doc3);
+      }
+    }
+    function findInDoc(doc2, fn, defaultValue) {
+      let result = defaultValue;
+      let hasStopped = false;
+      function findInDocOnEnterFn(doc3) {
+        const maybeResult = fn(doc3);
+        if (maybeResult !== void 0) {
+          hasStopped = true;
+          result = maybeResult;
+        }
+        if (hasStopped) {
+          return false;
+        }
+      }
+      traverseDoc(doc2, findInDocOnEnterFn);
+      return result;
+    }
+    function willBreakFn(doc2) {
+      if (doc2.type === "group" && doc2.break) {
+        return true;
+      }
+      if (doc2.type === "line" && doc2.hard) {
+        return true;
+      }
+      if (doc2.type === "break-parent") {
+        return true;
+      }
+    }
+    function willBreak(doc2) {
+      return findInDoc(doc2, willBreakFn, false);
+    }
+    function breakParentGroup(groupStack) {
+      if (groupStack.length > 0) {
+        const parentGroup = getLast(groupStack);
+        if (!parentGroup.expandedStates && !parentGroup.break) {
+          parentGroup.break = "propagated";
+        }
+      }
+      return null;
+    }
+    function propagateBreaks(doc2) {
+      const alreadyVisitedSet = /* @__PURE__ */ new Set();
+      const groupStack = [];
+      function propagateBreaksOnEnterFn(doc3) {
+        if (doc3.type === "break-parent") {
+          breakParentGroup(groupStack);
+        }
+        if (doc3.type === "group") {
+          groupStack.push(doc3);
+          if (alreadyVisitedSet.has(doc3)) {
+            return false;
+          }
+          alreadyVisitedSet.add(doc3);
+        }
+      }
+      function propagateBreaksOnExitFn(doc3) {
+        if (doc3.type === "group") {
+          const group = groupStack.pop();
+          if (group.break) {
+            breakParentGroup(groupStack);
+          }
+        }
+      }
+      traverseDoc(doc2, propagateBreaksOnEnterFn, propagateBreaksOnExitFn, true);
+    }
+    function removeLinesFn(doc2) {
+      if (doc2.type === "line" && !doc2.hard) {
+        return doc2.soft ? "" : " ";
+      }
+      if (doc2.type === "if-break") {
+        return doc2.flatContents || "";
+      }
+      return doc2;
+    }
+    function removeLines(doc2) {
+      return mapDoc(doc2, removeLinesFn);
+    }
+    var isHardline = (doc2, nextDoc) => doc2 && doc2.type === "line" && doc2.hard && nextDoc && nextDoc.type === "break-parent";
+    function stripDocTrailingHardlineFromDoc(doc2) {
+      if (!doc2) {
+        return doc2;
+      }
+      if (isConcat(doc2) || doc2.type === "fill") {
+        const parts = getDocParts(doc2);
+        while (parts.length > 1 && isHardline(...parts.slice(-2))) {
+          parts.length -= 2;
+        }
+        if (parts.length > 0) {
+          const lastPart = stripDocTrailingHardlineFromDoc(getLast(parts));
+          parts[parts.length - 1] = lastPart;
+        }
+        return Array.isArray(doc2) ? parts : Object.assign(Object.assign({}, doc2), {}, {
+          parts
+        });
+      }
+      switch (doc2.type) {
+        case "align":
+        case "indent":
+        case "indent-if-break":
+        case "group":
+        case "line-suffix":
+        case "label": {
+          const contents = stripDocTrailingHardlineFromDoc(doc2.contents);
+          return Object.assign(Object.assign({}, doc2), {}, {
+            contents
+          });
+        }
+        case "if-break": {
+          const breakContents = stripDocTrailingHardlineFromDoc(doc2.breakContents);
+          const flatContents = stripDocTrailingHardlineFromDoc(doc2.flatContents);
+          return Object.assign(Object.assign({}, doc2), {}, {
+            breakContents,
+            flatContents
+          });
+        }
+      }
+      return doc2;
+    }
+    function stripTrailingHardline(doc2) {
+      return stripDocTrailingHardlineFromDoc(cleanDoc(doc2));
+    }
+    function cleanDocFn(doc2) {
+      switch (doc2.type) {
+        case "fill":
+          if (doc2.parts.every((part) => part === "")) {
+            return "";
+          }
+          break;
+        case "group":
+          if (!doc2.contents && !doc2.id && !doc2.break && !doc2.expandedStates) {
+            return "";
+          }
+          if (doc2.contents.type === "group" && doc2.contents.id === doc2.id && doc2.contents.break === doc2.break && doc2.contents.expandedStates === doc2.expandedStates) {
+            return doc2.contents;
+          }
+          break;
+        case "align":
+        case "indent":
+        case "indent-if-break":
+        case "line-suffix":
+          if (!doc2.contents) {
+            return "";
+          }
+          break;
+        case "if-break":
+          if (!doc2.flatContents && !doc2.breakContents) {
+            return "";
+          }
+          break;
+      }
+      if (!isConcat(doc2)) {
+        return doc2;
+      }
+      const parts = [];
+      for (const part of getDocParts(doc2)) {
+        if (!part) {
+          continue;
+        }
+        const [currentPart, ...restParts] = isConcat(part) ? getDocParts(part) : [part];
+        if (typeof currentPart === "string" && typeof getLast(parts) === "string") {
+          parts[parts.length - 1] += currentPart;
+        } else {
+          parts.push(currentPart);
+        }
+        parts.push(...restParts);
+      }
+      if (parts.length === 0) {
+        return "";
+      }
+      if (parts.length === 1) {
+        return parts[0];
+      }
+      return Array.isArray(doc2) ? parts : Object.assign(Object.assign({}, doc2), {}, {
+        parts
+      });
+    }
+    function cleanDoc(doc2) {
+      return mapDoc(doc2, (currentDoc) => cleanDocFn(currentDoc));
+    }
+    function normalizeParts(parts) {
+      const newParts = [];
+      const restParts = parts.filter(Boolean);
+      while (restParts.length > 0) {
+        const part = restParts.shift();
+        if (!part) {
+          continue;
+        }
+        if (isConcat(part)) {
+          restParts.unshift(...getDocParts(part));
+          continue;
+        }
+        if (newParts.length > 0 && typeof getLast(newParts) === "string" && typeof part === "string") {
+          newParts[newParts.length - 1] += part;
+          continue;
+        }
+        newParts.push(part);
+      }
+      return newParts;
+    }
+    function normalizeDoc(doc2) {
+      return mapDoc(doc2, (currentDoc) => {
+        if (Array.isArray(currentDoc)) {
+          return normalizeParts(currentDoc);
+        }
+        if (!currentDoc.parts) {
+          return currentDoc;
+        }
+        return Object.assign(Object.assign({}, currentDoc), {}, {
+          parts: normalizeParts(currentDoc.parts)
+        });
+      });
+    }
+    function replaceEndOfLine(doc2) {
+      return mapDoc(doc2, (currentDoc) => typeof currentDoc === "string" && currentDoc.includes("\n") ? replaceTextEndOfLine(currentDoc) : currentDoc);
+    }
+    function replaceTextEndOfLine(text, replacement = literalline) {
+      return join(replacement, text.split("\n")).parts;
+    }
+    function canBreakFn(doc2) {
+      if (doc2.type === "line") {
+        return true;
+      }
+    }
+    function canBreak(doc2) {
+      return findInDoc(doc2, canBreakFn, false);
+    }
+    module2.exports = {
+      isConcat,
+      getDocParts,
+      willBreak,
+      traverseDoc,
+      findInDoc,
+      mapDoc,
+      propagateBreaks,
+      removeLines,
+      stripTrailingHardline,
+      normalizeParts,
+      normalizeDoc,
+      cleanDoc,
+      replaceTextEndOfLine,
+      replaceEndOfLine,
+      canBreak
+    };
+  }
+});
 var require_misc = __commonJS2({
   "src/language-js/print/misc.js"(exports2, module2) {
     "use strict";
@@ -25147,7 +25729,8 @@ var require_call_arguments = __commonJS2({
       isNextLineEmpty,
       isCallExpression,
       isStringLiteral,
-      isObjectProperty
+      isObjectProperty,
+      isTSTypeExpression
     } = require_utils7();
     var {
       builders: {
@@ -25251,7 +25834,7 @@ var require_call_arguments = __commonJS2({
       });
     }
     function couldGroupArg(arg, arrowChainRecursion = false) {
-      return arg.type === "ObjectExpression" && (arg.properties.length > 0 || hasComment(arg)) || arg.type === "ArrayExpression" && (arg.elements.length > 0 || hasComment(arg)) || arg.type === "TSTypeAssertion" && couldGroupArg(arg.expression) || arg.type === "TSAsExpression" && couldGroupArg(arg.expression) || arg.type === "FunctionExpression" || arg.type === "ArrowFunctionExpression" && (!arg.returnType || !arg.returnType.typeAnnotation || arg.returnType.typeAnnotation.type !== "TSTypeReference" || isNonEmptyBlockStatement(arg.body)) && (arg.body.type === "BlockStatement" || arg.body.type === "ArrowFunctionExpression" && couldGroupArg(arg.body, true) || arg.body.type === "ObjectExpression" || arg.body.type === "ArrayExpression" || !arrowChainRecursion && (isCallExpression(arg.body) || arg.body.type === "ConditionalExpression") || isJsxNode(arg.body)) || arg.type === "DoExpression" || arg.type === "ModuleExpression";
+      return arg.type === "ObjectExpression" && (arg.properties.length > 0 || hasComment(arg)) || arg.type === "ArrayExpression" && (arg.elements.length > 0 || hasComment(arg)) || arg.type === "TSTypeAssertion" && couldGroupArg(arg.expression) || isTSTypeExpression(arg) && couldGroupArg(arg.expression) || arg.type === "FunctionExpression" || arg.type === "ArrowFunctionExpression" && (!arg.returnType || !arg.returnType.typeAnnotation || arg.returnType.typeAnnotation.type !== "TSTypeReference" || isNonEmptyBlockStatement(arg.body)) && (arg.body.type === "BlockStatement" || arg.body.type === "ArrowFunctionExpression" && couldGroupArg(arg.body, true) || arg.body.type === "ObjectExpression" || arg.body.type === "ArrayExpression" || !arrowChainRecursion && (isCallExpression(arg.body) || arg.body.type === "ConditionalExpression") || isJsxNode(arg.body)) || arg.type === "DoExpression" || arg.type === "ModuleExpression";
     }
     function shouldGroupLastArg(args, options) {
       const lastArg = getLast(args);
@@ -26766,9 +27349,7 @@ var require_decorators = __commonJS2({
         return false;
       }
       const decorators = node.declaration && node.declaration.decorators;
-      return isNonEmptyArray(decorators) && locStart(node, {
-        ignoreDecorators: true
-      }) > locStart(decorators[0]);
+      return isNonEmptyArray(decorators) && locStart(node) === locStart(decorators[0]);
     }
     module2.exports = {
       printDecorators,
@@ -27438,6 +28019,9 @@ var require_flow = __commonJS2({
       locStart,
       locEnd
     } = require_loc();
+    var {
+      replaceTextEndOfLine
+    } = require_doc_utils();
     var {
       printClass
     } = require_class();
@@ -27618,7 +28202,7 @@ var require_flow = __commonJS2({
         case "QualifiedTypeIdentifier":
           return [print("qualification"), ".", print("id")];
         case "StringLiteralTypeAnnotation":
-          return printString(rawText(node), options);
+          return replaceTextEndOfLine(printString(rawText(node), options));
         case "NumberLiteralTypeAnnotation":
           assert.strictEqual(typeof node.value, "number");
         case "BigIntLiteralTypeAnnotation":
@@ -27719,7 +28303,8 @@ var require_ternary = __commonJS2({
       isJsxNode,
       getComments,
       isCallExpression,
-      isMemberExpression
+      isMemberExpression,
+      isTSTypeExpression
     } = require_utils7();
     var {
       locStart,
@@ -27779,7 +28364,7 @@ var require_ternary = __commonJS2({
           child = node2;
           continue;
         }
-        if (node2.type === "NewExpression" && node2.callee === child || node2.type === "TSAsExpression" && node2.expression === child) {
+        if (node2.type === "NewExpression" && node2.callee === child || isTSTypeExpression(node2) && node2.expression === child) {
           parent = path.getParentNode(ancestorCount + 1);
           child = node2;
         } else {
@@ -28260,8 +28845,10 @@ var require_typescript = __commonJS2({
           return printTypeParameters(path, options, print, "params");
         case "TSTypeParameter":
           return printTypeParameter(path, options, print);
+        case "TSSatisfiesExpression":
         case "TSAsExpression": {
-          parts.push(print("expression"), " as ", print("typeAnnotation"));
+          const operator = node.type === "TSAsExpression" ? "as" : "satisfies";
+          parts.push(print("expression"), ` ${operator} `, print("typeAnnotation"));
           const parent = path.getParentNode();
           if (isCallExpression(parent) && parent.callee === node || isMemberExpression(parent) && parent.object === node) {
             return group([indent([softline, ...parts]), softline]);
@@ -28534,6 +29121,9 @@ var require_literal = __commonJS2({
       printString,
       printNumber
     } = require_util();
+    var {
+      replaceTextEndOfLine
+    } = require_doc_utils();
     function printLiteral(path, options) {
       const node = path.getNode();
       switch (node.type) {
@@ -28544,7 +29134,7 @@ var require_literal = __commonJS2({
         case "NumericLiteral":
           return printNumber(node.extra.raw);
         case "StringLiteral":
-          return printString(node.extra.raw, options);
+          return replaceTextEndOfLine(printString(node.extra.raw, options));
         case "NullLiteral":
           return "null";
         case "BooleanLiteral":
@@ -28568,7 +29158,7 @@ var require_literal = __commonJS2({
             return printNumber(node.raw);
           }
           if (typeof value === "string") {
-            return printString(node.raw, options);
+            return replaceTextEndOfLine(printString(node.raw, options));
           }
           return String(value);
         }
@@ -30661,7 +31251,8 @@ var require_printer_postcss = __commonJS2({
           return [".", adjustNumbers(adjustStrings(node.value, options))];
         }
         case "selector-attribute": {
-          return ["[", node.namespace ? [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" : "", "]"];
+          var _node$operator;
+          return ["[", node.namespace ? [node.namespace === true ? "" : node.namespace.trim(), "|"] : "", node.attribute.trim(), (_node$operator = node.operator) !== null && _node$operator !== void 0 ? _node$operator : "", node.value ? quoteAttributeValue(adjustStrings(node.value.trim(), options), options) : "", node.insensitive ? " i" : "", "]"];
         }
         case "selector-combinator": {
           if (node.value === "+" || node.value === ">" || node.value === "~" || node.value === ">>>") {
@@ -30677,7 +31268,7 @@ var require_printer_postcss = __commonJS2({
           return [node.namespace ? [node.namespace === true ? "" : node.namespace.trim(), "|"] : "", node.value];
         }
         case "selector-pseudo": {
-          return [maybeToLowerCase(node.value), isNonEmptyArray(node.nodes) ? ["(", join(", ", path.map(print, "nodes")), ")"] : ""];
+          return [maybeToLowerCase(node.value), isNonEmptyArray(node.nodes) ? group(["(", indent([softline, join([",", line], path.map(print, "nodes"))]), softline, ")"]) : ""];
         }
         case "selector-nesting": {
           return node.value;
@@ -30723,6 +31314,7 @@ var require_printer_postcss = __commonJS2({
           let insideSCSSInterpolationInString = false;
           let didBreak = false;
           for (let i = 0; i < node.groups.length; ++i) {
+            var _iNode$value;
             parts.push(printed[i]);
             const iPrevNode = node.groups[i - 1];
             const iNode = node.groups[i];
@@ -30839,6 +31431,9 @@ var require_printer_postcss = __commonJS2({
               parts.push(" ");
               continue;
             }
+            if ((_iNode$value = iNode.value) !== null && _iNode$value !== void 0 && _iNode$value.endsWith("#") && iNextNode.value === "{" && isParenGroupNode(iNextNode.group)) {
+              continue;
+            }
             parts.push(line);
           }
           if (hasInlineComment) {
@@ -31311,9 +31906,9 @@ var require_printer_glimmer = __commonJS2({
         }
         case "BlockStatement": {
           const pp = path.getParentNode(1);
-          const isElseIf = pp && pp.inverse && pp.inverse.body.length === 1 && pp.inverse.body[0] === node && pp.inverse.body[0].path.parts[0] === "if";
-          if (isElseIf) {
-            return [printElseIfBlock(path, print2), printProgram(path, print2, options), printInverse(path, print2, options)];
+          const isElseIfLike = pp && pp.inverse && pp.inverse.body.length === 1 && pp.inverse.body[0] === node && pp.inverse.body[0].path.parts[0] === pp.path.parts[0];
+          if (isElseIfLike) {
+            return [printElseIfLikeBlock(path, print2, pp.inverse.body[0].path.parts[0]), printProgram(path, print2, options), printInverse(path, print2, options)];
           }
           return [printOpenBlock(path, print2), group([printProgram(path, print2, options), printInverse(path, print2, options), printCloseBlock(path, print2, options)])];
         }
@@ -31584,9 +32179,9 @@ var require_printer_glimmer = __commonJS2({
     function printElseBlock(node, options) {
       return [options.htmlWhitespaceSensitivity === "ignore" ? hardline : "", printInverseBlockOpeningMustache(node), "else", printInverseBlockClosingMustache(node)];
     }
-    function printElseIfBlock(path, print2) {
+    function printElseIfLikeBlock(path, print2, ifLikeKeyword) {
       const parentNode = path.getParentNode(1);
-      return [printInverseBlockOpeningMustache(parentNode), "else if ", printParams(path, print2), printInverseBlockClosingMustache(parentNode)];
+      return [printInverseBlockOpeningMustache(parentNode), "else ", ifLikeKeyword, " ", printParams(path, print2), printInverseBlockClosingMustache(parentNode)];
     }
     function printCloseBlock(path, print2, options) {
       const node = path.getValue();
@@ -31599,8 +32194,8 @@ var require_printer_glimmer = __commonJS2({
     function blockStatementHasOnlyWhitespaceInProgram(node) {
       return isNodeOfSomeType(node, ["BlockStatement"]) && node.program.body.every((node2) => isWhitespaceNode(node2));
     }
-    function blockStatementHasElseIf(node) {
-      return blockStatementHasElse(node) && node.inverse.body.length === 1 && isNodeOfSomeType(node.inverse.body[0], ["BlockStatement"]) && node.inverse.body[0].path.parts[0] === "if";
+    function blockStatementHasElseIfLike(node) {
+      return blockStatementHasElse(node) && node.inverse.body.length === 1 && isNodeOfSomeType(node.inverse.body[0], ["BlockStatement"]) && node.inverse.body[0].path.parts[0] === node.path.parts[0];
     }
     function blockStatementHasElse(node) {
       return isNodeOfSomeType(node, ["BlockStatement"]) && node.inverse;
@@ -31620,7 +32215,7 @@ var require_printer_glimmer = __commonJS2({
       const node = path.getValue();
       const inverse = print2("inverse");
       const printed = options.htmlWhitespaceSensitivity === "ignore" ? [hardline, inverse] : inverse;
-      if (blockStatementHasElseIf(node)) {
+      if (blockStatementHasElseIfLike(node)) {
         return printed;
       }
       if (blockStatementHasElse(node)) {
@@ -32386,7 +32981,7 @@ var require_print_preprocess2 = __commonJS2({
     function preprocess(ast, options) {
       ast = restoreUnescapedCharacter(ast, options);
       ast = mergeContinuousTexts(ast);
-      ast = transformInlineCode(ast);
+      ast = transformInlineCode(ast, options);
       ast = transformIndentedCodeblockAndMarkItsParentList(ast, options);
       ast = markAlignedList(ast, options);
       ast = splitTextIntoSentences(ast, options);
@@ -32404,9 +32999,9 @@ var require_print_preprocess2 = __commonJS2({
         });
       });
     }
-    function transformInlineCode(ast) {
+    function transformInlineCode(ast, options) {
       return mapAst(ast, (node) => {
-        if (node.type !== "inlineCode") {
+        if (node.type !== "inlineCode" || options.proseWrap === "preserve") {
           return node;
         }
         return Object.assign(Object.assign({}, node), {}, {
@@ -32979,7 +33574,7 @@ var require_printer_markdown = __commonJS2({
           if (ignoreRanges.length > 0) {
             const ignoreRange = ignoreRanges[0];
             if (index === ignoreRange.start.index) {
-              return [children[ignoreRange.start.index].value, options.originalText.slice(ignoreRange.start.offset, ignoreRange.end.offset), children[ignoreRange.end.index].value];
+              return [printIgnoreComment(children[ignoreRange.start.index]), options.originalText.slice(ignoreRange.start.offset, ignoreRange.end.offset), printIgnoreComment(children[ignoreRange.end.index])];
             }
             if (ignoreRange.start.index < index && index < ignoreRange.end.index) {
               return false;
@@ -33032,6 +33627,14 @@ var require_printer_markdown = __commonJS2({
       }, "children");
       return postprocessor ? postprocessor(parts) : parts;
     }
+    function printIgnoreComment(node) {
+      if (node.type === "html") {
+        return node.value;
+      }
+      if (node.type === "paragraph" && Array.isArray(node.children) && node.children.length === 1 && node.children[0].type === "esComment") {
+        return ["{/* ", node.children[0].value, " */}"];
+      }
+    }
     function getLastDescendantNode(node) {
       let current = node;
       while (isNonEmptyArray(current.children)) {
@@ -36249,7 +36852,7 @@ var require_embed5 = __commonJS2({
     "use strict";
     function embed(path, print, textToDoc, options) {
       const node = path.getValue();
-      if (node.type === "root" && options.filepath && /(?:[/\\]|^)\.(?:prettier|stylelint)rc$/.test(options.filepath)) {
+      if (node.type === "root" && options.filepath && /(?:[/\\]|^)\.(?:prettier|stylelint|lintstaged)rc$/.test(options.filepath)) {
         return textToDoc(options.originalText, Object.assign(Object.assign({}, options), {}, {
           parser: "json"
         }));
@@ -37100,7 +37703,7 @@ var require_language_yaml = __commonJS2({
       since: "1.14.0",
       parsers: ["yaml"],
       vscodeLanguageIds: ["yaml", "ansible", "home-assistant"],
-      filenames: [...data.filenames.filter((filename) => filename !== "yarn.lock"), ".prettierrc", ".stylelintrc"]
+      filenames: [...data.filenames.filter((filename) => filename !== "yarn.lock"), ".prettierrc", ".stylelintrc", ".lintstagedrc"]
     }))];
     module2.exports = {
       languages,