@isentinel/eslint-config 1.1.2 → 1.2.2

package/dist/eslint-plugin-simple-import-sort-FWMVSWU4.js

@@ -0,0 +1,808 @@
+import {
+  __commonJS,
+  init_esm_shims
+} from "./chunk-2HV5XKT7.js";
+
+// node_modules/.pnpm/eslint-plugin-simple-import-sort@12.1.1_eslint@9.25.1_jiti@2.4.2_/node_modules/eslint-plugin-simple-import-sort/shared.js
+var require_shared = __commonJS({
+  "node_modules/.pnpm/eslint-plugin-simple-import-sort@12.1.1_eslint@9.25.1_jiti@2.4.2_/node_modules/eslint-plugin-simple-import-sort/shared.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    function extractChunks(parentNode, isPartOfChunk) {
+      const chunks = [];
+      let chunk = [];
+      let lastNode = void 0;
+      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;
+          /* v8 ignore start */
+          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 = getSourceCode(context);
+      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);
+      const flattened = flatMap(sortedItems, (groups) => [].concat(...groups));
+      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)
+      }) : void 0;
+      const maybeNewline = nextToken != null && nextToken.loc.start.line === lastOriginalItem.node.loc.end.line ? newline : "";
+      return sorted + maybeNewline;
+    }
+    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;
+        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)
+        );
+        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);
+        const indentation = getIndentation(
+          commentsBefore.length > 0 ? commentsBefore[0] : node,
+          sourceCode
+        );
+        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])
+        };
+      });
+    }
+    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;
+      }
+      const newLastNode = {
+        ...lastNode,
+        range: [lastNode.range[0], nextToLastToken.range[1]],
+        loc: {
+          start: lastNode.loc.start,
+          end: nextToLastToken.loc.end
+        }
+      };
+      return chunk.slice(0, lastIndex).concat(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);
+      const hasTrailingComma = isPunctuator(
+        sourceCode.getTokenBefore(allTokens[closeBraceIndex]),
+        ","
+      );
+      const lastIndex = sortedItems.length - 1;
+      const sorted = flatMap(sortedItems, (item, index) => {
+        const previous = index === 0 ? void 0 : sortedItems[index - 1];
+        const maybeNewline2 = 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 [
+            ...maybeNewline2,
+            ...item.before,
+            ...item.specifier,
+            { type: "Comma", code: "," },
+            ...item.after
+          ];
+        }
+        const nonBlankIndex = item.after.findIndex(
+          (token) => !isNewline(token) && !isSpaces(token)
+        );
+        const after = !item.hadComma ? item.after : nonBlankIndex === -1 ? [] : item.after.slice(nonBlankIndex);
+        return [...maybeNewline2, ...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)
+      ]);
+    }
+    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);
+                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:
+                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":
+                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":
+                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;
+          /* v8 ignore start */
+          default:
+            throw new Error(`Unknown state: ${current.state}`);
+        }
+      }
+      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);
+          const newlineIndexRaw = after.findIndex((token2) => isNewline(token2));
+          const newlineIndex = newlineIndexRaw === -1 ? -1 : newlineIndexRaw + 1;
+          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;
+        /* v8 ignore start */
+        default:
+          throw new Error(`Unknown state: ${current.state}`);
+      }
+      return result;
+    }
+    function makeEmptyItem() {
+      return {
+        // "before" | "specifier" | "after"
+        state: "before",
+        before: [],
+        after: [],
+        specifier: [],
+        hadComma: false
+      };
+    }
+    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] : void 0;
+      return last == null ? false : isSpaces(last);
+    }
+    var NEWLINE = /(\r?\n)/;
+    function hasNewline(string) {
+      return 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);
+      const items = allItems.length >= 5 ? allItems.slice(0, 2).concat(allItems.slice(-1)) : allItems;
+      return items.map(
+        (spacesOrNewline, index) => index % 2 === 0 ? { type: "Spaces", code: spacesOrNewline } : { type: "Newline", code: spacesOrNewline }
+      ).filter((token) => token.code !== "");
+    }
+    function removeBlankLines(whitespace) {
+      return printTokens(parseWhitespace(whitespace));
+    }
+    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])
+          )
+        ];
+      });
+    }
+    function printTokens(tokens) {
+      return tokens.map((token) => token.code).join("");
+    }
+    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("");
+    }
+    function printCommentsAfter(node, comments, sourceCode) {
+      return 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 text2 = sourceCode.text.slice(0, node.range[0]);
+        const lines2 = text2.split(NEWLINE);
+        return lines2[lines2.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 text2 = sourceCode.text.slice(node.range[1]);
+        const lines2 = text2.split(NEWLINE);
+        return lines2[0];
+      }
+      const text = sourceCode.text.slice(node.range[1], tokenAfter.range[0]);
+      const lines = text.split(NEWLINE);
+      return lines[0];
+    }
+    function sortImportExportItems(items) {
+      return items.slice().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
+            )
+          )
+        )
+      );
+    }
+    function sortSpecifierItems(items) {
+      return items.slice().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)
+            /* v8 ignore start */
+          ) || // 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).
+          itemA.index - itemB.index
+        )
+        /* v8 ignore stop */
+      );
+    }
+    var collator = new Intl.Collator("en", {
+      sensitivity: "base",
+      numeric: true
+    });
+    function compare(a, b) {
+      return collator.compare(a, b) || (a < b ? -1 : a > b ? 1 : 0);
+    }
+    function isIdentifier(node) {
+      return node.type === "Identifier";
+    }
+    function isKeyword(node) {
+      return node.type === "Keyword";
+    }
+    function isPunctuator(node, value) {
+      return node.type === "Punctuator" && node.value === value;
+    }
+    function isBlockComment(node) {
+      return node.type === "Block";
+    }
+    function isLineComment(node) {
+      return node.type === "Line";
+    }
+    function isSpaces(node) {
+      return node.type === "Spaces";
+    }
+    function isNewline(node) {
+      return node.type === "Newline";
+    }
+    function getSource(node) {
+      const source = node.source.value;
+      return {
+        // Sort by directory level rather than by string length.
+        source: source.replace(/^[./]*\.$/, "$&/").replace(/^[./]*\/$/, "$&,").replace(/[./_-]/g, (char) => {
+          switch (char) {
+            case ".":
+              return "_";
+            case "/":
+              return "-";
+            case "_":
+              return ".";
+            case "-":
+              return "/";
+            /* v8 ignore start */
+            default:
+              throw new Error(`Unknown source substitution character: ${char}`);
+          }
+        }),
+        originalSource: source,
+        kind: getImportExportKind(node)
+      };
+    }
+    function getImportExportKind(node) {
+      return node.importKind || node.exportKind || "value";
+    }
+    function findLastIndex(array, fn) {
+      for (let index = array.length - 1; index >= 0; index--) {
+        if (fn(array[index], index, array)) {
+          return index;
+        }
+      }
+      return -1;
+    }
+    function flatMap(array, fn) {
+      return [].concat(...array.map(fn));
+    }
+    function getSourceCode(context) {
+      return context.sourceCode || context.getSourceCode();
+    }
+    module.exports = {
+      extractChunks,
+      flatMap,
+      getImportExportItems,
+      getSourceCode,
+      isPunctuator,
+      maybeReportSorting,
+      printSortedItems,
+      printWithSortedSpecifiers,
+      sortImportExportItems
+    };
+  }
+});
+
+// node_modules/.pnpm/eslint-plugin-simple-import-sort@12.1.1_eslint@9.25.1_jiti@2.4.2_/node_modules/eslint-plugin-simple-import-sort/imports.js
+var require_imports = __commonJS({
+  "node_modules/.pnpm/eslint-plugin-simple-import-sort@12.1.1_eslint@9.25.1_jiti@2.4.2_/node_modules/eslint-plugin-simple-import-sort/imports.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var shared = require_shared();
+    var defaultGroups = [
+      // Side effect imports.
+      ["^\\u0000"],
+      // 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.
+      ["^\\."]
+    ];
+    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",
+          description: "Automatically sort imports."
+        },
+        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) => RegExp(item, "u"))
+        );
+        const parents = /* @__PURE__ */ 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 = shared.getSourceCode(context);
+      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}\0` : originalSource;
+        const [matchedGroup] = shared.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],
+          [void 0, void 0]
+        );
+        if (matchedGroup == null) {
+          rest.push(item);
+        } else {
+          matchedGroup.items.push(item);
+        }
+      }
+      return itemGroups.concat([[{ 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))
+      );
+    }
+    function getSpecifiers(importNode) {
+      return importNode.specifiers.filter((node) => isImportSpecifier(node));
+    }
+    function isImport(node) {
+      return node.type === "ImportDeclaration";
+    }
+    function isImportSpecifier(node) {
+      return node.type === "ImportSpecifier";
+    }
+    function isSideEffectImport(importNode, sourceCode) {
+      return importNode.specifiers.length === 0 && (!importNode.importKind || importNode.importKind === "value") && !shared.isPunctuator(sourceCode.getFirstToken(importNode, { skip: 1 }), "{");
+    }
+  }
+});
+
+// node_modules/.pnpm/eslint-plugin-simple-import-sort@12.1.1_eslint@9.25.1_jiti@2.4.2_/node_modules/eslint-plugin-simple-import-sort/exports.js
+var require_exports = __commonJS({
+  "node_modules/.pnpm/eslint-plugin-simple-import-sort@12.1.1_eslint@9.25.1_jiti@2.4.2_/node_modules/eslint-plugin-simple-import-sort/exports.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var shared = require_shared();
+    module.exports = {
+      meta: {
+        type: "layout",
+        fixable: "code",
+        schema: [],
+        docs: {
+          url: "https://github.com/lydell/eslint-plugin-simple-import-sort#sort-order",
+          description: "Automatically sort exports."
+        },
+        messages: {
+          sort: "Run autofix to sort these exports!"
+        }
+      },
+      create: (context) => {
+        const parents = /* @__PURE__ */ new Set();
+        const 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 = shared.getSourceCode(context);
+            for (const parent of parents) {
+              for (const chunk of shared.extractChunks(
+                parent,
+                (node, lastNode) => isPartOfChunk(node, lastNode, sourceCode)
+              )) {
+                maybeReportChunkSorting(chunk, context);
+              }
+            }
+            parents.clear();
+          }
+        };
+      }
+    };
+    function maybeReportChunkSorting(chunk, context) {
+      const sourceCode = shared.getSourceCode(context);
+      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,
+        shared.getSourceCode(context),
+        getSpecifiers
+      );
+      const [start, end] = node.range;
+      shared.maybeReportSorting(context, sorted, start, end);
+    }
+    function getSpecifiers(exportNode) {
+      return exportNode.specifiers || [];
+    }
+    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 isExportFrom(node) {
+      return (node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") && node.source != null;
+    }
+  }
+});
+
+// node_modules/.pnpm/eslint-plugin-simple-import-sort@12.1.1_eslint@9.25.1_jiti@2.4.2_/node_modules/eslint-plugin-simple-import-sort/index.js
+var require_eslint_plugin_simple_import_sort = __commonJS({
+  "node_modules/.pnpm/eslint-plugin-simple-import-sort@12.1.1_eslint@9.25.1_jiti@2.4.2_/node_modules/eslint-plugin-simple-import-sort/index.js"(exports, module) {
+    init_esm_shims();
+    var importsRule = require_imports();
+    var exportsRule = require_exports();
+    module.exports = {
+      meta: {
+        name: "eslint-plugin-simple-import-sort",
+        version: "12.1.1"
+      },
+      rules: {
+        imports: importsRule,
+        exports: exportsRule
+      }
+    };
+  }
+});
+export default require_eslint_plugin_simple_import_sort();