prettier-plugin-sort 1.0.1 → 1.1.0

package/dist/index.js

@@ -1,3 +1,11 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/index.ts
 import acornPlugin from "prettier/plugins/acorn";
 import babelPlugin from "prettier/plugins/babel";
@@ -8,12 +16,21 @@ import typescriptPlugin from "prettier/plugins/typescript";
 // src/options.ts
 var DEFAULT_SORT_OPTIONS = {
   esmImportSort: true,
-  esmImportGroups: ["builtin", "external", "parent", "sibling", "index"],
+  esmImportGroups: [
+    "builtin",
+    "external",
+    "internal",
+    "parent",
+    "sibling",
+    "index"
+  ],
   esmImportSeparation: true,
   esmImportTypeStyle: "separate",
   esmImportMerge: true,
   esmExportSpecifierSort: true,
-  packageSort: true
+  packageSort: true,
+  tsconfigSort: true,
+  tsconfigSeparation: true
 };
 var VALID_IMPORT_GROUPS = new Set([
   "builtin",
@@ -38,7 +55,7 @@ function resolveBooleanSortOption(prettierOptions, optionName) {
   }
   return DEFAULT_SORT_OPTIONS[optionName];
 }
-function resolveSortOptions(prettierOptions) {
+function resolveEsmOptions(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];
@@ -49,8 +66,16 @@ function resolveSortOptions(prettierOptions) {
     esmImportSeparation: resolveBooleanSortOption(prettierOptions, "esmImportSeparation"),
     esmImportTypeStyle: resolvedTypeImportStyle,
     esmImportMerge: resolveBooleanSortOption(prettierOptions, "esmImportMerge"),
-    esmExportSpecifierSort: resolveBooleanSortOption(prettierOptions, "esmExportSpecifierSort"),
-    packageSort: resolveBooleanSortOption(prettierOptions, "packageSort")
+    esmExportSpecifierSort: resolveBooleanSortOption(prettierOptions, "esmExportSpecifierSort")
+  };
+}
+function isPackageSortEnabled(prettierOptions) {
+  return resolveBooleanSortOption(prettierOptions, "packageSort");
+}
+function resolveTsconfigOptions(prettierOptions) {
+  return {
+    tsconfigSort: resolveBooleanSortOption(prettierOptions, "tsconfigSort"),
+    tsconfigSeparation: resolveBooleanSortOption(prettierOptions, "tsconfigSeparation")
   };
 }
 var options = {
@@ -113,7 +138,19 @@ var options = {
     type: "boolean",
     default: DEFAULT_SORT_OPTIONS.packageSort,
     category: "package.json",
-    description: "Sort package.json fields using the sort-package-json community convention."
+    description: "Sort fields in package.json."
+  },
+  tsconfigSort: {
+    type: "boolean",
+    default: DEFAULT_SORT_OPTIONS.tsconfigSort,
+    category: "tsconfig.json",
+    description: "Sort fields in tsconfig.json."
+  },
+  tsconfigSeparation: {
+    type: "boolean",
+    default: DEFAULT_SORT_OPTIONS.tsconfigSeparation,
+    category: "tsconfig.json",
+    description: "Add blank lines between TypeScript 5.8 compilerOptions categories."
   }
 };
 
@@ -122,6 +159,9 @@ import findMinimumSemanticVersion from "semver/ranges/min-version.js";
 import getValidSemanticVersionRange from "semver/ranges/valid.js";
 
 // src/parser-ast.ts
+function isParserAstNode(value) {
+  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
 function getAstNodeTextRange(node) {
   if (!node) {
     return null;
@@ -479,7 +519,8 @@ class JsonSourceLiteral {
   }
 }
 var SEQUENTIAL_SCRIPT_PATTERN = /(?<=^|[\s&;<>|(])(?:run-s|npm-run-all2? .*(?:--sequential|--serial|-s))(?=$|[\s&;<>|)])/;
-function compareText(leftText, rightText) {
+var PACKAGE_JSON_FIELD_INDEXES = new Map(PACKAGE_JSON_FIELD_ORDER.map((fieldName, index) => [fieldName, index]));
+function compareStringsCaseSensitive(leftText, rightText) {
   if (leftText === rightText) {
     return 0;
   }
@@ -503,13 +544,10 @@ function getJsonString(jsonValue) {
 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)) {
+    if (!isParserAstNode(rootNode)) {
       return;
     }
     return preserveJsonSourceLiterals(jsonValue, rootNode, sourceText, fieldNameSourceTexts, jsonPath);
@@ -535,7 +573,7 @@ function preserveJsonSourceLiterals(jsonValue, parserJsonNode, sourceText, field
       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)) {
+      if (propertyNode.type !== "ObjectProperty" || propertyName === null || !propertyNameRange || propertyNames.has(propertyName) || !Object.hasOwn(jsonValue, propertyName) || !isParserAstNode(propertyValueNode)) {
         return;
       }
       propertyNames.add(propertyName);
@@ -617,7 +655,7 @@ function deduplicateStringValues(stringValues) {
   }
   return [...uniqueStringValues.values()];
 }
-function sortJsonObject(jsonObject, compareKeys = compareText) {
+function sortJsonObject(jsonObject, compareKeys = compareStringsCaseSensitive) {
   return Object.fromEntries(Object.entries(jsonObject).sort(([leftKey], [rightKey]) => compareKeys(leftKey, rightKey)));
 }
 function sortJsonObjectByKeyOrder(jsonObject, keyOrder) {
@@ -636,7 +674,7 @@ function sortJsonObjectByKeyOrder(jsonObject, keyOrder) {
     if (isRightKeyKnown) {
       return 1;
     }
-    return compareText(leftKey, rightKey);
+    return compareStringsCaseSensitive(leftKey, rightKey);
   });
 }
 function sortJsonObjectRecursively(jsonObject, sortObject = sortJsonObject) {
@@ -662,7 +700,7 @@ function sortUniqueStringArrayValue(fieldValue) {
   if (!isStringArray(fieldValue)) {
     return fieldValue;
   }
-  return deduplicateStringValues(fieldValue).sort((leftValue, rightValue) => compareText(getJsonString(leftValue), getJsonString(rightValue)));
+  return deduplicateStringValues(fieldValue).sort((leftValue, rightValue) => compareStringsCaseSensitive(getJsonString(leftValue), getJsonString(rightValue)));
 }
 function deduplicateStringArrayValue(fieldValue) {
   return isStringArray(fieldValue) ? deduplicateStringValues(fieldValue) : fieldValue;
@@ -677,10 +715,9 @@ function sortPeopleArrayValue(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 leftIndex = PACKAGE_JSON_FIELD_INDEXES.get(leftFieldName);
+    const rightIndex = PACKAGE_JSON_FIELD_INDEXES.get(rightFieldName);
     const isLeftFieldKnown = leftIndex !== undefined;
     const isRightFieldKnown = rightIndex !== undefined;
     if (isLeftFieldKnown && isRightFieldKnown) {
@@ -697,37 +734,16 @@ function sortPackageJsonFields(packageJson) {
     if (isLeftFieldPrivate !== isRightFieldPrivate) {
       return isLeftFieldPrivate ? 1 : -1;
     }
-    return compareText(leftFieldName, rightFieldName);
+    return compareStringsCaseSensitive(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);
-  }
+function sortDependencyObject(dependencyObject) {
   return sortJsonObject(dependencyObject, (leftName, rightName) => leftName.localeCompare(rightName, "en"));
 }
-function sortDependencyValue(fieldValue, packageJson) {
-  return sortJsonObjectValue(fieldValue, (dependencyObject) => sortDependencyObject(dependencyObject, packageJson));
+function sortDependencyValue(fieldValue) {
+  return sortJsonObjectValue(fieldValue, sortDependencyObject);
 }
-function sortWorkspacesValue(fieldValue, packageJson) {
+function sortWorkspacesValue(fieldValue) {
   if (!isJsonObject(fieldValue)) {
     return fieldValue;
   }
@@ -740,7 +756,7 @@ function sortWorkspacesValue(fieldValue, packageJson) {
     sortedWorkspaces.packages = sortUniqueStringArrayValue(workspacePackages);
   }
   if (isJsonObject(sortedWorkspaces.catalog)) {
-    sortedWorkspaces.catalog = sortDependencyObject(sortedWorkspaces.catalog, packageJson);
+    sortedWorkspaces.catalog = sortDependencyObject(sortedWorkspaces.catalog);
   }
   return sortedWorkspaces;
 }
@@ -770,7 +786,7 @@ function sortEslintConfigValue(fieldValue) {
   return sortJsonObjectValue(fieldValue, sortEslintConfigObject);
 }
 function sortPrettierConfigObject(prettierConfig) {
-  const keyOrder = Object.keys(prettierConfig).filter((key) => key !== "overrides").sort(compareText);
+  const keyOrder = Object.keys(prettierConfig).filter((key) => key !== "overrides").sort(compareStringsCaseSensitive);
   if (Object.hasOwn(prettierConfig, "overrides")) {
     keyOrder.push("overrides");
   }
@@ -849,13 +865,13 @@ function sortScriptNames(scriptNames, namespacePrefix = "") {
     groupedScriptNames.push(scriptName);
     scriptGroups.set(scriptGroupName, groupedScriptNames);
   }
-  return [...scriptGroups.keys()].sort(compareText).flatMap((scriptGroupName) => {
+  return [...scriptGroups.keys()].sort(compareStringsCaseSensitive).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);
+      return groupedScriptNames.sort(compareStringsCaseSensitive);
     }
-    const directScriptNames = groupedScriptNames.filter((scriptName) => scriptName === scriptGroupName || !scriptName.startsWith(`${scriptGroupName}:`)).sort(compareText);
+    const directScriptNames = groupedScriptNames.filter((scriptName) => scriptName === scriptGroupName || !scriptName.startsWith(`${scriptGroupName}:`)).sort(compareStringsCaseSensitive);
     const nestedScriptNames = groupedScriptNames.filter((scriptName) => scriptName.startsWith(`${scriptGroupName}:`));
     return [
       ...directScriptNames,
@@ -975,7 +991,7 @@ function comparePnpmOverrideSelectors(leftSelector, rightSelector) {
   const leftVersion = getMinimumSemanticVersion(leftPackage.versionRange);
   const rightVersion = getMinimumSemanticVersion(rightPackage.versionRange);
   if (!leftVersion && !rightVersion) {
-    return compareText(leftPackage.versionRange, rightPackage.versionRange);
+    return compareStringsCaseSensitive(leftPackage.versionRange, rightPackage.versionRange);
   }
   if (!leftVersion) {
     return 1;
@@ -987,7 +1003,7 @@ function comparePnpmOverrideSelectors(leftSelector, rightSelector) {
 }
 function sortDependencyMetadataValue(fieldValue) {
   return sortJsonObjectValue(fieldValue, (dependencyMetadata) => {
-    const compareDependencyIdentifiers = (leftIdentifier, rightIdentifier) => compareText(getDependencyName(leftIdentifier), getDependencyName(rightIdentifier));
+    const compareDependencyIdentifiers = (leftIdentifier, rightIdentifier) => compareStringsCaseSensitive(getDependencyName(leftIdentifier), getDependencyName(rightIdentifier));
     return sortJsonObjectRecursively(dependencyMetadata, (jsonObject) => sortJsonObject(jsonObject, compareDependencyIdentifiers));
   });
 }
@@ -1103,7 +1119,7 @@ function isPackageJsonFile(filePath) {
   return filePath?.split(/[\\/]/).at(-1) === "package.json";
 }
 async function preprocessPackageJson(sourceText, prettierOptions, parser) {
-  if (!isPackageJsonFile(prettierOptions.filepath) || !resolveSortOptions(prettierOptions).packageSort) {
+  if (!isPackageJsonFile(prettierOptions.filepath) || !isPackageSortEnabled(prettierOptions)) {
     return sourceText;
   }
   try {
@@ -1112,7 +1128,7 @@ async function preprocessPackageJson(sourceText, prettierOptions, parser) {
       return sourceText;
     }
     const parserJsonAst = await parser.parse(sourceText, prettierOptions);
-    if (!isParserJsonAstNode(parserJsonAst)) {
+    if (!isParserAstNode(parserJsonAst)) {
       return sourceText;
     }
     const fieldNameSourceTexts = new Map;
@@ -1126,6 +1142,367 @@ async function preprocessPackageJson(sourceText, prettierOptions, parser) {
   }
 }
 
+// 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/utils/tsconfig-rules.ts
+var TSCONFIG_ROOT_FIRST_FIELDS = ["$schema", "extends"];
+var TSCONFIG_ROOT_LAST_FIELDS = [
+  "files",
+  "include",
+  "exclude"
+];
+var COMPILER_OPTION_FIELD_GROUPS = [
+  [
+    "incremental",
+    "composite",
+    "tsBuildInfoFile",
+    "disableSourceOfProjectReferenceRedirect",
+    "disableSolutionSearching",
+    "disableReferencedProjectLoad"
+  ],
+  [
+    "target",
+    "lib",
+    "jsx",
+    "libReplacement",
+    "experimentalDecorators",
+    "emitDecoratorMetadata",
+    "jsxFactory",
+    "jsxFragmentFactory",
+    "jsxImportSource",
+    "reactNamespace",
+    "noLib",
+    "useDefineForClassFields",
+    "moduleDetection"
+  ],
+  [
+    "module",
+    "rootDir",
+    "moduleResolution",
+    "baseUrl",
+    "paths",
+    "rootDirs",
+    "typeRoots",
+    "types",
+    "allowUmdGlobalAccess",
+    "moduleSuffixes",
+    "allowImportingTsExtensions",
+    "rewriteRelativeImportExtensions",
+    "resolvePackageJsonExports",
+    "resolvePackageJsonImports",
+    "customConditions",
+    "noUncheckedSideEffectImports",
+    "resolveJsonModule",
+    "allowArbitraryExtensions",
+    "noResolve"
+  ],
+  ["allowJs", "checkJs", "maxNodeModuleJsDepth"],
+  [
+    "declaration",
+    "declarationMap",
+    "emitDeclarationOnly",
+    "sourceMap",
+    "inlineSourceMap",
+    "noEmit",
+    "outFile",
+    "outDir",
+    "removeComments",
+    "importHelpers",
+    "downlevelIteration",
+    "sourceRoot",
+    "mapRoot",
+    "inlineSources",
+    "emitBOM",
+    "newLine",
+    "stripInternal",
+    "noEmitHelpers",
+    "noEmitOnError",
+    "preserveConstEnums",
+    "declarationDir"
+  ],
+  [
+    "isolatedModules",
+    "verbatimModuleSyntax",
+    "isolatedDeclarations",
+    "erasableSyntaxOnly",
+    "allowSyntheticDefaultImports",
+    "esModuleInterop",
+    "preserveSymlinks",
+    "forceConsistentCasingInFileNames"
+  ],
+  [
+    "strict",
+    "noImplicitAny",
+    "strictNullChecks",
+    "strictFunctionTypes",
+    "strictBindCallApply",
+    "strictPropertyInitialization",
+    "strictBuiltinIteratorReturn",
+    "noImplicitThis",
+    "useUnknownInCatchVariables",
+    "alwaysStrict",
+    "noUnusedLocals",
+    "noUnusedParameters",
+    "exactOptionalPropertyTypes",
+    "noImplicitReturns",
+    "noFallthroughCasesInSwitch",
+    "noUncheckedIndexedAccess",
+    "noImplicitOverride",
+    "noPropertyAccessFromIndexSignature",
+    "allowUnusedLabels",
+    "allowUnreachableCode"
+  ],
+  ["skipDefaultLibCheck", "skipLibCheck"],
+  ["preserveWatchOutput", "pretty", "noErrorTruncation"],
+  [
+    "listFiles",
+    "explainFiles",
+    "listEmittedFiles",
+    "traceResolution",
+    "diagnostics",
+    "extendedDiagnostics",
+    "generateCpuProfile",
+    "generateTrace",
+    "noCheck"
+  ],
+  ["assumeChangesOnlyAffectDirectDependencies"],
+  [
+    "importsNotUsedAsValues",
+    "out",
+    "charset",
+    "noImplicitUseStrict",
+    "suppressExcessPropertyErrors",
+    "suppressImplicitAnyIndexErrors",
+    "noStrictGenericChecks",
+    "preserveValueImports",
+    "keyofStringsOnly"
+  ],
+  ["disableSizeLimit", "plugins"]
+];
+
+// src/sort-tsconfig.ts
+function createFieldIndexes(fieldNames) {
+  return new Map(fieldNames.map((fieldName, fieldIndex) => [fieldName, fieldIndex]));
+}
+var COMPILER_OPTION_FIELD_INDEXES = createFieldIndexes(COMPILER_OPTION_FIELD_GROUPS.flat());
+var COMPILER_OPTION_FIELD_GROUP_INDEXES = new Map(COMPILER_OPTION_FIELD_GROUPS.flatMap((fieldGroup, groupIndex) => fieldGroup.map((fieldName) => [fieldName, groupIndex])));
+var ROOT_FIRST_FIELD_INDEXES = createFieldIndexes(TSCONFIG_ROOT_FIRST_FIELDS);
+var ROOT_LAST_FIELD_INDEXES = createFieldIndexes(TSCONFIG_ROOT_LAST_FIELDS);
+function getTsconfigRootNode(parserAst) {
+  if (parserAst.type === "ObjectExpression") {
+    return parserAst;
+  }
+  return parserAst.type === "JsonRoot" && parserAst.node?.type === "ObjectExpression" ? parserAst.node : null;
+}
+function getCompilerOptionsNode(rootNode) {
+  const propertyNodes = rootNode.properties;
+  if (!Array.isArray(propertyNodes)) {
+    return null;
+  }
+  const compilerOptions = propertyNodes.filter((propertyNode) => getAstNodeName(propertyNode.key) === "compilerOptions");
+  if (compilerOptions.length !== 1) {
+    return null;
+  }
+  const property = compilerOptions[0];
+  const value = property?.value;
+  return property?.type === "ObjectProperty" && isParserAstNode(value) && value.type === "ObjectExpression" ? { property, value } : null;
+}
+function hasDirectComments(objectNode, propertyNodes, sortedComments) {
+  const objectRange = getAstNodeTextRange(objectNode);
+  const propertyRanges = propertyNodes.map(getAstNodeTextRange);
+  if (!objectRange || propertyRanges.some((propertyRange) => !propertyRange)) {
+    return true;
+  }
+  return sortedComments.some(({ textRange: commentRange }) => {
+    if (commentRange.start < objectRange.start || commentRange.end > objectRange.end) {
+      return false;
+    }
+    return !propertyRanges.some((propertyRange) => propertyRange && propertyRange.start <= commentRange.start && propertyRange.end >= commentRange.end);
+  });
+}
+function sortRenderedProperties(renderedProperties, fieldIndexes, lastFieldIndexes) {
+  return [...renderedProperties].sort((left, right) => {
+    const leftFieldIndex = fieldIndexes.get(left.name);
+    const rightFieldIndex = fieldIndexes.get(right.name);
+    if (leftFieldIndex !== undefined && rightFieldIndex !== undefined) {
+      return leftFieldIndex - rightFieldIndex;
+    }
+    if (leftFieldIndex !== undefined) {
+      return -1;
+    }
+    if (rightFieldIndex !== undefined) {
+      return 1;
+    }
+    const leftLastFieldIndex = lastFieldIndexes?.get(left.name);
+    const rightLastFieldIndex = lastFieldIndexes?.get(right.name);
+    if (leftLastFieldIndex !== undefined && rightLastFieldIndex !== undefined) {
+      return leftLastFieldIndex - rightLastFieldIndex;
+    }
+    if (leftLastFieldIndex !== undefined) {
+      return 1;
+    }
+    if (rightLastFieldIndex !== undefined) {
+      return -1;
+    }
+    return left.originalIndex - right.originalIndex;
+  });
+}
+function getPropertySeparator(property, shouldSeparateCategories, previousProperty) {
+  if (!previousProperty) {
+    return "";
+  }
+  if (!shouldSeparateCategories) {
+    return ",";
+  }
+  const previousGroupIndex = COMPILER_OPTION_FIELD_GROUP_INDEXES.get(previousProperty.name);
+  const groupIndex = COMPILER_OPTION_FIELD_GROUP_INDEXES.get(property.name);
+  return previousGroupIndex !== undefined && groupIndex !== undefined && previousGroupIndex !== groupIndex ? `,
+
+` : ",";
+}
+function renderProperty(sourceText, propertyNode, originalIndex, replacementText) {
+  const propertyName = getAstNodeName(propertyNode.key);
+  const propertyRange = getAstNodeTextRange(propertyNode);
+  const propertyValue = propertyNode.value;
+  if (propertyNode.type !== "ObjectProperty" || propertyName === null || !propertyRange || !isParserAstNode(propertyValue)) {
+    return null;
+  }
+  return {
+    name: propertyName,
+    originalIndex,
+    sourceText: replacementText ?? sourceText.slice(propertyRange.start, propertyRange.end)
+  };
+}
+function replacePropertyValue(sourceText, propertyNode, valueNode, replacementText) {
+  const propertyRange = getAstNodeTextRange(propertyNode);
+  const valueRange = getAstNodeTextRange(valueNode);
+  if (!propertyRange || !valueRange || valueRange.start < propertyRange.start || valueRange.end > propertyRange.end) {
+    return null;
+  }
+  return sourceText.slice(propertyRange.start, valueRange.start) + replacementText + sourceText.slice(valueRange.end, propertyRange.end);
+}
+function renderObject(sourceText, objectNode, sortedComments, fieldIndexes, shouldSeparateCategories, propertyReplacements, lastFieldIndexes) {
+  const objectRange = getAstNodeTextRange(objectNode);
+  const propertyNodes = objectNode.properties;
+  if (objectNode.type !== "ObjectExpression" || !objectRange || !Array.isArray(propertyNodes)) {
+    return null;
+  }
+  const objectSource = sourceText.slice(objectRange.start, objectRange.end);
+  if (propertyNodes.length === 0) {
+    return { hasOrderChanged: false, sourceText: objectSource };
+  }
+  if (hasDirectComments(objectNode, propertyNodes, sortedComments)) {
+    return null;
+  }
+  const propertyNames = new Set;
+  const renderedProperties = [];
+  for (const [propertyIndex, propertyNode] of propertyNodes.entries()) {
+    const renderedProperty = renderProperty(sourceText, propertyNode, propertyIndex, propertyReplacements?.get(propertyNode));
+    if (!renderedProperty || propertyNames.has(renderedProperty.name)) {
+      return null;
+    }
+    propertyNames.add(renderedProperty.name);
+    renderedProperties.push(renderedProperty);
+  }
+  const sortedProperties = sortRenderedProperties(renderedProperties, fieldIndexes, lastFieldIndexes);
+  const hasOrderChanged = sortedProperties.some((renderedProperty, propertyIndex) => renderedProperty.originalIndex !== propertyIndex);
+  return {
+    hasOrderChanged,
+    sourceText: `{${sortedProperties.map((renderedProperty, propertyIndex) => getPropertySeparator(renderedProperty, shouldSeparateCategories, sortedProperties[propertyIndex - 1]) + renderedProperty.sourceText).join("")}}`
+  };
+}
+function isTsconfigFile(filePath) {
+  const fileName = filePath?.split(/[\\/]/).at(-1);
+  return fileName ? /^tsconfig(?:\..+)?\.json$/.test(fileName) : false;
+}
+async function preprocessTsconfig(sourceText, prettierOptions, parser) {
+  if (!isTsconfigFile(prettierOptions.filepath)) {
+    return sourceText;
+  }
+  const { tsconfigSeparation, tsconfigSort } = resolveTsconfigOptions(prettierOptions);
+  if (!tsconfigSort) {
+    return sourceText;
+  }
+  try {
+    const parserAst = await parser.parse(sourceText, prettierOptions);
+    if (!isParserAstNode(parserAst)) {
+      return sourceText;
+    }
+    const rootNode = getTsconfigRootNode(parserAst);
+    if (!rootNode) {
+      return sourceText;
+    }
+    const sortedComments = getSortedAstCommentsWithTextRanges(getProgramComments(parserAst));
+    const rootRange = getAstNodeTextRange(rootNode);
+    if (!rootRange || isPrettierIgnored(sourceText, rootRange, sortedComments)) {
+      return sourceText;
+    }
+    let compilerOptionsEdit;
+    let propertyReplacements;
+    const compilerOptions = getCompilerOptionsNode(rootNode);
+    if (compilerOptions) {
+      const propertyRange = getAstNodeTextRange(compilerOptions.property);
+      const valueRange = getAstNodeTextRange(compilerOptions.value);
+      if (propertyRange && valueRange && !isPrettierIgnored(sourceText, propertyRange, sortedComments)) {
+        const renderedCompilerOptions = renderObject(sourceText, compilerOptions.value, sortedComments, COMPILER_OPTION_FIELD_INDEXES, tsconfigSeparation);
+        const renderedProperty = renderedCompilerOptions ? replacePropertyValue(sourceText, compilerOptions.property, compilerOptions.value, renderedCompilerOptions.sourceText) : null;
+        if (renderedCompilerOptions && renderedProperty) {
+          compilerOptionsEdit = {
+            start: valueRange.start,
+            end: valueRange.end,
+            replacementText: renderedCompilerOptions.sourceText
+          };
+          propertyReplacements = new Map([
+            [compilerOptions.property, renderedProperty]
+          ]);
+        }
+      }
+    }
+    const renderedRoot = renderObject(sourceText, rootNode, sortedComments, ROOT_FIRST_FIELD_INDEXES, false, propertyReplacements, ROOT_LAST_FIELD_INDEXES);
+    const sourceTextEdits = [];
+    if (renderedRoot && (renderedRoot.hasOrderChanged || propertyReplacements)) {
+      sourceTextEdits.push({
+        start: rootRange.start,
+        end: rootRange.end,
+        replacementText: renderedRoot.sourceText
+      });
+    } else if (compilerOptionsEdit) {
+      sourceTextEdits.push(compilerOptionsEdit);
+    }
+    if (sourceTextEdits.length === 0) {
+      return sourceText;
+    }
+    const editedSourceText = applySourceTextEdits(sourceText, sourceTextEdits);
+    if (editedSourceText === null) {
+      return sourceText;
+    }
+    await parser.parse(editedSourceText, prettierOptions);
+    return editedSourceText;
+  } catch {
+    return sourceText;
+  }
+}
+
 // src/sort-exports.ts
 function buildExportSortingEdits(sourceText, programStatements, sortedComments) {
   const sortingEdits = [];
@@ -1190,28 +1567,6 @@ function buildExportSortingEdits(sourceText, programStatements, sortedComments)
   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"];
@@ -1294,7 +1649,19 @@ function getPrettierFilePragmaComment(sortedComments, isPrettierFilePragmaPresen
   }
   return sortedComments.find(({ comment }) => getCommentLines(comment).some((commentLine) => hasCommentDirective(commentLine.trim(), PRETTIER_FILE_PRAGMA_DIRECTIVES)))?.comment ?? null;
 }
-function classifyImportGroup(moduleSpecifier) {
+function matchesPathPattern(moduleSpecifier, pathPattern) {
+  const wildcardIndex = pathPattern.indexOf("*");
+  if (wildcardIndex < 0) {
+    return moduleSpecifier === pathPattern;
+  }
+  if (pathPattern === "*" || wildcardIndex !== pathPattern.lastIndexOf("*")) {
+    return false;
+  }
+  const prefix = pathPattern.slice(0, wildcardIndex);
+  const suffix = pathPattern.slice(wildcardIndex + 1);
+  return moduleSpecifier.length >= prefix.length + suffix.length && moduleSpecifier.startsWith(prefix) && moduleSpecifier.endsWith(suffix);
+}
+function classifyImportGroup(moduleSpecifier, pathPatterns) {
   if (moduleSpecifier === "bun" || moduleSpecifier.startsWith("bun:") || moduleSpecifier.startsWith("node:")) {
     return "builtin";
   }
@@ -1307,7 +1674,7 @@ function classifyImportGroup(moduleSpecifier) {
   if (moduleSpecifier.startsWith("./")) {
     return "sibling";
   }
-  if (moduleSpecifier.startsWith("/") || moduleSpecifier.startsWith("~") || moduleSpecifier.startsWith("@/") || moduleSpecifier.startsWith("#")) {
+  if (pathPatterns.some((pathPattern) => matchesPathPattern(moduleSpecifier, pathPattern))) {
     return "internal";
   }
   return "external";
@@ -1734,7 +2101,7 @@ function getImportBindingShapeRank(importDeclaration) {
   }
   return 2;
 }
-function sortImportSegment(importDeclarations, sortOptions, importGroupOrder) {
+function renderSortedImportSegment(importDeclarations, sortOptions, pathPatterns, importGroupOrder) {
   let mergedImportDeclarations = [...importDeclarations];
   if (sortOptions.esmImportMerge) {
     mergedImportDeclarations = mergeCompatibleImports(importDeclarations);
@@ -1743,7 +2110,7 @@ function sortImportSegment(importDeclarations, sortOptions, importGroupOrder) {
   const unlistedGroupRank = sortOptions.esmImportGroups.length;
   const rankedImportDeclarations = styledImportDeclarations.map((importDeclaration, originalIndex) => ({
     importDeclaration,
-    importGroup: classifyImportGroup(importDeclaration.moduleSpecifier),
+    importGroup: classifyImportGroup(importDeclaration.moduleSpecifier, pathPatterns),
     originalIndex
   }));
   rankedImportDeclarations.sort((left, right) => {
@@ -1764,17 +2131,17 @@ function sortImportSegment(importDeclarations, sortOptions, importGroupOrder) {
     return getImportBindingShapeRank(left.importDeclaration) - getImportBindingShapeRank(right.importDeclaration) || left.originalIndex - right.originalIndex;
   });
   let previousImportGroup = null;
-  const renderedImportLines = [];
+  const renderedImports = [];
   for (const { importDeclaration, importGroup } of rankedImportDeclarations) {
     if (sortOptions.esmImportSeparation && previousImportGroup !== null && importGroup !== previousImportGroup) {
-      renderedImportLines.push("");
+      renderedImports.push("");
     }
-    renderedImportLines.push(renderImportDeclaration(importDeclaration));
+    renderedImports.push(renderImportDeclaration(importDeclaration));
     previousImportGroup = importGroup;
   }
-  return renderedImportLines;
+  return renderedImports;
 }
-function renderSortedImportLines(importDeclarations, sortOptions) {
+function renderSortedImports(importDeclarations, sortOptions, pathPatterns) {
   let currentSortableImportDeclarations = [];
   const importGroupOrder = new Map(sortOptions.esmImportGroups.map((importGroup, groupIndex) => [
     importGroup,
@@ -1802,19 +2169,19 @@ function renderSortedImportLines(importDeclarations, sortOptions) {
     });
   }
   let previousChunkKind = null;
-  const renderedImportLines = [];
+  const renderedImports = [];
   for (const importChunk of importDeclarationChunks) {
     if (sortOptions.esmImportSeparation && previousChunkKind !== null && previousChunkKind !== importChunk.kind) {
-      renderedImportLines.push("");
+      renderedImports.push("");
     }
     if (importChunk.kind === "sortable") {
-      renderedImportLines.push(...sortImportSegment(importChunk.importDeclarations, sortOptions, importGroupOrder));
+      renderedImports.push(...renderSortedImportSegment(importChunk.importDeclarations, sortOptions, pathPatterns, importGroupOrder));
     } else {
-      renderedImportLines.push(renderImportDeclaration(importChunk.importDeclaration));
+      renderedImports.push(renderImportDeclaration(importChunk.importDeclaration));
     }
     previousChunkKind = importChunk.kind;
   }
-  return renderedImportLines;
+  return renderedImports;
 }
 function isCommentPresentWithinRange(sortedComments, start, end) {
   const firstCommentIndex = findCommentIndexAtOrAfter(sortedComments, start);
@@ -1833,13 +2200,13 @@ function hasPositionSensitiveEslintCommentWithinRange(sourceText, sortedComments
   }
   return false;
 }
-function buildImportSegmentEdits(sourceText, importEntries, sortOptions, lineEnding, isBlankLineRequired) {
+function buildImportSegmentEdits(sourceText, importEntries, sortOptions, pathPatterns, lineEnding, isBlankLineRequired) {
   const [firstImportEntry] = importEntries;
   if (!firstImportEntry) {
     return null;
   }
   let trailingLineBreaks = lineEnding;
-  const replacementText = renderSortedImportLines(importEntries.map((importEntry) => importEntry.parsedImportDeclaration), sortOptions).join(lineEnding);
+  const replacementText = renderSortedImports(importEntries.map((importEntry) => importEntry.parsedImportDeclaration), sortOptions, pathPatterns).join(lineEnding);
   const removalEdits = importEntries.slice(1).map((importEntry) => ({
     start: importEntry.start,
     end: importEntry.end,
@@ -1864,7 +2231,7 @@ function buildImportSegmentEdits(sourceText, importEntries, sortOptions, lineEnd
     ...removalEdits
   ];
 }
-function buildImportSortingEdits(sourceText, programStatements, sortedComments, sortOptions, isPrettierFilePragmaPresent) {
+function buildImportSortingEdits(sourceText, programStatements, sortedComments, sortOptions, pathPatterns, isPrettierFilePragmaPresent) {
   const importDeclarationNodes = programStatements.filter((statement) => statement.type === "ImportDeclaration");
   if (importDeclarationNodes.length === 0) {
     return [];
@@ -1930,7 +2297,7 @@ function buildImportSortingEdits(sourceText, programStatements, sortedComments,
   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);
+    const importSegmentEdits = buildImportSegmentEdits(sourceText, sortableSegment, sortOptions, pathPatterns, lineEnding, isLastImportSegment);
     if (importSegmentEdits === null) {
       return [];
     }
@@ -1940,8 +2307,20 @@ function buildImportSortingEdits(sourceText, programStatements, sortedComments,
 }
 
 // src/sort-typescript.ts
+async function getTsconfigPathPatterns(filePath) {
+  if (!filePath) {
+    return [];
+  }
+  try {
+    const { getTsconfig } = await import("get-tsconfig");
+    const paths = getTsconfig(filePath)?.config.compilerOptions?.paths;
+    return paths ? Object.keys(paths) : [];
+  } catch {
+    return [];
+  }
+}
 async function sortTypeScript(sourceText, prettierOptions, parser) {
-  const sortOptions = resolveSortOptions(prettierOptions);
+  const sortOptions = resolveEsmOptions(prettierOptions);
   if (!sortOptions.esmImportSort && !sortOptions.esmExportSpecifierSort) {
     return sourceText;
   }
@@ -1956,7 +2335,8 @@ async function sortTypeScript(sourceText, prettierOptions, parser) {
   const sortingEdits = [];
   if (sortOptions.esmImportSort) {
     const isPrettierFilePragmaPresent = parser.hasPragma?.(sourceText) ?? false;
-    sortingEdits.push(...buildImportSortingEdits(sourceText, programStatements, sortedComments, sortOptions, isPrettierFilePragmaPresent));
+    const pathPatterns = programStatements.some((statement) => statement.type === "ImportDeclaration") ? await getTsconfigPathPatterns(prettierOptions.filepath) : [];
+    sortingEdits.push(...buildImportSortingEdits(sourceText, programStatements, sortedComments, sortOptions, pathPatterns, isPrettierFilePragmaPresent));
   }
   if (sortOptions.esmExportSpecifierSort) {
     sortingEdits.push(...buildExportSortingEdits(sourceText, programStatements, sortedComments));
@@ -1986,6 +2366,10 @@ function wrapParserPreprocess(parser, preprocessTransform) {
     }
   };
 }
+async function preprocessJson(sourceText, prettierOptions, parser) {
+  const packagePreprocessedText = await preprocessPackageJson(sourceText, prettierOptions, parser);
+  return preprocessTsconfig(packagePreprocessedText, prettierOptions, parser);
+}
 var sortPlugin = {
   options,
   parsers: {
@@ -1995,7 +2379,7 @@ var sortPlugin = {
     "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: wrapParserPreprocess(babelPlugin.parsers.json, preprocessJson),
     "json-stringify": wrapParserPreprocess(babelPlugin.parsers["json-stringify"], preprocessPackageJson),
     meriyah: wrapParserPreprocess(meriyahPlugin.parsers.meriyah, sortTypeScript),
     typescript: wrapParserPreprocess(typescriptPlugin.parsers.typescript, sortTypeScript)