prettier 3.0.0-alpha.0 → 3.0.0-alpha.2

package/doc.js

@@ -133,6 +133,21 @@
   var DOC_TYPE_LINE = "line";
   var DOC_TYPE_LABEL = "label";
   var DOC_TYPE_BREAK_PARENT = "break-parent";
+  var VALID_OBJECT_DOC_TYPES = /* @__PURE__ */ new Set([
+    DOC_TYPE_CURSOR,
+    DOC_TYPE_INDENT,
+    DOC_TYPE_ALIGN,
+    DOC_TYPE_TRIM,
+    DOC_TYPE_GROUP,
+    DOC_TYPE_FILL,
+    DOC_TYPE_IF_BREAK,
+    DOC_TYPE_INDENT_IF_BREAK,
+    DOC_TYPE_LINE_SUFFIX,
+    DOC_TYPE_LINE_SUFFIX_BOUNDARY,
+    DOC_TYPE_LINE,
+    DOC_TYPE_LABEL,
+    DOC_TYPE_BREAK_PARENT
+  ]);
 
   // src/document/builders.js
   function indent(contents) {
@@ -222,7 +237,7 @@
   var softline = { type: DOC_TYPE_LINE, soft: true };
   var hardline = [hardlineWithoutBreakParent, breakParent];
   var literalline = [literallineWithoutBreakParent, breakParent];
-  var cursor = { type: DOC_TYPE_CURSOR, placeholder: Symbol("cursor") };
+  var cursor = { type: DOC_TYPE_CURSOR };
   function join(sep, arr) {
     const res = [];
     for (let i = 0; i < arr.length; i++) {
@@ -245,7 +260,7 @@
     return aligned;
   }
   function label(label2, contents) {
-    return { type: DOC_TYPE_LABEL, label: label2, contents };
+    return label2 ? { type: DOC_TYPE_LABEL, label: label2, contents } : contents;
   }
   var concat = (parts) => parts;
 
@@ -256,6 +271,16 @@
   });
   init_define_process();
 
+  // scripts/build/shims/at.js
+  init_define_process();
+  var at = (isOptionalObject, object, index, ...args) => {
+    if (isOptionalObject && (object === void 0 || object === null)) {
+      return;
+    }
+    return object.at ? object.at(index, ...args) : object[index < 0 ? object.length + index : index];
+  };
+  var at_default = at;
+
   // src/common/end-of-line.js
   init_define_process();
   function convertEndOfLineToChars(value) {
@@ -269,11 +294,6 @@
     }
   }
 
-  // src/utils/get-last.js
-  init_define_process();
-  var getLast = (arr) => arr[arr.length - 1];
-  var get_last_default = getLast;
-
   // src/utils/get-string-width.js
   init_define_process();
 
@@ -358,28 +378,71 @@
     cleanDoc: () => cleanDoc,
     findInDoc: () => findInDoc,
     getDocParts: () => getDocParts,
-    getDocType: () => getDocType,
+    getDocType: () => get_doc_type_default,
     mapDoc: () => mapDoc,
     normalizeDoc: () => normalizeDoc,
     normalizeParts: () => normalizeParts,
     propagateBreaks: () => propagateBreaks,
     removeLines: () => removeLines,
     replaceEndOfLine: () => replaceEndOfLine,
-    replaceTextEndOfLine: () => replaceTextEndOfLine,
     stripTrailingHardline: () => stripTrailingHardline,
-    traverseDoc: () => traverseDoc,
+    traverseDoc: () => traverse_doc_default,
     willBreak: () => willBreak
   });
   init_define_process();
-  var getDocParts = (doc) => {
+
+  // src/document/utils/get-doc-type.js
+  init_define_process();
+  function getDocType(doc) {
+    if (typeof doc === "string") {
+      return DOC_TYPE_STRING;
+    }
     if (Array.isArray(doc)) {
-      return doc;
+      return DOC_TYPE_ARRAY;
     }
-    if (doc.type !== DOC_TYPE_FILL) {
-      throw new Error(`Expect doc to be 'array' or '${DOC_TYPE_FILL}'.`);
+    if (!doc) {
+      return;
+    }
+    const { type } = doc;
+    if (VALID_OBJECT_DOC_TYPES.has(type)) {
+      return type;
+    }
+  }
+  var get_doc_type_default = getDocType;
+
+  // src/document/utils/traverse-doc.js
+  init_define_process();
+
+  // src/document/invalid-doc-error.js
+  init_define_process();
+  var disjunctionListFormat = (list) => [...list.slice(0, -1), `or ${at_default(false, list, -1)}`].join(", ");
+  function getDocErrorMessage(doc) {
+    const type = doc === null ? null : typeof doc;
+    if (type !== "string" && type !== "object") {
+      return `Unexpected doc '${type}', 
+Expected it to be 'string' or 'object'.`;
+    }
+    if (get_doc_type_default(doc)) {
+      throw new Error("doc is valid.");
+    }
+    const objectType = Object.prototype.toString.call(doc);
+    if (objectType !== "[object Object]") {
+      return `Unexpected doc '${objectType}'.`;
+    }
+    const EXPECTED_TYPE_VALUES = disjunctionListFormat([...VALID_OBJECT_DOC_TYPES].map((type2) => `'${type2}'`));
+    return `Unexpected doc.type '${doc.type}'.
+Expected it to be ${EXPECTED_TYPE_VALUES}.`;
+  }
+  var InvalidDocError = class extends Error {
+    constructor(doc) {
+      super(getDocErrorMessage(doc));
+      __publicField(this, "name", "InvalidDocError");
+      this.doc = doc;
     }
-    return doc.parts;
   };
+  var invalid_doc_error_default = InvalidDocError;
+
+  // src/document/utils/traverse-doc.js
   var traverseDocOnExitStackMarker = {};
   function traverseDoc(doc, onEnter, onExit, shouldTraverseConditionalGroups) {
     const docsStack = [doc];
@@ -392,34 +455,71 @@
       if (onExit) {
         docsStack.push(doc2, traverseDocOnExitStackMarker);
       }
-      if (!onEnter || onEnter(doc2) !== false) {
-        if (Array.isArray(doc2) || doc2.type === DOC_TYPE_FILL) {
-          const parts = getDocParts(doc2);
+      if ((onEnter == null ? void 0 : onEnter(doc2)) === false) {
+        continue;
+      }
+      const docType = get_doc_type_default(doc2);
+      switch (docType) {
+        case DOC_TYPE_ARRAY:
+        case DOC_TYPE_FILL: {
+          const parts = docType === DOC_TYPE_ARRAY ? doc2 : doc2.parts;
           for (let ic = parts.length, i = ic - 1; i >= 0; --i) {
             docsStack.push(parts[i]);
           }
-        } else if (doc2.type === DOC_TYPE_IF_BREAK) {
+          break;
+        }
+        case DOC_TYPE_IF_BREAK:
           if (doc2.flatContents) {
             docsStack.push(doc2.flatContents);
           }
           if (doc2.breakContents) {
             docsStack.push(doc2.breakContents);
           }
-        } else if (doc2.type === DOC_TYPE_GROUP && doc2.expandedStates) {
-          if (shouldTraverseConditionalGroups) {
+          break;
+        case DOC_TYPE_GROUP:
+          if (shouldTraverseConditionalGroups && doc2.expandedStates) {
             for (let ic = doc2.expandedStates.length, i = ic - 1; i >= 0; --i) {
               docsStack.push(doc2.expandedStates[i]);
             }
           } else {
             docsStack.push(doc2.contents);
           }
-        } else if (doc2.contents) {
+          break;
+        case DOC_TYPE_ALIGN:
+        case DOC_TYPE_INDENT:
+        case DOC_TYPE_INDENT_IF_BREAK:
+        case DOC_TYPE_LABEL:
+        case DOC_TYPE_LINE_SUFFIX:
           docsStack.push(doc2.contents);
-        }
+          break;
+        case DOC_TYPE_STRING:
+        case DOC_TYPE_CURSOR:
+        case DOC_TYPE_TRIM:
+        case DOC_TYPE_LINE_SUFFIX_BOUNDARY:
+        case DOC_TYPE_LINE:
+        case DOC_TYPE_BREAK_PARENT:
+          break;
+        default:
+          throw new invalid_doc_error_default(doc2);
       }
     }
   }
+  var traverse_doc_default = traverseDoc;
+
+  // src/document/utils.js
+  var getDocParts = (doc) => {
+    if (Array.isArray(doc)) {
+      return doc;
+    }
+    if (doc.type !== DOC_TYPE_FILL) {
+      throw new Error(`Expect doc to be 'array' or '${DOC_TYPE_FILL}'.`);
+    }
+    return doc.parts;
+  };
   function mapDoc(doc, cb) {
+    if (typeof doc === "string") {
+      return cb(doc);
+    }
     const mapped = /* @__PURE__ */ new Map();
     return rec(doc);
     function rec(doc2) {
@@ -431,44 +531,79 @@
       return result;
     }
     function process2(doc2) {
-      if (Array.isArray(doc2)) {
-        return cb(doc2.map(rec));
-      }
-      if (doc2.type === DOC_TYPE_ARRAY || doc2.type === DOC_TYPE_FILL) {
-        const parts = doc2.parts.map(rec);
-        return cb({ ...doc2, parts });
-      }
-      if (doc2.type === DOC_TYPE_IF_BREAK) {
-        const breakContents = doc2.breakContents && rec(doc2.breakContents);
-        const flatContents = doc2.flatContents && rec(doc2.flatContents);
-        return cb({ ...doc2, breakContents, flatContents });
-      }
-      if (doc2.type === DOC_TYPE_GROUP && doc2.expandedStates) {
-        const expandedStates = doc2.expandedStates.map(rec);
-        const contents = expandedStates[0];
-        return cb({ ...doc2, contents, expandedStates });
-      }
-      if (doc2.contents) {
-        const contents = rec(doc2.contents);
-        return cb({ ...doc2, contents });
+      switch (get_doc_type_default(doc2)) {
+        case DOC_TYPE_ARRAY:
+          return cb(doc2.map(rec));
+        case DOC_TYPE_FILL:
+          return cb({
+            ...doc2,
+            parts: doc2.parts.map(rec)
+          });
+        case DOC_TYPE_IF_BREAK: {
+          let {
+            breakContents,
+            flatContents
+          } = doc2;
+          breakContents && (breakContents = rec(breakContents));
+          flatContents && (flatContents = rec(flatContents));
+          return cb({
+            ...doc2,
+            breakContents,
+            flatContents
+          });
+        }
+        case DOC_TYPE_GROUP: {
+          let {
+            expandedStates,
+            contents
+          } = doc2;
+          if (expandedStates) {
+            expandedStates = expandedStates.map(rec);
+            contents = expandedStates[0];
+          } else {
+            contents = rec(contents);
+          }
+          return cb({
+            ...doc2,
+            contents,
+            expandedStates
+          });
+        }
+        case DOC_TYPE_ALIGN:
+        case DOC_TYPE_INDENT:
+        case DOC_TYPE_INDENT_IF_BREAK:
+        case DOC_TYPE_LABEL:
+        case DOC_TYPE_LINE_SUFFIX:
+          return cb({
+            ...doc2,
+            contents: rec(doc2.contents)
+          });
+        case DOC_TYPE_STRING:
+        case DOC_TYPE_CURSOR:
+        case DOC_TYPE_TRIM:
+        case DOC_TYPE_LINE_SUFFIX_BOUNDARY:
+        case DOC_TYPE_LINE:
+        case DOC_TYPE_BREAK_PARENT:
+          return cb(doc2);
+        default:
+          throw new invalid_doc_error_default(doc2);
       }
-      return cb(doc2);
     }
   }
   function findInDoc(doc, fn, defaultValue) {
     let result = defaultValue;
-    let hasStopped = false;
+    let shouldSkipFurtherProcessing = false;
     function findInDocOnEnterFn(doc2) {
+      if (shouldSkipFurtherProcessing) {
+        return false;
+      }
       const maybeResult = fn(doc2);
       if (maybeResult !== void 0) {
-        hasStopped = true;
+        shouldSkipFurtherProcessing = true;
         result = maybeResult;
       }
-      if (hasStopped) {
-        return false;
-      }
     }
-    traverseDoc(doc, findInDocOnEnterFn);
+    traverse_doc_default(doc, findInDocOnEnterFn);
     return result;
   }
   function willBreakFn(doc) {
@@ -487,7 +622,7 @@
   }
   function breakParentGroup(groupStack) {
     if (groupStack.length > 0) {
-      const parentGroup = get_last_default(groupStack);
+      const parentGroup = at_default(false, groupStack, -1);
       if (!parentGroup.expandedStates && !parentGroup.break) {
         parentGroup.break = "propagated";
       }
@@ -517,7 +652,7 @@
         }
       }
     }
-    traverseDoc(
+    traverse_doc_default(
       doc,
       propagateBreaksOnEnterFn,
       propagateBreaksOnExitFn,
@@ -547,10 +682,13 @@
         parts.length -= 2;
       }
       if (parts.length > 0) {
-        const lastPart = stripDocTrailingHardlineFromDoc(get_last_default(parts));
+        const lastPart = stripDocTrailingHardlineFromDoc(at_default(false, parts, -1));
         parts[parts.length - 1] = lastPart;
       }
-      return Array.isArray(doc) ? parts : { ...doc, parts };
+      return Array.isArray(doc) ? parts : {
+        ...doc,
+        parts
+      };
     }
     switch (doc.type) {
       case DOC_TYPE_ALIGN:
@@ -560,12 +698,19 @@
       case DOC_TYPE_LINE_SUFFIX:
       case DOC_TYPE_LABEL: {
         const contents = stripDocTrailingHardlineFromDoc(doc.contents);
-        return { ...doc, contents };
+        return {
+          ...doc,
+          contents
+        };
       }
       case DOC_TYPE_IF_BREAK: {
         const breakContents = stripDocTrailingHardlineFromDoc(doc.breakContents);
         const flatContents = stripDocTrailingHardlineFromDoc(doc.flatContents);
-        return { ...doc, breakContents, flatContents };
+        return {
+          ...doc,
+          breakContents,
+          flatContents
+        };
       }
     }
     return doc;
@@ -577,7 +722,7 @@
     return stripDocTrailingHardlineFromDoc(cleanDoc(doc));
   }
   function cleanDocFn(doc) {
-    switch (doc.type) {
+    switch (get_doc_type_default(doc)) {
       case DOC_TYPE_FILL:
         if (doc.parts.every((part) => part === "")) {
           return "";
@@ -604,30 +749,40 @@
           return "";
         }
         break;
-    }
-    if (!Array.isArray(doc)) {
-      return doc;
-    }
-    const parts = [];
-    for (const part of doc) {
-      if (!part) {
-        continue;
-      }
-      const [currentPart, ...restParts] = Array.isArray(part) ? part : [part];
-      if (typeof currentPart === "string" && typeof get_last_default(parts) === "string") {
-        parts[parts.length - 1] += currentPart;
-      } else {
-        parts.push(currentPart);
+      case DOC_TYPE_ARRAY: {
+        const parts = [];
+        for (const part of doc) {
+          if (!part) {
+            continue;
+          }
+          const [currentPart, ...restParts] = Array.isArray(part) ? part : [part];
+          if (typeof currentPart === "string" && typeof at_default(false, parts, -1) === "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 parts;
       }
-      parts.push(...restParts);
-    }
-    if (parts.length === 0) {
-      return "";
-    }
-    if (parts.length === 1) {
-      return parts[0];
+      case DOC_TYPE_STRING:
+      case DOC_TYPE_CURSOR:
+      case DOC_TYPE_TRIM:
+      case DOC_TYPE_LINE_SUFFIX_BOUNDARY:
+      case DOC_TYPE_LINE:
+      case DOC_TYPE_LABEL:
+      case DOC_TYPE_BREAK_PARENT:
+        break;
+      default:
+        throw new invalid_doc_error_default(doc);
     }
-    return parts;
+    return doc;
   }
   function cleanDoc(doc) {
     return mapDoc(doc, (currentDoc) => cleanDocFn(currentDoc));
@@ -644,7 +799,7 @@
         restParts.unshift(...part);
         continue;
       }
-      if (newParts.length > 0 && typeof get_last_default(newParts) === "string" && typeof part === "string") {
+      if (newParts.length > 0 && typeof at_default(false, newParts, -1) === "string" && typeof part === "string") {
         newParts[newParts.length - 1] += part;
         continue;
       }
@@ -666,14 +821,8 @@
       };
     });
   }
-  function replaceEndOfLine(doc) {
-    return mapDoc(
-      doc,
-      (currentDoc) => typeof currentDoc === "string" && currentDoc.includes("\n") ? replaceTextEndOfLine(currentDoc) : currentDoc
-    );
-  }
-  function replaceTextEndOfLine(text, replacement = literalline) {
-    return join(replacement, text.split("\n"));
+  function replaceEndOfLine(doc, replacement = literalline) {
+    return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? join(replacement, currentDoc.split("\n")) : currentDoc);
   }
   function canBreakFn(doc) {
     if (doc.type === DOC_TYPE_LINE) {
@@ -683,88 +832,46 @@
   function canBreak(doc) {
     return findInDoc(doc, canBreakFn, false);
   }
-  function getDocType(doc) {
-    if (typeof doc === "string") {
-      return DOC_TYPE_STRING;
-    }
-    if (Array.isArray(doc)) {
-      return DOC_TYPE_ARRAY;
-    }
-    return doc == null ? void 0 : doc.type;
-  }
-
-  // src/document/invalid-doc-error.js
-  init_define_process();
-  var VALID_OBJECT_DOC_TYPE_VALUES = [
-    DOC_TYPE_CURSOR,
-    DOC_TYPE_INDENT,
-    DOC_TYPE_ALIGN,
-    DOC_TYPE_TRIM,
-    DOC_TYPE_GROUP,
-    DOC_TYPE_FILL,
-    DOC_TYPE_IF_BREAK,
-    DOC_TYPE_INDENT_IF_BREAK,
-    DOC_TYPE_LINE_SUFFIX,
-    DOC_TYPE_LINE_SUFFIX_BOUNDARY,
-    DOC_TYPE_LINE,
-    DOC_TYPE_LABEL,
-    DOC_TYPE_BREAK_PARENT
-  ];
-  var disjunctionListFormat = (list) => [...list.slice(0, -1), `or ${get_last_default(list)}`].join(", ");
-  function getDocErrorMessage(doc) {
-    const type = doc === null ? null : typeof doc;
-    if (type !== "string" && type !== "object") {
-      return `Unexpected doc '${type}', 
-Expected it to be 'string' or 'object'.`;
-    }
-    const docType = getDocType(doc);
-    if (docType === DOC_TYPE_STRING || docType === DOC_TYPE_ARRAY || VALID_OBJECT_DOC_TYPE_VALUES.includes(docType)) {
-      throw new Error("doc is valid.");
-    }
-    const objectType = Object.prototype.toString.call(doc);
-    if (objectType !== "[object Object]") {
-      return `Unexpected doc '${objectType}'.`;
-    }
-    const EXPECTED_TYPE_VALUES = disjunctionListFormat(
-      VALID_OBJECT_DOC_TYPE_VALUES.map((type2) => `'${type2}'`)
-    );
-    return `Unexpected doc.type '${docType}'.
-Expected it to be ${EXPECTED_TYPE_VALUES}.`;
-  }
-  var InvalidDocError = class extends Error {
-    constructor(doc) {
-      super(getDocErrorMessage(doc));
-      __publicField(this, "name", "InvalidDocError");
-      this.doc = doc;
-    }
-  };
-  var invalid_doc_error_default = InvalidDocError;
 
   // src/document/printer.js
-  var groupModeMap;
-  var MODE_BREAK = 1;
-  var MODE_FLAT = 2;
+  var MODE_BREAK = Symbol("MODE_BREAK");
+  var MODE_FLAT = Symbol("MODE_FLAT");
+  var CURSOR_PLACEHOLDER = Symbol("cursor");
   function rootIndent() {
-    return { value: "", length: 0, queue: [] };
+    return {
+      value: "",
+      length: 0,
+      queue: []
+    };
   }
   function makeIndent(ind, options) {
-    return generateInd(ind, { type: "indent" }, options);
+    return generateInd(ind, {
+      type: "indent"
+    }, options);
   }
   function makeAlign(indent2, widthOrDoc, options) {
     if (widthOrDoc === Number.NEGATIVE_INFINITY) {
       return indent2.root || rootIndent();
     }
     if (widthOrDoc < 0) {
-      return generateInd(indent2, { type: "dedent" }, options);
+      return generateInd(indent2, {
+        type: "dedent"
+      }, options);
     }
     if (!widthOrDoc) {
       return indent2;
     }
     if (widthOrDoc.type === "root") {
-      return { ...indent2, root: indent2 };
+      return {
+        ...indent2,
+        root: indent2
+      };
     }
     const alignType = typeof widthOrDoc === "string" ? "stringAlign" : "numberAlign";
-    return generateInd(indent2, { type: alignType, n: widthOrDoc }, options);
+    return generateInd(indent2, {
+      type: alignType,
+      n: widthOrDoc
+    }, options);
   }
   function generateInd(ind, newPart, options) {
     const queue = newPart.type === "dedent" ? ind.queue.slice(0, -1) : [...ind.queue, newPart];
@@ -796,7 +903,12 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
       }
     }
     flushSpaces();
-    return { ...ind, value, length, queue };
+    return {
+      ...ind,
+      value,
+      length,
+      queue
+    };
     function addTabs(count) {
       value += "	".repeat(count);
       length += options.tabWidth * count;
@@ -830,21 +942,38 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
     }
   }
   function trim2(out) {
-    if (out.length === 0) {
-      return 0;
-    }
     let trimCount = 0;
-    while (out.length > 0 && typeof get_last_default(out) === "string" && /^[\t ]*$/.test(get_last_default(out))) {
-      trimCount += out.pop().length;
-    }
-    if (out.length > 0 && typeof get_last_default(out) === "string") {
-      const trimmed = get_last_default(out).replace(/[\t ]*$/, "");
-      trimCount += get_last_default(out).length - trimmed.length;
-      out[out.length - 1] = trimmed;
+    let cursorCount = 0;
+    let outIndex = out.length;
+    outer:
+      while (outIndex--) {
+        const last = out[outIndex];
+        if (last === CURSOR_PLACEHOLDER) {
+          cursorCount++;
+          continue;
+        }
+        if (false) {
+          throw new Error(`Unexpected value in trim: '${typeof last}'`);
+        }
+        for (let charIndex = last.length - 1; charIndex >= 0; charIndex--) {
+          const char = last[charIndex];
+          if (char === " " || char === "	") {
+            trimCount++;
+          } else {
+            out[outIndex] = last.slice(0, charIndex + 1);
+            break outer;
+          }
+        }
+      }
+    if (trimCount > 0 || cursorCount > 0) {
+      out.length = outIndex + 1;
+      while (cursorCount-- > 0) {
+        out.push(CURSOR_PLACEHOLDER);
+      }
     }
     return trimCount;
   }
-  function fits(next, restCommands, width, hasLineSuffix, mustBeFlat) {
+  function fits(next, restCommands, width, hasLineSuffix, groupModeMap, mustBeFlat) {
     let restIdx = restCommands.length;
     const cmds = [next];
     const out = [];
@@ -856,8 +985,11 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
         cmds.push(restCommands[--restIdx]);
         continue;
       }
-      const { mode, doc } = cmds.pop();
-      switch (getDocType(doc)) {
+      const {
+        mode,
+        doc
+      } = cmds.pop();
+      switch (get_doc_type_default(doc)) {
         case DOC_TYPE_STRING:
           out.push(doc);
           width -= get_string_width_default(doc);
@@ -866,7 +998,10 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
         case DOC_TYPE_FILL: {
           const parts = getDocParts(doc);
           for (let i = parts.length - 1; i >= 0; i--) {
-            cmds.push({ mode, doc: parts[i] });
+            cmds.push({
+              mode,
+              doc: parts[i]
+            });
           }
           break;
         }
@@ -874,7 +1009,10 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
         case DOC_TYPE_ALIGN:
         case DOC_TYPE_INDENT_IF_BREAK:
         case DOC_TYPE_LABEL:
-          cmds.push({ mode, doc: doc.contents });
+          cmds.push({
+            mode,
+            doc: doc.contents
+          });
           break;
         case DOC_TYPE_TRIM:
           width += trim2(out);
@@ -884,15 +1022,21 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
             return false;
           }
           const groupMode = doc.break ? MODE_BREAK : mode;
-          const contents = doc.expandedStates && groupMode === MODE_BREAK ? get_last_default(doc.expandedStates) : doc.contents;
-          cmds.push({ mode: groupMode, doc: contents });
+          const contents = doc.expandedStates && groupMode === MODE_BREAK ? at_default(false, doc.expandedStates, -1) : doc.contents;
+          cmds.push({
+            mode: groupMode,
+            doc: contents
+          });
           break;
         }
         case DOC_TYPE_IF_BREAK: {
           const groupMode = doc.groupId ? groupModeMap[doc.groupId] || MODE_FLAT : mode;
           const contents = groupMode === MODE_BREAK ? doc.breakContents : doc.flatContents;
           if (contents) {
-            cmds.push({ mode, doc: contents });
+            cmds.push({
+              mode,
+              doc: contents
+            });
           }
           break;
         }
@@ -918,34 +1062,54 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
     return false;
   }
   function printDocToString(doc, options) {
-    groupModeMap = {};
+    const groupModeMap = {};
     const width = options.printWidth;
     const newLine = convertEndOfLineToChars(options.endOfLine);
     let pos = 0;
-    const cmds = [{ ind: rootIndent(), mode: MODE_BREAK, doc }];
+    const cmds = [{
+      ind: rootIndent(),
+      mode: MODE_BREAK,
+      doc
+    }];
     const out = [];
     let shouldRemeasure = false;
     const lineSuffix2 = [];
+    let printedCursorCount = 0;
     while (cmds.length > 0) {
-      const { ind, mode, doc: doc2 } = cmds.pop();
-      switch (getDocType(doc2)) {
+      const {
+        ind,
+        mode,
+        doc: doc2
+      } = cmds.pop();
+      switch (get_doc_type_default(doc2)) {
         case DOC_TYPE_STRING: {
           const formatted = newLine !== "\n" ? doc2.replace(/\n/g, newLine) : doc2;
           out.push(formatted);
           pos += get_string_width_default(formatted);
           break;
         }
-        case DOC_TYPE_ARRAY: {
+        case DOC_TYPE_ARRAY:
           for (let i = doc2.length - 1; i >= 0; i--) {
-            cmds.push({ ind, mode, doc: doc2[i] });
+            cmds.push({
+              ind,
+              mode,
+              doc: doc2[i]
+            });
           }
           break;
-        }
         case DOC_TYPE_CURSOR:
-          out.push(cursor.placeholder);
+          if (printedCursorCount >= 2) {
+            throw new Error("There are too many 'cursor' in doc.");
+          }
+          out.push(CURSOR_PLACEHOLDER);
+          printedCursorCount++;
           break;
         case DOC_TYPE_INDENT:
-          cmds.push({ ind: makeIndent(ind, options), mode, doc: doc2.contents });
+          cmds.push({
+            ind: makeIndent(ind, options),
+            mode,
+            doc: doc2.contents
+          });
           break;
         case DOC_TYPE_ALIGN:
           cmds.push({
@@ -970,26 +1134,42 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
               }
             case MODE_BREAK: {
               shouldRemeasure = false;
-              const next = { ind, mode: MODE_FLAT, doc: doc2.contents };
+              const next = {
+                ind,
+                mode: MODE_FLAT,
+                doc: doc2.contents
+              };
               const rem = width - pos;
               const hasLineSuffix = lineSuffix2.length > 0;
-              if (!doc2.break && fits(next, cmds, rem, hasLineSuffix)) {
+              if (!doc2.break && fits(next, cmds, rem, hasLineSuffix, groupModeMap)) {
                 cmds.push(next);
               } else {
                 if (doc2.expandedStates) {
-                  const mostExpanded = get_last_default(doc2.expandedStates);
+                  const mostExpanded = at_default(false, doc2.expandedStates, -1);
                   if (doc2.break) {
-                    cmds.push({ ind, mode: MODE_BREAK, doc: mostExpanded });
+                    cmds.push({
+                      ind,
+                      mode: MODE_BREAK,
+                      doc: mostExpanded
+                    });
                     break;
                   } else {
                     for (let i = 1; i < doc2.expandedStates.length + 1; i++) {
                       if (i >= doc2.expandedStates.length) {
-                        cmds.push({ ind, mode: MODE_BREAK, doc: mostExpanded });
+                        cmds.push({
+                          ind,
+                          mode: MODE_BREAK,
+                          doc: mostExpanded
+                        });
                         break;
                       } else {
                         const state = doc2.expandedStates[i];
-                        const cmd = { ind, mode: MODE_FLAT, doc: state };
-                        if (fits(cmd, cmds, rem, hasLineSuffix)) {
+                        const cmd = {
+                          ind,
+                          mode: MODE_FLAT,
+                          doc: state
+                        };
+                        if (fits(cmd, cmds, rem, hasLineSuffix, groupModeMap)) {
                           cmds.push(cmd);
                           break;
                         }
@@ -997,32 +1177,40 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
                     }
                   }
                 } else {
-                  cmds.push({ ind, mode: MODE_BREAK, doc: doc2.contents });
+                  cmds.push({
+                    ind,
+                    mode: MODE_BREAK,
+                    doc: doc2.contents
+                  });
                 }
               }
               break;
             }
           }
           if (doc2.id) {
-            groupModeMap[doc2.id] = get_last_default(cmds).mode;
+            groupModeMap[doc2.id] = at_default(false, cmds, -1).mode;
           }
           break;
         case DOC_TYPE_FILL: {
           const rem = width - pos;
-          const { parts } = doc2;
+          const {
+            parts
+          } = doc2;
           if (parts.length === 0) {
             break;
           }
           const [content, whitespace] = parts;
-          const contentFlatCmd = { ind, mode: MODE_FLAT, doc: content };
-          const contentBreakCmd = { ind, mode: MODE_BREAK, doc: content };
-          const contentFits = fits(
-            contentFlatCmd,
-            [],
-            rem,
-            lineSuffix2.length > 0,
-            true
-          );
+          const contentFlatCmd = {
+            ind,
+            mode: MODE_FLAT,
+            doc: content
+          };
+          const contentBreakCmd = {
+            ind,
+            mode: MODE_BREAK,
+            doc: content
+          };
+          const contentFits = fits(contentFlatCmd, [], rem, lineSuffix2.length > 0, groupModeMap, true);
           if (parts.length === 1) {
             if (contentFits) {
               cmds.push(contentFlatCmd);
@@ -1031,8 +1219,16 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
             }
             break;
           }
-          const whitespaceFlatCmd = { ind, mode: MODE_FLAT, doc: whitespace };
-          const whitespaceBreakCmd = { ind, mode: MODE_BREAK, doc: whitespace };
+          const whitespaceFlatCmd = {
+            ind,
+            mode: MODE_FLAT,
+            doc: whitespace
+          };
+          const whitespaceBreakCmd = {
+            ind,
+            mode: MODE_BREAK,
+            doc: whitespace
+          };
           if (parts.length === 2) {
             if (contentFits) {
               cmds.push(whitespaceFlatCmd, contentFlatCmd);
@@ -1042,20 +1238,18 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
             break;
           }
           parts.splice(0, 2);
-          const remainingCmd = { ind, mode, doc: fill(parts) };
+          const remainingCmd = {
+            ind,
+            mode,
+            doc: fill(parts)
+          };
           const secondContent = parts[0];
           const firstAndSecondContentFlatCmd = {
             ind,
             mode: MODE_FLAT,
             doc: [content, whitespace, secondContent]
           };
-          const firstAndSecondContentFits = fits(
-            firstAndSecondContentFlatCmd,
-            [],
-            rem,
-            lineSuffix2.length > 0,
-            true
-          );
+          const firstAndSecondContentFits = fits(firstAndSecondContentFlatCmd, [], rem, lineSuffix2.length > 0, groupModeMap, true);
           if (firstAndSecondContentFits) {
             cmds.push(remainingCmd, whitespaceFlatCmd, contentFlatCmd);
           } else if (contentFits) {
@@ -1071,23 +1265,39 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
           if (groupMode === MODE_BREAK) {
             const breakContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.breakContents : doc2.negate ? doc2.contents : indent(doc2.contents);
             if (breakContents) {
-              cmds.push({ ind, mode, doc: breakContents });
+              cmds.push({
+                ind,
+                mode,
+                doc: breakContents
+              });
             }
           }
           if (groupMode === MODE_FLAT) {
             const flatContents = doc2.type === DOC_TYPE_IF_BREAK ? doc2.flatContents : doc2.negate ? indent(doc2.contents) : doc2.contents;
             if (flatContents) {
-              cmds.push({ ind, mode, doc: flatContents });
+              cmds.push({
+                ind,
+                mode,
+                doc: flatContents
+              });
             }
           }
           break;
         }
         case DOC_TYPE_LINE_SUFFIX:
-          lineSuffix2.push({ ind, mode, doc: doc2.contents });
+          lineSuffix2.push({
+            ind,
+            mode,
+            doc: doc2.contents
+          });
           break;
         case DOC_TYPE_LINE_SUFFIX_BOUNDARY:
           if (lineSuffix2.length > 0) {
-            cmds.push({ ind, mode, doc: hardlineWithoutBreakParent });
+            cmds.push({
+              ind,
+              mode,
+              doc: hardlineWithoutBreakParent
+            });
           }
           break;
         case DOC_TYPE_LINE:
@@ -1104,7 +1314,11 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
               }
             case MODE_BREAK:
               if (lineSuffix2.length > 0) {
-                cmds.push({ ind, mode, doc: doc2 }, ...lineSuffix2.reverse());
+                cmds.push({
+                  ind,
+                  mode,
+                  doc: doc2
+                }, ...lineSuffix2.reverse());
                 lineSuffix2.length = 0;
                 break;
               }
@@ -1125,7 +1339,11 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
           }
           break;
         case DOC_TYPE_LABEL:
-          cmds.push({ ind, mode, doc: doc2.contents });
+          cmds.push({
+            ind,
+            mode,
+            doc: doc2.contents
+          });
           break;
         case DOC_TYPE_BREAK_PARENT:
           break;
@@ -1137,12 +1355,9 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
         lineSuffix2.length = 0;
       }
     }
-    const cursorPlaceholderIndex = out.indexOf(cursor.placeholder);
+    const cursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER);
     if (cursorPlaceholderIndex !== -1) {
-      const otherCursorPlaceholderIndex = out.indexOf(
-        cursor.placeholder,
-        cursorPlaceholderIndex + 1
-      );
+      const otherCursorPlaceholderIndex = out.indexOf(CURSOR_PLACEHOLDER, cursorPlaceholderIndex + 1);
       const beforeCursor = out.slice(0, cursorPlaceholderIndex).join("");
       const aroundCursor = out.slice(cursorPlaceholderIndex + 1, otherCursorPlaceholderIndex).join("");
       const afterCursor = out.slice(otherCursorPlaceholderIndex + 1).join("");
@@ -1152,7 +1367,9 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
         cursorNodeText: aroundCursor
       };
     }
-    return { formatted: out.join("") };
+    return {
+      formatted: out.join("")
+    };
   }
 
   // src/document/debug.js