prettier-plugin-sort 0.1.1 → 1.0.0

package/dist/index.js

@@ -1,17 +1,19 @@
 // src/index.ts
-import { parsers as babelParsers } from "prettier/plugins/babel";
-import { parsers as typescriptParsers } from "prettier/plugins/typescript";
+import acornPlugin from "prettier/plugins/acorn";
+import babelPlugin from "prettier/plugins/babel";
+import flowPlugin from "prettier/plugins/flow";
+import meriyahPlugin from "prettier/plugins/meriyah";
+import typescriptPlugin from "prettier/plugins/typescript";
 
 // src/options.ts
 var DEFAULT_SORT_OPTIONS = {
-  importOrder: true,
-  importOrderGroups: ["builtin", "external", "parent", "sibling", "index"],
-  importOrderSeparation: true,
-  importOrderTypeImports: "separate",
-  importOrderMergeDuplicates: true,
-  exportOrder: true,
-  packageJsonOrder: true,
-  packageJsonOrderExcludeKeys: []
+  esmImportSort: true,
+  esmImportGroups: ["builtin", "external", "parent", "sibling", "index"],
+  esmImportSeparation: true,
+  esmImportTypeStyle: "separate",
+  esmImportMerge: true,
+  esmExportSpecifierSort: true,
+  packageSort: true
 };
 var VALID_IMPORT_GROUPS = new Set([
   "builtin",
@@ -21,503 +23,250 @@ var VALID_IMPORT_GROUPS = new Set([
   "sibling",
   "index"
 ]);
-var VALID_TYPE_STYLES = new Set([
+var VALID_TYPE_IMPORT_STYLES = new Set([
   "separate",
   "inline-first",
   "inline-last",
   "mixed"
 ]);
-var isValidImportGroup = (value) => typeof value === "string" && VALID_IMPORT_GROUPS.has(value);
-var isValidTypeStyle = (value) => typeof value === "string" && VALID_TYPE_STYLES.has(value);
-function resolveBoolean(rawOptions, key) {
-  const raw = rawOptions[key];
-  return typeof raw === "boolean" ? raw : DEFAULT_SORT_OPTIONS[key];
-}
-function resolveSortOptions(rawOptions) {
-  const groups = Array.isArray(rawOptions.importOrderGroups) ? rawOptions.importOrderGroups.filter(isValidImportGroup) : [];
-  const excludeKeys = Array.isArray(rawOptions.packageJsonOrderExcludeKeys) ? rawOptions.packageJsonOrderExcludeKeys.filter((key) => typeof key === "string") : [];
-  const importOrderTypeImports = isValidTypeStyle(rawOptions.importOrderTypeImports) ? rawOptions.importOrderTypeImports : DEFAULT_SORT_OPTIONS.importOrderTypeImports;
+var isValidImportGroup = (candidateValue) => typeof candidateValue === "string" && VALID_IMPORT_GROUPS.has(candidateValue);
+var isValidTypeImportStyle = (candidateValue) => typeof candidateValue === "string" && VALID_TYPE_IMPORT_STYLES.has(candidateValue);
+function resolveBooleanSortOption(prettierOptions, optionName) {
+  const configuredValue = prettierOptions[optionName];
+  if (typeof configuredValue === "boolean") {
+    return configuredValue;
+  }
+  return DEFAULT_SORT_OPTIONS[optionName];
+}
+function resolveSortOptions(prettierOptions) {
+  const configuredImportGroups = Array.isArray(prettierOptions.esmImportGroups) ? [...new Set(prettierOptions.esmImportGroups.filter(isValidImportGroup))] : [];
+  const remainingDefaultImportGroups = DEFAULT_SORT_OPTIONS.esmImportGroups.filter((importGroup) => !configuredImportGroups.includes(importGroup));
+  const resolvedImportGroups = configuredImportGroups.length > 0 ? [...configuredImportGroups, ...remainingDefaultImportGroups] : [...DEFAULT_SORT_OPTIONS.esmImportGroups];
+  const resolvedTypeImportStyle = isValidTypeImportStyle(prettierOptions.esmImportTypeStyle) ? prettierOptions.esmImportTypeStyle : DEFAULT_SORT_OPTIONS.esmImportTypeStyle;
   return {
-    importOrder: resolveBoolean(rawOptions, "importOrder"),
-    importOrderGroups: groups.length > 0 ? groups : [...DEFAULT_SORT_OPTIONS.importOrderGroups],
-    importOrderSeparation: resolveBoolean(rawOptions, "importOrderSeparation"),
-    importOrderTypeImports,
-    importOrderMergeDuplicates: resolveBoolean(rawOptions, "importOrderMergeDuplicates"),
-    exportOrder: resolveBoolean(rawOptions, "exportOrder"),
-    packageJsonOrder: resolveBoolean(rawOptions, "packageJsonOrder"),
-    packageJsonOrderExcludeKeys: excludeKeys
+    esmImportSort: resolveBooleanSortOption(prettierOptions, "esmImportSort"),
+    esmImportGroups: resolvedImportGroups,
+    esmImportSeparation: resolveBooleanSortOption(prettierOptions, "esmImportSeparation"),
+    esmImportTypeStyle: resolvedTypeImportStyle,
+    esmImportMerge: resolveBooleanSortOption(prettierOptions, "esmImportMerge"),
+    esmExportSpecifierSort: resolveBooleanSortOption(prettierOptions, "esmExportSpecifierSort"),
+    packageSort: resolveBooleanSortOption(prettierOptions, "packageSort")
   };
 }
 var options = {
-  importOrder: {
+  esmImportSort: {
     type: "boolean",
-    default: DEFAULT_SORT_OPTIONS.importOrder,
-    category: "SortImports",
-    description: "Sort `import` declarations in JS/TS files."
+    default: DEFAULT_SORT_OPTIONS.esmImportSort,
+    category: "ES Module Imports",
+    description: "Sort top-level ES module import declarations and named specifiers."
   },
-  importOrderGroups: {
+  esmImportGroups: {
     type: "string",
     array: true,
-    default: [{ value: [...DEFAULT_SORT_OPTIONS.importOrderGroups] }],
-    category: "SortImports",
-    description: 'Ordered list of import groups. Valid values: "builtin", "external", "internal", "parent", "sibling", "index". Each group is sorted alphabetically; unknown groups are ignored.'
+    default: [{ value: [...DEFAULT_SORT_OPTIONS.esmImportGroups] }],
+    category: "ES Module Imports",
+    description: 'Set import group order. Valid groups: "builtin", "external", "internal", "parent", "sibling", and "index". Unlisted groups sort after listed groups.'
   },
-  importOrderSeparation: {
+  esmImportSeparation: {
     type: "boolean",
-    default: DEFAULT_SORT_OPTIONS.importOrderSeparation,
-    category: "SortImports",
-    description: "Insert a blank line between adjacent import groups."
+    default: DEFAULT_SORT_OPTIONS.esmImportSeparation,
+    category: "ES Module Imports",
+    description: "Add blank lines between import groups and around side-effect import boundaries."
   },
-  importOrderTypeImports: {
+  esmImportTypeStyle: {
     type: "choice",
-    default: DEFAULT_SORT_OPTIONS.importOrderTypeImports,
-    category: "SortImports",
-    description: "How to place `type` imports relative to value imports.",
+    default: DEFAULT_SORT_OPTIONS.esmImportTypeStyle,
+    category: "ES Module Imports",
+    description: "Format named type imports as separate declarations or inline specifiers.",
     choices: [
       {
         value: "separate",
-        description: "Keep `import type { … }` as its own statement."
+        description: "Use a separate import type declaration."
       },
       {
         value: "inline-first",
-        description: "Inline inside braces, type specifiers before value specifiers."
+        description: "Place inline type specifiers before value specifiers."
       },
       {
         value: "inline-last",
-        description: "Inline inside braces, type specifiers after value specifiers."
+        description: "Place inline type specifiers after value specifiers."
       },
       {
         value: "mixed",
-        description: "Inline inside braces, alphabetical without distinguishing type from value."
+        description: "Use inline type specifiers and sort all specifiers together."
       }
     ]
   },
-  importOrderMergeDuplicates: {
+  esmImportMerge: {
     type: "boolean",
-    default: DEFAULT_SORT_OPTIONS.importOrderMergeDuplicates,
-    category: "SortImports",
-    description: "Merge multiple `import` statements from the same source into one. Side-effect imports are never merged."
+    default: DEFAULT_SORT_OPTIONS.esmImportMerge,
+    category: "ES Module Imports",
+    description: "Merge compatible import declarations from the same module."
   },
-  exportOrder: {
+  esmExportSpecifierSort: {
     type: "boolean",
-    default: DEFAULT_SORT_OPTIONS.exportOrder,
-    category: "SortExports",
-    description: "Sort named specifiers inside `export { … }` alphabetically. Does not reorder export statements."
+    default: DEFAULT_SORT_OPTIONS.esmExportSpecifierSort,
+    category: "ES Module Exports",
+    description: "Sort named export specifiers without reordering export declarations."
   },
-  packageJsonOrder: {
+  packageSort: {
     type: "boolean",
-    default: DEFAULT_SORT_OPTIONS.packageJsonOrder,
-    category: "SortPackageJson",
-    description: "Sort top-level keys and string-array values inside `package.json`. Dependency maps are always alphabetised regardless of this option."
-  },
-  packageJsonOrderExcludeKeys: {
-    type: "string",
-    array: true,
-    default: [{ value: [...DEFAULT_SORT_OPTIONS.packageJsonOrderExcludeKeys] }],
-    category: "SortPackageJson",
-    description: "Top-level `package.json` keys to leave untouched (no key reordering or array sorting). Takes priority over `packageJsonOrder`."
+    default: DEFAULT_SORT_OPTIONS.packageSort,
+    category: "package.json",
+    description: "Sort package.json fields using the sort-package-json community convention."
   }
 };
 
-// src/utils.ts
-function splitTopLevel(input, separator) {
-  const segments = [];
-  let current = "";
-  let depth = 0;
-  for (const char of input) {
-    if (char === "{" || char === "(" || char === "[") {
-      depth++;
-    } else if (char === "}" || char === ")" || char === "]") {
-      depth--;
-    }
-    if (char === separator && depth === 0) {
-      segments.push(current);
-      current = "";
-      continue;
-    }
-    current += char;
-  }
-  if (current.length > 0) {
-    segments.push(current);
-  }
-  return segments.map((segment) => segment.trim()).filter((segment) => segment.length > 0);
-}
-
-// src/sort-exports.ts
-function sortExports(text, rawOptions) {
-  const options2 = resolveSortOptions(rawOptions);
-  if (!options2.exportOrder) {
-    return text;
-  }
-  return text.replace(/export(\s+type)?\s*\{([^}]*)\}/g, (match, typeKeyword, inner) => {
-    const members = splitTopLevel(inner, ",");
-    if (members.length <= 1) {
-      return match;
-    }
-    const sorted = [...members].sort((a, b) => stripTypePrefix(a).localeCompare(stripTypePrefix(b), "en", {
-      sensitivity: "base"
-    }));
-    const unchanged = sorted.every((member, index) => member === members[index]);
-    if (unchanged) {
-      return match;
-    }
-    const prefix = typeKeyword ? `export${typeKeyword}` : "export";
-    return `${prefix} { ${sorted.join(", ")} }`;
-  });
-}
-function stripTypePrefix(member) {
-  return member.replace(/^type\s+/, "");
-}
+// src/sort-package.ts
+import findMinimumSemanticVersion from "semver/ranges/min-version.js";
 
-// src/sort-imports.ts
-import { builtinModules } from "node:module";
-var NODE_BUILTINS = new Set(builtinModules);
-function detectGroup(source) {
-  if (source === "bun" || source.startsWith("bun:") || source.startsWith("node:")) {
-    return "builtin";
-  }
-  const slashIndex = source.indexOf("/");
-  const head = slashIndex === -1 ? source : source.slice(0, slashIndex);
-  if (head && NODE_BUILTINS.has(head)) {
-    return "builtin";
-  }
-  if (source === "." || source === "./" || /^\.\/index(\.[a-z]+)?$/.test(source)) {
-    return "index";
-  }
-  if (source.startsWith("../") || source === "..") {
-    return "parent";
-  }
-  if (source.startsWith("./")) {
-    return "sibling";
+// src/parser-ast.ts
+function getAstNodeTextRange(node) {
+  if (!node) {
+    return null;
   }
-  if (source.startsWith("/") || source.startsWith("~") || source.startsWith("@/")) {
-    return "internal";
+  const [start = NaN, end = NaN] = node.range ?? [node.start, node.end];
+  const isOffsetRangeValid = [start, end].every(Number.isSafeInteger) && start >= 0 && end >= start;
+  if (!isOffsetRangeValid) {
+    return null;
   }
-  return "external";
+  return { start, end };
 }
-var TYPE_PREFIX = /^type\s+(.+)$/s;
-function splitMembers(inner) {
-  return splitTopLevel(inner, ",").map((part) => {
-    const match = TYPE_PREFIX.exec(part);
-    return match ? { name: match[1].trim(), isType: true } : { name: part, isType: false };
-  });
+function getSortedAstCommentsWithTextRanges(comments) {
+  return comments.flatMap((comment) => {
+    const textRange = getAstNodeTextRange(comment);
+    return textRange ? [{ comment, textRange }] : [];
+  }).sort((left, right) => left.textRange.start - right.textRange.start || left.textRange.end - right.textRange.end);
 }
-function parseImport(statement) {
-  const trimmed = statement.raw.trim();
-  const leadingComments = statement.leadingComments;
-  const sideEffect = /^import\s*(['"])([^'"]+)\1(?:\s+with\s*(\{[^}]*\}))?\s*;?$/.exec(trimmed);
-  if (sideEffect) {
-    return {
-      source: sideEffect[2] ?? "",
-      typeClause: false,
-      sideEffect: true,
-      defaultSpec: null,
-      namespaceSpec: null,
-      members: null,
-      attributes: sideEffect[3] ?? null,
-      leadingComments
-    };
-  }
-  const match = /^import\s+(type\s+)?([\s\S]+?)\s*from\s*(['"])([^'"]+)\3(?:\s+with\s*(\{[^}]*\}))?\s*;?$/.exec(trimmed);
-  if (!match) {
-    return null;
-  }
-  const typeClause = Boolean(match[1]);
-  const clause = (match[2] ?? "").trim();
-  const source = match[4] ?? "";
-  const attributes = match[5] ?? null;
-  let defaultSpec = null;
-  let namespaceSpec = null;
-  let members = null;
-  for (const part of splitTopLevel(clause, ",")) {
-    if (part.startsWith("{")) {
-      const inner = part.slice(1, part.lastIndexOf("}")).trim();
-      members = inner ? splitMembers(inner) : [];
-    } else if (part.startsWith("*")) {
-      namespaceSpec = part;
+function findCommentIndexAtOrAfter(sortedComments, sourceIndex) {
+  let searchStartIndex = 0;
+  let searchEndIndex = sortedComments.length;
+  while (searchStartIndex < searchEndIndex) {
+    const middleIndex = Math.floor((searchStartIndex + searchEndIndex) / 2);
+    const middleCommentStart = sortedComments[middleIndex].textRange.start;
+    if (middleCommentStart < sourceIndex) {
+      searchStartIndex = middleIndex + 1;
     } else {
-      defaultSpec = part;
+      searchEndIndex = middleIndex;
     }
   }
-  return {
-    source,
-    typeClause,
-    sideEffect: false,
-    defaultSpec,
-    namespaceSpec,
-    members,
-    attributes,
-    leadingComments
-  };
+  return searchStartIndex;
 }
-function extractImportBlock(text) {
-  const firstRe = /(?:^|\n)(?:[ \t]*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)[ \t]*\n)*[ \t]*import\b(?![.(])/;
-  const first = firstRe.exec(text);
-  if (!first) {
+function getAstNodeName(node) {
+  if (!node) {
     return null;
   }
-  const start = first.index + (text[first.index] === `
-` ? 1 : 0);
-  const statements = [];
-  const skipRe = /(?:[ \t]*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)?[ \t]*\n)*/y;
-  const importRe = /[ \t]*(import\b(?![.(])[\s\S]*?(?:from\s*(['"])[^'"]+\2|(['"])[^'"]+\3)(?:\s+with\s*\{[^}]*\})?\s*;?)/y;
-  let cursor = start;
-  while (cursor < text.length) {
-    skipRe.lastIndex = cursor;
-    const skipMatch = skipRe.exec(text);
-    const skipped = skipMatch ? skipMatch[0] : "";
-    const afterSkip = cursor + skipped.length;
-    importRe.lastIndex = afterSkip;
-    const importMatch = importRe.exec(text);
-    if (!importMatch) {
-      break;
-    }
-    const normalised = skipped.endsWith(`
-`) ? skipped.slice(0, -1) : skipped;
-    const commentLines = normalised.length > 0 ? normalised.split(`
-`) : [];
-    const leadingLines = [];
-    for (let i = commentLines.length - 1;i >= 0; i--) {
-      const line = commentLines[i];
-      if (line === undefined) {
-        continue;
-      }
-      if (line.trim() === "") {
-        break;
-      }
-      leadingLines.unshift(line);
-    }
-    const leadingComments = leadingLines.length > 0 ? leadingLines.join(`
-`) + `
-` : "";
-    const statement = importMatch[1];
-    if (!statement) {
-      break;
-    }
-    statements.push({ raw: statement.trim(), leadingComments });
-    cursor = afterSkip + importMatch[0].length;
+  if (typeof node.name === "string") {
+    return node.name;
   }
-  if (statements.length === 0) {
-    return null;
+  switch (typeof node.value) {
+    case "string":
+    case "number":
+    case "boolean":
+      return String(node.value);
+    default:
+      return null;
   }
-  return { start, end: cursor, statements };
 }
-function renderMembers(members) {
-  return members.map((member) => member.isType ? `type ${member.name}` : member.name).join(", ");
+function getAstCommentText(comment) {
+  return typeof comment.value === "string" ? comment.value : null;
 }
-function renderSpecifiers(importDecl) {
-  const parts = [];
-  if (importDecl.defaultSpec) {
-    parts.push(importDecl.defaultSpec);
-  }
-  if (importDecl.namespaceSpec) {
-    parts.push(importDecl.namespaceSpec);
+function getProgramStatements(parserAst) {
+  if (Array.isArray(parserAst.body)) {
+    return parserAst.body;
   }
-  if (importDecl.members) {
-    parts.push(`{ ${renderMembers(importDecl.members)} }`);
+  const programNode = parserAst.program;
+  if (!programNode || !Array.isArray(programNode.body)) {
+    return [];
   }
-  return parts.join(", ");
-}
-function renderImport(importDecl) {
-  const suffix = importDecl.attributes ? ` with ${importDecl.attributes}` : "";
-  const source = `'${importDecl.source}'`;
-  const body = importDecl.sideEffect ? `import ${source}${suffix};` : importDecl.typeClause ? `import type ${renderSpecifiers(importDecl)} from ${source}${suffix};` : `import ${renderSpecifiers(importDecl)} from ${source}${suffix};`;
-  return importDecl.leadingComments + body;
+  return programNode.body;
 }
-function sortMembersAlpha(members) {
-  return [...members].sort((a, b) => a.name.localeCompare(b.name, "en", { sensitivity: "base" }));
-}
-function normalizeTypeClause(importDecl) {
-  if (!importDecl.typeClause || importDecl.members === null) {
-    return importDecl;
+function getProgramComments(parserAst) {
+  if (Array.isArray(parserAst.comments)) {
+    return parserAst.comments;
   }
-  return {
-    ...importDecl,
-    typeClause: false,
-    members: importDecl.members.map((member) => ({ ...member, isType: true }))
-  };
+  const programNode = parserAst.program;
+  if (!programNode || !Array.isArray(programNode.comments)) {
+    return [];
+  }
+  return programNode.comments;
 }
-function mergeImportsFromSameSource(imports) {
-  const indexByKey = new Map;
-  const result = [];
-  for (const rawImport of imports) {
-    const importDecl = normalizeTypeClause(rawImport);
-    if (importDecl.sideEffect || importDecl.typeClause) {
-      result.push(importDecl);
-      continue;
+function isSourceRangeWhitespaceOrComments(sourceText, sourceRange, sortedComments) {
+  let sourceIndex = sourceRange.start;
+  let commentIndex = Math.max(findCommentIndexAtOrAfter(sortedComments, sourceRange.start) - 1, 0);
+  for (;commentIndex < sortedComments.length; commentIndex++) {
+    const parserComment = sortedComments[commentIndex];
+    if (!parserComment || parserComment.textRange.start >= sourceRange.end) {
+      break;
     }
-    const mergeKey = `${importDecl.source}\x00${importDecl.attributes ?? ""}`;
-    const existingIndex = indexByKey.get(mergeKey);
-    if (existingIndex === undefined) {
-      indexByKey.set(mergeKey, result.length);
-      result.push(importDecl);
+    if (parserComment.textRange.end <= sourceIndex) {
       continue;
     }
-    const existing = result[existingIndex];
-    result[existingIndex] = {
-      source: existing.source,
-      typeClause: false,
-      sideEffect: false,
-      defaultSpec: existing.defaultSpec ?? importDecl.defaultSpec,
-      namespaceSpec: existing.namespaceSpec ?? importDecl.namespaceSpec,
-      members: existing.members === null && importDecl.members === null ? null : [...existing.members ?? [], ...importDecl.members ?? []],
-      attributes: existing.attributes,
-      leadingComments: existing.leadingComments
-    };
-  }
-  return result;
-}
-function applyTypeImports(importDecl, style) {
-  if (importDecl.sideEffect || !importDecl.members) {
-    return [importDecl];
-  }
-  if (style === "separate") {
-    if (importDecl.typeClause) {
-      return [importDecl];
-    }
-    const typeMembers2 = importDecl.members.filter((member) => member.isType);
-    const valueMembers2 = importDecl.members.filter((member) => !member.isType);
-    const out = [];
-    if (typeMembers2.length > 0) {
-      out.push({
-        source: importDecl.source,
-        typeClause: true,
-        sideEffect: false,
-        defaultSpec: null,
-        namespaceSpec: null,
-        members: sortMembersAlpha(typeMembers2.map((member) => ({ ...member, isType: false }))),
-        attributes: importDecl.attributes,
-        leadingComments: importDecl.leadingComments
-      });
-    }
-    const hasValueBody = valueMembers2.length > 0 || importDecl.defaultSpec !== null || importDecl.namespaceSpec !== null;
-    if (hasValueBody) {
-      out.push({
-        ...importDecl,
-        members: valueMembers2.length > 0 ? sortMembersAlpha(valueMembers2) : null,
-        leadingComments: typeMembers2.length > 0 ? "" : importDecl.leadingComments
-      });
+    const commentStart = Math.max(parserComment.textRange.start, sourceRange.start);
+    if (sourceText.slice(sourceIndex, commentStart).trim() !== "") {
+      return false;
     }
-    return out.length > 0 ? out : [importDecl];
-  }
-  const inlineBase = importDecl.typeClause ? {
-    ...importDecl,
-    typeClause: false,
-    members: importDecl.members.map((member) => ({
-      ...member,
-      isType: true
-    }))
-  } : { ...importDecl, members: importDecl.members };
-  if (style === "mixed") {
-    return [{ ...inlineBase, members: sortMembersAlpha(inlineBase.members) }];
-  }
-  const typeMembers = inlineBase.members.filter((member) => member.isType);
-  const valueMembers = inlineBase.members.filter((member) => !member.isType);
-  const sortedTypes = sortMembersAlpha(typeMembers);
-  const sortedValues = sortMembersAlpha(valueMembers);
-  const ordered = style === "inline-first" ? [...sortedTypes, ...sortedValues] : [...sortedValues, ...sortedTypes];
-  return [{ ...inlineBase, members: ordered }];
-}
-function sortSegment(imports, options2, groupIndex, fallback) {
-  if (imports.length === 0) {
-    return [];
+    sourceIndex = Math.min(parserComment.textRange.end, sourceRange.end);
   }
-  const style = options2.importOrderTypeImports;
-  const deduped = options2.importOrderMergeDuplicates ? mergeImportsFromSameSource(imports) : imports;
-  const rewritten = deduped.flatMap((importDecl) => applyTypeImports(importDecl, style));
-  const decorated = rewritten.map((importDecl, index) => ({
-    importDecl,
-    group: detectGroup(importDecl.source),
-    originalIndex: index
-  }));
-  decorated.sort((a, b) => {
-    const groupOrderA = groupIndex.get(a.group) ?? fallback;
-    const groupOrderB = groupIndex.get(b.group) ?? fallback;
-    if (groupOrderA !== groupOrderB) {
-      return groupOrderA - groupOrderB;
+  return sourceText.slice(sourceIndex, sourceRange.end).trim() === "";
+}
+function isPrettierIgnored(sourceText, statementRange, sortedComments) {
+  let leadingCommentsStart = statementRange.start;
+  for (let commentIndex = findCommentIndexAtOrAfter(sortedComments, statementRange.start) - 1;commentIndex >= 0; commentIndex--) {
+    const parserComment = sortedComments[commentIndex];
+    if (!parserComment || parserComment.textRange.end > statementRange.start) {
+      continue;
     }
-    const sourceA = a.importDecl.source.toLowerCase();
-    const sourceB = b.importDecl.source.toLowerCase();
-    if (sourceA !== sourceB) {
-      return sourceA < sourceB ? -1 : 1;
+    const { comment, textRange } = parserComment;
+    const followingText = sourceText.slice(textRange.end, leadingCommentsStart);
+    if (followingText.trim() !== "") {
+      break;
     }
-    if (a.importDecl.typeClause !== b.importDecl.typeClause) {
-      return a.importDecl.typeClause ? -1 : 1;
+    if (followingText.includes(`
+`)) {
+      const commentLineStart = sourceText.lastIndexOf(`
+`, textRange.start - 1) + 1;
+      const isCommentLinePrefixEmpty = isSourceRangeWhitespaceOrComments(sourceText, { start: commentLineStart, end: textRange.start }, sortedComments);
+      if (!isCommentLinePrefixEmpty) {
+        break;
+      }
     }
-    return a.originalIndex - b.originalIndex;
-  });
-  const lines = [];
-  let previousGroup = null;
-  for (const item of decorated) {
-    if (options2.importOrderSeparation && previousGroup !== null && item.group !== previousGroup) {
-      lines.push("");
+    const commentText = getAstCommentText(comment);
+    const isPrettierIgnoreComment = commentText?.trim() === "prettier-ignore";
+    if (isPrettierIgnoreComment) {
+      return true;
     }
-    lines.push(renderImport(item.importDecl));
-    previousGroup = item.group;
-  }
-  return lines;
-}
-function sortImports(text, rawOptions) {
-  const options2 = resolveSortOptions(rawOptions);
-  if (!options2.importOrder) {
-    return text;
-  }
-  const block = extractImportBlock(text);
-  if (!block || block.statements.length === 0) {
-    return text;
-  }
-  const parsed = block.statements.map((rawStatement) => parseImport(rawStatement)).filter((importDecl) => importDecl !== null);
-  if (parsed.length === 0) {
-    return text;
+    leadingCommentsStart = textRange.start;
   }
-  const groupIndex = new Map(options2.importOrderGroups.map((group, index) => [
-    group,
-    index
-  ]));
-  const fallback = options2.importOrderGroups.length;
-  const chunks = [];
-  let currentSegment = [];
-  for (const importDecl of parsed) {
-    if (importDecl.sideEffect) {
-      if (currentSegment.length > 0) {
-        chunks.push({ kind: "segment", imports: currentSegment });
-        currentSegment = [];
-      }
-      chunks.push({ kind: "side-effect", importDecl });
-    } else {
-      currentSegment.push(importDecl);
+  let trailingCommentsEnd = statementRange.end;
+  for (let commentIndex = findCommentIndexAtOrAfter(sortedComments, statementRange.end);commentIndex < sortedComments.length; commentIndex++) {
+    const parserComment = sortedComments[commentIndex];
+    if (!parserComment) {
+      break;
     }
-  }
-  if (currentSegment.length > 0) {
-    chunks.push({ kind: "segment", imports: currentSegment });
-  }
-  const allLines = [];
-  let previousKind = null;
-  for (const chunk of chunks) {
-    if (previousKind !== null && previousKind !== chunk.kind && options2.importOrderSeparation) {
-      allLines.push("");
+    const { comment, textRange } = parserComment;
+    const textBeforeComment = sourceText.slice(trailingCommentsEnd, textRange.start);
+    if (textBeforeComment.includes(`
+`) || textBeforeComment.trim() !== "") {
+      break;
     }
-    if (chunk.kind === "segment") {
-      allLines.push(...sortSegment(chunk.imports, options2, groupIndex, fallback));
-    } else {
-      allLines.push(renderImport(chunk.importDecl));
+    const commentLineEnd = sourceText.indexOf(`
+`, textRange.end);
+    const isCommentLastOnLine = isSourceRangeWhitespaceOrComments(sourceText, {
+      start: textRange.end,
+      end: commentLineEnd < 0 ? sourceText.length : commentLineEnd
+    }, sortedComments);
+    const commentText = getAstCommentText(comment);
+    if (isCommentLastOnLine && commentText?.trim() === "prettier-ignore") {
+      return true;
     }
-    previousKind = chunk.kind;
+    trailingCommentsEnd = textRange.end;
   }
-  const replacement = allLines.join(`
-`);
-  const trailing = text.slice(block.end);
-  const suffix = trailing.trim() ? `
-
-` + trailing.trimStart() : trailing;
-  return text.slice(0, block.start) + replacement + suffix;
+  return false;
 }
 
-// src/sort-package.ts
-import path from "node:path";
-
-// src/order-package.ts
-var PACKAGE_JSON_TOP_LEVEL_ORDER = [
+// src/utils/package-rules.ts
+var PACKAGE_JSON_FIELD_ORDER = [
   "$schema",
   "name",
   "displayName",
@@ -566,6 +315,7 @@ var PACKAGE_JSON_TOP_LEVEL_ORDER = [
   "binary",
   "scripts",
   "betterScripts",
+  "wireit",
   "l10n",
   "contributes",
   "activationEvents",
@@ -629,122 +379,1618 @@ var PACKAGE_JSON_TOP_LEVEL_ORDER = [
   "markdown",
   "pnpm"
 ];
-var DEPENDENCY_FIELDS = [
+var DIRECTORY_FIELD_ORDER = [
+  "lib",
+  "bin",
+  "man",
+  "doc",
+  "example",
+  "test"
+];
+var ESLINT_CONFIG_FIELD_ORDER = [
+  "files",
+  "excludedFiles",
+  "env",
+  "parser",
+  "parserOptions",
+  "settings",
+  "plugins",
+  "extends",
+  "rules",
+  "overrides",
+  "globals",
+  "processor",
+  "noInlineConfig",
+  "reportUnusedDisableDirectives"
+];
+var GIT_HOOK_ORDER = [
+  "applypatch-msg",
+  "pre-applypatch",
+  "post-applypatch",
+  "pre-commit",
+  "pre-merge-commit",
+  "prepare-commit-msg",
+  "commit-msg",
+  "post-commit",
+  "pre-rebase",
+  "post-checkout",
+  "post-merge",
+  "pre-push",
+  "pre-receive",
+  "update",
+  "proc-receive",
+  "post-receive",
+  "post-update",
+  "reference-transaction",
+  "push-to-checkout",
+  "pre-auto-gc",
+  "post-rewrite",
+  "sendemail-validate",
+  "fsmonitor-watchman",
+  "p4-changelist",
+  "p4-prepare-changelist",
+  "p4-post-changelist",
+  "p4-pre-submit",
+  "post-index-change"
+];
+var NPM_LIFECYCLE_SCRIPT_NAMES = new Set([
+  "install",
+  "pack",
+  "prepare",
+  "publish",
+  "restart",
+  "shrinkwrap",
+  "start",
+  "stop",
+  "test",
+  "uninstall",
+  "version"
+]);
+var PNPM_CONFIG_FIELD_ORDER = [
+  "peerDependencyRules",
+  "neverBuiltDependencies",
+  "onlyBuiltDependencies",
+  "onlyBuiltDependenciesFile",
+  "allowedDeprecatedVersions",
+  "allowNonAppliedPatches",
+  "updateConfig",
+  "auditConfig",
+  "requiredScripts",
+  "supportedArchitectures",
+  "overrides",
+  "patchedDependencies",
+  "packageExtensions"
+];
+var WIREIT_SCRIPT_FIELD_ORDER = [
+  "command",
   "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-  "bundledDependencies",
-  "bundleDependencies",
-  "resolutions",
-  "overrides"
+  "files",
+  "output"
 ];
 
 // src/sort-package.ts
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+class JsonSourceLiteral {
+  value;
+  sourceText;
+  constructor(value, sourceText) {
+    this.value = value;
+    this.sourceText = sourceText;
+  }
+}
+var SEQUENTIAL_SCRIPT_PATTERN = /(?<=^|[\s&;<>|(])(?:run-s|npm-run-all2? .*(?:--sequential|--serial|-s))(?=$|[\s&;<>|)])/;
+function compareText(leftText, rightText) {
+  if (leftText === rightText) {
+    return 0;
+  }
+  return leftText < rightText ? -1 : 1;
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof JsonSourceLiteral);
+}
+function getJsonPathKey(jsonPath) {
+  return JSON.stringify(jsonPath);
+}
+function getJsonString(jsonValue) {
+  if (typeof jsonValue === "string") {
+    return jsonValue;
+  }
+  if (jsonValue instanceof JsonSourceLiteral && typeof jsonValue.value === "string") {
+    return jsonValue.value;
+  }
+  return null;
+}
+function isJsonStringValue(jsonValue) {
+  return getJsonString(jsonValue) !== null;
+}
+function isParserJsonAstNode(value) {
+  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function preserveJsonSourceLiterals(jsonValue, parserJsonNode, sourceText, fieldNameSourceTexts, jsonPath = []) {
+  if (parserJsonNode.type === "JsonRoot") {
+    const rootNode = parserJsonNode.node;
+    if (!isParserJsonAstNode(rootNode)) {
+      return;
+    }
+    return preserveJsonSourceLiterals(jsonValue, rootNode, sourceText, fieldNameSourceTexts, jsonPath);
+  }
+  const isStringLiteral = parserJsonNode.type === "StringLiteral";
+  const isNumberLiteral = parserJsonNode.type === "NumericLiteral";
+  const isNegativeNumberLiteral = parserJsonNode.type === "UnaryExpression" && parserJsonNode.operator === "-" && parserJsonNode.argument?.type === "NumericLiteral";
+  if (isStringLiteral || isNumberLiteral || isNegativeNumberLiteral) {
+    const literalRange = getAstNodeTextRange(parserJsonNode);
+    const isLiteralValueValid = isStringLiteral && typeof jsonValue === "string" || !isStringLiteral && typeof jsonValue === "number";
+    if (!literalRange || !isLiteralValueValid) {
+      return;
+    }
+    return new JsonSourceLiteral(jsonValue, sourceText.slice(literalRange.start, literalRange.end));
+  }
+  if (parserJsonNode.type === "ObjectExpression") {
+    if (!isJsonObject(jsonValue) || !Array.isArray(parserJsonNode.properties)) {
+      return;
+    }
+    const jsonObject = { ...jsonValue };
+    const propertyNames = new Set;
+    for (const propertyNode of parserJsonNode.properties) {
+      const propertyName = getAstNodeName(propertyNode.key);
+      const propertyNameRange = getAstNodeTextRange(propertyNode.key);
+      const propertyValueNode = propertyNode.value;
+      if (propertyNode.type !== "ObjectProperty" || propertyName === null || !propertyNameRange || propertyNames.has(propertyName) || !Object.hasOwn(jsonValue, propertyName) || !isParserJsonAstNode(propertyValueNode)) {
+        return;
+      }
+      propertyNames.add(propertyName);
+      const propertyPath = [...jsonPath, propertyName];
+      const propertyValue = preserveJsonSourceLiterals(jsonValue[propertyName], propertyValueNode, sourceText, fieldNameSourceTexts, propertyPath);
+      if (propertyValue === undefined) {
+        return;
+      }
+      fieldNameSourceTexts.set(getJsonPathKey(propertyPath), sourceText.slice(propertyNameRange.start, propertyNameRange.end));
+      jsonObject[propertyName] = propertyValue;
+    }
+    return jsonObject;
+  }
+  if (parserJsonNode.type === "ArrayExpression") {
+    if (!Array.isArray(jsonValue) || !Array.isArray(parserJsonNode.elements) || jsonValue.length !== parserJsonNode.elements.length) {
+      return;
+    }
+    const jsonArray = [];
+    for (const [
+      elementIndex,
+      elementNode
+    ] of parserJsonNode.elements.entries()) {
+      if (!elementNode) {
+        return;
+      }
+      const elementValue = preserveJsonSourceLiterals(jsonValue[elementIndex], elementNode, sourceText, fieldNameSourceTexts, [...jsonPath, elementIndex]);
+      if (elementValue === undefined) {
+        return;
+      }
+      jsonArray.push(elementValue);
+    }
+    return jsonArray;
+  }
+  return jsonValue;
+}
+function serializeJsonValue(jsonValue, fieldNameSourceTexts, jsonPath = []) {
+  if (jsonValue instanceof JsonSourceLiteral) {
+    return jsonValue.sourceText;
+  }
+  if (typeof jsonValue === "number" || typeof jsonValue === "string") {
+    return null;
+  }
+  if (Array.isArray(jsonValue)) {
+    const serializedValues = [];
+    for (const [arrayIndex, arrayValue] of jsonValue.entries()) {
+      const serializedValue = serializeJsonValue(arrayValue, fieldNameSourceTexts, [...jsonPath, arrayIndex]);
+      if (serializedValue === null) {
+        return null;
+      }
+      serializedValues.push(serializedValue);
+    }
+    return `[${serializedValues.join(",")}]`;
+  }
+  if (isJsonObject(jsonValue)) {
+    const serializedFields = [];
+    for (const [fieldName, fieldValue] of Object.entries(jsonValue)) {
+      const fieldPath = [...jsonPath, fieldName];
+      const fieldNameSourceText = fieldNameSourceTexts.get(getJsonPathKey(fieldPath));
+      const serializedValue = serializeJsonValue(fieldValue, fieldNameSourceTexts, fieldPath);
+      if (!fieldNameSourceText || serializedValue === null) {
+        return null;
+      }
+      serializedFields.push(`${fieldNameSourceText}:${serializedValue}`);
+    }
+    return `{${serializedFields.join(",")}}`;
+  }
+  return JSON.stringify(jsonValue);
 }
 function isStringArray(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-function sortObjectKeysByOrder(record, order) {
-  const orderIndex = new Map(order.map((key, index) => [key, index]));
-  const known = [];
-  const rest = [];
-  for (const entry of Object.entries(record)) {
-    const [key] = entry;
-    if (orderIndex.has(key)) {
-      known.push(entry);
-    } else {
-      rest.push(entry);
+  return Array.isArray(value) && value.every(isJsonStringValue);
+}
+function deduplicateStringValues(stringValues) {
+  const uniqueStringValues = new Map;
+  for (const stringValue of stringValues) {
+    const text = getJsonString(stringValue);
+    if (!uniqueStringValues.has(text)) {
+      uniqueStringValues.set(text, stringValue);
+    }
+  }
+  return [...uniqueStringValues.values()];
+}
+function sortJsonObject(jsonObject, compareKeys = compareText) {
+  return Object.fromEntries(Object.entries(jsonObject).sort(([leftKey], [rightKey]) => compareKeys(leftKey, rightKey)));
+}
+function sortJsonObjectByKeyOrder(jsonObject, keyOrder) {
+  const keyOrderIndexes = new Map(keyOrder.map((key, index) => [key, index]));
+  return sortJsonObject(jsonObject, (leftKey, rightKey) => {
+    const leftIndex = keyOrderIndexes.get(leftKey);
+    const rightIndex = keyOrderIndexes.get(rightKey);
+    const isLeftKeyKnown = leftIndex !== undefined;
+    const isRightKeyKnown = rightIndex !== undefined;
+    if (isLeftKeyKnown && isRightKeyKnown) {
+      return leftIndex - rightIndex;
+    }
+    if (isLeftKeyKnown) {
+      return -1;
+    }
+    if (isRightKeyKnown) {
+      return 1;
+    }
+    return compareText(leftKey, rightKey);
+  });
+}
+function sortJsonObjectRecursively(jsonObject, sortObject = sortJsonObject) {
+  const sortedNestedValues = Object.fromEntries(Object.entries(jsonObject).map(([key, value]) => [
+    key,
+    isJsonObject(value) ? sortJsonObjectRecursively(value, sortObject) : value
+  ]));
+  return sortObject(sortedNestedValues);
+}
+function sortJsonObjectValue(fieldValue, sortObject) {
+  return isJsonObject(fieldValue) ? sortObject(fieldValue) : fieldValue;
+}
+function sortJsonObjectValueAlphabetically(fieldValue) {
+  return sortJsonObjectValue(fieldValue, sortJsonObject);
+}
+function sortJsonObjectValueRecursively(fieldValue) {
+  return sortJsonObjectValue(fieldValue, sortJsonObjectRecursively);
+}
+function sortJsonObjectValueByKeyOrder(fieldValue, keyOrder) {
+  return sortJsonObjectValue(fieldValue, (jsonObject) => sortJsonObjectByKeyOrder(jsonObject, keyOrder));
+}
+function sortUniqueStringArrayValue(fieldValue) {
+  if (!isStringArray(fieldValue)) {
+    return fieldValue;
+  }
+  return deduplicateStringValues(fieldValue).sort((leftValue, rightValue) => compareText(getJsonString(leftValue), getJsonString(rightValue)));
+}
+function deduplicateStringArrayValue(fieldValue) {
+  return isStringArray(fieldValue) ? deduplicateStringValues(fieldValue) : fieldValue;
+}
+function sortPersonValue(fieldValue) {
+  return sortJsonObjectValueByKeyOrder(fieldValue, ["name", "email", "url"]);
+}
+function sortPeopleArrayValue(fieldValue) {
+  if (!Array.isArray(fieldValue)) {
+    return fieldValue;
+  }
+  return fieldValue.map((person) => sortPersonValue(person));
+}
+function sortPackageJsonFields(packageJson) {
+  const fieldOrderIndexes = new Map(PACKAGE_JSON_FIELD_ORDER.map((fieldName, index) => [fieldName, index]));
+  return sortJsonObject(packageJson, (leftFieldName, rightFieldName) => {
+    const leftIndex = fieldOrderIndexes.get(leftFieldName);
+    const rightIndex = fieldOrderIndexes.get(rightFieldName);
+    const isLeftFieldKnown = leftIndex !== undefined;
+    const isRightFieldKnown = rightIndex !== undefined;
+    if (isLeftFieldKnown && isRightFieldKnown) {
+      return leftIndex - rightIndex;
+    }
+    if (isLeftFieldKnown) {
+      return -1;
+    }
+    if (isRightFieldKnown) {
+      return 1;
+    }
+    const isLeftFieldPrivate = leftFieldName.startsWith("_");
+    const isRightFieldPrivate = rightFieldName.startsWith("_");
+    if (isLeftFieldPrivate !== isRightFieldPrivate) {
+      return isLeftFieldPrivate ? 1 : -1;
+    }
+    return compareText(leftFieldName, rightFieldName);
+  });
+}
+function isNpmDependencyOrderPreferred(packageJson) {
+  const packageManager = getJsonString(packageJson.packageManager);
+  if (packageManager !== null) {
+    return packageManager.startsWith("npm@");
+  }
+  const devEngines = packageJson.devEngines;
+  if (isJsonObject(devEngines)) {
+    const devPackageManager = devEngines.packageManager;
+    const devPackageManagerName = isJsonObject(devPackageManager) ? getJsonString(devPackageManager.name) : null;
+    if (devPackageManagerName !== null) {
+      return devPackageManagerName === "npm";
+    }
+  }
+  if (isJsonObject(packageJson.pnpm)) {
+    return false;
+  }
+  return true;
+}
+function sortDependencyObject(dependencyObject, packageJson) {
+  if (!isNpmDependencyOrderPreferred(packageJson)) {
+    return sortJsonObject(dependencyObject);
+  }
+  return sortJsonObject(dependencyObject, (leftName, rightName) => leftName.localeCompare(rightName, "en"));
+}
+function sortDependencyValue(fieldValue, packageJson) {
+  return sortJsonObjectValue(fieldValue, (dependencyObject) => sortDependencyObject(dependencyObject, packageJson));
+}
+function sortWorkspacesValue(fieldValue, packageJson) {
+  if (!isJsonObject(fieldValue)) {
+    return fieldValue;
+  }
+  const sortedWorkspaces = sortJsonObjectByKeyOrder(fieldValue, [
+    "packages",
+    "catalog"
+  ]);
+  const workspacePackages = sortedWorkspaces.packages;
+  if (workspacePackages !== undefined) {
+    sortedWorkspaces.packages = sortUniqueStringArrayValue(workspacePackages);
+  }
+  if (isJsonObject(sortedWorkspaces.catalog)) {
+    sortedWorkspaces.catalog = sortDependencyObject(sortedWorkspaces.catalog, packageJson);
+  }
+  return sortedWorkspaces;
+}
+function sortEslintRules(rules) {
+  return sortJsonObject(rules, (leftRuleName, rightRuleName) => {
+    const leftPluginDepth = leftRuleName.split("/").length;
+    const rightPluginDepth = rightRuleName.split("/").length;
+    return leftPluginDepth - rightPluginDepth || leftRuleName.localeCompare(rightRuleName);
+  });
+}
+function sortEslintConfigObject(eslintConfig) {
+  const sortedConfig = sortJsonObjectByKeyOrder(eslintConfig, ESLINT_CONFIG_FIELD_ORDER);
+  for (const fieldName of ["env", "globals", "parserOptions", "settings"]) {
+    if (isJsonObject(sortedConfig[fieldName])) {
+      sortedConfig[fieldName] = sortJsonObject(sortedConfig[fieldName]);
     }
   }
-  known.sort(([a], [b]) => (orderIndex.get(a) ?? 0) - (orderIndex.get(b) ?? 0));
-  rest.sort(([a], [b]) => a.localeCompare(b, "en"));
-  return Object.fromEntries([...known, ...rest]);
+  if (isJsonObject(sortedConfig.rules)) {
+    sortedConfig.rules = sortEslintRules(sortedConfig.rules);
+  }
+  if (Array.isArray(sortedConfig.overrides)) {
+    sortedConfig.overrides = sortedConfig.overrides.map((override) => isJsonObject(override) ? sortEslintConfigObject(override) : override);
+  }
+  return sortedConfig;
+}
+function sortEslintConfigValue(fieldValue) {
+  return sortJsonObjectValue(fieldValue, sortEslintConfigObject);
+}
+function sortPrettierConfigObject(prettierConfig) {
+  const keyOrder = Object.keys(prettierConfig).filter((key) => key !== "overrides").sort(compareText);
+  if (Object.hasOwn(prettierConfig, "overrides")) {
+    keyOrder.push("overrides");
+  }
+  const sortedConfig = sortJsonObjectByKeyOrder(prettierConfig, keyOrder);
+  if (Array.isArray(sortedConfig.overrides)) {
+    sortedConfig.overrides = sortedConfig.overrides.map((override) => {
+      if (!isJsonObject(override)) {
+        return override;
+      }
+      const sortedOverride = sortJsonObject(override);
+      if (isJsonObject(sortedOverride.options)) {
+        sortedOverride.options = sortJsonObject(sortedOverride.options);
+      }
+      return sortedOverride;
+    });
+  }
+  return sortedConfig;
+}
+function sortPrettierConfigValue(fieldValue) {
+  return sortJsonObjectValue(fieldValue, sortPrettierConfigObject);
 }
-function sortObjectKeysAlpha(value) {
-  if (!isPlainObject(value)) {
-    return value;
+function sortWireitScriptObject(scriptConfig) {
+  const sortedConfig = sortJsonObjectByKeyOrder(scriptConfig, WIREIT_SCRIPT_FIELD_ORDER);
+  if (Array.isArray(sortedConfig.dependencies)) {
+    sortedConfig.dependencies = sortedConfig.dependencies.map((dependency) => sortJsonObjectValueByKeyOrder(dependency, ["script", "cascade"]));
+  }
+  if (isJsonObject(sortedConfig.env)) {
+    sortedConfig.env = sortJsonObject(Object.fromEntries(Object.entries(sortedConfig.env).map(([name, value]) => [
+      name,
+      sortJsonObjectValueByKeyOrder(value, ["external", "default"])
+    ])));
+  }
+  if (isJsonObject(sortedConfig.service)) {
+    sortedConfig.service = sortJsonObjectByKeyOrder(sortedConfig.service, [
+      "readyWhen"
+    ]);
+    if (isJsonObject(sortedConfig.service.readyWhen)) {
+      sortedConfig.service.readyWhen = sortJsonObject(sortedConfig.service.readyWhen);
+    }
   }
-  return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b, "en")));
+  return sortedConfig;
 }
-function sortStringArrayAlpha(value) {
-  return [...value].sort((a, b) => a.localeCompare(b, "en"));
+function sortWireitValue(fieldValue) {
+  if (!isJsonObject(fieldValue)) {
+    return fieldValue;
+  }
+  return sortJsonObject(Object.fromEntries(Object.entries(fieldValue).map(([scriptName, scriptConfig]) => [
+    scriptName,
+    sortJsonObjectValue(scriptConfig, sortWireitScriptObject)
+  ])));
 }
-function isPackageJson(filepath) {
-  if (!filepath) {
+function hasSequentialScript(packageJson) {
+  const devDependencies = packageJson.devDependencies;
+  if (!isJsonObject(devDependencies)) {
+    return false;
+  }
+  const isSequentialRunnerInstalled = Object.hasOwn(devDependencies, "npm-run-all") || Object.hasOwn(devDependencies, "npm-run-all2");
+  if (!isSequentialRunnerInstalled) {
     return false;
   }
-  return path.basename(filepath) === "package.json";
+  return ["scripts", "betterScripts"].some((fieldName) => {
+    const scripts = packageJson[fieldName];
+    return isJsonObject(scripts) && Object.values(scripts).some((script) => {
+      const scriptText = getJsonString(script);
+      return scriptText !== null && scriptText.includes("*") && SEQUENTIAL_SCRIPT_PATTERN.test(scriptText);
+    });
+  });
+}
+function sortScriptNames(scriptNames, namespacePrefix = "") {
+  const scriptGroups = new Map;
+  for (const scriptName of scriptNames) {
+    const unprefixedScriptName = namespacePrefix ? scriptName.slice(namespacePrefix.length + 1) : scriptName;
+    const namespaceSeparatorIndex = unprefixedScriptName.indexOf(":");
+    const scriptGroupName = namespaceSeparatorIndex > 0 ? scriptName.slice(0, (namespacePrefix ? namespacePrefix.length + 1 : 0) + namespaceSeparatorIndex) : scriptName;
+    const groupedScriptNames = scriptGroups.get(scriptGroupName) ?? [];
+    groupedScriptNames.push(scriptName);
+    scriptGroups.set(scriptGroupName, groupedScriptNames);
+  }
+  return [...scriptGroups.keys()].sort(compareText).flatMap((scriptGroupName) => {
+    const groupedScriptNames = scriptGroups.get(scriptGroupName);
+    const isNestedGroup = groupedScriptNames.length > 1 && groupedScriptNames.some((scriptName) => scriptName !== scriptGroupName && scriptName.startsWith(`${scriptGroupName}:`));
+    if (!isNestedGroup) {
+      return groupedScriptNames.sort(compareText);
+    }
+    const directScriptNames = groupedScriptNames.filter((scriptName) => scriptName === scriptGroupName || !scriptName.startsWith(`${scriptGroupName}:`)).sort(compareText);
+    const nestedScriptNames = groupedScriptNames.filter((scriptName) => scriptName.startsWith(`${scriptGroupName}:`));
+    return [
+      ...directScriptNames,
+      ...sortScriptNames(nestedScriptNames, scriptGroupName)
+    ];
+  });
+}
+function sortScriptsValue(fieldValue, packageJson) {
+  if (!isJsonObject(fieldValue)) {
+    return fieldValue;
+  }
+  const scriptNames = Object.keys(fieldValue);
+  const baseScriptNames = new Set;
+  const normalizedScriptNames = scriptNames.map((scriptName) => {
+    const baseScriptName = scriptName.replace(/^(?:pre|post)/, "");
+    const isLifecycleScript = NPM_LIFECYCLE_SCRIPT_NAMES.has(baseScriptName);
+    const isBaseScriptPresent = scriptNames.includes(baseScriptName);
+    if (isLifecycleScript || isBaseScriptPresent) {
+      baseScriptNames.add(baseScriptName);
+      return baseScriptName;
+    }
+    return scriptName;
+  });
+  const orderedBaseScriptNames = hasSequentialScript(packageJson) ? [...new Set(normalizedScriptNames)] : sortScriptNames(normalizedScriptNames);
+  const orderedScriptNames = orderedBaseScriptNames.flatMap((baseScriptName) => baseScriptNames.has(baseScriptName) ? [`pre${baseScriptName}`, baseScriptName, `post${baseScriptName}`] : [baseScriptName]);
+  return Object.fromEntries(orderedScriptNames.filter((scriptName) => Object.hasOwn(fieldValue, scriptName)).map((scriptName) => [scriptName, fieldValue[scriptName]]));
+}
+function sortExportsValue(fieldValue) {
+  if (!isJsonObject(fieldValue)) {
+    return fieldValue;
+  }
+  const exportKeys = Object.keys(fieldValue);
+  const exportPathKeys = exportKeys.filter((key) => key.startsWith("."));
+  const exportConditionKeys = exportKeys.filter((key) => !key.startsWith(".") && key !== "default");
+  if (Object.hasOwn(fieldValue, "default")) {
+    exportConditionKeys.push("default");
+  }
+  return Object.fromEntries([...exportPathKeys, ...exportConditionKeys].map((exportKey) => [exportKey, sortExportsValue(fieldValue[exportKey])]));
 }
-function detectIndent(source) {
-  const match = /\n([ \t]+)\S/.exec(source);
-  return match ? match[1] ?? "  " : "  ";
+function sortDevEnginesValue(fieldValue) {
+  if (!isJsonObject(fieldValue) || !isJsonObject(fieldValue.packageManager)) {
+    return fieldValue;
+  }
+  return {
+    ...fieldValue,
+    packageManager: sortJsonObjectByKeyOrder(fieldValue.packageManager, [
+      "name",
+      "version",
+      "onFail"
+    ])
+  };
+}
+function getDependencyName(dependencyIdentifier) {
+  const versionSeparatorIndex = dependencyIdentifier.indexOf("@", dependencyIdentifier.startsWith("@") ? 1 : 0);
+  return versionSeparatorIndex < 0 ? dependencyIdentifier : dependencyIdentifier.slice(0, versionSeparatorIndex);
 }
-function sortPackageJson(text, rawOptions) {
-  if (!isPackageJson(rawOptions.filepath)) {
-    return text;
+function parsePackageSelector(packageSelector) {
+  const [nameAndVersion = packageSelector] = packageSelector.split(">");
+  const versionSeparatorIndex = nameAndVersion.lastIndexOf("@");
+  if (versionSeparatorIndex <= 0) {
+    return { name: packageSelector, versionRange: null };
   }
-  const options2 = resolveSortOptions(rawOptions);
-  const exclude = new Set(options2.packageJsonOrderExcludeKeys);
-  let parsed;
+  return {
+    name: nameAndVersion.slice(0, versionSeparatorIndex),
+    versionRange: nameAndVersion.slice(versionSeparatorIndex + 1) || null
+  };
+}
+function getMinimumSemanticVersion(versionRange) {
   try {
-    parsed = JSON.parse(text);
+    return findMinimumSemanticVersion(versionRange);
   } catch {
-    return text;
+    return null;
   }
-  if (!isPlainObject(parsed)) {
-    return text;
+}
+function comparePnpmOverrideSelectors(leftSelector, rightSelector) {
+  const leftPackage = parsePackageSelector(leftSelector);
+  const rightPackage = parsePackageSelector(rightSelector);
+  if (leftPackage.name !== rightPackage.name) {
+    return leftPackage.name.localeCompare(rightPackage.name, "en");
+  }
+  if (!leftPackage.versionRange && !rightPackage.versionRange) {
+    return 0;
+  }
+  if (!leftPackage.versionRange) {
+    return -1;
+  }
+  if (!rightPackage.versionRange) {
+    return 1;
+  }
+  const leftVersion = getMinimumSemanticVersion(leftPackage.versionRange);
+  const rightVersion = getMinimumSemanticVersion(rightPackage.versionRange);
+  if (!leftVersion && !rightVersion) {
+    return compareText(leftPackage.versionRange, rightPackage.versionRange);
+  }
+  if (!leftVersion) {
+    return 1;
+  }
+  if (!rightVersion) {
+    return -1;
+  }
+  return leftVersion.compare(rightVersion);
+}
+function sortDependencyMetadataValue(fieldValue) {
+  return sortJsonObjectValue(fieldValue, (dependencyMetadata) => {
+    const compareDependencyIdentifiers = (leftIdentifier, rightIdentifier) => compareText(getDependencyName(leftIdentifier), getDependencyName(rightIdentifier));
+    return sortJsonObjectRecursively(dependencyMetadata, (jsonObject) => sortJsonObject(jsonObject, compareDependencyIdentifiers));
+  });
+}
+function sortPnpmConfigValue(fieldValue) {
+  return sortJsonObjectValue(fieldValue, (pnpmConfig) => {
+    const sortedPnpmConfig = sortJsonObjectRecursively(pnpmConfig, (jsonObject) => sortJsonObjectByKeyOrder(jsonObject, PNPM_CONFIG_FIELD_ORDER));
+    if (!isJsonObject(sortedPnpmConfig.overrides)) {
+      return sortedPnpmConfig;
+    }
+    return {
+      ...sortedPnpmConfig,
+      overrides: sortJsonObject(sortedPnpmConfig.overrides, comparePnpmOverrideSelectors)
+    };
+  });
+}
+var PACKAGE_JSON_FIELD_SORTERS = {
+  categories: deduplicateStringArrayValue,
+  keywords: deduplicateStringArrayValue,
+  bugs: (fieldValue) => sortJsonObjectValueByKeyOrder(fieldValue, ["url", "email"]),
+  repository: (fieldValue) => sortJsonObjectValueByKeyOrder(fieldValue, ["type", "url"]),
+  funding: (fieldValue) => sortJsonObjectValueByKeyOrder(fieldValue, ["type", "url"]),
+  license: (fieldValue) => sortJsonObjectValueByKeyOrder(fieldValue, ["type", "url"]),
+  author: sortPersonValue,
+  maintainers: sortPeopleArrayValue,
+  contributors: sortPeopleArrayValue,
+  exports: sortExportsValue,
+  bin: sortJsonObjectValueAlphabetically,
+  directories: (fieldValue) => sortJsonObjectValueByKeyOrder(fieldValue, DIRECTORY_FIELD_ORDER),
+  files: deduplicateStringArrayValue,
+  workspaces: sortWorkspacesValue,
+  binary: (fieldValue) => sortJsonObjectValueByKeyOrder(fieldValue, [
+    "module_name",
+    "module_path",
+    "remote_path",
+    "package_name",
+    "host"
+  ]),
+  scripts: sortScriptsValue,
+  betterScripts: sortScriptsValue,
+  wireit: sortWireitValue,
+  contributes: sortJsonObjectValueAlphabetically,
+  activationEvents: deduplicateStringArrayValue,
+  husky: (fieldValue) => {
+    if (!isJsonObject(fieldValue) || !isJsonObject(fieldValue.hooks)) {
+      return fieldValue;
+    }
+    return {
+      ...fieldValue,
+      hooks: sortJsonObjectByKeyOrder(fieldValue.hooks, GIT_HOOK_ORDER)
+    };
+  },
+  "simple-git-hooks": (fieldValue) => sortJsonObjectValueByKeyOrder(fieldValue, GIT_HOOK_ORDER),
+  commitlint: sortJsonObjectValueAlphabetically,
+  config: sortJsonObjectValueAlphabetically,
+  nodemonConfig: sortJsonObjectValueAlphabetically,
+  browserify: sortJsonObjectValueAlphabetically,
+  babel: sortJsonObjectValueAlphabetically,
+  xo: sortJsonObjectValueAlphabetically,
+  prettier: sortPrettierConfigValue,
+  eslintConfig: sortEslintConfigValue,
+  npmpkgjsonlint: sortJsonObjectValueAlphabetically,
+  npmPackageJsonLintConfig: sortJsonObjectValueAlphabetically,
+  npmpackagejsonlint: sortJsonObjectValueAlphabetically,
+  release: sortJsonObjectValueAlphabetically,
+  remarkConfig: sortJsonObjectValueAlphabetically,
+  ava: sortJsonObjectValueAlphabetically,
+  jest: sortJsonObjectValueAlphabetically,
+  "jest-junit": sortJsonObjectValueAlphabetically,
+  "jest-stare": sortJsonObjectValueAlphabetically,
+  mocha: sortJsonObjectValueAlphabetically,
+  nyc: sortJsonObjectValueAlphabetically,
+  c8: sortJsonObjectValueAlphabetically,
+  tap: sortJsonObjectValueAlphabetically,
+  oclif: sortJsonObjectValueRecursively,
+  resolutions: sortJsonObjectValueAlphabetically,
+  overrides: sortDependencyValue,
+  dependencies: sortDependencyValue,
+  devDependencies: sortDependencyValue,
+  dependenciesMeta: sortDependencyMetadataValue,
+  peerDependencies: sortDependencyValue,
+  peerDependenciesMeta: sortJsonObjectValueRecursively,
+  optionalDependencies: sortDependencyValue,
+  bundledDependencies: sortUniqueStringArrayValue,
+  bundleDependencies: sortUniqueStringArrayValue,
+  extensionPack: sortUniqueStringArrayValue,
+  extensionDependencies: sortUniqueStringArrayValue,
+  engines: sortJsonObjectValueAlphabetically,
+  engineStrict: sortJsonObjectValueAlphabetically,
+  devEngines: sortDevEnginesValue,
+  volta: (fieldValue) => sortJsonObjectValueByKeyOrder(fieldValue, ["node", "npm", "yarn"]),
+  preferGlobal: sortJsonObjectValueAlphabetically,
+  publishConfig: sortJsonObjectValueAlphabetically,
+  badges: (fieldValue) => {
+    if (!Array.isArray(fieldValue)) {
+      return fieldValue;
+    }
+    return fieldValue.map((badge) => sortJsonObjectValueByKeyOrder(badge, ["description", "url", "href"]));
+  },
+  galleryBanner: sortJsonObjectValueAlphabetically,
+  pnpm: sortPnpmConfigValue
+};
+function sortPackageJsonObject(packageJson) {
+  const sortedPackageJsonFields = sortPackageJsonFields(packageJson);
+  return Object.fromEntries(Object.entries(sortedPackageJsonFields).map(([fieldName, fieldValue]) => {
+    const fieldSorter = Object.hasOwn(PACKAGE_JSON_FIELD_SORTERS, fieldName) ? PACKAGE_JSON_FIELD_SORTERS[fieldName] : undefined;
+    return [
+      fieldName,
+      fieldSorter ? fieldSorter(fieldValue, packageJson) : fieldValue
+    ];
+  }));
+}
+function isPackageJsonFile(filePath) {
+  return filePath?.split(/[\\/]/).at(-1) === "package.json";
+}
+async function preprocessPackageJson(sourceText, prettierOptions, parser) {
+  if (!isPackageJsonFile(prettierOptions.filepath) || !resolveSortOptions(prettierOptions).packageSort) {
+    return sourceText;
   }
-  let result = parsed;
-  for (const field of DEPENDENCY_FIELDS) {
-    const dependencyMap = result[field];
-    if (dependencyMap !== undefined && !exclude.has(field)) {
-      result[field] = sortObjectKeysAlpha(dependencyMap);
+  try {
+    const parsedPackageJson = JSON.parse(sourceText);
+    if (!isJsonObject(parsedPackageJson)) {
+      return sourceText;
+    }
+    const parserJsonAst = await parser.parse(sourceText, prettierOptions);
+    if (!isParserJsonAstNode(parserJsonAst)) {
+      return sourceText;
     }
+    const fieldNameSourceTexts = new Map;
+    const packageJsonWithSourceLiterals = preserveJsonSourceLiterals(parsedPackageJson, parserJsonAst, sourceText, fieldNameSourceTexts);
+    if (!isJsonObject(packageJsonWithSourceLiterals)) {
+      return sourceText;
+    }
+    return serializeJsonValue(sortPackageJsonObject(packageJsonWithSourceLiterals), fieldNameSourceTexts) ?? sourceText;
+  } catch {
+    return sourceText;
   }
-  if (options2.packageJsonOrder) {
-    result = sortObjectKeysByOrder(result, PACKAGE_JSON_TOP_LEVEL_ORDER);
-    for (const [key, value] of Object.entries(result)) {
-      if (exclude.has(key)) {
-        continue;
+}
+
+// src/sort-exports.ts
+function buildExportSortingEdits(sourceText, programStatements, sortedComments) {
+  const sortingEdits = [];
+  for (const exportDeclarationNode of programStatements) {
+    if (exportDeclarationNode.type !== "ExportNamedDeclaration" || exportDeclarationNode.declaration) {
+      continue;
+    }
+    const declarationRange = getAstNodeTextRange(exportDeclarationNode);
+    const specifierNodes = exportDeclarationNode.specifiers;
+    if (!declarationRange || !specifierNodes || specifierNodes.length <= 1 || isPrettierIgnored(sourceText, declarationRange, sortedComments) || specifierNodes.some((specifierNode) => specifierNode.type !== "ExportSpecifier")) {
+      continue;
+    }
+    const firstSpecifierRange = getAstNodeTextRange(specifierNodes[0]);
+    const lastSpecifierRange = getAstNodeTextRange(specifierNodes.at(-1));
+    if (!firstSpecifierRange || !lastSpecifierRange) {
+      continue;
+    }
+    const openingBraceIndex = sourceText.lastIndexOf("{", firstSpecifierRange.start);
+    const closingBraceIndex = sourceText.indexOf("}", lastSpecifierRange.end);
+    if (openingBraceIndex < declarationRange.start || closingBraceIndex < lastSpecifierRange.end || closingBraceIndex >= declarationRange.end) {
+      continue;
+    }
+    const firstInternalCommentIndex = findCommentIndexAtOrAfter(sortedComments, openingBraceIndex + 1);
+    const firstInternalComment = sortedComments[firstInternalCommentIndex];
+    const isInternalCommentPresent = firstInternalComment !== undefined && firstInternalComment.textRange.start < closingBraceIndex;
+    if (isInternalCommentPresent) {
+      continue;
+    }
+    let isEverySpecifierValid = true;
+    const sortableSpecifiers = [];
+    for (const [originalIndex, specifierNode] of specifierNodes.entries()) {
+      const specifierRange = getAstNodeTextRange(specifierNode);
+      const exportedName = getAstNodeName(specifierNode.exported);
+      const localName = getAstNodeName(specifierNode.local);
+      const sortName = exportedName ?? localName;
+      if (!specifierRange || !sortName) {
+        isEverySpecifierValid = false;
+        break;
       }
-      if (isStringArray(value)) {
-        result[key] = sortStringArrayAlpha(value);
+      sortableSpecifiers.push({
+        originalIndex,
+        sortName,
+        specifierText: sourceText.slice(specifierRange.start, specifierRange.end)
+      });
+    }
+    if (!isEverySpecifierValid) {
+      continue;
+    }
+    const sortedSpecifiers = [...sortableSpecifiers].sort((left, right) => left.sortName.localeCompare(right.sortName, "en", {
+      sensitivity: "base"
+    }) || left.originalIndex - right.originalIndex);
+    const isSpecifierOrderUnchanged = sortedSpecifiers.every((specifier, sortedIndex) => specifier.originalIndex === sortedIndex);
+    if (isSpecifierOrderUnchanged) {
+      continue;
+    }
+    sortingEdits.push({
+      start: openingBraceIndex,
+      end: closingBraceIndex + 1,
+      replacementText: `{ ${sortedSpecifiers.map((specifier) => specifier.specifierText).join(", ")} }`
+    });
+  }
+  return sortingEdits;
+}
+
+// src/utils/source-text.ts
+function applySourceTextEdits(sourceText, sourceTextEdits) {
+  if (sourceTextEdits.length === 0) {
+    return sourceText;
+  }
+  let previousEditEnd = 0;
+  const ascendingEdits = [...sourceTextEdits].sort((left, right) => left.start - right.start || left.end - right.end);
+  for (const sourceTextEdit of ascendingEdits) {
+    const { start, end } = sourceTextEdit;
+    const isSourceTextEditValid = [start, end].every(Number.isSafeInteger) && start >= previousEditEnd && end >= start && end <= sourceText.length;
+    if (!isSourceTextEditValid) {
+      return null;
+    }
+    previousEditEnd = end;
+  }
+  let editedText = sourceText;
+  for (const sourceTextEdit of ascendingEdits.reverse()) {
+    editedText = editedText.slice(0, sourceTextEdit.start) + sourceTextEdit.replacementText + editedText.slice(sourceTextEdit.end);
+  }
+  return editedText;
+}
+
+// src/sort-imports.ts
+var INDEX_MODULE_PATTERN = /^\.\/index(?:\.[^/]+)*$/;
+var PRETTIER_FILE_PRAGMA_DIRECTIVES = ["@format", "@prettier"];
+var ESLINT_RANGE_DIRECTIVES = ["eslint-disable", "eslint-enable"];
+var ESLINT_GLOBAL_DIRECTIVES = ["global", "globals"];
+function getCommentDirectiveArguments(commentLine, directive) {
+  if (!commentLine.startsWith(directive)) {
+    return null;
+  }
+  const directiveArguments = commentLine.slice(directive.length);
+  if (directiveArguments === "") {
+    return "";
+  }
+  if (directiveArguments[0]?.trim() !== "") {
+    return null;
+  }
+  return directiveArguments.trimStart();
+}
+function hasCommentDirective(commentLine, directives) {
+  return directives.some((directive) => getCommentDirectiveArguments(commentLine, directive) !== null);
+}
+function isEslintRuleConfiguration(commentLine) {
+  const ruleConfiguration = getCommentDirectiveArguments(commentLine, "eslint");
+  if (!ruleConfiguration) {
+    return false;
+  }
+  const separatorIndex = ruleConfiguration.indexOf(":");
+  if (separatorIndex < 1) {
+    return false;
+  }
+  const ruleName = ruleConfiguration.slice(0, separatorIndex).trimEnd();
+  return ruleName.length > 0 && [...ruleName].every((character) => character.trim() !== "");
+}
+function isFixedEslintComment(comment, isBlockComment) {
+  if (!isBlockComment) {
+    return false;
+  }
+  const commentText = getAstCommentText(comment)?.trim();
+  if (!commentText) {
+    return false;
+  }
+  return hasCommentDirective(commentText, ESLINT_RANGE_DIRECTIVES) || isEslintRuleConfiguration(commentText) || hasCommentDirective(commentText, ESLINT_GLOBAL_DIRECTIVES);
+}
+function isEslintNextLineComment(comment) {
+  const commentText = getAstCommentText(comment)?.trim();
+  if (!commentText) {
+    return false;
+  }
+  return getCommentDirectiveArguments(commentText, "eslint-disable-next-line") !== null;
+}
+function isFixedEslintParserComment(sourceText, parserComment) {
+  const { comment, textRange } = parserComment;
+  const sourceCommentText = sourceText.slice(textRange.start, textRange.end);
+  return isFixedEslintComment(comment, sourceCommentText.startsWith("/*"));
+}
+function isPositionSensitiveEslintComment(sourceText, parserComment) {
+  return isEslintNextLineComment(parserComment.comment) || isFixedEslintParserComment(sourceText, parserComment);
+}
+function getCommentLines(comment) {
+  const commentText = getAstCommentText(comment);
+  if (commentText === null) {
+    return [];
+  }
+  return commentText.split(/\r?\n/).map((commentLine) => commentLine.replace(/^\s*\*+\s*/, ""));
+}
+function isFixedFileComment(sourceText, comment, commentRange, prettierFilePragmaComment) {
+  const sourceCommentText = sourceText.slice(commentRange.start, commentRange.end);
+  if (sourceCommentText.startsWith("#!")) {
+    return true;
+  }
+  if (comment === prettierFilePragmaComment) {
+    return true;
+  }
+  const isBlockComment = sourceCommentText.startsWith("/*");
+  return isFixedEslintComment(comment, isBlockComment);
+}
+function getPrettierFilePragmaComment(sortedComments, isPrettierFilePragmaPresent) {
+  if (!isPrettierFilePragmaPresent) {
+    return null;
+  }
+  return sortedComments.find(({ comment }) => getCommentLines(comment).some((commentLine) => hasCommentDirective(commentLine.trim(), PRETTIER_FILE_PRAGMA_DIRECTIVES)))?.comment ?? null;
+}
+function classifyImportGroup(moduleSpecifier) {
+  if (moduleSpecifier === "bun" || moduleSpecifier.startsWith("bun:") || moduleSpecifier.startsWith("node:")) {
+    return "builtin";
+  }
+  if (moduleSpecifier === "." || moduleSpecifier === "./" || INDEX_MODULE_PATTERN.test(moduleSpecifier)) {
+    return "index";
+  }
+  if (moduleSpecifier === ".." || moduleSpecifier.startsWith("../")) {
+    return "parent";
+  }
+  if (moduleSpecifier.startsWith("./")) {
+    return "sibling";
+  }
+  if (moduleSpecifier.startsWith("/") || moduleSpecifier.startsWith("~") || moduleSpecifier.startsWith("@/") || moduleSpecifier.startsWith("#")) {
+    return "internal";
+  }
+  return "external";
+}
+function findLeadingCommentsStart(sourceText, statementStart, sortedComments, prettierFilePragmaComment) {
+  let attachedTextStart = statementStart;
+  for (let commentIndex = findCommentIndexAtOrAfter(sortedComments, statementStart) - 1;commentIndex >= 0; commentIndex--) {
+    const parserComment = sortedComments[commentIndex];
+    if (!parserComment || parserComment.textRange.end > statementStart) {
+      continue;
+    }
+    const { comment, textRange } = parserComment;
+    if (isFixedFileComment(sourceText, comment, textRange, prettierFilePragmaComment)) {
+      break;
+    }
+    const textBetweenCommentAndImport = sourceText.slice(textRange.end, attachedTextStart);
+    const lineBreakCount = textBetweenCommentAndImport.match(/\n/g)?.length ?? 0;
+    const isEslintNextLineCommentAttached = attachedTextStart === statementStart && isEslintNextLineComment(comment) && textBetweenCommentAndImport.trim() === "" && lineBreakCount === 1;
+    if (isEslintNextLineCommentAttached) {
+      attachedTextStart = textRange.start;
+      continue;
+    }
+    const commentLineStart = sourceText.lastIndexOf(`
+`, textRange.start - 1) + 1;
+    if (sourceText.slice(commentLineStart, textRange.start).trim() !== "") {
+      break;
+    }
+    if (textBetweenCommentAndImport.trim() !== "" || lineBreakCount >= 2) {
+      break;
+    }
+    attachedTextStart = textRange.start;
+  }
+  while (attachedTextStart > 0 && /[ \t]/.test(sourceText[attachedTextStart - 1])) {
+    attachedTextStart--;
+  }
+  return attachedTextStart;
+}
+function getRangeEndIncludingLineBreak(sourceText, sourceIndex) {
+  if (sourceText[sourceIndex] === "\r" && sourceText[sourceIndex + 1] === `
+`) {
+    return sourceIndex + 2;
+  }
+  if (sourceText[sourceIndex] === `
+`) {
+    return sourceIndex + 1;
+  }
+  return sourceIndex;
+}
+function getTrailingComments(sourceText, statementEnd, sortedComments) {
+  let trailingCommentsEnd = statementEnd;
+  let isImportSortingBoundary = false;
+  const firstTrailingCommentIndex = findCommentIndexAtOrAfter(sortedComments, statementEnd);
+  for (let commentIndex = firstTrailingCommentIndex;commentIndex < sortedComments.length; commentIndex++) {
+    const trailingComment = sortedComments[commentIndex];
+    if (!trailingComment) {
+      break;
+    }
+    const { textRange } = trailingComment;
+    const textBeforeComment = sourceText.slice(trailingCommentsEnd, textRange.start);
+    if (textBeforeComment.includes(`
+`) || textBeforeComment.trim() !== "") {
+      break;
+    }
+    const commentLineEnd = sourceText.indexOf(`
+`, textRange.end);
+    if (!isSourceRangeWhitespaceOrComments(sourceText, {
+      start: textRange.end,
+      end: commentLineEnd < 0 ? sourceText.length : commentLineEnd
+    }, sortedComments)) {
+      break;
+    }
+    if (isFixedEslintParserComment(sourceText, trailingComment)) {
+      isImportSortingBoundary = true;
+      break;
+    }
+    if (isEslintNextLineComment(trailingComment.comment)) {
+      break;
+    }
+    trailingCommentsEnd = textRange.end;
+  }
+  return {
+    commentsText: sourceText.slice(statementEnd, trailingCommentsEnd),
+    rangeEnd: trailingCommentsEnd,
+    isImportSortingBoundary
+  };
+}
+function parseImportAttributes(sourceText, importDeclarationNode) {
+  const declarationRange = getAstNodeTextRange(importDeclarationNode);
+  const moduleSpecifierRange = getAstNodeTextRange(importDeclarationNode.source);
+  if (!declarationRange || !moduleSpecifierRange) {
+    return { attributesText: null, isValid: false };
+  }
+  const importAttributesText = sourceText.slice(moduleSpecifierRange.end, declarationRange.end).replace(/;\s*$/, "").trim();
+  if (importAttributesText === "") {
+    return { attributesText: null, isValid: true };
+  }
+  return {
+    attributesText: importAttributesText,
+    isValid: /^(?:with|assert)\s*\{[\s\S]*\}$/.test(importAttributesText)
+  };
+}
+function parseImportDeclaration(importDeclarationMetadata, sourceText) {
+  const {
+    importDeclarationNode,
+    declarationRange,
+    leadingCommentsText,
+    trailingCommentsText,
+    hasInternalComments
+  } = importDeclarationMetadata;
+  const moduleSpecifierNode = importDeclarationNode.source;
+  const moduleSpecifierRange = getAstNodeTextRange(moduleSpecifierNode);
+  const moduleSpecifier = getAstNodeName(moduleSpecifierNode);
+  if (!moduleSpecifierRange || moduleSpecifier === null) {
+    return null;
+  }
+  let importKind = "value";
+  const declarationText = sourceText.slice(declarationRange.start, declarationRange.end);
+  if (typeof importDeclarationNode.importKind === "string") {
+    importKind = importDeclarationNode.importKind;
+  }
+  let specifierNodes = [];
+  const isTypeOnly = importKind === "type";
+  if (Array.isArray(importDeclarationNode.specifiers)) {
+    specifierNodes = importDeclarationNode.specifiers;
+  }
+  let importPhase = null;
+  const isSideEffectOnly = specifierNodes.length === 0 && importKind === "value";
+  const parsedImportAttributes = parseImportAttributes(sourceText, importDeclarationNode);
+  if (typeof importDeclarationNode.phase === "string") {
+    importPhase = importDeclarationNode.phase;
+  }
+  let defaultBinding = null;
+  let namespaceBinding = null;
+  let isEverySpecifierSupported = true;
+  const namedSpecifiers = [];
+  for (const specifierNode of specifierNodes) {
+    if (specifierNode.type === "ImportDefaultSpecifier") {
+      defaultBinding = getAstNodeName(specifierNode.local);
+      isEverySpecifierSupported &&= defaultBinding !== null;
+      continue;
+    }
+    if (specifierNode.type === "ImportNamespaceSpecifier") {
+      namespaceBinding = getAstNodeName(specifierNode.local);
+      isEverySpecifierSupported &&= namespaceBinding !== null;
+      continue;
+    }
+    if (specifierNode.type !== "ImportSpecifier") {
+      isEverySpecifierSupported = false;
+      continue;
+    }
+    let specifierKind = "value";
+    const importedNode = specifierNode.imported;
+    const importedNameRange = getAstNodeTextRange(importedNode);
+    const importedName = getAstNodeName(importedNode);
+    const localName = getAstNodeName(specifierNode.local);
+    if (typeof specifierNode.importKind === "string") {
+      specifierKind = specifierNode.importKind;
+    }
+    if (!importedNameRange || importedName === null || localName === null || specifierKind !== "value" && specifierKind !== "type") {
+      isEverySpecifierSupported = false;
+      continue;
+    }
+    namedSpecifiers.push({
+      importedName,
+      importedNameText: sourceText.slice(importedNameRange.start, importedNameRange.end),
+      localName,
+      isTypeOnly: specifierKind === "type"
+    });
+  }
+  let parsedNamedSpecifiers = null;
+  const isTypeClauseRewriteUnsupported = isTypeOnly && (defaultBinding !== null || namespaceBinding !== null);
+  const isVerbatimRenderingRequired = specifierNodes.length === 0 || hasInternalComments || importPhase !== null || importKind !== "value" && importKind !== "type" || !isEverySpecifierSupported || !parsedImportAttributes.isValid || isTypeClauseRewriteUnsupported || isTypeOnly && parsedImportAttributes.attributesText !== null;
+  if (namedSpecifiers.length > 0) {
+    parsedNamedSpecifiers = namedSpecifiers;
+  }
+  let verbatimDeclaration = null;
+  if (isVerbatimRenderingRequired) {
+    verbatimDeclaration = declarationText;
+  }
+  return {
+    moduleSpecifier,
+    moduleSpecifierText: sourceText.slice(moduleSpecifierRange.start, moduleSpecifierRange.end),
+    isTypeOnly,
+    isSideEffectOnly,
+    defaultBinding,
+    namespaceBinding,
+    namedSpecifiers: parsedNamedSpecifiers,
+    importAttributes: parsedImportAttributes.attributesText,
+    verbatimDeclaration,
+    leadingCommentsText,
+    trailingCommentsText,
+    isMergeBoundary: leadingCommentsText.trim() !== "" || trailingCommentsText !== "" || hasInternalComments
+  };
+}
+function renderNamedImportSpecifiers(namedSpecifiers) {
+  return namedSpecifiers.map((importSpecifier) => {
+    let renderedSpecifier = importSpecifier.importedNameText;
+    const isAliasRequired = importSpecifier.importedNameText !== importSpecifier.importedName || importSpecifier.importedName !== importSpecifier.localName;
+    if (isAliasRequired) {
+      renderedSpecifier = `${importSpecifier.importedNameText} as ${importSpecifier.localName}`;
+    }
+    if (importSpecifier.isTypeOnly) {
+      return `type ${renderedSpecifier}`;
+    }
+    return renderedSpecifier;
+  }).join(", ");
+}
+function renderImportBindings(importDeclaration) {
+  const renderedBindings = [];
+  if (importDeclaration.defaultBinding) {
+    renderedBindings.push(importDeclaration.defaultBinding);
+  }
+  if (importDeclaration.namespaceBinding) {
+    renderedBindings.push(`* as ${importDeclaration.namespaceBinding}`);
+  }
+  if (importDeclaration.namedSpecifiers) {
+    renderedBindings.push(`{ ${renderNamedImportSpecifiers(importDeclaration.namedSpecifiers)} }`);
+  }
+  return renderedBindings.join(", ");
+}
+function renderImportDeclaration(importDeclaration) {
+  if (importDeclaration.verbatimDeclaration !== null) {
+    return importDeclaration.leadingCommentsText + importDeclaration.verbatimDeclaration + importDeclaration.trailingCommentsText;
+  }
+  let attributesSuffix = "";
+  if (importDeclaration.importAttributes) {
+    attributesSuffix = ` ${importDeclaration.importAttributes}`;
+  }
+  let declarationText = `import ${renderImportBindings(importDeclaration)} from ${importDeclaration.moduleSpecifierText}${attributesSuffix};`;
+  if (importDeclaration.isTypeOnly) {
+    declarationText = `import type ${renderImportBindings(importDeclaration)} from ${importDeclaration.moduleSpecifierText}${attributesSuffix};`;
+  }
+  return importDeclaration.leadingCommentsText + declarationText + importDeclaration.trailingCommentsText;
+}
+function sortNamedImportSpecifiers(namedSpecifiers) {
+  return [...namedSpecifiers].sort((left, right) => left.localName.localeCompare(right.localName, "en", {
+    sensitivity: "base"
+  }));
+}
+function getLocalBindingNames(importDeclaration) {
+  const localBindingNames = [];
+  if (importDeclaration.defaultBinding) {
+    localBindingNames.push(importDeclaration.defaultBinding);
+  }
+  if (importDeclaration.namespaceBinding) {
+    localBindingNames.push(importDeclaration.namespaceBinding);
+  }
+  if (importDeclaration.namedSpecifiers) {
+    localBindingNames.push(...importDeclaration.namedSpecifiers.map((importSpecifier) => importSpecifier.localName));
+  }
+  return localBindingNames;
+}
+function normalizeNamedTypeOnlyImport(importDeclaration) {
+  if (!importDeclaration.isTypeOnly || !importDeclaration.namedSpecifiers || importDeclaration.defaultBinding || importDeclaration.namespaceBinding || importDeclaration.verbatimDeclaration !== null) {
+    return importDeclaration;
+  }
+  return {
+    ...importDeclaration,
+    isTypeOnly: false,
+    namedSpecifiers: importDeclaration.namedSpecifiers.map((importSpecifier) => ({
+      ...importSpecifier,
+      isTypeOnly: true
+    }))
+  };
+}
+function getImportRequestKey(importDeclaration) {
+  return `${importDeclaration.moduleSpecifier}\x00${importDeclaration.importAttributes ?? ""}`;
+}
+function isImportDeclarationMergeSafe(targetImportDeclaration, candidateImportDeclaration, bindingCounts) {
+  if (targetImportDeclaration.verbatimDeclaration !== null || candidateImportDeclaration.verbatimDeclaration !== null || targetImportDeclaration.isSideEffectOnly || candidateImportDeclaration.isSideEffectOnly || targetImportDeclaration.moduleSpecifier !== candidateImportDeclaration.moduleSpecifier || targetImportDeclaration.importAttributes !== candidateImportDeclaration.importAttributes || targetImportDeclaration.isMergeBoundary || candidateImportDeclaration.isMergeBoundary) {
+    return false;
+  }
+  if (bindingCounts.defaultBindingCount > 1 && (targetImportDeclaration.defaultBinding !== null || candidateImportDeclaration.defaultBinding !== null) || bindingCounts.namespaceBindingCount > 1 && (targetImportDeclaration.namespaceBinding !== null || candidateImportDeclaration.namespaceBinding !== null) || targetImportDeclaration.defaultBinding !== null && candidateImportDeclaration.defaultBinding !== null || targetImportDeclaration.namespaceBinding !== null && candidateImportDeclaration.namespaceBinding !== null) {
+    return false;
+  }
+  const isAnyNamedSpecifierPresent = (targetImportDeclaration.namedSpecifiers?.length ?? 0) > 0 || (candidateImportDeclaration.namedSpecifiers?.length ?? 0) > 0;
+  if (isAnyNamedSpecifierPresent && (targetImportDeclaration.namespaceBinding !== null || candidateImportDeclaration.namespaceBinding !== null)) {
+    return false;
+  }
+  const usedLocalNames = new Set(getLocalBindingNames(targetImportDeclaration));
+  return getLocalBindingNames(candidateImportDeclaration).every((localName) => !usedLocalNames.has(localName));
+}
+function mergeImportDeclarations(targetImportDeclaration, candidateImportDeclaration) {
+  let namedSpecifiers = null;
+  const mergedNamedSpecifiers = [
+    ...targetImportDeclaration.namedSpecifiers ?? [],
+    ...candidateImportDeclaration.namedSpecifiers ?? []
+  ];
+  if (mergedNamedSpecifiers.length > 0) {
+    namedSpecifiers = mergedNamedSpecifiers;
+  }
+  return {
+    moduleSpecifier: targetImportDeclaration.moduleSpecifier,
+    moduleSpecifierText: targetImportDeclaration.moduleSpecifierText,
+    isTypeOnly: false,
+    isSideEffectOnly: false,
+    defaultBinding: targetImportDeclaration.defaultBinding ?? candidateImportDeclaration.defaultBinding,
+    namespaceBinding: targetImportDeclaration.namespaceBinding ?? candidateImportDeclaration.namespaceBinding,
+    namedSpecifiers,
+    importAttributes: targetImportDeclaration.importAttributes,
+    verbatimDeclaration: null,
+    leadingCommentsText: targetImportDeclaration.leadingCommentsText,
+    trailingCommentsText: "",
+    isMergeBoundary: false
+  };
+}
+function mergeCompatibleImports(importDeclarations) {
+  const bindingCountsByImportDeclaration = new Map;
+  const currentBindingCountsByRequest = new Map;
+  const minimumMergeTargetIndexByRequest = new Map;
+  for (const importDeclaration of importDeclarations) {
+    const importRequestKey = getImportRequestKey(importDeclaration);
+    if (importDeclaration.isMergeBoundary) {
+      currentBindingCountsByRequest.delete(importRequestKey);
+      continue;
+    }
+    if (importDeclaration.verbatimDeclaration !== null || importDeclaration.isSideEffectOnly) {
+      continue;
+    }
+    const bindingCounts = currentBindingCountsByRequest.get(importRequestKey) ?? {
+      defaultBindingCount: 0,
+      namespaceBindingCount: 0
+    };
+    if (importDeclaration.defaultBinding !== null) {
+      bindingCounts.defaultBindingCount++;
+    }
+    if (importDeclaration.namespaceBinding !== null) {
+      bindingCounts.namespaceBindingCount++;
+    }
+    currentBindingCountsByRequest.set(importRequestKey, bindingCounts);
+    bindingCountsByImportDeclaration.set(importDeclaration, bindingCounts);
+  }
+  const mergedImportDeclarations = [];
+  for (const originalImportDeclaration of importDeclarations) {
+    const importDeclaration = normalizeNamedTypeOnlyImport(originalImportDeclaration);
+    const importRequestKey = getImportRequestKey(importDeclaration);
+    const bindingCounts = bindingCountsByImportDeclaration.get(originalImportDeclaration) ?? {
+      defaultBindingCount: 0,
+      namespaceBindingCount: 0
+    };
+    const minimumMergeTargetIndex = minimumMergeTargetIndexByRequest.get(importRequestKey) ?? 0;
+    const mergeTargetIndex = mergedImportDeclarations.findIndex((existingImportDeclaration, existingImportIndex) => existingImportIndex >= minimumMergeTargetIndex && isImportDeclarationMergeSafe(existingImportDeclaration, importDeclaration, bindingCounts));
+    if (mergeTargetIndex < 0) {
+      mergedImportDeclarations.push(importDeclaration);
+    } else {
+      mergedImportDeclarations[mergeTargetIndex] = mergeImportDeclarations(mergedImportDeclarations[mergeTargetIndex], importDeclaration);
+    }
+    if (importDeclaration.isMergeBoundary) {
+      minimumMergeTargetIndexByRequest.set(importRequestKey, mergedImportDeclarations.length);
+    }
+  }
+  return mergedImportDeclarations;
+}
+function applyTypeImportStyle(importDeclaration, typeImportStyle) {
+  if (importDeclaration.verbatimDeclaration !== null || !importDeclaration.namedSpecifiers) {
+    return [importDeclaration];
+  }
+  const namedSpecifiers = importDeclaration.namedSpecifiers;
+  if (typeImportStyle === "separate") {
+    if (importDeclaration.isTypeOnly) {
+      return [
+        {
+          ...importDeclaration,
+          namedSpecifiers: sortNamedImportSpecifiers(namedSpecifiers)
+        }
+      ];
+    }
+    const typeSpecifiers2 = namedSpecifiers.filter((importSpecifier) => importSpecifier.isTypeOnly);
+    const valueSpecifiers2 = namedSpecifiers.filter((importSpecifier) => !importSpecifier.isTypeOnly);
+    if (typeSpecifiers2.length > 0 && (importDeclaration.importAttributes !== null || importDeclaration.leadingCommentsText.trim() !== "" || importDeclaration.trailingCommentsText !== "")) {
+      return [
+        {
+          ...importDeclaration,
+          namedSpecifiers: sortNamedImportSpecifiers(namedSpecifiers)
+        }
+      ];
+    }
+    const styledImportDeclarations = [];
+    if (typeSpecifiers2.length > 0) {
+      styledImportDeclarations.push({
+        ...importDeclaration,
+        isTypeOnly: true,
+        defaultBinding: null,
+        namespaceBinding: null,
+        namedSpecifiers: sortNamedImportSpecifiers(typeSpecifiers2.map((importSpecifier) => ({
+          ...importSpecifier,
+          isTypeOnly: false
+        })))
+      });
+    }
+    if (valueSpecifiers2.length > 0 || importDeclaration.defaultBinding !== null || importDeclaration.namespaceBinding !== null) {
+      let namedValueSpecifiers = null;
+      if (valueSpecifiers2.length > 0) {
+        namedValueSpecifiers = sortNamedImportSpecifiers(valueSpecifiers2);
       }
+      let leadingCommentsText = importDeclaration.leadingCommentsText;
+      if (typeSpecifiers2.length > 0) {
+        leadingCommentsText = "";
+      }
+      styledImportDeclarations.push({
+        ...importDeclaration,
+        namedSpecifiers: namedValueSpecifiers,
+        leadingCommentsText
+      });
     }
+    return styledImportDeclarations;
+  }
+  let inlineImportDeclaration = { ...importDeclaration, namedSpecifiers };
+  if (importDeclaration.isTypeOnly) {
+    inlineImportDeclaration = {
+      ...importDeclaration,
+      isTypeOnly: false,
+      namedSpecifiers: namedSpecifiers.map((importSpecifier) => ({
+        ...importSpecifier,
+        isTypeOnly: true
+      }))
+    };
+  }
+  if (typeImportStyle === "mixed") {
+    return [
+      {
+        ...inlineImportDeclaration,
+        namedSpecifiers: sortNamedImportSpecifiers(inlineImportDeclaration.namedSpecifiers)
+      }
+    ];
+  }
+  const typeSpecifiers = sortNamedImportSpecifiers(inlineImportDeclaration.namedSpecifiers.filter((importSpecifier) => importSpecifier.isTypeOnly));
+  const valueSpecifiers = sortNamedImportSpecifiers(inlineImportDeclaration.namedSpecifiers.filter((importSpecifier) => !importSpecifier.isTypeOnly));
+  let orderedSpecifiers = [...valueSpecifiers, ...typeSpecifiers];
+  if (typeImportStyle === "inline-first") {
+    orderedSpecifiers = [...typeSpecifiers, ...valueSpecifiers];
+  }
+  return [{ ...inlineImportDeclaration, namedSpecifiers: orderedSpecifiers }];
+}
+function getImportBindingShapeRank(importDeclaration) {
+  if (importDeclaration.defaultBinding !== null) {
+    return 0;
+  }
+  if (importDeclaration.namespaceBinding !== null) {
+    return 1;
+  }
+  return 2;
+}
+function sortImportSegment(importDeclarations, sortOptions, importGroupOrder) {
+  let mergedImportDeclarations = [...importDeclarations];
+  if (sortOptions.esmImportMerge) {
+    mergedImportDeclarations = mergeCompatibleImports(importDeclarations);
+  }
+  const styledImportDeclarations = mergedImportDeclarations.flatMap((importDeclaration) => applyTypeImportStyle(importDeclaration, sortOptions.esmImportTypeStyle));
+  const unlistedGroupRank = sortOptions.esmImportGroups.length;
+  const rankedImportDeclarations = styledImportDeclarations.map((importDeclaration, originalIndex) => ({
+    importDeclaration,
+    importGroup: classifyImportGroup(importDeclaration.moduleSpecifier),
+    originalIndex
+  }));
+  rankedImportDeclarations.sort((left, right) => {
+    const groupRankDifference = (importGroupOrder.get(left.importGroup) ?? unlistedGroupRank) - (importGroupOrder.get(right.importGroup) ?? unlistedGroupRank);
+    if (groupRankDifference !== 0) {
+      return groupRankDifference;
+    }
+    const moduleSpecifierDifference = left.importDeclaration.moduleSpecifier.localeCompare(right.importDeclaration.moduleSpecifier, "en", { sensitivity: "base" });
+    if (moduleSpecifierDifference !== 0) {
+      return moduleSpecifierDifference;
+    }
+    if (left.importDeclaration.isTypeOnly !== right.importDeclaration.isTypeOnly) {
+      if (left.importDeclaration.isTypeOnly) {
+        return -1;
+      }
+      return 1;
+    }
+    return getImportBindingShapeRank(left.importDeclaration) - getImportBindingShapeRank(right.importDeclaration) || left.originalIndex - right.originalIndex;
+  });
+  let previousImportGroup = null;
+  const renderedImportLines = [];
+  for (const { importDeclaration, importGroup } of rankedImportDeclarations) {
+    if (sortOptions.esmImportSeparation && previousImportGroup !== null && importGroup !== previousImportGroup) {
+      renderedImportLines.push("");
+    }
+    renderedImportLines.push(renderImportDeclaration(importDeclaration));
+    previousImportGroup = importGroup;
+  }
+  return renderedImportLines;
+}
+function renderSortedImportLines(importDeclarations, sortOptions) {
+  let currentSortableImportDeclarations = [];
+  const importGroupOrder = new Map(sortOptions.esmImportGroups.map((importGroup, groupIndex) => [
+    importGroup,
+    groupIndex
+  ]));
+  const importDeclarationChunks = [];
+  for (const importDeclaration of importDeclarations) {
+    if (!importDeclaration.isSideEffectOnly) {
+      currentSortableImportDeclarations.push(importDeclaration);
+      continue;
+    }
+    if (currentSortableImportDeclarations.length > 0) {
+      importDeclarationChunks.push({
+        kind: "sortable",
+        importDeclarations: currentSortableImportDeclarations
+      });
+      currentSortableImportDeclarations = [];
+    }
+    importDeclarationChunks.push({ kind: "side-effect", importDeclaration });
+  }
+  if (currentSortableImportDeclarations.length > 0) {
+    importDeclarationChunks.push({
+      kind: "sortable",
+      importDeclarations: currentSortableImportDeclarations
+    });
+  }
+  let previousChunkKind = null;
+  const renderedImportLines = [];
+  for (const importChunk of importDeclarationChunks) {
+    if (sortOptions.esmImportSeparation && previousChunkKind !== null && previousChunkKind !== importChunk.kind) {
+      renderedImportLines.push("");
+    }
+    if (importChunk.kind === "sortable") {
+      renderedImportLines.push(...sortImportSegment(importChunk.importDeclarations, sortOptions, importGroupOrder));
+    } else {
+      renderedImportLines.push(renderImportDeclaration(importChunk.importDeclaration));
+    }
+    previousChunkKind = importChunk.kind;
+  }
+  return renderedImportLines;
+}
+function isCommentPresentWithinRange(sortedComments, start, end) {
+  const firstCommentIndex = findCommentIndexAtOrAfter(sortedComments, start);
+  const firstComment = sortedComments[firstCommentIndex];
+  return firstComment !== undefined && firstComment.textRange.end <= end;
+}
+function hasPositionSensitiveEslintCommentWithinRange(sourceText, sortedComments, start, end) {
+  for (let commentIndex = findCommentIndexAtOrAfter(sortedComments, start);commentIndex < sortedComments.length; commentIndex++) {
+    const parserComment = sortedComments[commentIndex];
+    if (!parserComment || parserComment.textRange.start >= end) {
+      return false;
+    }
+    if (parserComment.textRange.end <= end && isPositionSensitiveEslintComment(sourceText, parserComment)) {
+      return true;
+    }
+  }
+  return false;
+}
+function buildImportSegmentEdits(sourceText, importEntries, sortOptions, lineEnding, isBlankLineRequired) {
+  const [firstImportEntry] = importEntries;
+  if (!firstImportEntry) {
+    return null;
+  }
+  let trailingLineBreaks = lineEnding;
+  const replacementText = renderSortedImportLines(importEntries.map((importEntry) => importEntry.parsedImportDeclaration), sortOptions).join(lineEnding);
+  const removalEdits = importEntries.slice(1).map((importEntry) => ({
+    start: importEntry.start,
+    end: importEntry.end,
+    replacementText: ""
+  }));
+  if (isBlankLineRequired) {
+    const textWithoutLaterImports = applySourceTextEdits(sourceText, removalEdits);
+    if (textWithoutLaterImports === null) {
+      return null;
+    }
+    const isFollowingContentPresent = textWithoutLaterImports.slice(firstImportEntry.end).trim() !== "";
+    if (isFollowingContentPresent) {
+      trailingLineBreaks += lineEnding;
+    }
+  }
+  return [
+    {
+      start: firstImportEntry.start,
+      end: firstImportEntry.end,
+      replacementText: replacementText + trailingLineBreaks
+    },
+    ...removalEdits
+  ];
+}
+function buildImportSortingEdits(sourceText, programStatements, sortedComments, sortOptions, isPrettierFilePragmaPresent) {
+  const importDeclarationNodes = programStatements.filter((statement) => statement.type === "ImportDeclaration");
+  if (importDeclarationNodes.length === 0) {
+    return [];
+  }
+  const prettierFilePragmaComment = getPrettierFilePragmaComment(sortedComments, isPrettierFilePragmaPresent);
+  if (isPrettierFilePragmaPresent && !prettierFilePragmaComment) {
+    return [];
+  }
+  let currentSortableSegment = [];
+  const sortableSegments = [];
+  for (const importDeclarationNode of importDeclarationNodes) {
+    const declarationRange = getAstNodeTextRange(importDeclarationNode);
+    if (!declarationRange) {
+      return [];
+    }
+    if (hasPositionSensitiveEslintCommentWithinRange(sourceText, sortedComments, declarationRange.start, declarationRange.end)) {
+      return [];
+    }
+    const isImportIgnoredByPrettier = isPrettierIgnored(sourceText, declarationRange, sortedComments);
+    const leadingCommentsStart = findLeadingCommentsStart(sourceText, declarationRange.start, sortedComments, prettierFilePragmaComment);
+    const trailingComments = getTrailingComments(sourceText, declarationRange.end, sortedComments);
+    if (isImportIgnoredByPrettier || trailingComments.isImportSortingBoundary) {
+      if (currentSortableSegment.length > 0) {
+        sortableSegments.push(currentSortableSegment);
+        currentSortableSegment = [];
+      }
+      continue;
+    }
+    const parsedImportDeclaration = parseImportDeclaration({
+      importDeclarationNode,
+      declarationRange,
+      leadingCommentsText: sourceText.slice(leadingCommentsStart, declarationRange.start),
+      trailingCommentsText: trailingComments.commentsText,
+      hasInternalComments: isCommentPresentWithinRange(sortedComments, declarationRange.start, declarationRange.end)
+    }, sourceText);
+    if (parsedImportDeclaration === null) {
+      return [];
+    }
+    const parsedImportEntry = {
+      importDeclarationNode,
+      start: leadingCommentsStart,
+      end: getRangeEndIncludingLineBreak(sourceText, trailingComments.rangeEnd),
+      parsedImportDeclaration
+    };
+    const previousImportEntry = currentSortableSegment.at(-1);
+    if (previousImportEntry && isCommentPresentWithinRange(sortedComments, previousImportEntry.end, parsedImportEntry.start)) {
+      sortableSegments.push(currentSortableSegment);
+      currentSortableSegment = [];
+    }
+    currentSortableSegment.push(parsedImportEntry);
+  }
+  if (currentSortableSegment.length > 0) {
+    sortableSegments.push(currentSortableSegment);
+  }
+  let lineEnding = `
+`;
+  if (sourceText.includes(`\r
+`)) {
+    lineEnding = `\r
+`;
+  }
+  const sortingEdits = [];
+  const lastImportDeclarationNode = importDeclarationNodes.at(-1);
+  for (const sortableSegment of sortableSegments) {
+    const isLastImportSegment = sortableSegment.at(-1)?.importDeclarationNode === lastImportDeclarationNode;
+    const importSegmentEdits = buildImportSegmentEdits(sourceText, sortableSegment, sortOptions, lineEnding, isLastImportSegment);
+    if (importSegmentEdits === null) {
+      return [];
+    }
+    sortingEdits.push(...importSegmentEdits);
+  }
+  return sortingEdits;
+}
+
+// src/sort-typescript.ts
+async function sortTypeScript(sourceText, prettierOptions, parser) {
+  const sortOptions = resolveSortOptions(prettierOptions);
+  if (!sortOptions.esmImportSort && !sortOptions.esmExportSpecifierSort) {
+    return sourceText;
+  }
+  let parserAst;
+  try {
+    parserAst = await parser.parse(sourceText, prettierOptions);
+  } catch {
+    return sourceText;
+  }
+  const programStatements = getProgramStatements(parserAst);
+  const sortedComments = getSortedAstCommentsWithTextRanges(getProgramComments(parserAst));
+  const sortingEdits = [];
+  if (sortOptions.esmImportSort) {
+    const isPrettierFilePragmaPresent = parser.hasPragma?.(sourceText) ?? false;
+    sortingEdits.push(...buildImportSortingEdits(sourceText, programStatements, sortedComments, sortOptions, isPrettierFilePragmaPresent));
+  }
+  if (sortOptions.esmExportSpecifierSort) {
+    sortingEdits.push(...buildExportSortingEdits(sourceText, programStatements, sortedComments));
+  }
+  const sortedText = applySourceTextEdits(sourceText, sortingEdits);
+  if (sortedText === null || sortedText === sourceText) {
+    return sourceText;
+  }
+  try {
+    await parser.parse(sortedText, prettierOptions);
+    return sortedText;
+  } catch {
+    return sourceText;
   }
-  const indent = detectIndent(text);
-  const output = JSON.stringify(result, null, indent);
-  return text.endsWith(`
-`) ? output + `
-` : output;
 }
 
 // src/index.ts
-function wrap(parser, ...transforms) {
+function wrapParserPreprocess(parser, preprocessTransform) {
   return {
     ...parser,
-    async preprocess(text, parserOptions) {
-      let source = parser.preprocess ? await parser.preprocess(text, parserOptions) : text;
-      for (const transform of transforms) {
-        source = transform(source, parserOptions);
+    async preprocess(sourceText, prettierOptions) {
+      let transformedText = sourceText;
+      if (parser.preprocess) {
+        transformedText = await parser.preprocess(sourceText, prettierOptions);
       }
-      return source;
+      return preprocessTransform(transformedText, prettierOptions, parser);
     }
   };
 }
-var plugin = {
+var sortPlugin = {
   options,
   parsers: {
-    babel: wrap(babelParsers.babel, sortImports, sortExports),
-    "babel-ts": wrap(babelParsers["babel-ts"], sortImports, sortExports),
-    typescript: wrap(typescriptParsers.typescript, sortImports, sortExports),
-    "json-stringify": wrap(babelParsers["json-stringify"], sortPackageJson)
+    acorn: wrapParserPreprocess(acornPlugin.parsers.acorn, sortTypeScript),
+    babel: wrapParserPreprocess(babelPlugin.parsers.babel, sortTypeScript),
+    "babel-flow": wrapParserPreprocess(babelPlugin.parsers["babel-flow"], sortTypeScript),
+    "babel-ts": wrapParserPreprocess(babelPlugin.parsers["babel-ts"], sortTypeScript),
+    espree: wrapParserPreprocess(acornPlugin.parsers.espree, sortTypeScript),
+    flow: wrapParserPreprocess(flowPlugin.parsers.flow, sortTypeScript),
+    json: wrapParserPreprocess(babelPlugin.parsers.json, preprocessPackageJson),
+    "json-stringify": wrapParserPreprocess(babelPlugin.parsers["json-stringify"], preprocessPackageJson),
+    meriyah: wrapParserPreprocess(meriyahPlugin.parsers.meriyah, sortTypeScript),
+    typescript: wrapParserPreprocess(typescriptPlugin.parsers.typescript, sortTypeScript)
   }
 };
-var src_default = plugin;
+var src_default = sortPlugin;
 export {
   options,
   src_default as default