prettier-plugin-sort 0.0.3 → 0.1.1

package/README.md

@@ -56,7 +56,7 @@ import react from 'react';
 import App from './App.tsx';
 ```
 
-Each import belongs to a group. For example, `node:fs` is a `builtin` (covers Node.js / Bun / Deno built-ins), while `react` and `lodash` are `external` npm packages. The plugin first classifies each import by group, then sorts alphabetically within each group.
+Each import belongs to a group. For example, `node:fs` is a `builtin` (covers Node.js and Bun **runtime** built-ins), while `react` and `lodash` are `external` npm packages. The plugin first classifies each import by group, then sorts alphabetically within each group.
 
 Grouping and ordering follow the conventions of [eslint-plugin-import](https://github.com/import-js/eslint-plugin-import)'s [import/order](https://github.com/import-js/eslint-plugin-import/blob/main/docs/rules/order.md) rule.
 
@@ -76,7 +76,7 @@ Group matchers:
 
 | Group      | Matches                                                     | Examples                           |
 | ---------- | ----------------------------------------------------------- | ---------------------------------- |
-| `builtin`  | `node:*`, `bun:*`, `deno:*`, and unprefixed Node built-ins  | `node:fs`, `path`                  |
+| `builtin`  | `node:*`, `bun:*`, `bun`, and unprefixed Node built-ins     | `node:fs`, `path`, `bun`           |
 | `external` | npm packages, and anything that doesn't match another group | `react`, `@scope/pkg`              |
 | `internal` | Project absolute paths and aliases                          | `/utils`, `~/app`, `@/shared`      |
 | `parent`   | Parent-relative paths                                       | `../Button`                        |

package/README.zh.md

@@ -56,7 +56,7 @@ import react from 'react';
 import App from './App.tsx';
 ```
 
-import 的模块一般可以按其来源分为不同的类别，例如上面的示例代码，'node:fs' 就属于 builtin 分类，该分类涵盖 Node.js、Bun、Deno 等**运行时**的内置模块。而像 react 和 lodash 这种直接从 npm 下载的依赖模块，属于 external 分类。
+import 的模块一般可以按其来源分为不同的类别，例如上面的示例代码，'node:fs' 就属于 builtin 分类，该分类涵盖 Node.js 和 Bun **运行时**的内置模块。而像 react 和 lodash 这种直接从 npm 下载的依赖模块，属于 external 分类。
 
 插件会先根据不同的模块进行分类，然后在模块内部基于字母顺序进行排列。
 
@@ -76,14 +76,14 @@ import 的模块一般可以按其来源分为不同的类别，例如上面的
 
 各分组的匹配规则如下：
 
-| 分组       | 匹配内容                                                | 示例                               |
-| ---------- | ------------------------------------------------------- | ---------------------------------- |
-| `builtin`  | `node:*`、`bun:*`、`deno:*`，以及无前缀的 Node 内置模块 | `node:fs`、`path`                  |
-| `external` | npm 包，以及不属于其他分组的模块                        | `react`、`@scope/pkg`              |
-| `internal` | 项目绝对路径与别名                                      | `/utils`、`~/app`、`@/shared`      |
-| `parent`   | 向上跳级的相对路径                                      | `../Button`                        |
-| `sibling`  | 同级相对路径（不包含 index）                            | `./Icon`                           |
-| `index`    | 当前目录的 index 模块                                   | `.`、`./`、`./index`、`./index.ts` |
+| 分组       | 匹配内容                                             | 示例                               |
+| ---------- | ---------------------------------------------------- | ---------------------------------- |
+| `builtin`  | `node:*`、`bun:*`、`bun`，以及无前缀的 Node 内置模块 | `node:fs`、`path`、`bun`           |
+| `external` | npm 包，以及不属于其他分组的模块                     | `react`、`@scope/pkg`              |
+| `internal` | 项目绝对路径与别名                                   | `/utils`、`~/app`、`@/shared`      |
+| `parent`   | 向上跳级的相对路径                                   | `../Button`                        |
+| `sibling`  | 同级相对路径（不包含 index）                         | `./Icon`                           |
+| `index`    | 当前目录的 index 模块                                | `.`、`./`、`./index`、`./index.ts` |
 
 > **关于 `internal` 的检测方式：** 插件目前通过说明符的前缀硬编码（`/`、`~`、`@/`）来判断，不会读取 tsconfig `paths` 或任何构建工具的配置。后续版本可能会提供 `importOrderInternalPatterns` 选项，支持自定义正则匹配。
 

package/dist/index.js

@@ -27,26 +27,24 @@ var VALID_TYPE_STYLES = new Set([
   "inline-last",
   "mixed"
 ]);
-var isValidImportGroup = (g) => typeof g === "string" && VALID_IMPORT_GROUPS.has(g);
-var isValidTypeStyle = (s) => typeof s === "string" && VALID_TYPE_STYLES.has(s);
+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((k) => typeof k === "string") : [];
-  const importOrder = typeof rawOptions.importOrder === "boolean" ? rawOptions.importOrder : DEFAULT_SORT_OPTIONS.importOrder;
-  const importOrderGroups = groups.length > 0 ? groups : [...DEFAULT_SORT_OPTIONS.importOrderGroups];
-  const importOrderSeparation = typeof rawOptions.importOrderSeparation === "boolean" ? rawOptions.importOrderSeparation : DEFAULT_SORT_OPTIONS.importOrderSeparation;
+  const excludeKeys = Array.isArray(rawOptions.packageJsonOrderExcludeKeys) ? rawOptions.packageJsonOrderExcludeKeys.filter((key) => typeof key === "string") : [];
   const importOrderTypeImports = isValidTypeStyle(rawOptions.importOrderTypeImports) ? rawOptions.importOrderTypeImports : DEFAULT_SORT_OPTIONS.importOrderTypeImports;
-  const importOrderMergeDuplicates = typeof rawOptions.importOrderMergeDuplicates === "boolean" ? rawOptions.importOrderMergeDuplicates : DEFAULT_SORT_OPTIONS.importOrderMergeDuplicates;
-  const exportOrder = typeof rawOptions.exportOrder === "boolean" ? rawOptions.exportOrder : DEFAULT_SORT_OPTIONS.exportOrder;
-  const packageJsonOrder = typeof rawOptions.packageJsonOrder === "boolean" ? rawOptions.packageJsonOrder : DEFAULT_SORT_OPTIONS.packageJsonOrder;
   return {
-    importOrder,
-    importOrderGroups,
-    importOrderSeparation,
+    importOrder: resolveBoolean(rawOptions, "importOrder"),
+    importOrderGroups: groups.length > 0 ? groups : [...DEFAULT_SORT_OPTIONS.importOrderGroups],
+    importOrderSeparation: resolveBoolean(rawOptions, "importOrderSeparation"),
     importOrderTypeImports,
-    importOrderMergeDuplicates,
-    exportOrder,
-    packageJsonOrder,
+    importOrderMergeDuplicates: resolveBoolean(rawOptions, "importOrderMergeDuplicates"),
+    exportOrder: resolveBoolean(rawOptions, "exportOrder"),
+    packageJsonOrder: resolveBoolean(rawOptions, "packageJsonOrder"),
     packageJsonOrderExcludeKeys: excludeKeys
   };
 }
@@ -123,26 +121,26 @@ var options = {
 
 // src/utils.ts
 function splitTopLevel(input, separator) {
-  const out = [];
-  let buf = "";
+  const segments = [];
+  let current = "";
   let depth = 0;
-  for (const ch of input) {
-    if (ch === "{" || ch === "(" || ch === "[") {
+  for (const char of input) {
+    if (char === "{" || char === "(" || char === "[") {
       depth++;
-    } else if (ch === "}" || ch === ")" || ch === "]") {
+    } else if (char === "}" || char === ")" || char === "]") {
       depth--;
     }
-    if (ch === separator && depth === 0) {
-      out.push(buf);
-      buf = "";
+    if (char === separator && depth === 0) {
+      segments.push(current);
+      current = "";
       continue;
     }
-    buf += ch;
+    current += char;
   }
-  if (buf.length > 0) {
-    out.push(buf);
+  if (current.length > 0) {
+    segments.push(current);
   }
-  return out.map((s) => s.trim()).filter((s) => s.length > 0);
+  return segments.map((segment) => segment.trim()).filter((segment) => segment.length > 0);
 }
 
 // src/sort-exports.ts
@@ -159,8 +157,8 @@ function sortExports(text, rawOptions) {
     const sorted = [...members].sort((a, b) => stripTypePrefix(a).localeCompare(stripTypePrefix(b), "en", {
       sensitivity: "base"
     }));
-    const same = sorted.every((m, i) => m === members[i]);
-    if (same) {
+    const unchanged = sorted.every((member, index) => member === members[index]);
+    if (unchanged) {
       return match;
     }
     const prefix = typeKeyword ? `export${typeKeyword}` : "export";
@@ -175,7 +173,7 @@ function stripTypePrefix(member) {
 import { builtinModules } from "node:module";
 var NODE_BUILTINS = new Set(builtinModules);
 function detectGroup(source) {
-  if (source.startsWith("node:") || source.startsWith("bun:") || source.startsWith("deno:")) {
+  if (source === "bun" || source.startsWith("bun:") || source.startsWith("node:")) {
     return "builtin";
   }
   const slashIndex = source.indexOf("/");
@@ -197,20 +195,19 @@ function detectGroup(source) {
   }
   return "external";
 }
+var TYPE_PREFIX = /^type\s+(.+)$/s;
 function splitMembers(inner) {
   return splitTopLevel(inner, ",").map((part) => {
-    const isType = /^type\s+/.test(part);
-    const name = isType ? part.replace(/^type\s+/, "").trim() : part;
-    return { name, isType };
+    const match = TYPE_PREFIX.exec(part);
+    return match ? { name: match[1].trim(), isType: true } : { name: part, isType: false };
   });
 }
-function parseImport(stmt) {
-  const trimmed = stmt.raw.trim();
-  const leadingComments = stmt.leadingComments;
+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 {
-      raw: trimmed,
       source: sideEffect[2] ?? "",
       typeClause: false,
       sideEffect: true,
@@ -221,14 +218,14 @@ function parseImport(stmt) {
       leadingComments
     };
   }
-  const m = /^import\s+(type\s+)?([\s\S]+?)\s*from\s*(['"])([^'"]+)\3(?:\s+with\s*(\{[^}]*\}))?\s*;?$/.exec(trimmed);
-  if (!m) {
+  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(m[1]);
-  const clause = (m[2] ?? "").trim();
-  const source = m[4] ?? "";
-  const attributes = m[5] ?? 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;
@@ -243,7 +240,6 @@ function parseImport(stmt) {
     }
   }
   return {
-    raw: trimmed,
     source,
     typeClause,
     sideEffect: false,
@@ -255,7 +251,7 @@ function parseImport(stmt) {
   };
 }
 function extractImportBlock(text) {
-  const firstRe = /(?:^|\n)(?:[ \t]*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)[ \t]*\n)*[ \t]*import\b/;
+  const firstRe = /(?:^|\n)(?:[ \t]*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)[ \t]*\n)*[ \t]*import\b(?![.(])/;
   const first = firstRe.exec(text);
   if (!first) {
     return null;
@@ -263,17 +259,21 @@ function extractImportBlock(text) {
   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) {
-    const chunkMatch = /^(?:[ \t]*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)?[ \t]*\n)*/.exec(text.slice(cursor));
-    const chunk = chunkMatch ? chunkMatch[0] : "";
-    const afterSkip = cursor + chunk.length;
-    const importMatch = /^[ \t]*(import\b[\s\S]*?(?:from\s*(['"])[^'"]+\2|(['"])[^'"]+\3)(?:\s+with\s*\{[^}]*\})?\s*;?)/.exec(text.slice(afterSkip));
+    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 = chunk.endsWith(`
-`) ? chunk.slice(0, -1) : chunk;
+    const normalised = skipped.endsWith(`
+`) ? skipped.slice(0, -1) : skipped;
     const commentLines = normalised.length > 0 ? normalised.split(`
 `) : [];
     const leadingLines = [];
@@ -305,28 +305,23 @@ function extractImportBlock(text) {
 function renderMembers(members) {
   return members.map((member) => member.isType ? `type ${member.name}` : member.name).join(", ");
 }
+function renderSpecifiers(importDecl) {
+  const parts = [];
+  if (importDecl.defaultSpec) {
+    parts.push(importDecl.defaultSpec);
+  }
+  if (importDecl.namespaceSpec) {
+    parts.push(importDecl.namespaceSpec);
+  }
+  if (importDecl.members) {
+    parts.push(`{ ${renderMembers(importDecl.members)} }`);
+  }
+  return parts.join(", ");
+}
 function renderImport(importDecl) {
   const suffix = importDecl.attributes ? ` with ${importDecl.attributes}` : "";
-  const body = (() => {
-    if (importDecl.sideEffect) {
-      return `import '${importDecl.source}'${suffix};`;
-    }
-    if (importDecl.typeClause) {
-      const inner = importDecl.members ? `{ ${renderMembers(importDecl.members)} }` : "";
-      return `import type ${inner} from '${importDecl.source}'${suffix};`;
-    }
-    const leftParts = [];
-    if (importDecl.defaultSpec) {
-      leftParts.push(importDecl.defaultSpec);
-    }
-    if (importDecl.namespaceSpec) {
-      leftParts.push(importDecl.namespaceSpec);
-    }
-    if (importDecl.members) {
-      leftParts.push(`{ ${renderMembers(importDecl.members)} }`);
-    }
-    return `import ${leftParts.join(", ")} from '${importDecl.source}'${suffix};`;
-  })();
+  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;
 }
 function sortMembersAlpha(members) {
@@ -343,30 +338,30 @@ function normalizeTypeClause(importDecl) {
   };
 }
 function mergeImportsFromSameSource(imports) {
-  const indexBySource = new Map;
+  const indexByKey = new Map;
   const result = [];
-  for (const raw of imports) {
-    const importDecl = normalizeTypeClause(raw);
-    if (importDecl.sideEffect) {
+  for (const rawImport of imports) {
+    const importDecl = normalizeTypeClause(rawImport);
+    if (importDecl.sideEffect || importDecl.typeClause) {
       result.push(importDecl);
       continue;
     }
-    const existingIndex = indexBySource.get(importDecl.source);
+    const mergeKey = `${importDecl.source}\x00${importDecl.attributes ?? ""}`;
+    const existingIndex = indexByKey.get(mergeKey);
     if (existingIndex === undefined) {
-      indexBySource.set(importDecl.source, result.length);
+      indexByKey.set(mergeKey, result.length);
       result.push(importDecl);
       continue;
     }
     const existing = result[existingIndex];
     result[existingIndex] = {
-      raw: "",
       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 ?? importDecl.attributes,
+      attributes: existing.attributes,
       leadingComments: existing.leadingComments
     };
   }
@@ -385,7 +380,6 @@ function applyTypeImports(importDecl, style) {
     const out = [];
     if (typeMembers2.length > 0) {
       out.push({
-        raw: "",
         source: importDecl.source,
         typeClause: true,
         sideEffect: false,
@@ -406,7 +400,7 @@ function applyTypeImports(importDecl, style) {
     }
     return out.length > 0 ? out : [importDecl];
   }
-  const base = importDecl.typeClause ? {
+  const inlineBase = importDecl.typeClause ? {
     ...importDecl,
     typeClause: false,
     members: importDecl.members.map((member) => ({
@@ -415,14 +409,14 @@ function applyTypeImports(importDecl, style) {
     }))
   } : { ...importDecl, members: importDecl.members };
   if (style === "mixed") {
-    return [{ ...base, members: sortMembersAlpha(base.members) }];
+    return [{ ...inlineBase, members: sortMembersAlpha(inlineBase.members) }];
   }
-  const typeMembers = base.members.filter((m) => m.isType);
-  const valueMembers = base.members.filter((m) => !m.isType);
+  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 [{ ...base, members: ordered }];
+  return [{ ...inlineBase, members: ordered }];
 }
 function sortSegment(imports, options2, groupIndex, fallback) {
   if (imports.length === 0) {
@@ -432,7 +426,7 @@ function sortSegment(imports, options2, groupIndex, fallback) {
   const deduped = options2.importOrderMergeDuplicates ? mergeImportsFromSameSource(imports) : imports;
   const rewritten = deduped.flatMap((importDecl) => applyTypeImports(importDecl, style));
   const decorated = rewritten.map((importDecl, index) => ({
-    stmt: importDecl,
+    importDecl,
     group: detectGroup(importDecl.source),
     originalIndex: index
   }));
@@ -442,24 +436,24 @@ function sortSegment(imports, options2, groupIndex, fallback) {
     if (groupOrderA !== groupOrderB) {
       return groupOrderA - groupOrderB;
     }
-    const sourceA = a.stmt.source.toLowerCase();
-    const sourceB = b.stmt.source.toLowerCase();
+    const sourceA = a.importDecl.source.toLowerCase();
+    const sourceB = b.importDecl.source.toLowerCase();
     if (sourceA !== sourceB) {
       return sourceA < sourceB ? -1 : 1;
     }
-    if (a.stmt.typeClause !== b.stmt.typeClause) {
-      return a.stmt.typeClause ? -1 : 1;
+    if (a.importDecl.typeClause !== b.importDecl.typeClause) {
+      return a.importDecl.typeClause ? -1 : 1;
     }
     return a.originalIndex - b.originalIndex;
   });
   const lines = [];
-  let prevGroup = null;
+  let previousGroup = null;
   for (const item of decorated) {
-    if (options2.importOrderSeparation && prevGroup !== null && item.group !== prevGroup) {
+    if (options2.importOrderSeparation && previousGroup !== null && item.group !== previousGroup) {
       lines.push("");
     }
-    lines.push(renderImport(item.stmt));
-    prevGroup = item.group;
+    lines.push(renderImport(item.importDecl));
+    previousGroup = item.group;
   }
   return lines;
 }
@@ -472,7 +466,7 @@ function sortImports(text, rawOptions) {
   if (!block || block.statements.length === 0) {
     return text;
   }
-  const parsed = block.statements.map((rawStmt) => parseImport(rawStmt)).filter((decl) => decl !== null);
+  const parsed = block.statements.map((rawStatement) => parseImport(rawStatement)).filter((importDecl) => importDecl !== null);
   if (parsed.length === 0) {
     return text;
   }
@@ -485,31 +479,30 @@ function sortImports(text, rawOptions) {
   let currentSegment = [];
   for (const importDecl of parsed) {
     if (importDecl.sideEffect) {
-      chunks.push({ kind: "segment", imports: currentSegment });
-      chunks.push({ kind: "side-effect", stmt: importDecl });
-      currentSegment = [];
+      if (currentSegment.length > 0) {
+        chunks.push({ kind: "segment", imports: currentSegment });
+        currentSegment = [];
+      }
+      chunks.push({ kind: "side-effect", importDecl });
     } else {
       currentSegment.push(importDecl);
     }
   }
-  chunks.push({ kind: "segment", imports: currentSegment });
+  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("");
+    }
     if (chunk.kind === "segment") {
-      if (chunk.imports.length === 0) {
-        continue;
-      }
-      const segmentLines = sortSegment(chunk.imports, options2, groupIndex, fallback);
-      if (allLines.length > 0 && options2.importOrderSeparation) {
-        allLines.push("");
-      }
-      allLines.push(...segmentLines);
+      allLines.push(...sortSegment(chunk.imports, options2, groupIndex, fallback));
     } else {
-      if (allLines.length > 0 && options2.importOrderSeparation) {
-        allLines.push("");
-      }
-      allLines.push(renderImport(chunk.stmt));
+      allLines.push(renderImport(chunk.importDecl));
     }
+    previousKind = chunk.kind;
   }
   const replacement = allLines.join(`
 `);
@@ -666,15 +659,15 @@ function sortObjectKeysByOrder(record, order) {
       rest.push(entry);
     }
   }
-  known.sort(([left], [right]) => (orderIndex.get(left) ?? 0) - (orderIndex.get(right) ?? 0));
-  rest.sort(([left], [right]) => left.localeCompare(right, "en"));
+  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]);
 }
 function sortObjectKeysAlpha(value) {
   if (!isPlainObject(value)) {
     return value;
   }
-  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right, "en")));
+  return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b, "en")));
 }
 function sortStringArrayAlpha(value) {
   return [...value].sort((a, b) => a.localeCompare(b, "en"));
@@ -704,7 +697,7 @@ function sortPackageJson(text, rawOptions) {
   if (!isPlainObject(parsed)) {
     return text;
   }
-  let result = { ...parsed };
+  let result = parsed;
   for (const field of DEPENDENCY_FIELDS) {
     const dependencyMap = result[field];
     if (dependencyMap !== undefined && !exclude.has(field)) {
@@ -735,8 +728,8 @@ function wrap(parser, ...transforms) {
     ...parser,
     async preprocess(text, parserOptions) {
       let source = parser.preprocess ? await parser.preprocess(text, parserOptions) : text;
-      for (const fn of transforms) {
-        source = fn(source, parserOptions);
+      for (const transform of transforms) {
+        source = transform(source, parserOptions);
       }
       return source;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-sort",
-  "version": "0.0.3",
+  "version": "0.1.1",
   "description": "An all-in-one Prettier plugin to sort imports, package.json keys, and more.",
   "keywords": [
     "imports",