prettier-plugin-sort 1.1.0 → 1.1.2

package/README.md

@@ -30,7 +30,7 @@ import App from './App';
 
 ## Install
 
-Requires Prettier 3.9 or newer.
+Requires Prettier 3.x, version 3.9 or later.
 
 ```shell
 npm i -D prettier prettier-plugin-sort
@@ -56,20 +56,20 @@ Dynamic `import()` calls and import-like text in strings or comments are left un
 
 `esmImportGroups` accepts these values:
 
-| Group      | Matches                                                            |
-| ---------- | ------------------------------------------------------------------ |
-| `builtin`  | Modules beginning with `node:` or `bun:`, plus `bun`               |
-| `external` | Packages and module paths not matched by any other group           |
-| `internal` | Path aliases defined by `compilerOptions.paths` in `tsconfig.json` |
-| `parent`   | Parent-relative paths such as `../utils`                           |
-| `sibling`  | Sibling paths such as `./Button`                                   |
-| `index`    | `.`, `./`, `./index`, and `./index` with an optional extension     |
+| Group      | Matches                                                                                         |
+| ---------- | ----------------------------------------------------------------------------------------------- |
+| `builtin`  | Modules beginning with `node:` or `bun:`, plus `bun`                                            |
+| `external` | Packages and module paths not matched by any other group                                        |
+| `internal` | Path aliases from `compilerOptions.paths` in the TypeScript project containing the current file |
+| `parent`   | Parent-relative paths such as `../utils`                                                        |
+| `sibling`  | Sibling paths such as `./Button`                                                                |
+| `index`    | `.`, `./`, `./index`, and `./index` with an optional extension                                  |
 
 Modern Node.js code should reference built-ins explicitly with [`node:` URLs](https://nodejs.org/api/esm.html#node-imports). The plugin also classifies only `node:`-prefixed modules as `builtin`. Module specifiers without the prefix, such as `fs` and `path`, belong to `external`.
 
 The table also shows the default order. Duplicate entries are removed automatically, and omitted default groups are appended in their default order.
 
-The plugin searches upward from the current file for the nearest `tsconfig.json` and identifies `internal` imports from the resolved `compilerOptions.paths`. Inherited `paths` are supported. Non-relative paths not declared in `paths` remain `external`. The catch-all pattern `*` is ignored because it cannot distinguish project modules from third-party packages.
+The plugin searches upward from the current file for the nearest `tsconfig.json`, then uses `files`, `include`, and `exclude` to select the TypeScript project containing the file, following `references` when necessary. Each project is resolved through `extends` before matching the file and reading `compilerOptions.paths`. Only `paths` from the selected project are used to classify `internal`; `paths` from other referenced projects are not merged. Non-relative paths not declared there remain `external`. The catch-all pattern `*` is ignored because it cannot distinguish project modules from third-party packages.
 
 With `esmImportSeparation` set to `false`, blank lines are removed both between groups and around side-effect imports.
 
@@ -94,6 +94,8 @@ With `esmImportMerge` enabled, imports from the same module are merged when safe
 
 Imports are not merged when their import attributes differ, comments cannot move safely, or default and namespace bindings conflict. Side-effect imports always remain separate.
 
+An import with an attached comment keeps its position relative to surrounding declarations from the same module, preserving the merge boundary after sorting.
+
 ## Export sorting
 
 `esmExportSpecifierSort` sorts top-level `export { ... }` and `export type { ... }` entries by name. Aliased entries use their exported names.
@@ -262,6 +264,10 @@ The plugin only handles ES module syntax. It does not modify CommonJS `require()
 
 `tsconfig.json` sorting supports the `json` parser. The file must be named `tsconfig.json` or `tsconfig.*.json`.
 
+Range formatting in JavaScript, TypeScript, Flow, or JSON files applies Prettier's layout rules and preserves the original order. For embedded code, the host parser determines the range. For example, Vue may expand a selection to the entire `<script>` block, which still participates in sorting.
+
+With `formatWithCursor()`, the cursor follows the corresponding source content. If its position after sorting cannot be determined reliably, the plugin preserves the original order and continues with Prettier's formatting.
+
 ## TypeScript configuration
 
 The plugin also exports the `SortOptions`, `ImportGroup`, and `TypeImportStyle` types for use in TypeScript configuration files:

package/README.zh.md

@@ -30,7 +30,7 @@ import App from './App';
 
 ## 安装
 
-要求 Prettier 3.9 或更高版本。
+要求 Prettier 3.9 及以上的 3.x 版本。
 
 ```shell
 npm i -D prettier prettier-plugin-sort
@@ -56,20 +56,20 @@ npm i -D prettier prettier-plugin-sort
 
 `esmImportGroups` 支持以下分组：
 
-| 分组       | 匹配范围                                                  |
-| ---------- | --------------------------------------------------------- |
-| `builtin`  | 以 `node:`、`bun:` 开头的模块，以及 `bun`                 |
-| `external` | 第三方包，以及没有匹配其他分组的模块路径                  |
-| `internal` | `tsconfig.json` 中 `compilerOptions.paths` 定义的路径别名 |
-| `parent`   | `../utils` 这类指向上级目录的相对路径                     |
-| `sibling`  | `./Button` 这类指向同级目录的相对路径                     |
-| `index`    | `.`、`./`、`./index` 及带扩展名的 `./index`               |
+| 分组       | 匹配范围                                                                    |
+| ---------- | --------------------------------------------------------------------------- |
+| `builtin`  | 以 `node:`、`bun:` 开头的模块，以及 `bun`                                   |
+| `external` | 第三方包，以及没有匹配其他分组的模块路径                                    |
+| `internal` | 当前文件所属 TypeScript project 的 `compilerOptions.paths` 中定义的路径别名 |
+| `parent`   | `../utils` 这类指向上级目录的相对路径                                       |
+| `sibling`  | `./Button` 这类指向同级目录的相对路径                                       |
+| `index`    | `.`、`./`、`./index` 及带扩展名的 `./index`                                 |
 
 现代 Node.js 代码应使用 [`node:` URL](https://nodejs.org/api/esm.html#node-imports) 显式引用内置模块。本插件也只把带 `node:` 前缀的内置模块归入 `builtin`。`fs`、`path` 等未带前缀的模块归入 `external`。
 
 默认顺序就是表中的顺序。配置数组会自动去重，遗漏的默认分组则按默认顺序补到末尾。
 
-插件会从当前文件所在目录向上查找最近的 `tsconfig.json`，并根据解析后的 `compilerOptions.paths` 识别 `internal`。继承配置中的 `paths` 同样有效。没有在 `paths` 中声明的非相对路径仍归入 `external`。`*` 无法区分项目代码和第三方包，因此不会用于判断 `internal`。
+插件会从当前文件所在目录向上查找最近的 `tsconfig.json`，根据 `files`、`include` 和 `exclude` 选择包含当前文件的 TypeScript project，并在需要时沿 `references` 查找。每个 project 都会先解析 `extends`，再匹配文件并读取 `compilerOptions.paths`。识别 `internal` 时只使用当前文件所属 project 的 `paths`，不会合并其他 referenced project 的 `paths`。没有在该 `paths` 中声明的非相对路径仍归入 `external`。`*` 无法区分项目代码和第三方包，因此不会用于判断 `internal`。
 
 将 `esmImportSeparation` 设为 `false` 后，分组之间和副作用 `import` 上下两侧都不再留空行。
 
@@ -94,6 +94,8 @@ npm i -D prettier prettier-plugin-sort
 
 `import` 属性不同、注释无法安全移动，或默认导入与命名空间导入发生冲突时，都不会合并。副作用 `import` 始终保持独立。
 
+带注释的 `import` 会保留与两侧同源声明的相对顺序，避免排序后改变合并边界。
+
 ## `export` 排序
 
 `esmExportSpecifierSort` 按名称排列顶层 `export { ... }` 和 `export type { ... }`。使用 `as` 时，以导出后的名称为准。
@@ -262,6 +264,10 @@ Vue、Markdown 等文件中的 JavaScript 和 TypeScript 的**嵌入式代码**
 
 `tsconfig.json` 排序支持 `json` 解析器，文件名必须是 `tsconfig.json` 或 `tsconfig.*.json`。
 
+直接格式化 JavaScript、TypeScript、Flow 或 JSON 文件的局部选区时，插件只执行 Prettier 排版，保留内容原有顺序。嵌入式代码的范围由宿主解析器决定。例如 Vue 可能将选区扩展为整个 `<script>` 块，该代码块仍会参与排序。
+
+使用 `formatWithCursor()` 时，光标会跟随对应的源码内容。无法明确定位排序后的光标位置时，插件保留原有顺序，继续执行 Prettier 排版。
+
 ## TypeScript 配置
 
 插件还导出 `SortOptions`、`ImportGroup` 和 `TypeImportStyle` 类型，可直接用于 TypeScript 配置文件：

package/dist/cursor.d.ts

@@ -0,0 +1,4 @@
+import { type ParserOptions } from 'prettier';
+import { type ParserAstNode } from '#/parser-ast';
+/** 在 Prettier 根据新 AST 定位光标之前，先跟随源码未变的唯一节点移动。 */
+export declare function updateCursorOffset(sourceText: string, sortedText: string, originalAst: ParserAstNode, sortedAst: ParserAstNode, prettierOptions: ParserOptions): boolean;

package/dist/index.js

@@ -1,11 +1,3 @@
-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";
@@ -32,14 +24,7 @@ var DEFAULT_SORT_OPTIONS = {
   tsconfigSort: true,
   tsconfigSeparation: true
 };
-var VALID_IMPORT_GROUPS = new Set([
-  "builtin",
-  "external",
-  "internal",
-  "parent",
-  "sibling",
-  "index"
-]);
+var VALID_IMPORT_GROUPS = new Set(DEFAULT_SORT_OPTIONS.esmImportGroups);
 var VALID_TYPE_IMPORT_STYLES = new Set([
   "separate",
   "inline-first",
@@ -58,7 +43,10 @@ function resolveBooleanSortOption(prettierOptions, optionName) {
 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];
+  const resolvedImportGroups = [
+    ...configuredImportGroups,
+    ...remainingDefaultImportGroups
+  ];
   const resolvedTypeImportStyle = isValidTypeImportStyle(prettierOptions.esmImportTypeStyle) ? prettierOptions.esmImportTypeStyle : DEFAULT_SORT_OPTIONS.esmImportTypeStyle;
   return {
     esmImportSort: resolveBooleanSortOption(prettierOptions, "esmImportSort"),
@@ -306,6 +294,123 @@ function isPrettierIgnored(sourceText, statementRange, sortedComments) {
   return false;
 }
 
+// src/cursor.ts
+function collectCursorAnchors(parserAst, sourceText) {
+  const anchors = [];
+  function addAnchor(path, node) {
+    const range = getAstNodeTextRange(node);
+    if (!range || range.end > sourceText.length) {
+      return;
+    }
+    anchors.push({
+      ...range,
+      key: JSON.stringify([...path, node?.type ?? "comment"])
+    });
+  }
+  function collectJsonAnchors(node, path) {
+    addAnchor(path, node);
+    if (node.type === "ObjectExpression") {
+      for (const property of node.properties ?? []) {
+        const name = getAstNodeName(property.key);
+        if (name === null || !isParserAstNode(property.value)) {
+          continue;
+        }
+        const propertyPath = [...path, "property", name];
+        addAnchor(propertyPath, property);
+        addAnchor([...propertyPath, "key"], property.key);
+        collectJsonAnchors(property.value, [...propertyPath, "value"]);
+      }
+    } else if (node.type === "ArrayExpression") {
+      for (const [index, element] of (node.elements ?? []).entries()) {
+        if (!element) {
+          continue;
+        }
+        const elementPath = typeof element.value === "string" ? [...path, "string", element.value] : [...path, "index", index];
+        collectJsonAnchors(element, elementPath);
+      }
+    }
+  }
+  const jsonRoot = parserAst.type === "JsonRoot" ? parserAst.node : undefined;
+  if (jsonRoot) {
+    collectJsonAnchors(jsonRoot, ["json"]);
+  } else {
+    let statementIndex = 0;
+    for (const statement of getProgramStatements(parserAst)) {
+      if (statement.type === "ImportDeclaration") {
+        const sourceName = getAstNodeName(statement.source);
+        if (sourceName === null) {
+          continue;
+        }
+        const importPath = [
+          "import",
+          sourceName,
+          typeof statement.phase === "string" ? statement.phase : ""
+        ];
+        addAnchor([...importPath, "declaration"], statement);
+        addAnchor([...importPath, "source"], statement.source);
+        for (const specifier of statement.specifiers ?? []) {
+          const localName = getAstNodeName(specifier.local);
+          if (localName === null) {
+            continue;
+          }
+          const specifierPath = [...importPath, "binding", localName];
+          addAnchor(specifierPath, specifier);
+          addAnchor([...specifierPath, "local"], specifier.local);
+          addAnchor([...specifierPath, "imported"], specifier.imported);
+        }
+        continue;
+      }
+      const statementPath = ["statement", statementIndex++];
+      addAnchor(statementPath, statement);
+      if (statement.type === "ExportNamedDeclaration") {
+        addAnchor([...statementPath, "source"], statement.source);
+        for (const specifier of statement.specifiers ?? []) {
+          const exportedName = getAstNodeName(specifier.exported);
+          if (exportedName === null) {
+            continue;
+          }
+          const specifierPath = [...statementPath, "specifier", exportedName];
+          addAnchor(specifierPath, specifier);
+          addAnchor([...specifierPath, "local"], specifier.local);
+          addAnchor([...specifierPath, "exported"], specifier.exported);
+        }
+      }
+    }
+  }
+  for (const comment of getProgramComments(parserAst)) {
+    const range = getAstNodeTextRange(comment);
+    if (range) {
+      addAnchor(["comment", sourceText.slice(range.start, range.end)], comment);
+    }
+  }
+  return anchors;
+}
+function updateCursorOffset(sourceText, sortedText, originalAst, sortedAst, prettierOptions) {
+  const cursorOffset = prettierOptions.cursorOffset;
+  if (typeof cursorOffset !== "number" || cursorOffset < 0 || sourceText === sortedText) {
+    return true;
+  }
+  if (!Number.isSafeInteger(cursorOffset) || cursorOffset > sourceText.length) {
+    return false;
+  }
+  if (cursorOffset === 0 || cursorOffset === sourceText.length) {
+    prettierOptions.cursorOffset = cursorOffset === 0 ? 0 : sortedText.length;
+    return true;
+  }
+  const originalAnchors = collectCursorAnchors(originalAst, sourceText).filter((anchor) => anchor.start <= cursorOffset && cursorOffset <= anchor.end).sort((left, right) => left.end - left.start - (right.end - right.start) || right.start - left.start);
+  const sortedAnchors = collectCursorAnchors(sortedAst, sortedText);
+  for (const originalAnchor of originalAnchors) {
+    const originalNodeText = sourceText.slice(originalAnchor.start, originalAnchor.end);
+    const matches = sortedAnchors.filter((anchor) => anchor.key === originalAnchor.key && sortedText.slice(anchor.start, anchor.end) === originalNodeText);
+    const [matchingAnchor] = matches;
+    if (matches.length === 1 && matchingAnchor) {
+      prettierOptions.cursorOffset = matchingAnchor.start + cursorOffset - originalAnchor.start;
+      return true;
+    }
+  }
+  return false;
+}
+
 // src/utils/package-rules.ts
 var PACKAGE_JSON_FIELD_ORDER = [
   "$schema",
@@ -518,6 +623,7 @@ class JsonSourceLiteral {
     this.sourceText = sourceText;
   }
 }
+var JSON_KEY_ORDER = Symbol("jsonKeyOrder");
 var SEQUENTIAL_SCRIPT_PATTERN = /(?<=^|[\s&;<>|(])(?:run-s|npm-run-all2? .*(?:--sequential|--serial|-s))(?=$|[\s&;<>|)])/;
 var PACKAGE_JSON_FIELD_INDEXES = new Map(PACKAGE_JSON_FIELD_ORDER.map((fieldName, index) => [fieldName, index]));
 function compareStringsCaseSensitive(leftText, rightText) {
@@ -529,6 +635,19 @@ function compareStringsCaseSensitive(leftText, rightText) {
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof JsonSourceLiteral);
 }
+function createJsonObject(entries) {
+  const fields = new Map(entries);
+  return {
+    ...Object.fromEntries(fields),
+    [JSON_KEY_ORDER]: [...fields.keys()]
+  };
+}
+function getJsonKeys(jsonObject) {
+  return jsonObject[JSON_KEY_ORDER] ?? Object.keys(jsonObject);
+}
+function getJsonEntries(jsonObject) {
+  return getJsonKeys(jsonObject).map((key) => [key, jsonObject[key]]);
+}
 function getJsonPathKey(jsonPath) {
   return JSON.stringify(jsonPath);
 }
@@ -585,6 +704,7 @@ function preserveJsonSourceLiterals(jsonValue, parserJsonNode, sourceText, field
       fieldNameSourceTexts.set(getJsonPathKey(propertyPath), sourceText.slice(propertyNameRange.start, propertyNameRange.end));
       jsonObject[propertyName] = propertyValue;
     }
+    jsonObject[JSON_KEY_ORDER] = [...propertyNames];
     return jsonObject;
   }
   if (parserJsonNode.type === "ArrayExpression") {
@@ -629,7 +749,7 @@ function serializeJsonValue(jsonValue, fieldNameSourceTexts, jsonPath = []) {
   }
   if (isJsonObject(jsonValue)) {
     const serializedFields = [];
-    for (const [fieldName, fieldValue] of Object.entries(jsonValue)) {
+    for (const [fieldName, fieldValue] of getJsonEntries(jsonValue)) {
       const fieldPath = [...jsonPath, fieldName];
       const fieldNameSourceText = fieldNameSourceTexts.get(getJsonPathKey(fieldPath));
       const serializedValue = serializeJsonValue(fieldValue, fieldNameSourceTexts, fieldPath);
@@ -656,7 +776,7 @@ function deduplicateStringValues(stringValues) {
   return [...uniqueStringValues.values()];
 }
 function sortJsonObject(jsonObject, compareKeys = compareStringsCaseSensitive) {
-  return Object.fromEntries(Object.entries(jsonObject).sort(([leftKey], [rightKey]) => compareKeys(leftKey, rightKey)));
+  return createJsonObject(getJsonEntries(jsonObject).sort(([leftKey], [rightKey]) => compareKeys(leftKey, rightKey)));
 }
 function sortJsonObjectByKeyOrder(jsonObject, keyOrder) {
   const keyOrderIndexes = new Map(keyOrder.map((key, index) => [key, index]));
@@ -678,7 +798,7 @@ function sortJsonObjectByKeyOrder(jsonObject, keyOrder) {
   });
 }
 function sortJsonObjectRecursively(jsonObject, sortObject = sortJsonObject) {
-  const sortedNestedValues = Object.fromEntries(Object.entries(jsonObject).map(([key, value]) => [
+  const sortedNestedValues = createJsonObject(getJsonEntries(jsonObject).map(([key, value]) => [
     key,
     isJsonObject(value) ? sortJsonObjectRecursively(value, sortObject) : value
   ]));
@@ -786,11 +906,7 @@ function sortEslintConfigValue(fieldValue) {
   return sortJsonObjectValue(fieldValue, sortEslintConfigObject);
 }
 function sortPrettierConfigObject(prettierConfig) {
-  const keyOrder = Object.keys(prettierConfig).filter((key) => key !== "overrides").sort(compareStringsCaseSensitive);
-  if (Object.hasOwn(prettierConfig, "overrides")) {
-    keyOrder.push("overrides");
-  }
-  const sortedConfig = sortJsonObjectByKeyOrder(prettierConfig, keyOrder);
+  const sortedConfig = sortJsonObject(prettierConfig, (leftKey, rightKey) => Number(leftKey === "overrides") - Number(rightKey === "overrides") || compareStringsCaseSensitive(leftKey, rightKey));
   if (Array.isArray(sortedConfig.overrides)) {
     sortedConfig.overrides = sortedConfig.overrides.map((override) => {
       if (!isJsonObject(override)) {
@@ -814,7 +930,7 @@ function sortWireitScriptObject(scriptConfig) {
     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]) => [
+    sortedConfig.env = sortJsonObject(createJsonObject(getJsonEntries(sortedConfig.env).map(([name, value]) => [
       name,
       sortJsonObjectValueByKeyOrder(value, ["external", "default"])
     ])));
@@ -833,7 +949,7 @@ function sortWireitValue(fieldValue) {
   if (!isJsonObject(fieldValue)) {
     return fieldValue;
   }
-  return sortJsonObject(Object.fromEntries(Object.entries(fieldValue).map(([scriptName, scriptConfig]) => [
+  return sortJsonObject(createJsonObject(getJsonEntries(fieldValue).map(([scriptName, scriptConfig]) => [
     scriptName,
     sortJsonObjectValue(scriptConfig, sortWireitScriptObject)
   ])));
@@ -883,7 +999,7 @@ function sortScriptsValue(fieldValue, packageJson) {
   if (!isJsonObject(fieldValue)) {
     return fieldValue;
   }
-  const scriptNames = Object.keys(fieldValue);
+  const scriptNames = getJsonKeys(fieldValue);
   const baseScriptNames = new Set;
   const normalizedScriptNames = scriptNames.map((scriptName) => {
     const baseScriptName = scriptName.replace(/^(?:pre|post)/, "");
@@ -895,21 +1011,22 @@ function sortScriptsValue(fieldValue, packageJson) {
     }
     return scriptName;
   });
-  const orderedBaseScriptNames = hasSequentialScript(packageJson) ? [...new Set(normalizedScriptNames)] : sortScriptNames(normalizedScriptNames);
+  const uniqueScriptNames = [...new Set(normalizedScriptNames)];
+  const orderedBaseScriptNames = hasSequentialScript(packageJson) ? uniqueScriptNames : sortScriptNames(uniqueScriptNames);
   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]]));
+  return createJsonObject(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 exportKeys = getJsonKeys(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])]));
+  return createJsonObject([...exportPathKeys, ...exportConditionKeys].map((exportKey) => [exportKey, sortExportsValue(fieldValue[exportKey])]));
 }
 function sortDevEnginesValue(fieldValue) {
   if (!isJsonObject(fieldValue) || !isJsonObject(fieldValue.packageManager)) {
@@ -1107,7 +1224,7 @@ var PACKAGE_JSON_FIELD_SORTERS = {
 };
 function sortPackageJsonObject(packageJson) {
   const sortedPackageJsonFields = sortPackageJsonFields(packageJson);
-  return Object.fromEntries(Object.entries(sortedPackageJsonFields).map(([fieldName, fieldValue]) => {
+  return createJsonObject(getJsonEntries(sortedPackageJsonFields).map(([fieldName, fieldValue]) => {
     const fieldSorter = Object.hasOwn(PACKAGE_JSON_FIELD_SORTERS, fieldName) ? PACKAGE_JSON_FIELD_SORTERS[fieldName] : undefined;
     return [
       fieldName,
@@ -1136,7 +1253,17 @@ async function preprocessPackageJson(sourceText, prettierOptions, parser) {
     if (!isJsonObject(packageJsonWithSourceLiterals)) {
       return sourceText;
     }
-    return serializeJsonValue(sortPackageJsonObject(packageJsonWithSourceLiterals), fieldNameSourceTexts) ?? sourceText;
+    const sortedText = serializeJsonValue(sortPackageJsonObject(packageJsonWithSourceLiterals), fieldNameSourceTexts);
+    if (sortedText === null || sortedText === sourceText) {
+      return sourceText;
+    }
+    if (typeof prettierOptions.cursorOffset === "number" && prettierOptions.cursorOffset >= 0) {
+      const sortedAst = await parser.parse(sortedText, prettierOptions);
+      if (!isParserAstNode(sortedAst) || !updateCursorOffset(sourceText, sortedText, parserJsonAst, sortedAst, prettierOptions)) {
+        return sourceText;
+      }
+    }
+    return sortedText;
   } catch {
     return sourceText;
   }
@@ -1463,7 +1590,7 @@ async function preprocessTsconfig(sourceText, prettierOptions, parser) {
     if (compilerOptions) {
       const propertyRange = getAstNodeTextRange(compilerOptions.property);
       const valueRange = getAstNodeTextRange(compilerOptions.value);
-      if (propertyRange && valueRange && !isPrettierIgnored(sourceText, propertyRange, sortedComments)) {
+      if (propertyRange && valueRange && !isPrettierIgnored(sourceText, propertyRange, sortedComments) && !isPrettierIgnored(sourceText, valueRange, 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) {
@@ -1496,7 +1623,10 @@ async function preprocessTsconfig(sourceText, prettierOptions, parser) {
     if (editedSourceText === null) {
       return sourceText;
     }
-    await parser.parse(editedSourceText, prettierOptions);
+    const sortedAst = await parser.parse(editedSourceText, prettierOptions);
+    if (!updateCursorOffset(sourceText, editedSourceText, parserAst, sortedAst, prettierOptions)) {
+      return sourceText;
+    }
     return editedSourceText;
   } catch {
     return sourceText;
@@ -1692,7 +1822,11 @@ function findLeadingCommentsStart(sourceText, statementStart, sortedComments, pr
     }
     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;
+    const isEslintNextLine = isEslintNextLineComment(comment);
+    if (isEslintNextLine && lineBreakCount === 0) {
+      return null;
+    }
+    const isEslintNextLineCommentAttached = attachedTextStart === statementStart && isEslintNextLine && textBetweenCommentAndImport.trim() === "" && lineBreakCount === 1;
     if (isEslintNextLineCommentAttached) {
       attachedTextStart = textRange.start;
       continue;
@@ -1761,19 +1895,47 @@ function getTrailingComments(sourceText, statementEnd, sortedComments) {
     isImportSortingBoundary
   };
 }
+function getImportAttributesKey(importDeclarationNode, syntax) {
+  const attributeNodes = importDeclarationNode.attributes;
+  if (!Array.isArray(attributeNodes)) {
+    return null;
+  }
+  const attributes = [];
+  const attributeNames = new Set;
+  for (const attributeNode of attributeNodes) {
+    if (!isParserAstNode(attributeNode) || attributeNode.type !== "ImportAttribute" || !isParserAstNode(attributeNode.value)) {
+      return null;
+    }
+    const keyNode = attributeNode.key;
+    const valueNode = attributeNode.value;
+    if (!keyNode || !["Identifier", "Literal", "StringLiteral"].includes(keyNode.type) || valueNode.type !== "Literal" && valueNode.type !== "StringLiteral" || typeof valueNode.value !== "string") {
+      return null;
+    }
+    const attributeName = getAstNodeName(keyNode);
+    if (attributeName === null || attributeNames.has(attributeName)) {
+      return null;
+    }
+    attributeNames.add(attributeName);
+    attributes.push([attributeName, valueNode.value]);
+  }
+  return JSON.stringify([syntax, attributes]);
+}
 function parseImportAttributes(sourceText, importDeclarationNode) {
   const declarationRange = getAstNodeTextRange(importDeclarationNode);
   const moduleSpecifierRange = getAstNodeTextRange(importDeclarationNode.source);
   if (!declarationRange || !moduleSpecifierRange) {
-    return { attributesText: null, isValid: false };
+    return { attributesText: null, attributesKey: null, isValid: false };
   }
   const importAttributesText = sourceText.slice(moduleSpecifierRange.end, declarationRange.end).replace(/;\s*$/, "").trim();
   if (importAttributesText === "") {
-    return { attributesText: null, isValid: true };
+    return { attributesText: null, attributesKey: null, isValid: true };
   }
+  const attributeSyntax = /^(with|assert)\s*\{[\s\S]*\}$/.exec(importAttributesText)?.[1];
+  const attributesKey = attributeSyntax ? getImportAttributesKey(importDeclarationNode, attributeSyntax) : null;
   return {
     attributesText: importAttributesText,
-    isValid: /^(?:with|assert)\s*\{[\s\S]*\}$/.test(importAttributesText)
+    attributesKey,
+    isValid: attributesKey !== null
   };
 }
 function parseImportDeclaration(importDeclarationMetadata, sourceText) {
@@ -1863,6 +2025,7 @@ function parseImportDeclaration(importDeclarationMetadata, sourceText) {
     namespaceBinding,
     namedSpecifiers: parsedNamedSpecifiers,
     importAttributes: parsedImportAttributes.attributesText,
+    importAttributesKey: parsedImportAttributes.attributesKey,
     verbatimDeclaration,
     leadingCommentsText,
     trailingCommentsText,
@@ -1928,10 +2091,10 @@ function getLocalBindingNames(importDeclaration) {
   return localBindingNames;
 }
 function getImportRequestKey(importDeclaration) {
-  return `${importDeclaration.moduleSpecifier}\x00${importDeclaration.importAttributes ?? ""}`;
+  return `${importDeclaration.moduleSpecifier}\x00${importDeclaration.importAttributesKey ?? 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) {
+  if (targetImportDeclaration.verbatimDeclaration !== null || candidateImportDeclaration.verbatimDeclaration !== null || targetImportDeclaration.moduleSpecifier !== candidateImportDeclaration.moduleSpecifier || targetImportDeclaration.importAttributesKey !== candidateImportDeclaration.importAttributesKey || 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) {
@@ -1963,6 +2126,7 @@ function mergeImportDeclarations(targetImportDeclaration, candidateImportDeclara
     namespaceBinding: targetImportDeclaration.namespaceBinding ?? candidateImportDeclaration.namespaceBinding,
     namedSpecifiers,
     importAttributes: targetImportDeclaration.importAttributes,
+    importAttributesKey: targetImportDeclaration.importAttributesKey,
     verbatimDeclaration: null,
     leadingCommentsText: targetImportDeclaration.leadingCommentsText,
     trailingCommentsText: "",
@@ -1985,7 +2149,7 @@ function mergeCompatibleImports(importDeclarations) {
       currentBindingCountsByRequest.delete(importRequestKey);
       continue;
     }
-    if (importDeclaration.verbatimDeclaration !== null || importDeclaration.isSideEffectOnly) {
+    if (importDeclaration.verbatimDeclaration !== null) {
       continue;
     }
     const bindingCounts = currentBindingCountsByRequest.get(importRequestKey) ?? {
@@ -2035,10 +2199,10 @@ function applyTypeImportStyle(importDeclaration, typeImportStyle) {
     ];
   }
   if (typeImportStyle === "separate") {
-    const typeSpecifiers2 = namedSpecifiers.filter((importSpecifier) => importSpecifier.isTypeOnly);
-    const valueSpecifiers2 = namedSpecifiers.filter((importSpecifier) => !importSpecifier.isTypeOnly);
-    const hasValueBinding = valueSpecifiers2.length > 0 || importDeclaration.defaultBinding !== null || importDeclaration.namespaceBinding !== null;
-    if (typeSpecifiers2.length > 0 && (!hasValueBinding || importDeclaration.importAttributes !== null || importDeclaration.leadingCommentsText.trim() !== "" || importDeclaration.trailingCommentsText !== "")) {
+    const typeSpecifiers = namedSpecifiers.filter((importSpecifier) => importSpecifier.isTypeOnly);
+    const valueSpecifiers = namedSpecifiers.filter((importSpecifier) => !importSpecifier.isTypeOnly);
+    const hasValueBinding = valueSpecifiers.length > 0 || importDeclaration.defaultBinding !== null || importDeclaration.namespaceBinding !== null;
+    if (typeSpecifiers.length > 0 && (!hasValueBinding || importDeclaration.importAttributes !== null || importDeclaration.leadingCommentsText.trim() !== "" || importDeclaration.trailingCommentsText !== "")) {
       return [
         {
           ...importDeclaration,
@@ -2047,25 +2211,25 @@ function applyTypeImportStyle(importDeclaration, typeImportStyle) {
       ];
     }
     const styledImportDeclarations = [];
-    if (typeSpecifiers2.length > 0) {
+    if (typeSpecifiers.length > 0) {
       styledImportDeclarations.push({
         ...importDeclaration,
         isTypeOnly: true,
         defaultBinding: null,
         namespaceBinding: null,
-        namedSpecifiers: sortNamedImportSpecifiers(typeSpecifiers2.map((importSpecifier) => ({
+        namedSpecifiers: sortNamedImportSpecifiers(typeSpecifiers.map((importSpecifier) => ({
           ...importSpecifier,
           isTypeOnly: false
         })))
       });
     }
-    if (valueSpecifiers2.length > 0 || importDeclaration.defaultBinding !== null || importDeclaration.namespaceBinding !== null) {
+    if (hasValueBinding) {
       let namedValueSpecifiers = null;
-      if (valueSpecifiers2.length > 0) {
-        namedValueSpecifiers = sortNamedImportSpecifiers(valueSpecifiers2);
+      if (valueSpecifiers.length > 0) {
+        namedValueSpecifiers = sortNamedImportSpecifiers(valueSpecifiers);
       }
       let leadingCommentsText = importDeclaration.leadingCommentsText;
-      if (typeSpecifiers2.length > 0) {
+      if (typeSpecifiers.length > 0) {
         leadingCommentsText = "";
       }
       styledImportDeclarations.push({
@@ -2108,11 +2272,19 @@ function renderSortedImportSegment(importDeclarations, sortOptions, pathPatterns
   }
   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, pathPatterns),
-    originalIndex
-  }));
+  const sortRegionByRequest = new Map;
+  const rankedImportDeclarations = styledImportDeclarations.map((importDeclaration, originalIndex) => {
+    const importRequestKey = getImportRequestKey(importDeclaration);
+    const regionOffset = importDeclaration.isMergeBoundary ? 1 : 0;
+    const sortRegion = (sortRegionByRequest.get(importRequestKey) ?? 0) + regionOffset;
+    sortRegionByRequest.set(importRequestKey, sortRegion + regionOffset);
+    return {
+      importDeclaration,
+      importGroup: classifyImportGroup(importDeclaration.moduleSpecifier, pathPatterns),
+      sortRegion,
+      originalIndex
+    };
+  });
   rankedImportDeclarations.sort((left, right) => {
     const groupRankDifference = (importGroupOrder.get(left.importGroup) ?? unlistedGroupRank) - (importGroupOrder.get(right.importGroup) ?? unlistedGroupRank);
     if (groupRankDifference !== 0) {
@@ -2122,6 +2294,10 @@ function renderSortedImportSegment(importDeclarations, sortOptions, pathPatterns
     if (moduleSpecifierDifference !== 0) {
       return moduleSpecifierDifference;
     }
+    const sortRegionDifference = left.sortRegion - right.sortRegion;
+    if (sortRegionDifference !== 0) {
+      return sortRegionDifference;
+    }
     if (left.importDeclaration.isTypeOnly !== right.importDeclaration.isTypeOnly) {
       if (left.importDeclaration.isTypeOnly) {
         return -1;
@@ -2252,6 +2428,9 @@ function buildImportSortingEdits(sourceText, programStatements, sortedComments,
     }
     const isImportIgnoredByPrettier = isPrettierIgnored(sourceText, declarationRange, sortedComments);
     const leadingCommentsStart = findLeadingCommentsStart(sourceText, declarationRange.start, sortedComments, prettierFilePragmaComment);
+    if (leadingCommentsStart === null) {
+      return [];
+    }
     const trailingComments = getTrailingComments(sourceText, declarationRange.end, sortedComments);
     if (isImportIgnoredByPrettier || trailingComments.isImportSortingBoundary) {
       if (currentSortableSegment.length > 0) {
@@ -2307,14 +2486,92 @@ function buildImportSortingEdits(sourceText, programStatements, sortedComments,
 }
 
 // src/sort-typescript.ts
+var SCRIPT_FILE_EXTENSION_PATTERN = /\.[cm]?[jt]sx?$/i;
 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) : [];
+    let isFileIncluded = function(project) {
+      try {
+        if (createFilesMatcher(project, isFileSystemCaseSensitive)(absoluteFilePath)) {
+          return true;
+        }
+        const fileExtension = extname(absoluteFilePath);
+        if (!fileExtension || SCRIPT_FILE_EXTENSION_PATTERN.test(fileExtension)) {
+          return false;
+        }
+        const virtualExtension = ".ts";
+        const normalizedFileExtension = isFileSystemCaseSensitive ? fileExtension : fileExtension.toLowerCase();
+        const addVirtualExtension = (patterns) => patterns?.map((pattern) => {
+          const normalizedPattern = isFileSystemCaseSensitive ? pattern : pattern.toLowerCase();
+          return normalizedPattern.endsWith(normalizedFileExtension) ? `${pattern}${virtualExtension}` : pattern;
+        });
+        const virtualConfig = {
+          ...project.config,
+          files: addVirtualExtension(project.config.files),
+          include: addVirtualExtension(project.config.include),
+          exclude: addVirtualExtension(project.config.exclude)
+        };
+        return Boolean(createFilesMatcher({ path: project.path, config: virtualConfig }, isFileSystemCaseSensitive)(`${absoluteFilePath}${virtualExtension}`));
+      } catch {
+        return false;
+      }
+    }, findProjectForFile = function(project) {
+      if (visitedConfigPaths.has(project.path)) {
+        return;
+      }
+      visitedConfigPaths.add(project.path);
+      if (isFileIncluded(project)) {
+        return project;
+      }
+      for (const reference of project.config.references ?? []) {
+        if (typeof reference.path !== "string") {
+          continue;
+        }
+        let referencedProject;
+        try {
+          const referencePath = resolve(dirname(project.path), reference.path);
+          const configPath = extname(referencePath).toLowerCase() === ".json" ? referencePath : join(referencePath, "tsconfig.json");
+          referencedProject = {
+            path: configPath,
+            config: parseTsconfig(configPath, cache)
+          };
+        } catch {
+          continue;
+        }
+        const selectedProject = findProjectForFile(referencedProject);
+        if (selectedProject) {
+          return selectedProject;
+        }
+      }
+      return;
+    };
+    const { createFilesMatcher, getTsconfig, parseTsconfig } = await import("get-tsconfig");
+    const { dirname, extname, join, resolve } = await import("node:path");
+    const cache = new Map;
+    const absoluteFilePath = resolve(filePath);
+    const isFileSystemCaseSensitive = !["darwin", "win32"].includes(process.platform);
+    const nearestProject = getTsconfig(absoluteFilePath, "tsconfig.json", cache);
+    if (!nearestProject) {
+      return [];
+    }
+    const visitedConfigPaths = new Set;
+    let currentProject = nearestProject;
+    while (currentProject) {
+      const selectedProject = findProjectForFile(currentProject);
+      if (selectedProject) {
+        const paths = selectedProject.config.compilerOptions?.paths;
+        return paths ? Object.keys(paths) : [];
+      }
+      const configDirectory = dirname(currentProject.path);
+      const parentDirectory = dirname(configDirectory);
+      if (parentDirectory === configDirectory) {
+        break;
+      }
+      currentProject = getTsconfig(parentDirectory, "tsconfig.json", cache);
+    }
+    return [];
   } catch {
     return [];
   }
@@ -2346,7 +2603,10 @@ async function sortTypeScript(sourceText, prettierOptions, parser) {
     return sourceText;
   }
   try {
-    await parser.parse(sortedText, prettierOptions);
+    const sortedAst = await parser.parse(sortedText, prettierOptions);
+    if (!updateCursorOffset(sourceText, sortedText, parserAst, sortedAst, prettierOptions)) {
+      return sourceText;
+    }
     return sortedText;
   } catch {
     return sourceText;
@@ -2354,6 +2614,7 @@ async function sortTypeScript(sourceText, prettierOptions, parser) {
 }
 
 // src/index.ts
+var IS_RANGE_FORMATTING = Symbol("isRangeFormatting");
 function wrapParserPreprocess(parser, preprocessTransform) {
   return {
     ...parser,
@@ -2362,6 +2623,10 @@ function wrapParserPreprocess(parser, preprocessTransform) {
       if (parser.preprocess) {
         transformedText = await parser.preprocess(sourceText, prettierOptions);
       }
+      if (prettierOptions[IS_RANGE_FORMATTING] || prettierOptions.rangeStart > 0 || prettierOptions.rangeEnd < sourceText.length) {
+        prettierOptions[IS_RANGE_FORMATTING] = true;
+        return transformedText;
+      }
       return preprocessTransform(transformedText, prettierOptions, parser);
     }
   };
@@ -2387,6 +2652,6 @@ var sortPlugin = {
 };
 var src_default = sortPlugin;
 export {
-  options,
-  src_default as default
+  src_default as default,
+  options
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-sort",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "A Prettier plugin for sorting ES module imports, export specifiers, and fields in package.json and tsconfig.json.",
   "keywords": [
     "imports",