@tai-kun/vp-lint-plugins 0.0.0 → 0.0.1

package/dist/src/rules/member-ordering.js

@@ -0,0 +1,66 @@
+import { defineRule } from "vite-plus/lint/plugins";
+const MEMBER_GROUP_ORDER = {
+    constructor: 3,
+    "static-block": 1,
+    "static-field": 0,
+    "static-method": 4,
+    "instance-field": 2,
+    "instance-method": 5,
+};
+function getMemberGroup(member) {
+    if (member.type === "StaticBlock") {
+        return "static-block";
+    }
+    if (member.type === "TSIndexSignature") {
+        return null;
+    }
+    if (member.type === "PropertyDefinition" ||
+        member.type === "TSAbstractPropertyDefinition" ||
+        member.type === "AccessorProperty" ||
+        member.type === "TSAbstractAccessorProperty") {
+        return member.static ? "static-field" : "instance-field";
+    }
+    if (member.type === "MethodDefinition" || member.type === "TSAbstractMethodDefinition") {
+        if (member.kind === "constructor") {
+            return "constructor";
+        }
+        return member.static ? "static-method" : "instance-method";
+    }
+    return null;
+}
+/**
+ * クラスメンバーを「static フィールド → static ブロック → インスタンスフィールド → constructor → static メソッド → インスタンスメソッド」の順に要求します。
+ */
+const memberOrdering = defineRule({
+    meta: {
+        docs: {
+            description: "Require class members to be ordered as static fields, static blocks, instance fields, constructor, static methods, and instance methods.",
+        },
+        type: "suggestion",
+        messages: {
+            order: "Class members must be ordered as static fields, static blocks, instance fields, constructor, static methods, and instance methods.",
+        },
+    },
+    create(context) {
+        return {
+            ClassBody(node) {
+                let previousRank = null;
+                for (const member of node.body) {
+                    const group = getMemberGroup(member);
+                    if (group === null) {
+                        continue;
+                    }
+                    const rank = MEMBER_GROUP_ORDER[group];
+                    if (previousRank !== null && rank < previousRank) {
+                        context.report({
+                            node: member,
+                            messageId: "order",
+                        });
+                    }
+                    previousRank = rank;
+                }
+            },
+        };
+    },
+});
+export default memberOrdering;

package/dist/src/rules/object-properties-newline.d.ts

@@ -0,0 +1,9 @@
+/**
+ * プロパティーが 2 つ以上あるオブジェクトリテラルを複数行にします。
+ *
+ * Oxfmt の `objectWrap` には「プロパティー数で改行を強制する」オプションがないため、改行を挿入する最小限の fix を提供します。
+ * `objectWrap: "preserve"` と組み合わせることで、後続の Oxfmt がプロパティーごとの改行とインデントを整えます。
+ */
+declare const objectPropertiesNewline: import("vite-plus/lint/plugins").Rule;
+export default objectPropertiesNewline;
+//# sourceMappingURL=object-properties-newline.d.ts.map

package/dist/src/rules/object-properties-newline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-properties-newline.d.ts","sourceRoot":"","sources":["../../../src/rules/object-properties-newline.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,QAAA,MAAM,uBAAuB,uCAyC3B,CAAC;eAEY,uBAAuB"}

package/dist/src/rules/object-properties-newline.js

@@ -0,0 +1,47 @@
+import { defineRule } from "vite-plus/lint/plugins";
+import { getSortPlan } from "./object-sort-utils.js";
+/**
+ * プロパティーが 2 つ以上あるオブジェクトリテラルを複数行にします。
+ *
+ * Oxfmt の `objectWrap` には「プロパティー数で改行を強制する」オプションがないため、改行を挿入する最小限の fix を提供します。
+ * `objectWrap: "preserve"` と組み合わせることで、後続の Oxfmt がプロパティーごとの改行とインデントを整えます。
+ */
+const objectPropertiesNewline = defineRule({
+    meta: {
+        docs: {
+            description: "Enforce multiline object literals when they have two or more properties.",
+        },
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            multiline: "Objects with 2 or more properties must be multiline.",
+        },
+    },
+    create(context) {
+        return {
+            ObjectExpression(node) {
+                if (node.properties.length < 2) {
+                    return;
+                }
+                // 並び替え可能なオブジェクトは sort-object-properties が複数行化も担当します。
+                if (getSortPlan(node, context.sourceCode) !== null) {
+                    return;
+                }
+                // Oxfmt は `{` の直後に改行があるかどうかで複数行を維持するため、最初のプロパティーが `{` と同じ行にある場合だけを対象にします。
+                const firstProperty = node.properties[0];
+                if (firstProperty === undefined || firstProperty.loc.start.line !== node.loc.start.line) {
+                    return;
+                }
+                context.report({
+                    fix(fixer) {
+                        // Oxfmt は `{` の直後の改行を複数行オブジェクトの目印にするため、ここでは改行を 1 つ挿入するだけで十分です。
+                        return fixer.insertTextAfterRange([node.range[0], node.range[0] + 1], "\n");
+                    },
+                    node,
+                    messageId: "multiline",
+                });
+            },
+        };
+    },
+});
+export default objectPropertiesNewline;

package/dist/src/rules/object-sort-utils.d.ts

@@ -0,0 +1,32 @@
+import type { ESTree, SourceCode } from "vite-plus/lint/plugins";
+type SortableObject = ESTree.ObjectExpression | ESTree.ObjectPattern;
+interface SortPlanOptions {
+    /**
+     * 末尾の RestElement を許可するかどうかです。
+     */
+    allowRest?: boolean;
+    /**
+     * 1 行のオブジェクトを複数行に整形するかどうかです。
+     */
+    forceMultiline?: boolean;
+}
+type SortPlan = {
+    needsFix: false;
+    replacement: null;
+} | {
+    needsFix: true;
+    replacement: string;
+};
+declare function compareNames(left: string, right: string): number;
+/**
+ * オブジェクトリテラル／オブジェクトパターンの並び替え計画を返します。
+ *
+ * - プロパティー名の長さが短い順、同じ長さなら名前順
+ * - 空行で区切られたグループ内だけで並び替え
+ * - プロパティー直上のコメントはプロパティーと一緒に移動
+ *
+ * 並び替えが安全でない場合は null を返します。
+ */
+declare function getSortPlan(node: SortableObject, sourceCode: SourceCode, options?: SortPlanOptions): SortPlan | null;
+export { getSortPlan, compareNames };
+//# sourceMappingURL=object-sort-utils.d.ts.map

package/dist/src/rules/object-sort-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-sort-utils.d.ts","sourceRoot":"","sources":["../../../src/rules/object-sort-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAW,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAE1E,KAAK,cAAc,GAAG,MAAM,CAAC,gBAAgB,GAAG,MAAM,CAAC,aAAa,CAAC;AAIrE,UAAU,eAAe;IACvB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAYD,KAAK,QAAQ,GACT;IACE,QAAQ,EAAE,KAAK,CAAC;IAChB,WAAW,EAAE,IAAI,CAAC;CACnB,GACD;IACE,QAAQ,EAAE,IAAI,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAuEN,iBAAS,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAiBzD;AAeD;;;;;;;;GAQG;AACH,iBAAS,WAAW,CAClB,IAAI,EAAE,cAAc,EACpB,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,eAAoB,GAC5B,QAAQ,GAAG,IAAI,CAwLjB;AAED,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,CAAC"}

package/dist/src/rules/object-sort-utils.js

@@ -0,0 +1,221 @@
+function getLineStarts(text) {
+    const starts = [0];
+    for (let index = 0; index < text.length; index += 1) {
+        if (text[index] === "\n") {
+            starts.push(index + 1);
+        }
+    }
+    return starts;
+}
+function getLineIndent(text, lineStarts, line) {
+    const start = lineStarts[line - 1] ?? 0;
+    const match = /^[ \t]*/u.exec(text.slice(start));
+    return match?.[0] ?? "";
+}
+function getPropertyName(property) {
+    if (property.type !== "Property" || property.computed || property.kind !== "init") {
+        return null;
+    }
+    const key = property.key;
+    let name;
+    if (key.type === "Identifier") {
+        name = key.name;
+    }
+    else if (key.type === "Literal" &&
+        (typeof key.value === "string" || typeof key.value === "number")) {
+        name = String(key.value);
+    }
+    else {
+        return null;
+    }
+    return name === "__proto__" ? null : name;
+}
+function isSortableObject(node, allowRest) {
+    if (node.properties.length < 2) {
+        return false;
+    }
+    const names = new Set();
+    for (const [index, property] of node.properties.entries()) {
+        if (property.type === "RestElement") {
+            if (!allowRest || index !== node.properties.length - 1) {
+                return false;
+            }
+            continue;
+        }
+        const name = getPropertyName(property);
+        if (name === null || names.has(name)) {
+            return false;
+        }
+        names.add(name);
+    }
+    return true;
+}
+function compareNames(left, right) {
+    if (left.length !== right.length) {
+        return left.length - right.length;
+    }
+    const leftLower = left.toLowerCase();
+    const rightLower = right.toLowerCase();
+    if (leftLower !== rightLower) {
+        return leftLower < rightLower ? -1 : 1;
+    }
+    if (left === right) {
+        return 0;
+    }
+    return left < right ? -1 : 1;
+}
+function compareUnits(left, right) {
+    return compareNames(left.name, right.name);
+}
+function sortGroup(group) {
+    const sortable = group.filter((unit) => unit.name !== null);
+    sortable.sort(compareUnits);
+    const rest = group.filter((unit) => unit.name === null);
+    return [...sortable, ...rest];
+}
+/**
+ * オブジェクトリテラル／オブジェクトパターンの並び替え計画を返します。
+ *
+ * - プロパティー名の長さが短い順、同じ長さなら名前順
+ * - 空行で区切られたグループ内だけで並び替え
+ * - プロパティー直上のコメントはプロパティーと一緒に移動
+ *
+ * 並び替えが安全でない場合は null を返します。
+ */
+function getSortPlan(node, sourceCode, options = {}) {
+    const { allowRest = false, forceMultiline = true } = options;
+    if (!isSortableObject(node, allowRest)) {
+        return null;
+    }
+    const source = sourceCode.text;
+    const lineStarts = getLineStarts(source);
+    const lineIndent = getLineIndent(source, lineStarts, node.loc.start.line);
+    const comments = sourceCode
+        .getAllComments()
+        .filter((comment) => comment.range[0] >= node.range[0] && comment.range[1] <= node.range[1]);
+    const firstProperty = node.properties[0];
+    if (firstProperty === undefined) {
+        return null;
+    }
+    const inlineStart = firstProperty.loc.start.line === node.loc.start.line;
+    const singleLine = node.loc.start.line === node.loc.end.line;
+    const units = [];
+    if (inlineStart) {
+        if (comments.length > 0) {
+            return null;
+        }
+        for (const property of node.properties) {
+            const isRest = property.type === "RestElement";
+            units.push({
+                name: isRest ? null : getPropertyName(property),
+                text: source.slice(property.range[0], property.range[1]),
+                endLine: property.loc.end.line,
+                property,
+                startLine: property.loc.start.line,
+            });
+        }
+    }
+    else {
+        let previousProperty = null;
+        for (const property of node.properties) {
+            const previous = previousProperty;
+            const boundary = previous === null ? node.range[0] + 1 : previous.range[1];
+            const candidates = comments.filter((comment) => comment.range[0] >= boundary && comment.range[1] <= property.range[0]);
+            if (previous !== null &&
+                comments.some((comment) => comment.loc.start.line === previous.loc.end.line &&
+                    comment.range[0] >= previous.range[1] &&
+                    comment.range[1] <= property.range[0])) {
+                return null;
+            }
+            const attached = [];
+            let expectedLine = property.loc.start.line;
+            for (let index = candidates.length - 1; index >= 0; index -= 1) {
+                const comment = candidates[index];
+                if (comment === undefined) {
+                    continue;
+                }
+                if (comment.loc.end.line !== expectedLine && comment.loc.end.line !== expectedLine - 1) {
+                    return null;
+                }
+                if (comment.loc.start.line === expectedLine) {
+                    return null;
+                }
+                if (comment.loc.start.line === node.loc.start.line) {
+                    return null;
+                }
+                attached.unshift(comment);
+                expectedLine = comment.loc.start.line;
+            }
+            if (attached.length !== candidates.length) {
+                return null;
+            }
+            const first = attached[0] ?? property;
+            const startLine = first.loc.start.line;
+            const unitStart = lineStarts[startLine - 1] ?? 0;
+            const isRest = property.type === "RestElement";
+            units.push({
+                name: isRest ? null : getPropertyName(property),
+                text: source.slice(unitStart, property.range[1]),
+                endLine: property.loc.end.line,
+                property,
+                startLine,
+            });
+            previousProperty = property;
+        }
+        const lastProperty = node.properties.at(-1);
+        if (lastProperty === undefined) {
+            return null;
+        }
+        if (comments.some((comment) => comment.range[0] >= lastProperty.range[1] && comment.range[1] <= node.range[1] - 1)) {
+            return null;
+        }
+    }
+    const groups = [];
+    let currentGroup = [];
+    let previousEndLine = null;
+    for (const unit of units) {
+        if (previousEndLine !== null && unit.startLine > previousEndLine + 1) {
+            groups.push(currentGroup);
+            currentGroup = [];
+        }
+        currentGroup.push(unit);
+        previousEndLine = unit.endLine;
+    }
+    if (currentGroup.length > 0) {
+        groups.push(currentGroup);
+    }
+    let needsSort = false;
+    for (const group of groups) {
+        const sorted = sortGroup(group);
+        if (sorted.some((unit, index) => unit !== group[index])) {
+            needsSort = true;
+            break;
+        }
+    }
+    const needsFormat = forceMultiline && inlineStart;
+    if (!needsSort && !needsFormat) {
+        return {
+            needsFix: false,
+            replacement: null,
+        };
+    }
+    if (singleLine && !forceMultiline) {
+        const sortedUnits = sortGroup(units);
+        return {
+            needsFix: true,
+            replacement: `{ ${sortedUnits.map((unit) => unit.text).join(", ")} }`,
+        };
+    }
+    const groupsText = groups
+        .map((group) => sortGroup(group)
+        .map((unit) => unit.text)
+        .join(",\n"))
+        .join(",\n\n");
+    const lastUnit = groups.flatMap((group) => sortGroup(group)).at(-1);
+    const trailingComma = lastUnit?.property.type === "RestElement" ? "" : ",";
+    return {
+        needsFix: true,
+        replacement: `{\n${groupsText}${trailingComma}\n${lineIndent}}`,
+    };
+}
+export { getSortPlan, compareNames };

package/dist/src/rules/overload-signatures-adjacent.d.ts

@@ -0,0 +1,6 @@
+/**
+ * オーバーロード署名と実装の間に空行を入れないようにします。
+ */
+declare const overloadSignaturesAdjacent: import("vite-plus/lint/plugins").Rule;
+export default overloadSignaturesAdjacent;
+//# sourceMappingURL=overload-signatures-adjacent.d.ts.map

package/dist/src/rules/overload-signatures-adjacent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overload-signatures-adjacent.d.ts","sourceRoot":"","sources":["../../../src/rules/overload-signatures-adjacent.ts"],"names":[],"mappings":"AAiGA;;GAEG;AACH,QAAA,MAAM,0BAA0B,uCAqG9B,CAAC;eAEY,0BAA0B"}

package/dist/src/rules/overload-signatures-adjacent.js

@@ -0,0 +1,143 @@
+import { defineRule } from "vite-plus/lint/plugins";
+import { getNextStatement } from "./blank-line.js";
+function getFunction(node) {
+    if (node.type === "FunctionDeclaration" || node.type === "TSDeclareFunction") {
+        return node;
+    }
+    if (node.type === "ExportNamedDeclaration" && node.declaration !== null) {
+        const declaration = node.declaration;
+        if (declaration.type === "FunctionDeclaration" || declaration.type === "TSDeclareFunction") {
+            return declaration;
+        }
+    }
+    return null;
+}
+function getKeyName(node) {
+    if (node.computed) {
+        return null;
+    }
+    const key = node.key;
+    if (key.type === "Identifier") {
+        return key.name;
+    }
+    if (key.type === "Literal" && (typeof key.value === "string" || typeof key.value === "number")) {
+        return String(key.value);
+    }
+    return null;
+}
+function getRemoveBlankLinesFix(fixer, sourceCode, previous, next) {
+    if (next.loc.start.line <= previous.loc.end.line + 1) {
+        return null;
+    }
+    const fromLineEnd = sourceCode.text.indexOf("\n", previous.range[1]);
+    if (fromLineEnd === -1) {
+        return null;
+    }
+    const nextLineStart = sourceCode.text.lastIndexOf("\n", next.range[0]) + 1;
+    const indent = sourceCode.text.slice(nextLineStart, next.range[0]);
+    if (indent.trim() !== "") {
+        return null;
+    }
+    return fixer.replaceTextRange([fromLineEnd, next.range[0]], `\n${indent}`);
+}
+function hasCommentBetween(sourceCode, previous, next) {
+    return sourceCode
+        .getAllComments()
+        .some((comment) => comment.range[0] >= previous.range[1] && comment.range[1] <= next.range[0]);
+}
+function reportIfSeparated(context, sourceCode, previous, next) {
+    if (next.loc.start.line <= previous.loc.end.line + 1 ||
+        hasCommentBetween(sourceCode, previous, next)) {
+        return;
+    }
+    context.report({
+        fix(fixer) {
+            return getRemoveBlankLinesFix(fixer, sourceCode, previous, next);
+        },
+        node: next,
+        messageId: "adjacent",
+    });
+}
+/**
+ * オーバーロード署名と実装の間に空行を入れないようにします。
+ */
+const overloadSignaturesAdjacent = defineRule({
+    meta: {
+        docs: {
+            description: "Require overload signatures and their implementation to be adjacent.",
+        },
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            adjacent: "Overload signatures must be adjacent to each other and to the implementation.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            ClassBody(node) {
+                for (let index = 1; index < node.body.length; index += 1) {
+                    const previous = node.body[index - 1];
+                    const next = node.body[index];
+                    if (previous === undefined ||
+                        next === undefined ||
+                        previous.type !== "MethodDefinition" ||
+                        previous.value.body !== null ||
+                        next.type !== "MethodDefinition") {
+                        continue;
+                    }
+                    const previousName = getKeyName(previous);
+                    const nextName = getKeyName(next);
+                    if (previousName === null || previousName !== nextName) {
+                        continue;
+                    }
+                    reportIfSeparated(context, sourceCode, previous, next);
+                }
+            },
+            TSDeclareFunction(node) {
+                if (node.body !== null) {
+                    return;
+                }
+                const nextStatement = getNextStatement(node);
+                if (nextStatement === null) {
+                    return;
+                }
+                const nextFunction = getFunction(nextStatement);
+                if (nextFunction === null || nextFunction.id?.name !== node.id?.name) {
+                    return;
+                }
+                reportIfSeparated(context, sourceCode, node, nextStatement);
+            },
+            FunctionDeclaration(node) {
+                if (node.body !== null) {
+                    return;
+                }
+                const nextStatement = getNextStatement(node);
+                if (nextStatement === null) {
+                    return;
+                }
+                const nextFunction = getFunction(nextStatement);
+                if (nextFunction === null || nextFunction.id?.name !== node.id?.name) {
+                    return;
+                }
+                reportIfSeparated(context, sourceCode, node, nextStatement);
+            },
+            ExportNamedDeclaration(node) {
+                const currentFunction = getFunction(node);
+                if (currentFunction === null || currentFunction.body !== null) {
+                    return;
+                }
+                const nextStatement = getNextStatement(node);
+                if (nextStatement === null) {
+                    return;
+                }
+                const nextFunction = getFunction(nextStatement);
+                if (nextFunction === null || nextFunction.id?.name !== currentFunction.id?.name) {
+                    return;
+                }
+                reportIfSeparated(context, sourceCode, node, nextStatement);
+            },
+        };
+    },
+});
+export default overloadSignaturesAdjacent;

package/dist/src/rules/sort-import-export-specifiers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * import / export の波括弧内の specifier を並べます。
+ *
+ * 「型 → 変数など → default」のグループ順で、各グループ内は名前の長さが短い順、同じ長さなら名前順です。
+ */
+declare const sortImportExportSpecifiers: import("vite-plus/lint/plugins").Rule;
+export default sortImportExportSpecifiers;
+//# sourceMappingURL=sort-import-export-specifiers.d.ts.map

package/dist/src/rules/sort-import-export-specifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-import-export-specifiers.d.ts","sourceRoot":"","sources":["../../../src/rules/sort-import-export-specifiers.ts"],"names":[],"mappings":"AAwEA;;;;GAIG;AACH,QAAA,MAAM,0BAA0B,uCAkH9B,CAAC;eAEY,0BAA0B"}

package/dist/src/rules/sort-import-export-specifiers.js

@@ -0,0 +1,130 @@
+import { defineRule } from "vite-plus/lint/plugins";
+import { compareNames } from "./object-sort-utils.js";
+function getSpecifierName(node) {
+    if (node.type === "Identifier") {
+        return node.name;
+    }
+    if (node.type === "Literal") {
+        return node.value;
+    }
+    return null;
+}
+function getLineIndent(source, offset) {
+    const lineStart = source.lastIndexOf("\n", offset) + 1;
+    const match = /^[ \t]*/u.exec(source.slice(lineStart, offset));
+    return match?.[0] ?? "";
+}
+function hasUnsafeComment(node, specifiers, sourceCode) {
+    const comments = sourceCode
+        .getAllComments()
+        .filter((comment) => comment.range[0] >= node.range[0] && comment.range[1] <= node.range[1]);
+    return comments.some((comment) => !specifiers.some((specifier) => comment.range[0] >= specifier.range[0] && comment.range[1] <= specifier.range[1]));
+}
+function buildReplacement(units, sourceCode, first, last) {
+    const sorted = [...units].sort((left, right) => {
+        if (left.group !== right.group) {
+            return left.group - right.group;
+        }
+        return compareNames(left.name, right.name);
+    });
+    if (sorted.every((unit, index) => unit === units[index])) {
+        return null;
+    }
+    const multiline = first.loc.start.line !== last.loc.end.line;
+    const separator = multiline ? `,\n${getLineIndent(sourceCode.text, first.range[0])}` : ", ";
+    return sorted.map((unit) => unit.text).join(separator);
+}
+/**
+ * import / export の波括弧内の specifier を並べます。
+ *
+ * 「型 → 変数など → default」のグループ順で、各グループ内は名前の長さが短い順、同じ長さなら名前順です。
+ */
+const sortImportExportSpecifiers = defineRule({
+    meta: {
+        docs: {
+            description: "Sort import and export specifiers by group (type, value, default), then by name length and name.",
+        },
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            sort: "Import/export specifiers must be sorted by group, name length, then name.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        function reportSort(node, specifiers, units) {
+            const first = specifiers[0];
+            const last = specifiers.at(-1);
+            if (first === undefined || last === undefined) {
+                return;
+            }
+            const replacement = buildReplacement(units, sourceCode, first, last);
+            if (replacement === null) {
+                return;
+            }
+            context.report({
+                fix(fixer) {
+                    return fixer.replaceTextRange([first.range[0], last.range[1]], replacement);
+                },
+                node,
+                messageId: "sort",
+            });
+        }
+        return {
+            ImportDeclaration(node) {
+                const specifiers = node.specifiers.filter((specifier) => specifier.type === "ImportSpecifier");
+                if (specifiers.length < 2 || hasUnsafeComment(node, specifiers, sourceCode)) {
+                    return;
+                }
+                const units = [];
+                for (const specifier of specifiers) {
+                    const name = getSpecifierName(specifier.imported);
+                    if (name === null) {
+                        return;
+                    }
+                    let group = 1;
+                    if (node.importKind === "type" || specifier.importKind === "type") {
+                        group = 0;
+                    }
+                    else if (name === "default") {
+                        group = 2;
+                    }
+                    units.push({
+                        name,
+                        text: sourceCode.text.slice(specifier.range[0], specifier.range[1]),
+                        group,
+                    });
+                }
+                reportSort(node, specifiers, units);
+            },
+            ExportNamedDeclaration(node) {
+                const { specifiers } = node;
+                if (specifiers.length < 2 || hasUnsafeComment(node, specifiers, sourceCode)) {
+                    return;
+                }
+                const units = [];
+                for (const specifier of specifiers) {
+                    const localName = getSpecifierName(specifier.local);
+                    const exportedName = getSpecifierName(specifier.exported);
+                    if (localName === null || exportedName === null) {
+                        return;
+                    }
+                    let group = 1;
+                    if (node.exportKind === "type" || specifier.exportKind === "type") {
+                        group = 0;
+                    }
+                    else if (localName === "default" || exportedName === "default") {
+                        group = 2;
+                    }
+                    units.push({
+                        name: localName,
+                        text: sourceCode.text.slice(specifier.range[0], specifier.range[1]),
+                        group,
+                    });
+                }
+                reportSort(node, specifiers, units);
+            },
+        };
+    },
+});
+export default sortImportExportSpecifiers;