prettier-plugin-sort 0.0.2 → 0.1.0

package/README.md

@@ -182,6 +182,35 @@ import { useEffect, useState } from 'react';
 
 Set `importOrderMergeDuplicates` to `false` if you want to keep the original separate statements. Side-effect imports (`import 'mod';`) are never merged because their order has runtime semantics.
 
+#### Side-effect imports
+
+The order of side-effect imports (`import 'mod'`) often carries runtime meaning, such as CSS cascade order or polyfills that must load before a framework. The plugin never moves other imports across a side-effect import — imports on each side are sorted independently, and the side-effect import itself stays in place.
+
+Before:
+
+<!-- prettier-ignore -->
+```typescript
+import Button from './Button';
+import App from './App';
+import 'normalize.css';
+import theme from './theme';
+import Icon from './Icon';
+```
+
+After:
+
+```typescript
+import App from './App';
+import Button from './Button';
+
+import 'normalize.css';
+
+import Icon from './Icon';
+import theme from './theme';
+```
+
+Imports on each side are sorted independently. The side-effect import itself stays in place.
+
 Sorting rules:
 
 - Imports are classified into groups. Within each group they are sorted alphabetically
@@ -189,7 +218,7 @@ Sorting rules:
 - A blank line is inserted between groups by default. Disable with `importOrderSeparation`
 - `type` imports are split into their own statement by default. Use `importOrderTypeImports` to inline them instead
 - Multiple imports from the same source are merged into one by default. Disable with `importOrderMergeDuplicates`
-- Side-effect imports (`import 'mod'`) are never merged or moved across groups
+- Side-effect imports (`import 'mod'`) carry semantic order and are never moved. Imports on either side are sorted independently
 
 ### Exports
 

package/README.zh.md

@@ -185,6 +185,35 @@ import { useEffect, useState } from 'react';
 
 如果你希望保留原本分离的两条语句，把 `importOrderMergeDuplicates` 设为 `false` 即可。副作用导入（`import 'mod';`）因为顺序有语义，永远不会被合并。
 
+#### 副作用导入
+
+副作用导入（`import 'mod'`）的顺序通常有运行时语义，例如 CSS 的层叠顺序、polyfill 必须在框架之前加载等。插件不会跨越副作用导入移动其他 import 语句：
+
+排序前：
+
+<!-- prettier-ignore -->
+```typescript
+import Button from './Button';
+import App from './App';
+import 'normalize.css';
+import theme from './theme';
+import Icon from './Icon';
+```
+
+排序后：
+
+```typescript
+import App from './App';
+import Button from './Button';
+
+import 'normalize.css';
+
+import Icon from './Icon';
+import theme from './theme';
+```
+
+副作用导入两侧的 import 各自独立排序，副作用导入本身保持原位不动。
+
 排序规则：
 
 - import 按分组分类，分组内按字母序排列
@@ -192,7 +221,7 @@ import { useEffect, useState } from 'react';
 - 分组之间默认插入空行，可通过 `importOrderSeparation` 关闭
 - `type` import 默认拆成独立语句，可通过 `importOrderTypeImports` 调整为内联
 - 同一来源的多条 import 默认合并为一条，可通过 `importOrderMergeDuplicates` 关闭
-- 副作用导入（`import 'mod'`）顺序有语义，永远不参与合并或跨位移动
+- 副作用导入（`import 'mod'`）其顺序有语义，不会被移动，两侧的 import 各自独立排序
 
 ### export
 

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
   };
 }
@@ -121,6 +119,30 @@ var options = {
   }
 };
 
+// src/utils.ts
+function splitTopLevel(input, separator) {
+  const segments = [];
+  let current = "";
+  let depth = 0;
+  for (const char of input) {
+    if (char === "{" || char === "(" || char === "[") {
+      depth++;
+    } else if (char === "}" || char === ")" || char === "]") {
+      depth--;
+    }
+    if (char === separator && depth === 0) {
+      segments.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.length > 0) {
+    segments.push(current);
+  }
+  return segments.map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+}
+
 // src/sort-exports.ts
 function sortExports(text, rawOptions) {
   const options2 = resolveSortOptions(rawOptions);
@@ -135,36 +157,14 @@ 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";
     return `${prefix} { ${sorted.join(", ")} }`;
   });
 }
-function splitTopLevel(input, separator) {
-  const out = [];
-  let buf = "";
-  let depth = 0;
-  for (const ch of input) {
-    if (ch === "{" || ch === "(" || ch === "[") {
-      depth++;
-    } else if (ch === "}" || ch === ")" || ch === "]") {
-      depth--;
-    }
-    if (ch === separator && depth === 0) {
-      out.push(buf);
-      buf = "";
-      continue;
-    }
-    buf += ch;
-  }
-  if (buf.length > 0) {
-    out.push(buf);
-  }
-  return out.map((s) => s.trim()).filter((s) => s.length > 0);
-}
 function stripTypePrefix(member) {
   return member.replace(/^type\s+/, "");
 }
@@ -195,62 +195,41 @@ function detectGroup(source) {
   }
   return "external";
 }
-function splitTopLevel2(input, separator) {
-  const out = [];
-  let buf = "";
-  let depth = 0;
-  for (const ch of input) {
-    if (ch === "{" || ch === "(" || ch === "[") {
-      depth++;
-    } else if (ch === "}" || ch === ")" || ch === "]") {
-      depth--;
-    }
-    if (ch === separator && depth === 0) {
-      out.push(buf);
-      buf = "";
-      continue;
-    }
-    buf += ch;
-  }
-  if (buf.length > 0) {
-    out.push(buf);
-  }
-  return out.map((s) => s.trim()).filter((s) => s.length > 0);
-}
+var TYPE_PREFIX = /^type\s+(.+)$/s;
 function splitMembers(inner) {
-  return splitTopLevel2(inner, ",").map((part) => {
-    const isType = /^type\s+/.test(part);
-    const name = isType ? part.replace(/^type\s+/, "").trim() : part;
-    return { name, isType };
+  return splitTopLevel(inner, ",").map((part) => {
+    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;
-  const sideEffect = /^import\s*(['"])([^'"]+)\1\s*;?$/.exec(trimmed);
+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,
       defaultSpec: null,
       namespaceSpec: null,
       members: null,
+      attributes: sideEffect[3] ?? null,
       leadingComments
     };
   }
-  const m = /^import\s+(type\s+)?([\s\S]+?)\s*from\s*(['"])([^'"]+)\3\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 typeClause = Boolean(match[1]);
+  const clause = (match[2] ?? "").trim();
+  const source = match[4] ?? "";
+  const attributes = match[5] ?? null;
   let defaultSpec = null;
   let namespaceSpec = null;
   let members = null;
-  for (const part of splitTopLevel2(clause, ",")) {
+  for (const part of splitTopLevel(clause, ",")) {
     if (part.startsWith("{")) {
       const inner = part.slice(1, part.lastIndexOf("}")).trim();
       members = inner ? splitMembers(inner) : [];
@@ -261,13 +240,13 @@ function parseImport(stmt) {
     }
   }
   return {
-    raw: trimmed,
     source,
     typeClause,
     sideEffect: false,
     defaultSpec,
     namespaceSpec,
     members,
+    attributes,
     leadingComments
   };
 }
@@ -280,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*;?)/.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 = [];
@@ -322,27 +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 body = (() => {
-    if (importDecl.sideEffect) {
-      return `import '${importDecl.source}';`;
-    }
-    if (importDecl.typeClause) {
-      const inner = importDecl.members ? `{ ${renderMembers(importDecl.members)} }` : "";
-      return `import type ${inner} from '${importDecl.source}';`;
-    }
-    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}';`;
-  })();
+  const suffix = importDecl.attributes ? ` with ${importDecl.attributes}` : "";
+  const source = `'${importDecl.source}'`;
+  const body = importDecl.sideEffect ? `import ${source}${suffix};` : importDecl.typeClause ? `import type ${renderSpecifiers(importDecl)} from ${source}${suffix};` : `import ${renderSpecifiers(importDecl)} from ${source}${suffix};`;
   return importDecl.leadingComments + body;
 }
 function sortMembersAlpha(members) {
@@ -361,9 +340,9 @@ function normalizeTypeClause(importDecl) {
 function mergeImportsFromSameSource(imports) {
   const indexBySource = 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;
     }
@@ -375,13 +354,13 @@ function mergeImportsFromSameSource(imports) {
     }
     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,
       leadingComments: existing.leadingComments
     };
   }
@@ -400,13 +379,13 @@ function applyTypeImports(importDecl, style) {
     const out = [];
     if (typeMembers2.length > 0) {
       out.push({
-        raw: "",
         source: importDecl.source,
         typeClause: true,
         sideEffect: false,
         defaultSpec: null,
         namespaceSpec: null,
         members: sortMembersAlpha(typeMembers2.map((member) => ({ ...member, isType: false }))),
+        attributes: importDecl.attributes,
         leadingComments: importDecl.leadingComments
       });
     }
@@ -420,7 +399,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) => ({
@@ -429,38 +408,24 @@ 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 sortImports(text, rawOptions) {
-  const options2 = resolveSortOptions(rawOptions);
-  if (!options2.importOrder) {
-    return text;
-  }
-  const block = extractImportBlock(text);
-  if (!block || block.statements.length === 0) {
-    return text;
-  }
-  const parsed = block.statements.map((rawStmt) => parseImport(rawStmt)).filter((decl) => decl !== null);
-  if (parsed.length === 0) {
-    return text;
+function sortSegment(imports, options2, groupIndex, fallback) {
+  if (imports.length === 0) {
+    return [];
   }
   const style = options2.importOrderTypeImports;
-  const deduped = options2.importOrderMergeDuplicates ? mergeImportsFromSameSource(parsed) : parsed;
+  const deduped = options2.importOrderMergeDuplicates ? mergeImportsFromSameSource(imports) : imports;
   const rewritten = deduped.flatMap((importDecl) => applyTypeImports(importDecl, style));
-  const groupIndex = new Map(options2.importOrderGroups.map((group, index) => [
-    group,
-    index
-  ]));
-  const fallback = options2.importOrderGroups.length;
   const decorated = rewritten.map((importDecl, index) => ({
-    stmt: importDecl,
+    importDecl,
     group: detectGroup(importDecl.source),
     originalIndex: index
   }));
@@ -470,26 +435,75 @@ function sortImports(text, rawOptions) {
     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;
+}
+function sortImports(text, rawOptions) {
+  const options2 = resolveSortOptions(rawOptions);
+  if (!options2.importOrder) {
+    return text;
+  }
+  const block = extractImportBlock(text);
+  if (!block || block.statements.length === 0) {
+    return text;
+  }
+  const parsed = block.statements.map((rawStatement) => parseImport(rawStatement)).filter((importDecl) => importDecl !== null);
+  if (parsed.length === 0) {
+    return text;
+  }
+  const groupIndex = new Map(options2.importOrderGroups.map((group, index) => [
+    group,
+    index
+  ]));
+  const fallback = options2.importOrderGroups.length;
+  const chunks = [];
+  let currentSegment = [];
+  for (const importDecl of parsed) {
+    if (importDecl.sideEffect) {
+      if (currentSegment.length > 0) {
+        chunks.push({ kind: "segment", imports: currentSegment });
+        currentSegment = [];
+      }
+      chunks.push({ kind: "side-effect", importDecl });
+    } else {
+      currentSegment.push(importDecl);
+    }
+  }
+  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") {
+      allLines.push(...sortSegment(chunk.imports, options2, groupIndex, fallback));
+    } else {
+      allLines.push(renderImport(chunk.importDecl));
+    }
+    previousKind = chunk.kind;
   }
-  const replacement = lines.join(`
+  const replacement = allLines.join(`
 `);
   const trailing = text.slice(block.end);
   const suffix = trailing.trim() ? `
@@ -644,15 +658,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"));
@@ -682,7 +696,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)) {
@@ -713,8 +727,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.2",
+  "version": "0.1.0",
   "description": "An all-in-one Prettier plugin to sort imports, package.json keys, and more.",
   "keywords": [
     "imports",