prettier-plugin-sort 0.0.0 → 0.0.1

package/dist/index.js

@@ -0,0 +1,732 @@
+// src/index.ts
+import { parsers as babelParsers } from "prettier/plugins/babel";
+import { parsers as typescriptParsers } from "prettier/plugins/typescript";
+
+// src/options.ts
+var DEFAULT_SORT_OPTIONS = {
+  importOrder: true,
+  importOrderGroups: ["builtin", "external", "parent", "sibling", "index"],
+  importOrderSeparation: true,
+  importOrderTypeImports: "separate",
+  importOrderMergeDuplicates: true,
+  exportOrder: true,
+  packageJsonOrder: true,
+  packageJsonOrderExcludeKeys: []
+};
+var VALID_IMPORT_GROUPS = new Set([
+  "builtin",
+  "external",
+  "internal",
+  "parent",
+  "sibling",
+  "index"
+]);
+var VALID_TYPE_STYLES = new Set([
+  "separate",
+  "inline-first",
+  "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);
+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 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,
+    importOrderTypeImports,
+    importOrderMergeDuplicates,
+    exportOrder,
+    packageJsonOrder,
+    packageJsonOrderExcludeKeys: excludeKeys
+  };
+}
+var options = {
+  importOrder: {
+    type: "boolean",
+    default: DEFAULT_SORT_OPTIONS.importOrder,
+    category: "SortImports",
+    description: "Sort `import` declarations in JS/TS files."
+  },
+  importOrderGroups: {
+    type: "string",
+    array: true,
+    default: [{ value: [...DEFAULT_SORT_OPTIONS.importOrderGroups] }],
+    category: "SortImports",
+    description: 'Ordered list of import groups. Valid values: "builtin", "external", "internal", "parent", "sibling", "index". Each group is sorted alphabetically; unknown groups are ignored.'
+  },
+  importOrderSeparation: {
+    type: "boolean",
+    default: DEFAULT_SORT_OPTIONS.importOrderSeparation,
+    category: "SortImports",
+    description: "Insert a blank line between adjacent import groups."
+  },
+  importOrderTypeImports: {
+    type: "choice",
+    default: DEFAULT_SORT_OPTIONS.importOrderTypeImports,
+    category: "SortImports",
+    description: "How to place `type` imports relative to value imports.",
+    choices: [
+      {
+        value: "separate",
+        description: "Keep `import type { … }` as its own statement."
+      },
+      {
+        value: "inline-first",
+        description: "Inline inside braces, type specifiers before value specifiers."
+      },
+      {
+        value: "inline-last",
+        description: "Inline inside braces, type specifiers after value specifiers."
+      },
+      {
+        value: "mixed",
+        description: "Inline inside braces, alphabetical without distinguishing type from value."
+      }
+    ]
+  },
+  importOrderMergeDuplicates: {
+    type: "boolean",
+    default: DEFAULT_SORT_OPTIONS.importOrderMergeDuplicates,
+    category: "SortImports",
+    description: "Merge multiple `import` statements from the same source into one. Side-effect imports are never merged."
+  },
+  exportOrder: {
+    type: "boolean",
+    default: DEFAULT_SORT_OPTIONS.exportOrder,
+    category: "SortExports",
+    description: "Sort named specifiers inside `export { … }` alphabetically. Does not reorder export statements."
+  },
+  packageJsonOrder: {
+    type: "boolean",
+    default: DEFAULT_SORT_OPTIONS.packageJsonOrder,
+    category: "SortPackageJson",
+    description: "Sort top-level keys and string-array values inside `package.json`. Dependency maps are always alphabetised regardless of this option."
+  },
+  packageJsonOrderExcludeKeys: {
+    type: "string",
+    array: true,
+    default: [{ value: [...DEFAULT_SORT_OPTIONS.packageJsonOrderExcludeKeys] }],
+    category: "SortPackageJson",
+    description: "Top-level `package.json` keys to leave untouched (no key reordering or array sorting). Takes priority over `packageJsonOrder`."
+  }
+};
+
+// src/sort-exports.ts
+function sortExports(text, rawOptions) {
+  const options2 = resolveSortOptions(rawOptions);
+  if (!options2.exportOrder) {
+    return text;
+  }
+  return text.replace(/export(\s+type)?\s*\{([^}]*)\}/g, (match, typeKeyword, inner) => {
+    const members = splitTopLevel(inner, ",");
+    if (members.length <= 1) {
+      return match;
+    }
+    const sorted = [...members].sort((a, b) => stripTypePrefix(a).localeCompare(stripTypePrefix(b), "en", {
+      sensitivity: "base"
+    }));
+    const same = sorted.every((m, i) => m === members[i]);
+    if (same) {
+      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+/, "");
+}
+
+// src/sort-imports.ts
+import { builtinModules } from "node:module";
+var NODE_BUILTINS = new Set(builtinModules);
+function detectGroup(source) {
+  if (source.startsWith("node:") || source.startsWith("bun:") || source.startsWith("deno:")) {
+    return "builtin";
+  }
+  const slashIndex = source.indexOf("/");
+  const head = slashIndex === -1 ? source : source.slice(0, slashIndex);
+  if (head && NODE_BUILTINS.has(head)) {
+    return "builtin";
+  }
+  if (source === "." || source === "./" || /^\.\/index(\.[a-z]+)?$/.test(source)) {
+    return "index";
+  }
+  if (source.startsWith("../") || source === "..") {
+    return "parent";
+  }
+  if (source.startsWith("./")) {
+    return "sibling";
+  }
+  if (source.startsWith("/") || source.startsWith("~") || source.startsWith("@/")) {
+    return "internal";
+  }
+  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);
+}
+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 };
+  });
+}
+function parseImport(stmt) {
+  const trimmed = stmt.raw.trim();
+  const leadingComments = stmt.leadingComments;
+  const sideEffect = /^import\s*(['"])([^'"]+)\1\s*;?$/.exec(trimmed);
+  if (sideEffect) {
+    return {
+      raw: trimmed,
+      source: sideEffect[2] ?? "",
+      typeClause: false,
+      sideEffect: true,
+      defaultSpec: null,
+      namespaceSpec: null,
+      members: null,
+      leadingComments
+    };
+  }
+  const m = /^import\s+(type\s+)?([\s\S]+?)\s+from\s*(['"])([^'"]+)\3\s*;?$/.exec(trimmed);
+  if (!m) {
+    return null;
+  }
+  const typeClause = Boolean(m[1]);
+  const clause = (m[2] ?? "").trim();
+  const source = m[4] ?? "";
+  let defaultSpec = null;
+  let namespaceSpec = null;
+  let members = null;
+  for (const part of splitTopLevel2(clause, ",")) {
+    if (part.startsWith("{")) {
+      const inner = part.slice(1, part.lastIndexOf("}")).trim();
+      members = inner ? splitMembers(inner) : [];
+    } else if (part.startsWith("*")) {
+      namespaceSpec = part;
+    } else {
+      defaultSpec = part;
+    }
+  }
+  return {
+    raw: trimmed,
+    source,
+    typeClause,
+    sideEffect: false,
+    defaultSpec,
+    namespaceSpec,
+    members,
+    leadingComments
+  };
+}
+function extractImportBlock(text) {
+  const firstRe = /(?:^|\n)(?:[ \t]*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)[ \t]*\n)*[ \t]*import\b/;
+  const first = firstRe.exec(text);
+  if (!first) {
+    return null;
+  }
+  const start = first.index + (text[first.index] === `
+` ? 1 : 0);
+  const statements = [];
+  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));
+    if (!importMatch) {
+      break;
+    }
+    const normalised = chunk.endsWith(`
+`) ? chunk.slice(0, -1) : chunk;
+    const commentLines = normalised.length > 0 ? normalised.split(`
+`) : [];
+    const leadingLines = [];
+    for (let i = commentLines.length - 1;i >= 0; i--) {
+      const line = commentLines[i];
+      if (line === undefined) {
+        continue;
+      }
+      if (line.trim() === "") {
+        break;
+      }
+      leadingLines.unshift(line);
+    }
+    const leadingComments = leadingLines.length > 0 ? leadingLines.join(`
+`) + `
+` : "";
+    const statement = importMatch[1];
+    if (!statement) {
+      break;
+    }
+    statements.push({ raw: statement.trim(), leadingComments });
+    cursor = afterSkip + importMatch[0].length;
+  }
+  if (statements.length === 0) {
+    return null;
+  }
+  return { start, end: cursor, statements };
+}
+function renderMembers(members) {
+  return members.map((member) => member.isType ? `type ${member.name}` : member.name).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}';`;
+  })();
+  return importDecl.leadingComments + body;
+}
+function sortMembersAlpha(members) {
+  return [...members].sort((a, b) => a.name.localeCompare(b.name, "en", { sensitivity: "base" }));
+}
+function normalizeTypeClause(importDecl) {
+  if (!importDecl.typeClause || importDecl.members === null) {
+    return importDecl;
+  }
+  return {
+    ...importDecl,
+    typeClause: false,
+    members: importDecl.members.map((member) => ({ ...member, isType: true }))
+  };
+}
+function mergeImportsFromSameSource(imports) {
+  const indexBySource = new Map;
+  const result = [];
+  for (const raw of imports) {
+    const importDecl = normalizeTypeClause(raw);
+    if (importDecl.sideEffect) {
+      result.push(importDecl);
+      continue;
+    }
+    const existingIndex = indexBySource.get(importDecl.source);
+    if (existingIndex === undefined) {
+      indexBySource.set(importDecl.source, 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 ?? []],
+      leadingComments: existing.leadingComments
+    };
+  }
+  return result;
+}
+function applyTypeImports(importDecl, style) {
+  if (importDecl.sideEffect || !importDecl.members) {
+    return [importDecl];
+  }
+  if (style === "separate") {
+    if (importDecl.typeClause) {
+      return [importDecl];
+    }
+    const typeMembers2 = importDecl.members.filter((member) => member.isType);
+    const valueMembers2 = importDecl.members.filter((member) => !member.isType);
+    const out = [];
+    if (typeMembers2.length > 0) {
+      out.push({
+        raw: "",
+        source: importDecl.source,
+        typeClause: true,
+        sideEffect: false,
+        defaultSpec: null,
+        namespaceSpec: null,
+        members: sortMembersAlpha(typeMembers2.map((member) => ({ ...member, isType: false }))),
+        leadingComments: importDecl.leadingComments
+      });
+    }
+    const hasValueBody = valueMembers2.length > 0 || importDecl.defaultSpec !== null || importDecl.namespaceSpec !== null;
+    if (hasValueBody) {
+      out.push({
+        ...importDecl,
+        members: valueMembers2.length > 0 ? sortMembersAlpha(valueMembers2) : null,
+        leadingComments: typeMembers2.length > 0 ? "" : importDecl.leadingComments
+      });
+    }
+    return out.length > 0 ? out : [importDecl];
+  }
+  const base = importDecl.typeClause ? {
+    ...importDecl,
+    typeClause: false,
+    members: importDecl.members.map((member) => ({
+      ...member,
+      isType: true
+    }))
+  } : { ...importDecl, members: importDecl.members };
+  if (style === "mixed") {
+    return [{ ...base, members: sortMembersAlpha(base.members) }];
+  }
+  const typeMembers = base.members.filter((m) => m.isType);
+  const valueMembers = base.members.filter((m) => !m.isType);
+  const sortedTypes = sortMembersAlpha(typeMembers);
+  const sortedValues = sortMembersAlpha(valueMembers);
+  const ordered = style === "inline-first" ? [...sortedTypes, ...sortedValues] : [...sortedValues, ...sortedTypes];
+  return [{ ...base, 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;
+  }
+  const style = options2.importOrderTypeImports;
+  const deduped = options2.importOrderMergeDuplicates ? mergeImportsFromSameSource(parsed) : parsed;
+  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,
+    group: detectGroup(importDecl.source),
+    originalIndex: index
+  }));
+  decorated.sort((a, b) => {
+    const groupOrderA = groupIndex.get(a.group) ?? fallback;
+    const groupOrderB = groupIndex.get(b.group) ?? fallback;
+    if (groupOrderA !== groupOrderB) {
+      return groupOrderA - groupOrderB;
+    }
+    const sourceA = a.stmt.source.toLowerCase();
+    const sourceB = b.stmt.source.toLowerCase();
+    if (sourceA !== sourceB) {
+      return sourceA < sourceB ? -1 : 1;
+    }
+    if (a.stmt.typeClause !== b.stmt.typeClause) {
+      return a.stmt.typeClause ? -1 : 1;
+    }
+    return a.originalIndex - b.originalIndex;
+  });
+  const lines = [];
+  let prevGroup = null;
+  for (const item of decorated) {
+    if (options2.importOrderSeparation && prevGroup !== null && item.group !== prevGroup) {
+      lines.push("");
+    }
+    lines.push(renderImport(item.stmt));
+    prevGroup = item.group;
+  }
+  const replacement = lines.join(`
+`);
+  return text.slice(0, block.start) + replacement + text.slice(block.end);
+}
+
+// src/sort-package.ts
+import path from "node:path";
+
+// src/order-package.ts
+var PACKAGE_JSON_TOP_LEVEL_ORDER = [
+  "$schema",
+  "name",
+  "displayName",
+  "version",
+  "stableVersion",
+  "private",
+  "description",
+  "categories",
+  "keywords",
+  "homepage",
+  "bugs",
+  "repository",
+  "funding",
+  "license",
+  "qna",
+  "author",
+  "maintainers",
+  "contributors",
+  "publisher",
+  "sideEffects",
+  "type",
+  "imports",
+  "exports",
+  "main",
+  "svelte",
+  "umd:main",
+  "jsdelivr",
+  "unpkg",
+  "module",
+  "source",
+  "jsnext:main",
+  "browser",
+  "react-native",
+  "types",
+  "typesVersions",
+  "typings",
+  "style",
+  "example",
+  "examplestyle",
+  "assets",
+  "bin",
+  "man",
+  "directories",
+  "files",
+  "workspaces",
+  "binary",
+  "scripts",
+  "betterScripts",
+  "l10n",
+  "contributes",
+  "activationEvents",
+  "husky",
+  "simple-git-hooks",
+  "pre-commit",
+  "commitlint",
+  "lint-staged",
+  "nano-staged",
+  "config",
+  "nodemonConfig",
+  "browserify",
+  "babel",
+  "browserslist",
+  "xo",
+  "prettier",
+  "eslintConfig",
+  "eslintIgnore",
+  "npmpkgjsonlint",
+  "npmPackageJsonLintConfig",
+  "npmpackagejsonlint",
+  "release",
+  "remarkConfig",
+  "stylelint",
+  "ava",
+  "jest",
+  "jest-junit",
+  "jest-stare",
+  "mocha",
+  "nyc",
+  "c8",
+  "tap",
+  "oclif",
+  "resolutions",
+  "overrides",
+  "dependencies",
+  "devDependencies",
+  "dependenciesMeta",
+  "peerDependencies",
+  "peerDependenciesMeta",
+  "optionalDependencies",
+  "bundledDependencies",
+  "bundleDependencies",
+  "extensionPack",
+  "extensionDependencies",
+  "flat",
+  "packageManager",
+  "engines",
+  "engineStrict",
+  "devEngines",
+  "volta",
+  "languageName",
+  "os",
+  "cpu",
+  "preferGlobal",
+  "publishConfig",
+  "icon",
+  "badges",
+  "galleryBanner",
+  "preview",
+  "markdown",
+  "pnpm"
+];
+var DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies",
+  "bundledDependencies",
+  "bundleDependencies",
+  "resolutions",
+  "overrides"
+];
+
+// src/sort-package.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function sortObjectKeysByOrder(record, order) {
+  const orderIndex = new Map(order.map((key, index) => [key, index]));
+  const known = [];
+  const rest = [];
+  for (const entry of Object.entries(record)) {
+    const [key] = entry;
+    if (orderIndex.has(key)) {
+      known.push(entry);
+    } else {
+      rest.push(entry);
+    }
+  }
+  known.sort(([left], [right]) => (orderIndex.get(left) ?? 0) - (orderIndex.get(right) ?? 0));
+  rest.sort(([left], [right]) => left.localeCompare(right, "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")));
+}
+function sortStringArrayAlpha(value) {
+  return [...value].sort((a, b) => a.localeCompare(b, "en"));
+}
+function isPackageJson(filepath) {
+  if (!filepath) {
+    return false;
+  }
+  return path.basename(filepath) === "package.json";
+}
+function detectIndent(source) {
+  const match = /\n([ \t]+)\S/.exec(source);
+  return match ? match[1] ?? "  " : "  ";
+}
+function sortPackageJson(text, rawOptions) {
+  if (!isPackageJson(rawOptions.filepath)) {
+    return text;
+  }
+  const options2 = resolveSortOptions(rawOptions);
+  const exclude = new Set(options2.packageJsonOrderExcludeKeys);
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return text;
+  }
+  if (!isPlainObject(parsed)) {
+    return text;
+  }
+  let result = { ...parsed };
+  for (const field of DEPENDENCY_FIELDS) {
+    const dependencyMap = result[field];
+    if (dependencyMap !== undefined && !exclude.has(field)) {
+      result[field] = sortObjectKeysAlpha(dependencyMap);
+    }
+  }
+  if (options2.packageJsonOrder) {
+    result = sortObjectKeysByOrder(result, PACKAGE_JSON_TOP_LEVEL_ORDER);
+    for (const [key, value] of Object.entries(result)) {
+      if (exclude.has(key)) {
+        continue;
+      }
+      if (isStringArray(value)) {
+        result[key] = sortStringArrayAlpha(value);
+      }
+    }
+  }
+  const indent = detectIndent(text);
+  const output = JSON.stringify(result, null, indent);
+  return text.endsWith(`
+`) ? output + `
+` : output;
+}
+
+// src/index.ts
+function wrap(parser, ...transforms) {
+  return {
+    ...parser,
+    async preprocess(text, parserOptions) {
+      let source = parser.preprocess ? await parser.preprocess(text, parserOptions) : text;
+      for (const fn of transforms) {
+        source = fn(source, parserOptions);
+      }
+      return source;
+    }
+  };
+}
+var plugin = {
+  options,
+  parsers: {
+    babel: wrap(babelParsers.babel, sortImports, sortExports),
+    "babel-ts": wrap(babelParsers["babel-ts"], sortImports, sortExports),
+    typescript: wrap(typescriptParsers.typescript, sortImports, sortExports),
+    "json-stringify": wrap(babelParsers["json-stringify"], sortPackageJson)
+  }
+};
+var src_default = plugin;
+export {
+  options,
+  src_default as default
+};