@so1ve/eslint-plugin-sort-imports 3.26.0 → 4.0.0

package/src/shared.js

@@ -7,60 +7,60 @@ const NEWLINE = /(\r?\n)/;
 const hasNewline = (string) => NEWLINE.test(string);
 
 function guessNewline(sourceCode) {
-	const match = NEWLINE.exec(sourceCode.text);
+  const match = NEWLINE.exec(sourceCode.text);
 
-	return match == null ? "\n" : match[0];
+  return match == null ? "\n" : match[0];
 }
 
 function parseWhitespace(whitespace) {
-	const allItems = whitespace.split(NEWLINE);
-
-	// Remove blank lines. `allItems` contains alternating `spaces` (which can be
-	// the empty string) and `newline` (which is either "\r\n" or "\n"). So in
-	// practice `allItems` grows like this as there are more newlines in
-	// `whitespace`:
-	//
-	//     [spaces]
-	//     [spaces, newline, spaces]
-	//     [spaces, newline, spaces, newline, spaces]
-	//     [spaces, newline, spaces, newline, spaces, newline, spaces]
-	//
-	// If there are 5 or more items we have at least one blank line. If so, keep
-	// the first `spaces`, the first `newline` and the last `spaces`.
-	const items =
-		allItems.length >= 5
-			? [...allItems.slice(0, 2), ...allItems.slice(-1)]
-			: allItems;
-
-	return (
-		items
-			.map((spacesOrNewline, index) =>
-				index % 2 === 0
-					? { type: "Spaces", code: spacesOrNewline }
-					: { type: "Newline", code: spacesOrNewline },
-			)
-			// Remove empty spaces since it makes debugging easier.
-			.filter((token) => token.code !== "")
-	);
+  const allItems = whitespace.split(NEWLINE);
+
+  // Remove blank lines. `allItems` contains alternating `spaces` (which can be
+  // the empty string) and `newline` (which is either "\r\n" or "\n"). So in
+  // practice `allItems` grows like this as there are more newlines in
+  // `whitespace`:
+  //
+  //     [spaces]
+  //     [spaces, newline, spaces]
+  //     [spaces, newline, spaces, newline, spaces]
+  //     [spaces, newline, spaces, newline, spaces, newline, spaces]
+  //
+  // If there are 5 or more items we have at least one blank line. If so, keep
+  // the first `spaces`, the first `newline` and the last `spaces`.
+  const items =
+    allItems.length >= 5
+      ? [...allItems.slice(0, 2), ...allItems.slice(-1)]
+      : allItems;
+
+  return (
+    items
+      .map((spacesOrNewline, index) =>
+        index % 2 === 0
+          ? { type: "Spaces", code: spacesOrNewline }
+          : { type: "Newline", code: spacesOrNewline },
+      )
+      // Remove empty spaces since it makes debugging easier.
+      .filter((token) => token.code !== "")
+  );
 }
 
 const naturalSort = natsort();
 function compare(path1, path2) {
-	const path1Depth = path1.split("-").filter((p) => p === "__").length;
-	const path2Depth = path2.split("-").filter((p) => p === "__").length;
-	const path1IsDot = path1 === "_-,";
-	const path2IsDot = path2 === "_-,";
-
-	if (path1IsDot && !path2IsDot) {
-		return 1;
-	}
-	if (path2IsDot && !path1IsDot) {
-		return -1;
-	}
-
-	return path1Depth === path2Depth
-		? naturalSort(path1, path2)
-		: path2Depth - path1Depth;
+  const path1Depth = path1.split("-").filter((p) => p === "__").length;
+  const path2Depth = path2.split("-").filter((p) => p === "__").length;
+  const path1IsDot = path1 === "_-,";
+  const path2IsDot = path2 === "_-,";
+
+  if (path1IsDot && !path2IsDot) {
+    return 1;
+  }
+  if (path2IsDot && !path1IsDot) {
+    return -1;
+  }
+
+  return path1Depth === path2Depth
+    ? naturalSort(path1, path2)
+    : path2Depth - path1Depth;
 }
 
 const isIdentifier = (node) => node.type === "Identifier";
@@ -68,7 +68,7 @@ const isIdentifier = (node) => node.type === "Identifier";
 const isKeyword = (node) => node.type === "Keyword";
 
 const isPunctuator = (node, value) =>
-	node.type === "Punctuator" && node.value === value;
+  node.type === "Punctuator" && node.value === value;
 
 const isBlockComment = (node) => node.type === "Block";
 
@@ -79,58 +79,58 @@ const isSpaces = (node) => node.type === "Spaces";
 const isNewline = (node) => node.type === "Newline";
 
 const getImportExportKind = (node) =>
-	node.importKind || node.exportKind || "value";
+  node.importKind || node.exportKind || "value";
 
 function getSource(node) {
-	const source = node.source.value;
-
-	return {
-		// Sort by directory level rather than by string length.
-		source: source
-			// Treat `.` as `./`, `..` as `../`, `../..` as `../../` etc.
-			.replace(/^[./]*\.$/, "$&/")
-			// Make `../` sort after `../../` but before `../a` etc.
-			// Why a comma? See the next comment.
-			.replace(/^[./]*\/$/, "$&,")
-			// Make `.` and `/` sort before any other punctation.
-			// The default order is: _ - , x x x . x x x / x x x
-			// We’re changing it to: . / , x x x _ x x x - x x x
-			.replace(/[./_-]/g, (char) => {
-				switch (char) {
-					case ".": {
-						return "_";
-					}
-					case "/": {
-						return "-";
-					}
-					case "_": {
-						return ".";
-					}
-					case "-": {
-						return "/";
-					}
-					// istanbul ignore next
-					default: {
-						throw new Error(`Unknown source substitution character: ${char}`);
-					}
-				}
-			}),
-		originalSource: source,
-		kind: getImportExportKind(node),
-	};
+  const source = node.source.value;
+
+  return {
+    // Sort by directory level rather than by string length.
+    source: source
+      // Treat `.` as `./`, `..` as `../`, `../..` as `../../` etc.
+      .replace(/^[./]*\.$/, "$&/")
+      // Make `../` sort after `../../` but before `../a` etc.
+      // Why a comma? See the next comment.
+      .replace(/^[./]*\/$/, "$&,")
+      // Make `.` and `/` sort before any other punctation.
+      // The default order is: _ - , x x x . x x x / x x x
+      // We’re changing it to: . / , x x x _ x x x - x x x
+      .replace(/[./_-]/g, (char) => {
+        switch (char) {
+          case ".": {
+            return "_";
+          }
+          case "/": {
+            return "-";
+          }
+          case "_": {
+            return ".";
+          }
+          case "-": {
+            return "/";
+          }
+          // istanbul ignore next
+          default: {
+            throw new Error(`Unknown source substitution character: ${char}`);
+          }
+        }
+      }),
+    originalSource: source,
+    kind: getImportExportKind(node),
+  };
 }
 
 // Like `Array.prototype.findIndex`, but searches from the end.
 function findLastIndex(array, fn) {
-	for (let index = array.length - 1; index >= 0; index--) {
-		if (fn(array[index], index, array)) {
-			return index;
-		}
-	}
-
-	// There are currently no usages of `findLastIndex` where nothing is found.
-	// istanbul ignore next
-	return -1;
+  for (let index = array.length - 1; index >= 0; index--) {
+    if (fn(array[index], index, array)) {
+      return index;
+    }
+  }
+
+  // There are currently no usages of `findLastIndex` where nothing is found.
+  // istanbul ignore next
+  return -1;
 }
 
 // Like `Array.prototype.flatMap`, had it been available.
@@ -139,38 +139,38 @@ const flatMap = (array, fn) => array.flatMap(fn);
 // Returns `sourceCode.getTokens(node)` plus whitespace and comments. All tokens
 // have a `code` property with `sourceCode.getText(token)`.
 function getAllTokens(node, sourceCode) {
-	const tokens = sourceCode.getTokens(node);
-	const lastTokenIndex = tokens.length - 1;
-
-	return flatMap(tokens, (token, tokenIndex) => {
-		const newToken = { ...token, code: sourceCode.getText(token) };
-
-		if (tokenIndex === lastTokenIndex) {
-			return [newToken];
-		}
-
-		const comments = sourceCode.getCommentsAfter(token);
-		const last = comments.length > 0 ? comments[comments.length - 1] : token;
-		const nextToken = tokens[tokenIndex + 1];
-
-		return [
-			newToken,
-			...flatMap(comments, (comment, commentIndex) => {
-				const previous =
-					commentIndex === 0 ? token : comments[commentIndex - 1];
-
-				return [
-					...parseWhitespace(
-						sourceCode.text.slice(previous.range[1], comment.range[0]),
-					),
-					{ ...comment, code: sourceCode.getText(comment) },
-				];
-			}),
-			...parseWhitespace(
-				sourceCode.text.slice(last.range[1], nextToken.range[0]),
-			),
-		];
-	});
+  const tokens = sourceCode.getTokens(node);
+  const lastTokenIndex = tokens.length - 1;
+
+  return flatMap(tokens, (token, tokenIndex) => {
+    const newToken = { ...token, code: sourceCode.getText(token) };
+
+    if (tokenIndex === lastTokenIndex) {
+      return [newToken];
+    }
+
+    const comments = sourceCode.getCommentsAfter(token);
+    const last = comments.length > 0 ? comments[comments.length - 1] : token;
+    const nextToken = tokens[tokenIndex + 1];
+
+    return [
+      newToken,
+      ...flatMap(comments, (comment, commentIndex) => {
+        const previous =
+          commentIndex === 0 ? token : comments[commentIndex - 1];
+
+        return [
+          ...parseWhitespace(
+            sourceCode.text.slice(previous.range[1], comment.range[0]),
+          ),
+          { ...comment, code: sourceCode.getText(comment) },
+        ];
+      }),
+      ...parseWhitespace(
+        sourceCode.text.slice(last.range[1], nextToken.range[0]),
+      ),
+    ];
+  });
 }
 
 // Prints tokens that are enhanced with a `code` property – like those returned
@@ -178,220 +178,220 @@ function getAllTokens(node, sourceCode) {
 const printTokens = (tokens) => tokens.map((token) => token.code).join("");
 
 const removeBlankLines = (whitespace) =>
-	printTokens(parseWhitespace(whitespace));
+  printTokens(parseWhitespace(whitespace));
 
 // `comments` is a list of comments that occur before `node`. Print those and
 // the whitespace between themselves and between `node`.
 function printCommentsBefore(node, comments, sourceCode) {
-	const lastIndex = comments.length - 1;
-
-	return comments
-		.map((comment, index) => {
-			const next = index === lastIndex ? node : comments[index + 1];
-
-			return (
-				sourceCode.getText(comment) +
-				removeBlankLines(sourceCode.text.slice(comment.range[1], next.range[0]))
-			);
-		})
-		.join("");
+  const lastIndex = comments.length - 1;
+
+  return comments
+    .map((comment, index) => {
+      const next = index === lastIndex ? node : comments[index + 1];
+
+      return (
+        sourceCode.getText(comment) +
+        removeBlankLines(sourceCode.text.slice(comment.range[1], next.range[0]))
+      );
+    })
+    .join("");
 }
 
 // `comments` is a list of comments that occur after `node`. Print those and
 // the whitespace between themselves and between `node`.
 const printCommentsAfter = (node, comments, sourceCode) =>
-	comments
-		.map((comment, index) => {
-			const previous = index === 0 ? node : comments[index - 1];
-
-			return (
-				removeBlankLines(
-					sourceCode.text.slice(previous.range[1], comment.range[0]),
-				) + sourceCode.getText(comment)
-			);
-		})
-		.join("");
+  comments
+    .map((comment, index) => {
+      const previous = index === 0 ? node : comments[index - 1];
+
+      return (
+        removeBlankLines(
+          sourceCode.text.slice(previous.range[1], comment.range[0]),
+        ) + sourceCode.getText(comment)
+      );
+    })
+    .join("");
 
 function getIndentation(node, sourceCode) {
-	const tokenBefore = sourceCode.getTokenBefore(node, {
-		includeComments: true,
-	});
-	if (tokenBefore == null) {
-		const text = sourceCode.text.slice(0, node.range[0]);
-		const lines = text.split(NEWLINE);
-
-		return lines[lines.length - 1];
-	}
-	const text = sourceCode.text.slice(tokenBefore.range[1], node.range[0]);
-	const lines = text.split(NEWLINE);
-
-	return lines.length > 1 ? lines[lines.length - 1] : "";
+  const tokenBefore = sourceCode.getTokenBefore(node, {
+    includeComments: true,
+  });
+  if (tokenBefore == null) {
+    const text = sourceCode.text.slice(0, node.range[0]);
+    const lines = text.split(NEWLINE);
+
+    return lines[lines.length - 1];
+  }
+  const text = sourceCode.text.slice(tokenBefore.range[1], node.range[0]);
+  const lines = text.split(NEWLINE);
+
+  return lines.length > 1 ? lines[lines.length - 1] : "";
 }
 
 function getTrailingSpaces(node, sourceCode) {
-	const tokenAfter = sourceCode.getTokenAfter(node, {
-		includeComments: true,
-	});
-	if (tokenAfter == null) {
-		const text = sourceCode.text.slice(node.range[1]);
-		const lines = text.split(NEWLINE);
-
-		return lines[0];
-	}
-	const text = sourceCode.text.slice(node.range[1], tokenAfter.range[0]);
-	const lines = text.split(NEWLINE);
-
-	return lines[0];
+  const tokenAfter = sourceCode.getTokenAfter(node, {
+    includeComments: true,
+  });
+  if (tokenAfter == null) {
+    const text = sourceCode.text.slice(node.range[1]);
+    const lines = text.split(NEWLINE);
+
+    return lines[0];
+  }
+  const text = sourceCode.text.slice(node.range[1], tokenAfter.range[0]);
+  const lines = text.split(NEWLINE);
+
+  return lines[0];
 }
 
 const sortImportExportItems = (items) =>
-	[...items].sort((itemA, itemB) =>
-		// If both items are side effect imports, keep their original order.
-		itemA.isSideEffectImport && itemB.isSideEffectImport
-			? itemA.index - itemB.index
-			: // If one of the items is a side effect import, move it first.
-				itemA.isSideEffectImport
-				? -1
-				: itemB.isSideEffectImport
-					? 1
-					: // Compare the `from` part.
-						compare(itemA.source.source, itemB.source.source) ||
-						// The `.source` has been slightly tweaked. To stay fully deterministic,
-						// also sort on the original value.
-						compare(itemA.source.originalSource, itemB.source.originalSource) ||
-						// Then put type imports/exports before regular ones.
-						compare(itemA.source.kind, itemB.source.kind) ||
-						// Keep the original order if the sources are the same. It’s not worth
-						// trying to compare anything else, and you can use `import/no-duplicates`
-						// to get rid of the problem anyway.
-						itemA.index - itemB.index,
-	);
+  [...items].sort((itemA, itemB) =>
+    // If both items are side effect imports, keep their original order.
+    itemA.isSideEffectImport && itemB.isSideEffectImport
+      ? itemA.index - itemB.index
+      : // If one of the items is a side effect import, move it first.
+        itemA.isSideEffectImport
+        ? -1
+        : itemB.isSideEffectImport
+          ? 1
+          : // Compare the `from` part.
+            compare(itemA.source.source, itemB.source.source) ||
+            // The `.source` has been slightly tweaked. To stay fully deterministic,
+            // also sort on the original value.
+            compare(itemA.source.originalSource, itemB.source.originalSource) ||
+            // Then put type imports/exports before regular ones.
+            compare(itemA.source.kind, itemB.source.kind) ||
+            // Keep the original order if the sources are the same. It’s not worth
+            // trying to compare anything else, and you can use `import/no-duplicates`
+            // to get rid of the problem anyway.
+            itemA.index - itemB.index,
+  );
 
 const sortSpecifierItems = (items) =>
-	[...items].sort(
-		(itemA, itemB) =>
-			// Compare by imported or exported name (external interface name).
-			// import { a as b } from "a"
-			//          ^
-			// export { b as a }
-			//               ^
-			compare(
-				(itemA.node.imported || itemA.node.exported).name,
-				(itemB.node.imported || itemB.node.exported).name,
-			) ||
-			// Then compare by the file-local name.
-			// import { a as b } from "a"
-			//               ^
-			// export { b as a }
-			//          ^
-			compare(itemA.node.local.name, itemB.node.local.name) ||
-			// Then put type specifiers before regular ones.
-			compare(
-				getImportExportKind(itemA.node),
-				getImportExportKind(itemB.node),
-			) ||
-			// Keep the original order if the names are the same. It’s not worth
-			// trying to compare anything else, `import {a, a} from "mod"` is a syntax
-			// error anyway (but @babel/eslint-parser kind of supports it).
-			// istanbul ignore next
-			itemA.index - itemB.index,
-	);
+  [...items].sort(
+    (itemA, itemB) =>
+      // Compare by imported or exported name (external interface name).
+      // import { a as b } from "a"
+      //          ^
+      // export { b as a }
+      //               ^
+      compare(
+        (itemA.node.imported || itemA.node.exported).name,
+        (itemB.node.imported || itemB.node.exported).name,
+      ) ||
+      // Then compare by the file-local name.
+      // import { a as b } from "a"
+      //               ^
+      // export { b as a }
+      //          ^
+      compare(itemA.node.local.name, itemB.node.local.name) ||
+      // Then put type specifiers before regular ones.
+      compare(
+        getImportExportKind(itemA.node),
+        getImportExportKind(itemB.node),
+      ) ||
+      // Keep the original order if the names are the same. It’s not worth
+      // trying to compare anything else, `import {a, a} from "mod"` is a syntax
+      // error anyway (but @babel/eslint-parser kind of supports it).
+      // istanbul ignore next
+      itemA.index - itemB.index,
+  );
 
 // A “chunk” is a sequence of statements of a certain type with only comments
 // and whitespace between.
 function extractChunks(parentNode, isPartOfChunk) {
-	const chunks = [];
-	let chunk = [];
-	let lastNode;
-
-	for (const node of parentNode.body) {
-		const result = isPartOfChunk(node, lastNode);
-		switch (result) {
-			case "PartOfChunk": {
-				chunk.push(node);
-				break;
-			}
-
-			case "PartOfNewChunk": {
-				if (chunk.length > 0) {
-					chunks.push(chunk);
-				}
-				chunk = [node];
-				break;
-			}
-
-			case "NotPartOfChunk": {
-				if (chunk.length > 0) {
-					chunks.push(chunk);
-					chunk = [];
-				}
-				break;
-			}
-
-			// istanbul ignore next
-			default: {
-				throw new Error(`Unknown chunk result: ${result}`);
-			}
-		}
-
-		lastNode = node;
-	}
-
-	if (chunk.length > 0) {
-		chunks.push(chunk);
-	}
-
-	return chunks;
+  const chunks = [];
+  let chunk = [];
+  let lastNode;
+
+  for (const node of parentNode.body) {
+    const result = isPartOfChunk(node, lastNode);
+    switch (result) {
+      case "PartOfChunk": {
+        chunk.push(node);
+        break;
+      }
+
+      case "PartOfNewChunk": {
+        if (chunk.length > 0) {
+          chunks.push(chunk);
+        }
+        chunk = [node];
+        break;
+      }
+
+      case "NotPartOfChunk": {
+        if (chunk.length > 0) {
+          chunks.push(chunk);
+          chunk = [];
+        }
+        break;
+      }
+
+      // istanbul ignore next
+      default: {
+        throw new Error(`Unknown chunk result: ${result}`);
+      }
+    }
+
+    lastNode = node;
+  }
+
+  if (chunk.length > 0) {
+    chunks.push(chunk);
+  }
+
+  return chunks;
 }
 
 function maybeReportSorting(context, sorted, start, end) {
-	const sourceCode = context.sourceCode;
-	const original = sourceCode.getText().slice(start, end);
-	if (original !== sorted) {
-		context.report({
-			messageId: "sort",
-			loc: {
-				start: sourceCode.getLocFromIndex(start),
-				end: sourceCode.getLocFromIndex(end),
-			},
-			fix: (fixer) => fixer.replaceTextRange([start, end], sorted),
-		});
-	}
+  const sourceCode = context.sourceCode;
+  const original = sourceCode.getText().slice(start, end);
+  if (original !== sorted) {
+    context.report({
+      messageId: "sort",
+      loc: {
+        start: sourceCode.getLocFromIndex(start),
+        end: sourceCode.getLocFromIndex(end),
+      },
+      fix: (fixer) => fixer.replaceTextRange([start, end], sorted),
+    });
+  }
 }
 
 function printSortedItems(sortedItems, originalItems, sourceCode) {
-	const newline = guessNewline(sourceCode);
-
-	const sorted = sortedItems
-		.map((groups) =>
-			groups
-				.map((groupItems) => groupItems.map((item) => item.code).join(newline))
-				.join(newline),
-		)
-		.join(newline + newline);
-
-	// Edge case: If the last import/export (after sorting) ends with a line
-	// comment and there’s code (or a multiline block comment) on the same line,
-	// add a newline so we don’t accidentally comment stuff out.
-	const flattened = flatMap(sortedItems, (groups) => groups.flat());
-	const lastSortedItem = flattened[flattened.length - 1];
-	const lastOriginalItem = originalItems[originalItems.length - 1];
-	const nextToken = lastSortedItem.needsNewline
-		? sourceCode.getTokenAfter(lastOriginalItem.node, {
-				includeComments: true,
-				filter: (token) =>
-					!isLineComment(token) &&
-					(!isBlockComment(token) ||
-						token.loc.end.line !== lastOriginalItem.node.loc.end.line),
-			})
-		: undefined;
-	const maybeNewline =
-		nextToken != null &&
-		nextToken.loc.start.line === lastOriginalItem.node.loc.end.line
-			? newline
-			: "";
-
-	return sorted + maybeNewline;
+  const newline = guessNewline(sourceCode);
+
+  const sorted = sortedItems
+    .map((groups) =>
+      groups
+        .map((groupItems) => groupItems.map((item) => item.code).join(newline))
+        .join(newline),
+    )
+    .join(newline + newline);
+
+  // Edge case: If the last import/export (after sorting) ends with a line
+  // comment and there’s code (or a multiline block comment) on the same line,
+  // add a newline so we don’t accidentally comment stuff out.
+  const flattened = flatMap(sortedItems, (groups) => groups.flat());
+  const lastSortedItem = flattened[flattened.length - 1];
+  const lastOriginalItem = originalItems[originalItems.length - 1];
+  const nextToken = lastSortedItem.needsNewline
+    ? sourceCode.getTokenAfter(lastOriginalItem.node, {
+        includeComments: true,
+        filter: (token) =>
+          !isLineComment(token) &&
+          (!isBlockComment(token) ||
+            token.loc.end.line !== lastOriginalItem.node.loc.end.line),
+      })
+    : undefined;
+  const maybeNewline =
+    nextToken != null &&
+    nextToken.loc.start.line === lastOriginalItem.node.loc.end.line
+      ? newline
+      : "";
+
+  return sorted + maybeNewline;
 }
 
 // Wrap the import/export nodes in `passedChunk` in objects with more data about
@@ -399,86 +399,86 @@ function printSortedItems(sortedItems, originalItems, sourceCode) {
 // the node as a string, with comments (if any). Finding the corresponding
 // comments is the hard part.
 function getImportExportItems(
-	passedChunk,
-	sourceCode,
-	isSideEffectImport,
-	getSpecifiers,
+  passedChunk,
+  sourceCode,
+  isSideEffectImport,
+  getSpecifiers,
 ) {
-	const chunk = handleLastSemicolon(passedChunk, sourceCode);
-
-	return chunk.map((node, nodeIndex) => {
-		const lastLine =
-			nodeIndex === 0
-				? node.loc.start.line - 1
-				: chunk[nodeIndex - 1].loc.end.line;
-
-		// Get all comments before the import/export, except:
-		//
-		// - Comments on another line for the first import/export.
-		// - Comments that belong to the previous import/export (if any) – that is,
-		//   comments that are on the same line as the previous import/export. But
-		//   multiline block comments always belong to this import/export, not the
-		//   previous.
-		const commentsBefore = sourceCode
-			.getCommentsBefore(node)
-			.filter(
-				(comment) =>
-					comment.loc.start.line <= node.loc.start.line &&
-					comment.loc.end.line > lastLine &&
-					(nodeIndex > 0 || comment.loc.start.line > lastLine),
-			);
-
-		// Get all comments after the import/export that are on the same line.
-		// Multiline block comments belong to the _next_ import/export (or the
-		// following code in case of the last import/export).
-		const commentsAfter = sourceCode
-			.getCommentsAfter(node)
-			.filter((comment) => comment.loc.end.line === node.loc.end.line);
-
-		const before = printCommentsBefore(node, commentsBefore, sourceCode);
-		const after = printCommentsAfter(node, commentsAfter, sourceCode);
-
-		// Print the indentation before the import/export or its first comment, if
-		// any, to support indentation in `<script>` tags.
-		const indentation = getIndentation(
-			commentsBefore.length > 0 ? commentsBefore[0] : node,
-			sourceCode,
-		);
-
-		// Print spaces after the import/export or its last comment, if any, to
-		// avoid producing a sort error just because you accidentally added a few
-		// trailing spaces among the imports/exports.
-		const trailingSpaces = getTrailingSpaces(
-			commentsAfter.length > 0 ? commentsAfter[commentsAfter.length - 1] : node,
-			sourceCode,
-		);
-
-		const code =
-			indentation +
-			before +
-			printWithSortedSpecifiers(node, sourceCode, getSpecifiers) +
-			after +
-			trailingSpaces;
-
-		const all = [...commentsBefore, node, ...commentsAfter];
-		const [start] = all[0].range;
-		const [, end] = all[all.length - 1].range;
-
-		const source = getSource(node);
-
-		return {
-			node,
-			code,
-			start: start - indentation.length,
-			end: end + trailingSpaces.length,
-			isSideEffectImport: isSideEffectImport(node, sourceCode),
-			source,
-			index: nodeIndex,
-			needsNewline:
-				commentsAfter.length > 0 &&
-				isLineComment(commentsAfter[commentsAfter.length - 1]),
-		};
-	});
+  const chunk = handleLastSemicolon(passedChunk, sourceCode);
+
+  return chunk.map((node, nodeIndex) => {
+    const lastLine =
+      nodeIndex === 0
+        ? node.loc.start.line - 1
+        : chunk[nodeIndex - 1].loc.end.line;
+
+    // Get all comments before the import/export, except:
+    //
+    // - Comments on another line for the first import/export.
+    // - Comments that belong to the previous import/export (if any) – that is,
+    //   comments that are on the same line as the previous import/export. But
+    //   multiline block comments always belong to this import/export, not the
+    //   previous.
+    const commentsBefore = sourceCode
+      .getCommentsBefore(node)
+      .filter(
+        (comment) =>
+          comment.loc.start.line <= node.loc.start.line &&
+          comment.loc.end.line > lastLine &&
+          (nodeIndex > 0 || comment.loc.start.line > lastLine),
+      );
+
+    // Get all comments after the import/export that are on the same line.
+    // Multiline block comments belong to the _next_ import/export (or the
+    // following code in case of the last import/export).
+    const commentsAfter = sourceCode
+      .getCommentsAfter(node)
+      .filter((comment) => comment.loc.end.line === node.loc.end.line);
+
+    const before = printCommentsBefore(node, commentsBefore, sourceCode);
+    const after = printCommentsAfter(node, commentsAfter, sourceCode);
+
+    // Print the indentation before the import/export or its first comment, if
+    // any, to support indentation in `<script>` tags.
+    const indentation = getIndentation(
+      commentsBefore.length > 0 ? commentsBefore[0] : node,
+      sourceCode,
+    );
+
+    // Print spaces after the import/export or its last comment, if any, to
+    // avoid producing a sort error just because you accidentally added a few
+    // trailing spaces among the imports/exports.
+    const trailingSpaces = getTrailingSpaces(
+      commentsAfter.length > 0 ? commentsAfter[commentsAfter.length - 1] : node,
+      sourceCode,
+    );
+
+    const code =
+      indentation +
+      before +
+      printWithSortedSpecifiers(node, sourceCode, getSpecifiers) +
+      after +
+      trailingSpaces;
+
+    const all = [...commentsBefore, node, ...commentsAfter];
+    const [start] = all[0].range;
+    const [, end] = all[all.length - 1].range;
+
+    const source = getSource(node);
+
+    return {
+      node,
+      code,
+      start: start - indentation.length,
+      end: end + trailingSpaces.length,
+      isSideEffectImport: isSideEffectImport(node, sourceCode),
+      source,
+      index: nodeIndex,
+      needsNewline:
+        commentsAfter.length > 0 &&
+        isLineComment(commentsAfter[commentsAfter.length - 1]),
+    };
+  });
 }
 
 // Parsers think that a semicolon after a statement belongs to that statement.
@@ -493,141 +493,141 @@ function getImportExportItems(
 //
 // In the above example, the import is adjusted to end after `"x"`.
 function handleLastSemicolon(chunk, sourceCode) {
-	const lastIndex = chunk.length - 1;
-	const lastNode = chunk[lastIndex];
-	const [nextToLastToken, lastToken] = sourceCode.getLastTokens(lastNode, {
-		count: 2,
-	});
-	const lastIsSemicolon = isPunctuator(lastToken, ";");
-
-	if (!lastIsSemicolon) {
-		return chunk;
-	}
-
-	const semicolonBelongsToNode =
-		nextToLastToken.loc.end.line === lastToken.loc.start.line ||
-		// If there’s no more code after the last import/export the semicolon has to
-		// belong to the import/export, even if it is not on the same line.
-		sourceCode.getTokenAfter(lastToken) == null;
-
-	if (semicolonBelongsToNode) {
-		return chunk;
-	}
-
-	// Preserve the start position, but use the end position of the `from` string.
-	const newLastNode = {
-		...lastNode,
-		range: [lastNode.range[0], nextToLastToken.range[1]],
-		loc: {
-			start: lastNode.loc.start,
-			end: nextToLastToken.loc.end,
-		},
-	};
-
-	return [...chunk.slice(0, lastIndex), newLastNode];
+  const lastIndex = chunk.length - 1;
+  const lastNode = chunk[lastIndex];
+  const [nextToLastToken, lastToken] = sourceCode.getLastTokens(lastNode, {
+    count: 2,
+  });
+  const lastIsSemicolon = isPunctuator(lastToken, ";");
+
+  if (!lastIsSemicolon) {
+    return chunk;
+  }
+
+  const semicolonBelongsToNode =
+    nextToLastToken.loc.end.line === lastToken.loc.start.line ||
+    // If there’s no more code after the last import/export the semicolon has to
+    // belong to the import/export, even if it is not on the same line.
+    sourceCode.getTokenAfter(lastToken) == null;
+
+  if (semicolonBelongsToNode) {
+    return chunk;
+  }
+
+  // Preserve the start position, but use the end position of the `from` string.
+  const newLastNode = {
+    ...lastNode,
+    range: [lastNode.range[0], nextToLastToken.range[1]],
+    loc: {
+      start: lastNode.loc.start,
+      end: nextToLastToken.loc.end,
+    },
+  };
+
+  return [...chunk.slice(0, lastIndex), newLastNode];
 }
 
 function printWithSortedSpecifiers(node, sourceCode, getSpecifiers) {
-	const allTokens = getAllTokens(node, sourceCode);
-	const openBraceIndex = allTokens.findIndex((token) =>
-		isPunctuator(token, "{"),
-	);
-	const closeBraceIndex = allTokens.findIndex((token) =>
-		isPunctuator(token, "}"),
-	);
-
-	const specifiers = getSpecifiers(node);
-
-	if (
-		openBraceIndex === -1 ||
-		closeBraceIndex === -1 ||
-		specifiers.length <= 1
-	) {
-		return printTokens(allTokens);
-	}
-
-	const specifierTokens = allTokens.slice(openBraceIndex + 1, closeBraceIndex);
-	const itemsResult = getSpecifierItems(specifierTokens, sourceCode);
-
-	const items = itemsResult.items.map((originalItem, index) => ({
-		...originalItem,
-		node: specifiers[index],
-	}));
-
-	const sortedItems = sortSpecifierItems(items);
-
-	const newline = guessNewline(sourceCode);
-
-	// `allTokens[closeBraceIndex - 1]` wouldn’t work because `allTokens` contains
-	// comments and whitespace.
-	const hasTrailingComma = isPunctuator(
-		sourceCode.getTokenBefore(allTokens[closeBraceIndex]),
-		",",
-	);
-
-	const lastIndex = sortedItems.length - 1;
-	const sorted = flatMap(sortedItems, (item, index) => {
-		const previous = index === 0 ? undefined : sortedItems[index - 1];
-
-		// Add a newline if the item needs one, unless the previous item (if any)
-		// already ends with a newline.
-		const maybeNewline =
-			previous != null &&
-			needsStartingNewline(item.before) &&
-			(previous.after.length <= 0 ||
-				!isNewline(previous.after[previous.after.length - 1]))
-				? [{ type: "Newline", code: newline }]
-				: [];
-
-		if (index < lastIndex || hasTrailingComma) {
-			return [
-				...maybeNewline,
-				...item.before,
-				...item.specifier,
-				{ type: "Comma", code: "," },
-				...item.after,
-			];
-		}
-
-		const nonBlankIndex = item.after.findIndex(
-			(token) => !isNewline(token) && !isSpaces(token),
-		);
-
-		// Remove whitespace and newlines at the start of `.after` if the item had a
-		// comma before, but now hasn’t to avoid blank lines and excessive
-		// whitespace before `}`.
-		const after = item.hadComma
-			? nonBlankIndex === -1
-				? []
-				: item.after.slice(nonBlankIndex)
-			: item.after;
-
-		return [...maybeNewline, ...item.before, ...item.specifier, ...after];
-	});
-
-	const maybeNewline =
-		needsStartingNewline(itemsResult.after) &&
-		!isNewline(sorted[sorted.length - 1])
-			? [{ type: "Newline", code: newline }]
-			: [];
-
-	return printTokens([
-		...allTokens.slice(0, openBraceIndex + 1),
-		...itemsResult.before,
-		...sorted,
-		...maybeNewline,
-		...itemsResult.after,
-		...allTokens.slice(closeBraceIndex),
-	]);
+  const allTokens = getAllTokens(node, sourceCode);
+  const openBraceIndex = allTokens.findIndex((token) =>
+    isPunctuator(token, "{"),
+  );
+  const closeBraceIndex = allTokens.findIndex((token) =>
+    isPunctuator(token, "}"),
+  );
+
+  const specifiers = getSpecifiers(node);
+
+  if (
+    openBraceIndex === -1 ||
+    closeBraceIndex === -1 ||
+    specifiers.length <= 1
+  ) {
+    return printTokens(allTokens);
+  }
+
+  const specifierTokens = allTokens.slice(openBraceIndex + 1, closeBraceIndex);
+  const itemsResult = getSpecifierItems(specifierTokens, sourceCode);
+
+  const items = itemsResult.items.map((originalItem, index) => ({
+    ...originalItem,
+    node: specifiers[index],
+  }));
+
+  const sortedItems = sortSpecifierItems(items);
+
+  const newline = guessNewline(sourceCode);
+
+  // `allTokens[closeBraceIndex - 1]` wouldn’t work because `allTokens` contains
+  // comments and whitespace.
+  const hasTrailingComma = isPunctuator(
+    sourceCode.getTokenBefore(allTokens[closeBraceIndex]),
+    ",",
+  );
+
+  const lastIndex = sortedItems.length - 1;
+  const sorted = flatMap(sortedItems, (item, index) => {
+    const previous = index === 0 ? undefined : sortedItems[index - 1];
+
+    // Add a newline if the item needs one, unless the previous item (if any)
+    // already ends with a newline.
+    const maybeNewline =
+      previous != null &&
+      needsStartingNewline(item.before) &&
+      (previous.after.length <= 0 ||
+        !isNewline(previous.after[previous.after.length - 1]))
+        ? [{ type: "Newline", code: newline }]
+        : [];
+
+    if (index < lastIndex || hasTrailingComma) {
+      return [
+        ...maybeNewline,
+        ...item.before,
+        ...item.specifier,
+        { type: "Comma", code: "," },
+        ...item.after,
+      ];
+    }
+
+    const nonBlankIndex = item.after.findIndex(
+      (token) => !isNewline(token) && !isSpaces(token),
+    );
+
+    // Remove whitespace and newlines at the start of `.after` if the item had a
+    // comma before, but now hasn’t to avoid blank lines and excessive
+    // whitespace before `}`.
+    const after = item.hadComma
+      ? nonBlankIndex === -1
+        ? []
+        : item.after.slice(nonBlankIndex)
+      : item.after;
+
+    return [...maybeNewline, ...item.before, ...item.specifier, ...after];
+  });
+
+  const maybeNewline =
+    needsStartingNewline(itemsResult.after) &&
+    !isNewline(sorted[sorted.length - 1])
+      ? [{ type: "Newline", code: newline }]
+      : [];
+
+  return printTokens([
+    ...allTokens.slice(0, openBraceIndex + 1),
+    ...itemsResult.before,
+    ...sorted,
+    ...maybeNewline,
+    ...itemsResult.after,
+    ...allTokens.slice(closeBraceIndex),
+  ]);
 }
 
 const makeEmptyItem = () => ({
-	// "before" | "specifier" | "after"
-	state: "before",
-	before: [],
-	after: [],
-	specifier: [],
-	hadComma: false,
+  // "before" | "specifier" | "after"
+  state: "before",
+  before: [],
+  after: [],
+  specifier: [],
+  hadComma: false,
 });
 
 // Turns a list of tokens between the `{` and `}` of an import/export specifiers
@@ -650,234 +650,234 @@ const makeEmptyItem = () => ({
 // We have to do carefully preserve all original whitespace this way in order to
 // be compatible with other stylistic ESLint rules.
 function getSpecifierItems(tokens) {
-	const result = {
-		before: [],
-		after: [],
-		items: [],
-	};
-
-	let current = makeEmptyItem();
-
-	for (const token of tokens) {
-		switch (current.state) {
-			case "before": {
-				switch (token.type) {
-					case "Newline": {
-						current.before.push(token);
-
-						// All whitespace and comments before the first newline or
-						// identifier belong to the `{`, not the first specifier.
-						if (result.before.length === 0 && result.items.length === 0) {
-							result.before = current.before;
-							current = makeEmptyItem();
-						}
-						break;
-					}
-
-					case "Spaces":
-					case "Block":
-					case "Line": {
-						current.before.push(token);
-						break;
-					}
-
-					// We’ve reached an identifier.
-					default: {
-						// All whitespace and comments before the first newline or
-						// identifier belong to the `{`, not the first specifier.
-						if (result.before.length === 0 && result.items.length === 0) {
-							result.before = current.before;
-							current = makeEmptyItem();
-						}
-
-						current.state = "specifier";
-						current.specifier.push(token);
-					}
-				}
-				break;
-			}
-
-			case "specifier": {
-				switch (token.type) {
-					case "Punctuator": {
-						// There can only be comma punctuators, but future-proof by checking.
-						// istanbul ignore else
-						if (isPunctuator(token, ",")) {
-							current.hadComma = true;
-							current.state = "after";
-						} else {
-							current.specifier.push(token);
-						}
-						break;
-					}
-
-					// When consuming the specifier part, we eat every token until a comma
-					// or to the end, basically.
-					default: {
-						current.specifier.push(token);
-					}
-				}
-				break;
-			}
-
-			case "after": {
-				switch (token.type) {
-					// Only whitespace and comments after a specifier that are on the same
-					// belong to the specifier.
-					case "Newline": {
-						current.after.push(token);
-						result.items.push(current);
-						current = makeEmptyItem();
-						break;
-					}
-
-					case "Spaces":
-					case "Line": {
-						current.after.push(token);
-						break;
-					}
-
-					case "Block": {
-						// Multiline block comments belong to the next specifier.
-						if (hasNewline(token.code)) {
-							result.items.push(current);
-							current = makeEmptyItem();
-							current.before.push(token);
-						} else {
-							current.after.push(token);
-						}
-						break;
-					}
-
-					// We’ve reached another specifier – time to process that one.
-					default: {
-						result.items.push(current);
-						current = makeEmptyItem();
-						current.state = "specifier";
-						current.specifier.push(token);
-					}
-				}
-				break;
-			}
-
-			// istanbul ignore next
-			default: {
-				throw new Error(`Unknown state: ${current.state}`);
-			}
-		}
-	}
-
-	// We’ve reached the end of the tokens. Handle what’s currently in `current`.
-	switch (current.state) {
-		// If the last specifier has a trailing comma and some of the remaining
-		// whitespace and comments are on the same line we end up here. If so we
-		// want to put that whitespace and comments in `result.after`.
-		case "before": {
-			result.after = current.before;
-			break;
-		}
-
-		// If the last specifier has no trailing comma we end up here. Move all
-		// trailing comments and whitespace from `.specifier` to `.after`, and
-		// comments and whitespace that don’t belong to the specifier to
-		// `result.after`. The last non-comment and non-whitespace token is usually
-		// an identifier, but in this case it’s a keyword:
-		//
-		//    export { z, d as default } from "a"
-		case "specifier": {
-			const lastIdentifierIndex = findLastIndex(
-				current.specifier,
-				(token2) => isIdentifier(token2) || isKeyword(token2),
-			);
-
-			const specifier = current.specifier.slice(0, lastIdentifierIndex + 1);
-			const after = current.specifier.slice(lastIdentifierIndex + 1);
-
-			// If there’s a newline, put everything up to and including (hence the `+
-			// 1`) that newline in the specifiers’s `.after`.
-			const newlineIndexRaw = after.findIndex((token2) => isNewline(token2));
-			const newlineIndex = newlineIndexRaw === -1 ? -1 : newlineIndexRaw + 1;
-
-			// If there’s a multiline block comment, put everything _befor_ that
-			// comment in the specifiers’s `.after`.
-			const multilineBlockCommentIndex = after.findIndex(
-				(token2) => isBlockComment(token2) && hasNewline(token2.code),
-			);
-
-			const sliceIndex =
-				// If both a newline and a multiline block comment exists, choose the
-				// earlier one.
-				newlineIndex >= 0 && multilineBlockCommentIndex !== -1
-					? Math.min(newlineIndex, multilineBlockCommentIndex)
-					: newlineIndex >= 0
-						? newlineIndex
-						: multilineBlockCommentIndex === -1
-							? endsWithSpaces(after)
-								? after.length - 1
-								: -1
-							: // If there are no newlines, move the last whitespace into `result.after`.
-								multilineBlockCommentIndex;
-
-			current.specifier = specifier;
-			current.after = sliceIndex === -1 ? after : after.slice(0, sliceIndex);
-			result.items.push(current);
-			result.after = sliceIndex === -1 ? [] : after.slice(sliceIndex);
-
-			break;
-		}
-
-		// If the last specifier has a trailing comma and all remaining whitespace
-		// and comments are on the same line we end up here. If so we want to move
-		// the final whitespace to `result.after`.
-		case "after": {
-			if (endsWithSpaces(current.after)) {
-				const last = current.after.pop();
-				result.after = [last];
-			}
-			result.items.push(current);
-			break;
-		}
-
-		// istanbul ignore next
-		default: {
-			throw new Error(`Unknown state: ${current.state}`);
-		}
-	}
-
-	return result;
+  const result = {
+    before: [],
+    after: [],
+    items: [],
+  };
+
+  let current = makeEmptyItem();
+
+  for (const token of tokens) {
+    switch (current.state) {
+      case "before": {
+        switch (token.type) {
+          case "Newline": {
+            current.before.push(token);
+
+            // All whitespace and comments before the first newline or
+            // identifier belong to the `{`, not the first specifier.
+            if (result.before.length === 0 && result.items.length === 0) {
+              result.before = current.before;
+              current = makeEmptyItem();
+            }
+            break;
+          }
+
+          case "Spaces":
+          case "Block":
+          case "Line": {
+            current.before.push(token);
+            break;
+          }
+
+          // We’ve reached an identifier.
+          default: {
+            // All whitespace and comments before the first newline or
+            // identifier belong to the `{`, not the first specifier.
+            if (result.before.length === 0 && result.items.length === 0) {
+              result.before = current.before;
+              current = makeEmptyItem();
+            }
+
+            current.state = "specifier";
+            current.specifier.push(token);
+          }
+        }
+        break;
+      }
+
+      case "specifier": {
+        switch (token.type) {
+          case "Punctuator": {
+            // There can only be comma punctuators, but future-proof by checking.
+            // istanbul ignore else
+            if (isPunctuator(token, ",")) {
+              current.hadComma = true;
+              current.state = "after";
+            } else {
+              current.specifier.push(token);
+            }
+            break;
+          }
+
+          // When consuming the specifier part, we eat every token until a comma
+          // or to the end, basically.
+          default: {
+            current.specifier.push(token);
+          }
+        }
+        break;
+      }
+
+      case "after": {
+        switch (token.type) {
+          // Only whitespace and comments after a specifier that are on the same
+          // belong to the specifier.
+          case "Newline": {
+            current.after.push(token);
+            result.items.push(current);
+            current = makeEmptyItem();
+            break;
+          }
+
+          case "Spaces":
+          case "Line": {
+            current.after.push(token);
+            break;
+          }
+
+          case "Block": {
+            // Multiline block comments belong to the next specifier.
+            if (hasNewline(token.code)) {
+              result.items.push(current);
+              current = makeEmptyItem();
+              current.before.push(token);
+            } else {
+              current.after.push(token);
+            }
+            break;
+          }
+
+          // We’ve reached another specifier – time to process that one.
+          default: {
+            result.items.push(current);
+            current = makeEmptyItem();
+            current.state = "specifier";
+            current.specifier.push(token);
+          }
+        }
+        break;
+      }
+
+      // istanbul ignore next
+      default: {
+        throw new Error(`Unknown state: ${current.state}`);
+      }
+    }
+  }
+
+  // We’ve reached the end of the tokens. Handle what’s currently in `current`.
+  switch (current.state) {
+    // If the last specifier has a trailing comma and some of the remaining
+    // whitespace and comments are on the same line we end up here. If so we
+    // want to put that whitespace and comments in `result.after`.
+    case "before": {
+      result.after = current.before;
+      break;
+    }
+
+    // If the last specifier has no trailing comma we end up here. Move all
+    // trailing comments and whitespace from `.specifier` to `.after`, and
+    // comments and whitespace that don’t belong to the specifier to
+    // `result.after`. The last non-comment and non-whitespace token is usually
+    // an identifier, but in this case it’s a keyword:
+    //
+    //    export { z, d as default } from "a"
+    case "specifier": {
+      const lastIdentifierIndex = findLastIndex(
+        current.specifier,
+        (token2) => isIdentifier(token2) || isKeyword(token2),
+      );
+
+      const specifier = current.specifier.slice(0, lastIdentifierIndex + 1);
+      const after = current.specifier.slice(lastIdentifierIndex + 1);
+
+      // If there’s a newline, put everything up to and including (hence the `+
+      // 1`) that newline in the specifiers’s `.after`.
+      const newlineIndexRaw = after.findIndex((token2) => isNewline(token2));
+      const newlineIndex = newlineIndexRaw === -1 ? -1 : newlineIndexRaw + 1;
+
+      // If there’s a multiline block comment, put everything _befor_ that
+      // comment in the specifiers’s `.after`.
+      const multilineBlockCommentIndex = after.findIndex(
+        (token2) => isBlockComment(token2) && hasNewline(token2.code),
+      );
+
+      const sliceIndex =
+        // If both a newline and a multiline block comment exists, choose the
+        // earlier one.
+        newlineIndex >= 0 && multilineBlockCommentIndex !== -1
+          ? Math.min(newlineIndex, multilineBlockCommentIndex)
+          : newlineIndex >= 0
+            ? newlineIndex
+            : multilineBlockCommentIndex === -1
+              ? endsWithSpaces(after)
+                ? after.length - 1
+                : -1
+              : // If there are no newlines, move the last whitespace into `result.after`.
+                multilineBlockCommentIndex;
+
+      current.specifier = specifier;
+      current.after = sliceIndex === -1 ? after : after.slice(0, sliceIndex);
+      result.items.push(current);
+      result.after = sliceIndex === -1 ? [] : after.slice(sliceIndex);
+
+      break;
+    }
+
+    // If the last specifier has a trailing comma and all remaining whitespace
+    // and comments are on the same line we end up here. If so we want to move
+    // the final whitespace to `result.after`.
+    case "after": {
+      if (endsWithSpaces(current.after)) {
+        const last = current.after.pop();
+        result.after = [last];
+      }
+      result.items.push(current);
+      break;
+    }
+
+    // istanbul ignore next
+    default: {
+      throw new Error(`Unknown state: ${current.state}`);
+    }
+  }
+
+  return result;
 }
 
 // If a specifier item starts with a line comment or a singleline block comment
 // it needs a newline before that. Otherwise that comment can end up belonging
 // to the _previous_ specifier after sorting.
 function needsStartingNewline(tokens) {
-	const before = tokens.filter((token) => !isSpaces(token));
+  const before = tokens.filter((token) => !isSpaces(token));
 
-	if (before.length === 0) {
-		return false;
-	}
+  if (before.length === 0) {
+    return false;
+  }
 
-	const firstToken = before[0];
+  const firstToken = before[0];
 
-	return (
-		isLineComment(firstToken) ||
-		(isBlockComment(firstToken) && !hasNewline(firstToken.code))
-	);
+  return (
+    isLineComment(firstToken) ||
+    (isBlockComment(firstToken) && !hasNewline(firstToken.code))
+  );
 }
 
 function endsWithSpaces(tokens) {
-	const last = tokens.length > 0 ? tokens[tokens.length - 1] : undefined;
+  const last = tokens.length > 0 ? tokens[tokens.length - 1] : undefined;
 
-	return last == null ? false : isSpaces(last);
+  return last == null ? false : isSpaces(last);
 }
 
 module.exports = {
-	extractChunks,
-	flatMap,
-	getImportExportItems,
-	isPunctuator,
-	maybeReportSorting,
-	printSortedItems,
-	printWithSortedSpecifiers,
-	sortImportExportItems,
+  extractChunks,
+  flatMap,
+  getImportExportItems,
+  isPunctuator,
+  maybeReportSorting,
+  printSortedItems,
+  printWithSortedSpecifiers,
+  sortImportExportItems,
 };