@so1ve/eslint-plugin-sort-imports 0.104.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-PRESENT Anthony Fu<https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@so1ve/eslint-plugin-sort-imports",
+  "version": "0.104.0",
+  "author": "Simon Lydell",
+  "contributors": [
+    "Ray (https://github.com/so1ve) <i@mk1.io>"
+  ],
+  "description": "Easy autofixable import sorting",
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "eslintplugin",
+    "import",
+    "imports",
+    "order",
+    "sort",
+    "sorter",
+    "sorting"
+  ],
+  "homepage": "https://github.com/so1ve/eslint-config#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/so1ve/eslint-config.git"
+  },
+  "bugs": {
+    "url": "https://github.com/so1ve/eslint-config/issues"
+  },
+  "license": "MIT",
+  "main": "src/index.js",
+  "files": [
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "natsort": "^2.0.3"
+  },
+  "peerDependencies": {
+    "eslint": ">=8.40.0"
+  }
+}

package/src/exports.js

@@ -0,0 +1,103 @@
+"use strict";
+
+const shared = require("./shared");
+
+// `export * from "a"` does not have `.specifiers`.
+const getSpecifiers = (exportNode) => exportNode.specifiers || [];
+
+// Full export-from statement.
+// export {a, b} from "A"
+// export * from "A"
+// export * as A from "A"
+const isExportFrom = (node) =>
+  (node.type === "ExportNamedDeclaration" ||
+    node.type === "ExportAllDeclaration") &&
+  node.source != null;
+
+function isPartOfChunk(node, lastNode, sourceCode) {
+  if (!isExportFrom(node)) {
+    return "NotPartOfChunk";
+  }
+
+  const hasGroupingComment = sourceCode
+    .getCommentsBefore(node)
+    .some(
+      (comment) =>
+        (lastNode == null || comment.loc.start.line > lastNode.loc.end.line) &&
+        comment.loc.end.line < node.loc.start.line,
+    );
+
+  return hasGroupingComment ? "PartOfNewChunk" : "PartOfChunk";
+}
+
+function maybeReportChunkSorting(chunk, context) {
+  const sourceCode = context.getSourceCode();
+  const items = shared.getImportExportItems(
+    chunk,
+    sourceCode,
+    () => false, // isSideEffectImport
+    getSpecifiers,
+  );
+  const sortedItems = [[shared.sortImportExportItems(items)]];
+  const sorted = shared.printSortedItems(sortedItems, items, sourceCode);
+  const { start } = items[0];
+  const { end } = items[items.length - 1];
+  shared.maybeReportSorting(context, sorted, start, end);
+}
+
+function maybeReportExportSpecifierSorting(node, context) {
+  const sorted = shared.printWithSortedSpecifiers(
+    node,
+    context.getSourceCode(),
+    getSpecifiers,
+  );
+  const [start, end] = node.range;
+  shared.maybeReportSorting(context, sorted, start, end);
+}
+
+module.exports = {
+  meta: {
+    type: "layout",
+    fixable: "code",
+    schema: [],
+    docs: {
+      url: "https://github.com/lydell/eslint-plugin-simple-import-sort#sort-order",
+    },
+    messages: {
+      sort: "Run autofix to sort these exports!",
+    },
+  },
+  create: (context) => {
+    const parents = new Set();
+
+    function addParent(node) {
+      if (isExportFrom(node)) {
+        parents.add(node.parent);
+      }
+    }
+
+    return {
+      "ExportNamedDeclaration": (node) => {
+        if (node.source == null && node.declaration == null) {
+          maybeReportExportSpecifierSorting(node, context);
+        } else {
+          addParent(node);
+        }
+      },
+
+      "ExportAllDeclaration": addParent,
+
+      "Program:exit": () => {
+        const sourceCode = context.getSourceCode();
+        for (const parent of parents) {
+          for (const chunk of shared.extractChunks(parent, (node, lastNode) =>
+            isPartOfChunk(node, lastNode, sourceCode),
+          )) {
+            maybeReportChunkSorting(chunk, context);
+          }
+        }
+        parents.clear();
+      },
+    };
+  },
+};

package/src/imports.js

@@ -0,0 +1,150 @@
+"use strict";
+
+const shared = require("./shared");
+
+const defaultGroups = [
+  // Node.js builtins prefixed with `node:`.
+  ["^node:"],
+  // Packages.
+  // Things that start with a letter (or digit or underscore), or `@` followed by a letter.
+  ["^@?\\w"],
+  // Absolute imports and other imports such as Vue-style `@/foo`.
+  // Anything not matched in another group.
+  ["^"],
+  // Relative imports.
+  // Anything that starts with a dot.
+  ["^\\."],
+  // Side effect imports.
+  ["^\\u0000"],
+];
+
+// import def, { a, b as c, type d } from "A"
+//               ^  ^^^^^^  ^^^^^^
+const isImportSpecifier = (node) => node.type === "ImportSpecifier";
+
+// Exclude "ImportDefaultSpecifier" – the "def" in `import def, {a, b}`.
+const getSpecifiers = (importNode) =>
+  importNode.specifiers.filter((node) => isImportSpecifier(node));
+
+// Full import statement.
+const isImport = (node) => node.type === "ImportDeclaration";
+
+// import "setup"
+// But not: import {} from "setup"
+// And not: import type {} from "setup"
+const isSideEffectImport = (importNode, sourceCode) =>
+  importNode.specifiers.length === 0 &&
+  (!importNode.importKind || importNode.importKind === "value") &&
+  !shared.isPunctuator(sourceCode.getFirstToken(importNode, { skip: 1 }), "{");
+
+module.exports = {
+  meta: {
+    type: "layout",
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          groups: {
+            type: "array",
+            items: {
+              type: "array",
+              items: {
+                type: "string",
+              },
+            },
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    docs: {
+      url: "https://github.com/lydell/eslint-plugin-simple-import-sort#sort-order",
+    },
+    messages: {
+      sort: "Run autofix to sort these imports!",
+    },
+  },
+  create: (context) => {
+    const { groups: rawGroups = defaultGroups } = context.options[0] || {};
+
+    const outerGroups = rawGroups.map((groups) =>
+      groups.map((item) => new RegExp(item, "u")),
+    );
+
+    const parents = new Set();
+
+    return {
+      "ImportDeclaration": (node) => {
+        parents.add(node.parent);
+      },
+
+      "Program:exit": () => {
+        for (const parent of parents) {
+          for (const chunk of shared.extractChunks(parent, (node) =>
+            isImport(node) ? "PartOfChunk" : "NotPartOfChunk",
+          )) {
+            maybeReportChunkSorting(chunk, context, outerGroups);
+          }
+        }
+        parents.clear();
+      },
+    };
+  },
+};
+
+function maybeReportChunkSorting(chunk, context, outerGroups) {
+  const sourceCode = context.getSourceCode();
+  const items = shared.getImportExportItems(
+    chunk,
+    sourceCode,
+    isSideEffectImport,
+    getSpecifiers,
+  );
+  const sortedItems = makeSortedItems(items, outerGroups);
+  const sorted = shared.printSortedItems(sortedItems, items, sourceCode);
+  const { start } = items[0];
+  const { end } = items[items.length - 1];
+  shared.maybeReportSorting(context, sorted, start, end);
+}
+
+function makeSortedItems(items, outerGroups) {
+  const itemGroups = outerGroups.map((groups) =>
+    groups.map((regex) => ({ regex, items: [] })),
+  );
+  const rest = [];
+
+  for (const item of items) {
+    const { originalSource } = item.source;
+    const source = item.isSideEffectImport
+      ? `\0${originalSource}`
+      : item.source.kind === "value"
+      ? originalSource
+      : `${originalSource}\0`;
+    const [matchedGroup] = shared
+      // eslint-disable-next-line unicorn/no-array-method-this-argument
+      .flatMap(itemGroups, (groups) =>
+        groups.map((group) => [group, group.regex.exec(source)]),
+      )
+      .reduce(
+        ([group, longestMatch], [nextGroup, nextMatch]) =>
+          nextMatch != null &&
+          (longestMatch == null || nextMatch[0].length > longestMatch[0].length)
+            ? [nextGroup, nextMatch]
+            : [group, longestMatch],
+        [undefined, undefined],
+      );
+    if (matchedGroup == null) {
+      rest.push(item);
+    } else {
+      matchedGroup.items.push(item);
+    }
+  }
+
+  return [...itemGroups, [{ regex: /^/, items: rest }]]
+    .map((groups) => groups.filter((group) => group.items.length > 0))
+    .filter((groups) => groups.length > 0)
+    .map((groups) =>
+      groups.map((group) => shared.sortImportExportItems(group.items)),
+    );
+}

package/src/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const importsRule = require("./imports");
+const exportsRule = require("./exports");
+
+module.exports = {
+  rules: {
+    imports: importsRule,
+    exports: exportsRule,
+  },
+};

package/src/shared.js

@@ -0,0 +1,870 @@
+"use strict";
+
+const natsort = require("natsort");
+
+const NEWLINE = /(\r?\n)/;
+
+const hasNewline = (string) => NEWLINE.test(string);
+
+function guessNewline(sourceCode) {
+  const match = NEWLINE.exec(sourceCode.text);
+
+  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 compare = natsort.default();
+
+const isIdentifier = (node) => node.type === "Identifier";
+
+const isKeyword = (node) => node.type === "Keyword";
+
+const isPunctuator = (node, value) =>
+  node.type === "Punctuator" && node.value === value;
+
+const isBlockComment = (node) => node.type === "Block";
+
+const isLineComment = (node) => node.type === "Line";
+
+const isSpaces = (node) => node.type === "Spaces";
+
+const isNewline = (node) => node.type === "Newline";
+
+const getImportExportKind = (node) =>
+  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),
+  };
+}
+
+// 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;
+}
+
+// Like `Array.prototype.flatMap`, had it been available.
+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]),
+      ),
+    ];
+  });
+}
+
+// Prints tokens that are enhanced with a `code` property – like those returned
+// by `getAllTokens` and `parseWhitespace`.
+const printTokens = (tokens) => tokens.map((token) => token.code).join("");
+
+const removeBlankLines = (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("");
+}
+
+// `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("");
+
+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] : "";
+}
+
+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 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,
+  );
+
+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,
+  );
+
+// 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;
+}
+
+function maybeReportSorting(context, sorted, start, end) {
+  const sourceCode = context.getSourceCode();
+  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;
+}
+
+// Wrap the import/export nodes in `passedChunk` in objects with more data about
+// the import/export. Most importantly there’s a `code` property that contains
+// the node as a string, with comments (if any). Finding the corresponding
+// comments is the hard part.
+function getImportExportItems(
+  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]),
+    };
+  });
+}
+
+// Parsers think that a semicolon after a statement belongs to that statement.
+// But in a semicolon-free code style it might belong to the next statement:
+//
+//     import x from "x"
+//     ;[].forEach()
+//
+// If the last import/export of a chunk ends with a semicolon, and that
+// semicolon isn’t located on the same line as the `from` string, adjust the
+// node to end at the `from` string instead.
+//
+// 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];
+}
+
+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 makeEmptyItem = () => ({
+  // "before" | "specifier" | "after"
+  state: "before",
+  before: [],
+  after: [],
+  specifier: [],
+  hadComma: false,
+});
+
+// Turns a list of tokens between the `{` and `}` of an import/export specifiers
+// list into an object with the following properties:
+//
+// - before: Array of tokens – whitespace and comments after the `{` that do not
+//   belong to any specifier.
+// - after: Array of tokens – whitespace and comments before the `}` that do not
+//   belong to any specifier.
+// - items: Array of specifier items.
+//
+// Each specifier item looks like this:
+//
+// - before: Array of tokens – whitespace and comments before the specifier.
+// - after: Array of tokens – whitespace and comments after the specifier.
+// - specifier: Array of tokens – identifiers, whitespace and comments of the
+//   specifier.
+// - hadComma: A Boolean representing if the specifier had a comma originally.
+//
+// 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 >= 0
+          ? Math.min(newlineIndex, multilineBlockCommentIndex)
+          : newlineIndex >= 0
+          ? newlineIndex
+          : multilineBlockCommentIndex >= 0
+          ? multilineBlockCommentIndex
+          : // If there are no newlines, move the last whitespace into `result.after`.
+          endsWithSpaces(after)
+          ? after.length - 1
+          : -1;
+
+      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));
+
+  if (before.length === 0) {
+    return false;
+  }
+
+  const firstToken = before[0];
+
+  return (
+    isLineComment(firstToken) ||
+    (isBlockComment(firstToken) && !hasNewline(firstToken.code))
+  );
+}
+
+function endsWithSpaces(tokens) {
+  const last = tokens.length > 0 ? tokens[tokens.length - 1] : undefined;
+
+  return last == null ? false : isSpaces(last);
+}
+
+module.exports = {
+  extractChunks,
+  flatMap,
+  getImportExportItems,
+  isPunctuator,
+  maybeReportSorting,
+  printSortedItems,
+  printWithSortedSpecifiers,
+  sortImportExportItems,
+};