tailwint 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peter Wang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# tailwint
+
+Tailwind CSS linter for CI. Drives the official `@tailwindcss/language-server` to catch class errors and auto-fix them — the same diagnostics VS Code shows, but from the command line.
+
+Works with Tailwind CSS v4.
+
+## Install
+
+```bash
+npm install -D tailwint @tailwindcss/language-server
+```
+
+## Usage
+
+```bash
+# Check default file types (tsx, jsx, html, vue, svelte)
+npx tailwint
+
+# Check specific files
+npx tailwint "src/**/*.tsx"
+
+# Auto-fix issues
+npx tailwint --fix
+
+# Fix specific files
+npx tailwint --fix "app/**/*.tsx"
+```
+
+## Programmatic API
+
+```ts
+import { run } from "tailwint";
+
+const exitCode = await run({
+  patterns: ["src/**/*.tsx"],
+  fix: true,
+  cwd: "/path/to/project",
+});
+```
+
+## How it works
+
+tailwint spawns the official Tailwind CSS language server over stdio, opens your files via LSP, and collects the published diagnostics. In `--fix` mode it requests quickfix code actions and applies the resulting edits.
+
+## Requirements
+
+- Node.js 18+
+- `@tailwindcss/language-server` >= 0.14.0 (peer dependency)
+
+## License
+
+MIT

package/bin/tailwint.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.js";

package/dist/applyEdits.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/applyEdits.test.js

@@ -0,0 +1,133 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { applyEdits } from "./index.js";
+// Helper to build a TextEdit concisely
+function edit(startLine, startChar, endLine, endChar, newText) {
+    return {
+        range: {
+            start: { line: startLine, character: startChar },
+            end: { line: endLine, character: endChar },
+        },
+        newText,
+    };
+}
+describe("applyEdits", () => {
+    it("returns content unchanged when edits array is empty", () => {
+        assert.equal(applyEdits("hello\nworld", []), "hello\nworld");
+    });
+    it("replaces a single word on a single line", () => {
+        const result = applyEdits("bg-red-999", [edit(0, 0, 0, 10, "bg-red-500")]);
+        assert.equal(result, "bg-red-500");
+    });
+    it("replaces a substring in the middle of a line", () => {
+        const result = applyEdits("class=\"bg-red-999 p-4\"", [
+            edit(0, 7, 0, 17, "bg-red-500"),
+        ]);
+        assert.equal(result, "class=\"bg-red-500 p-4\"");
+    });
+    it("handles insertion (zero-width range)", () => {
+        const result = applyEdits("hello world", [edit(0, 5, 0, 5, " beautiful")]);
+        assert.equal(result, "hello beautiful world");
+    });
+    it("handles deletion (empty newText)", () => {
+        const result = applyEdits("hello beautiful world", [edit(0, 5, 0, 15, "")]);
+        assert.equal(result, "hello world");
+    });
+    it("handles multi-line replacement", () => {
+        const content = "line one\nline two\nline three";
+        const result = applyEdits(content, [edit(0, 5, 1, 5, "ONE\nline TWO\nline")]);
+        // Replaced range (0,5)-(1,5) is " one\nline ", so suffix is "two"
+        assert.equal(result, "line ONE\nline TWO\nlinetwo\nline three");
+    });
+    it("handles edit that spans multiple lines and collapses them", () => {
+        const content = "aaa\nbbb\nccc\nddd";
+        // Delete from middle of line 1 to middle of line 2
+        const result = applyEdits(content, [edit(1, 1, 2, 2, "")]);
+        assert.equal(result, "aaa\nbc\nddd");
+    });
+    it("applies multiple non-overlapping edits on the same line", () => {
+        const content = "class=\"bg-red-999 text-blue-999\"";
+        const result = applyEdits(content, [
+            edit(0, 7, 0, 17, "bg-red-500"),
+            edit(0, 18, 0, 31, "text-blue-500"),
+        ]);
+        assert.equal(result, "class=\"bg-red-500 text-blue-500\"");
+    });
+    it("applies multiple edits on different lines", () => {
+        const content = "line0\nline1\nline2";
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 5, "LINE0"),
+            edit(2, 0, 2, 5, "LINE2"),
+        ]);
+        assert.equal(result, "LINE0\nline1\nLINE2");
+    });
+    it("handles edit at the very end of file (no trailing newline)", () => {
+        const content = "hello";
+        const result = applyEdits(content, [edit(0, 5, 0, 5, " world")]);
+        assert.equal(result, "hello world");
+    });
+    it("handles edit on empty string", () => {
+        const result = applyEdits("", [edit(0, 0, 0, 0, "inserted")]);
+        assert.equal(result, "inserted");
+    });
+    it("handles replacement that introduces new lines", () => {
+        const content = "one line";
+        const result = applyEdits(content, [edit(0, 3, 0, 4, "\n")]);
+        assert.equal(result, "one\nline");
+    });
+    it("handles replacement that removes newlines (joining lines)", () => {
+        const content = "one\nline";
+        const result = applyEdits(content, [edit(0, 3, 1, 0, " ")]);
+        assert.equal(result, "one line");
+    });
+    it("handles edit past the actual content length of a line", () => {
+        // What if the range references characters beyond the line length?
+        const content = "hi";
+        const result = applyEdits(content, [edit(0, 2, 0, 100, " there")]);
+        assert.equal(result, "hi there");
+    });
+    it("handles edit referencing a line beyond file length", () => {
+        // File has 1 line, edit references line 5.
+        // Line 5 maps to content.length, so this is an append at the end — no newline inserted.
+        // An LSP server wouldn't actually send this, but we shouldn't crash.
+        const content = "only line";
+        const result = applyEdits(content, [edit(5, 0, 5, 0, "new line")]);
+        assert.equal(result, "only linenew line");
+    });
+    it("handles multiple edits where earlier edit changes line count", () => {
+        // This tests whether applying in reverse order is correct.
+        // Edit on line 2 first (applied first in reverse), then edit on line 0.
+        const content = "aaa\nbbb\nccc";
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 3, "AAA"),
+            edit(2, 0, 2, 3, "CCC"),
+        ]);
+        assert.equal(result, "AAA\nbbb\nCCC");
+    });
+    it("handles adjacent edits (end of one = start of next)", () => {
+        const content = "abcdef";
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 3, "ABC"),
+            edit(0, 3, 0, 6, "DEF"),
+        ]);
+        assert.equal(result, "ABCDEF");
+    });
+    it("does not mutate the original edits array", () => {
+        const edits = [
+            edit(1, 0, 1, 3, "BBB"),
+            edit(0, 0, 0, 3, "AAA"),
+        ];
+        const original = JSON.stringify(edits);
+        applyEdits("aaa\nbbb", edits);
+        assert.equal(JSON.stringify(edits), original);
+    });
+    // Stress test: many edits
+    it("handles a large number of single-line edits", () => {
+        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`);
+        const content = lines.join("\n");
+        const edits = lines.map((_, i) => edit(i, 0, i, `line${i}`.length, `LINE${i}`));
+        const result = applyEdits(content, edits);
+        const expected = Array.from({ length: 100 }, (_, i) => `LINE${i}`).join("\n");
+        assert.equal(result, expected);
+    });
+});

package/dist/batchEdits.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/batchEdits.test.js

@@ -0,0 +1,132 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { applyEdits } from "./index.js";
+function edit(startLine, startChar, endLine, endChar, newText) {
+    return {
+        range: {
+            start: { line: startLine, character: startChar },
+            end: { line: endLine, character: endChar },
+        },
+        newText,
+    };
+}
+describe("batched edits — multiple diagnostics fixed at once", () => {
+    // Scenario: two cssConflict warnings on separate lines, both fixed in one pass
+    it("removes conflicting classes on separate lines", () => {
+        const content = [
+            'export default function App() {',
+            '  return (',
+            '    <div className="text-red-500 text-blue-500 p-4">',
+            '      <span className="font-bold font-semibold">hello</span>',
+            '    </div>',
+            '  )',
+            '}',
+        ].join("\n");
+        // Simulate: LSP says remove "text-blue-500 " on line 2, and " font-semibold" on line 3
+        const result = applyEdits(content, [
+            edit(2, 33, 2, 47, ""),
+            edit(3, 32, 3, 46, ""),
+        ]);
+        assert.ok(result.includes('"text-red-500 p-4"'), "should keep text-red-500");
+        assert.ok(!result.includes("text-blue-500"), "should remove text-blue-500");
+        assert.ok(result.includes('"font-bold"'), "should keep font-bold");
+        assert.ok(!result.includes("font-semibold"), "should remove font-semibold");
+    });
+    // Scenario: two conflicting pairs on the SAME line
+    it("removes two conflicting classes on the same line", () => {
+        //                     0123456789...
+        const content = '<div className="text-red-500 text-blue-500 bg-red-500 bg-blue-500 p-4">';
+        const result = applyEdits(content, [
+            edit(0, 29, 0, 43, ""),
+            edit(0, 54, 0, 66, ""),
+        ]);
+        assert.ok(result.includes("text-red-500"), "should keep text-red-500");
+        assert.ok(!result.includes("text-blue-500"), "should remove text-blue-500");
+        assert.ok(result.includes("bg-red-500"), "should keep bg-red-500");
+        assert.ok(!result.includes("bg-blue-500"), "should remove bg-blue-500");
+        assert.ok(result.includes("p-4"), "should keep p-4");
+    });
+    // Scenario: edits that are adjacent (one right after the other, no gap)
+    it("handles adjacent removals with no gap between them", () => {
+        const content = "aabbcc";
+        // Remove "bb" (chars 2-4) and "cc" (chars 4-6) — adjacent edits
+        const result = applyEdits(content, [
+            edit(0, 2, 0, 4, ""),
+            edit(0, 4, 0, 6, ""),
+        ]);
+        assert.equal(result, "aa");
+    });
+    // Scenario: what happens if two code actions try to edit overlapping ranges?
+    // This is the dangerous case for batching.
+    it("overlapping edits produce unpredictable results", () => {
+        const content = "abcdefgh";
+        // Edit 1: replace chars 2-5 ("cdef") with "XX"
+        // Edit 2: replace chars 4-7 ("efgh") with "YY"
+        // These overlap at chars 4-5.
+        // Forward pass: cursor=0, edit1(2,5): "ab" + "XX", cursor=5
+        //   edit2(4,7): 4 < cursor(5), so we skip the slice — start is behind cursor!
+        //   Actually, the code does: if (e.start > cursor) parts.push(...)
+        //   e.start=4, cursor=5, 4 > 5 is false, so no gap pushed.
+        //   parts.push("YY"), cursor=7
+        //   remaining: parts.push("h")
+        //   Result: "abXXYYh"
+        //
+        // But what SHOULD happen? The LSP spec says overlapping edits are invalid.
+        // We just need to not crash.
+        const result = applyEdits(content, [
+            edit(0, 2, 0, 5, "XX"),
+            edit(0, 4, 0, 7, "YY"),
+        ]);
+        // We don't care about the exact output, just that we don't crash
+        // and produce a string (not undefined/null/error)
+        assert.equal(typeof result, "string");
+        console.log("Overlapping edit result:", JSON.stringify(result));
+    });
+    // Scenario: realistic Tailwind — class reordering across a whole file
+    it("handles edits across many lines (simulating a file-wide fix)", () => {
+        const lines = [];
+        for (let i = 0; i < 50; i++) {
+            lines.push(`<div className="flex items-center p-${i}">line ${i}</div>`);
+        }
+        const content = lines.join("\n");
+        // Simulate: replace "p-N" with "p-0" on every line
+        const edits = [];
+        for (let i = 0; i < 50; i++) {
+            const pClass = `p-${i}`;
+            const lineContent = lines[i];
+            const start = lineContent.indexOf(pClass);
+            edits.push(edit(i, start, i, start + pClass.length, "p-0"));
+        }
+        const result = applyEdits(content, edits);
+        const resultLines = result.split("\n");
+        assert.equal(resultLines.length, 50);
+        for (let i = 0; i < 50; i++) {
+            assert.ok(resultLines[i].includes("p-0"), `line ${i} should have p-0`);
+            if (i > 0) {
+                assert.ok(!resultLines[i].includes(`p-${i}`), `line ${i} should not have p-${i}`);
+            }
+        }
+    });
+    // Scenario: what if we batch a deletion that shifts everything,
+    // with another edit on a later line? This is the safe case.
+    it("handles deletion on one line + edit on later line", () => {
+        const content = "line0 extra\nline1\nline2 extra";
+        // Delete " extra" on line 0, replace "line2" with "LINE2" on line 2
+        const result = applyEdits(content, [
+            edit(0, 5, 0, 11, ""),
+            edit(2, 0, 2, 5, "LINE2"),
+        ]);
+        assert.equal(result, "line0\nline1\nLINE2 extra");
+    });
+    // Scenario: mixed insertions and deletions across lines
+    it("handles mixed insertions and deletions", () => {
+        const content = "aaa\nbbb\nccc\nddd";
+        const result = applyEdits(content, [
+            edit(0, 3, 0, 3, " inserted"), // insert at end of line 0
+            edit(1, 0, 1, 3, ""), // delete all of line 1 content
+            edit(2, 0, 2, 3, "CCC"), // replace line 2
+            edit(3, 0, 3, 0, "pre-"), // insert at start of line 3
+        ]);
+        assert.equal(result, "aaa inserted\n\nCCC\npre-ddd");
+    });
+});

package/dist/cli.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * tailwint — Tailwind CSS linter that drives the official language server.
+ *
+ * Usage:  tailwint [--fix] [glob...]
+ *         tailwint                              # default: **\/*.{tsx,jsx,html,vue,svelte}
+ *         tailwint --fix                        # auto-fix all issues
+ *         tailwint "src/**\/*.tsx"               # custom glob
+ *         tailwint --fix "app/**\/*.tsx"          # fix specific files
+ *
+ * Set DEBUG=1 for verbose LSP message logging.
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+/**
+ * tailwint — Tailwind CSS linter that drives the official language server.
+ *
+ * Usage:  tailwint [--fix] [glob...]
+ *         tailwint                              # default: **\/*.{tsx,jsx,html,vue,svelte}
+ *         tailwint --fix                        # auto-fix all issues
+ *         tailwint "src/**\/*.tsx"               # custom glob
+ *         tailwint --fix "app/**\/*.tsx"          # fix specific files
+ *
+ * Set DEBUG=1 for verbose LSP message logging.
+ */
+import { run } from "./index.js";
+const args = process.argv.slice(2);
+const fix = args.includes("--fix");
+const patterns = args.filter((a) => a !== "--fix");
+run({ fix, patterns: patterns.length > 0 ? patterns : undefined }).then((code) => process.exit(code), (err) => {
+    process.stderr.write("\x1b[?25h"); // restore cursor if hidden
+    console.error(`\n  tailwint crashed: ${err}`);
+    process.exit(2);
+});

package/dist/edgeCases.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/edgeCases.test.js

@@ -0,0 +1,99 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { applyEdits } from "./index.js";
+function edit(startLine, startChar, endLine, endChar, newText) {
+    return {
+        range: {
+            start: { line: startLine, character: startChar },
+            end: { line: endLine, character: endChar },
+        },
+        newText,
+    };
+}
+describe("applyEdits edge cases", () => {
+    it("handles Windows-style CRLF content", () => {
+        const content = "hello\r\nworld";
+        const result = applyEdits(content, [edit(0, 0, 0, 5, "HELLO")]);
+        assert.equal(result, "HELLO\r\nworld");
+    });
+    it("handles file with trailing newline", () => {
+        const content = "hello\n";
+        const result = applyEdits(content, [edit(0, 0, 0, 5, "HELLO")]);
+        assert.equal(result, "HELLO\n");
+    });
+    it("handles file with multiple trailing newlines", () => {
+        const content = "hello\n\n\n";
+        const result = applyEdits(content, [edit(0, 0, 0, 5, "HELLO")]);
+        assert.equal(result, "HELLO\n\n\n");
+    });
+    it("handles edit that replaces entire file content", () => {
+        const content = "aaa\nbbb\nccc";
+        const result = applyEdits(content, [edit(0, 0, 2, 3, "replaced")]);
+        assert.equal(result, "replaced");
+    });
+    it("handles two edits on same line — order independence", () => {
+        const content = "abcdefghij";
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 2, "AB"),
+            edit(0, 5, 0, 7, "FG"),
+        ]);
+        assert.equal(result, "ABcdeFGhij");
+    });
+    it("handles two edits on same line — provided in reverse order", () => {
+        const content = "abcdefghij";
+        const result = applyEdits(content, [
+            edit(0, 5, 0, 7, "FG"),
+            edit(0, 0, 0, 2, "AB"),
+        ]);
+        assert.equal(result, "ABcdeFGhij");
+    });
+    it("handles edit with unicode characters", () => {
+        const content = "café latte";
+        const result = applyEdits(content, [edit(0, 0, 0, 4, "CAFÉ")]);
+        assert.equal(result, "CAFÉ latte");
+    });
+    it("handles edit with emoji (multi-codepoint)", () => {
+        // 👋 is 2 UTF-16 code units. LSP uses UTF-16 offsets, as does JS string indexing.
+        const content = "👋 hello";
+        const result = applyEdits(content, [edit(0, 2, 0, 3, "-")]);
+        assert.equal(result, "👋-hello");
+    });
+    it("handles three same-line edits that all grow in length", () => {
+        const content = "class=\"aa bb cc\"";
+        const result = applyEdits(content, [
+            edit(0, 7, 0, 9, "xxxx"),
+            edit(0, 10, 0, 12, "yyyy"),
+            edit(0, 13, 0, 15, "zzzz"),
+        ]);
+        assert.equal(result, "class=\"xxxx yyyy zzzz\"");
+    });
+});
+describe("applyEdits same-line multi-edit correctness", () => {
+    it("correctly handles two non-overlapping edits on the same line", () => {
+        const content = "___foo___bar___";
+        const result = applyEdits(content, [
+            edit(0, 3, 0, 6, "FOO"),
+            edit(0, 9, 0, 12, "BAR"),
+        ]);
+        assert.equal(result, "___FOO___BAR___");
+    });
+    it("handles same-line edits where replacement changes length", () => {
+        const content = "___foo___bar___";
+        const result = applyEdits(content, [
+            edit(0, 3, 0, 6, "FOOOO"),
+            edit(0, 9, 0, 12, "B"),
+        ]);
+        assert.equal(result, "___FOOOO___B___");
+    });
+    it("handles three non-overlapping same-line edits with varying lengths", () => {
+        // Edits replace chars at positions 0('a'), 2('c'), 4('e').
+        // Chars at positions 1('b'), 3('d'), 5('f') are preserved.
+        const content = "abcdef";
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 1, "XX"),
+            edit(0, 2, 0, 3, "YYYYYY"),
+            edit(0, 4, 0, 5, "ZZ"),
+        ]);
+        assert.equal(result, "XXbYYYYYYdZZf");
+    });
+});

package/dist/edits.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Text edit application and fix orchestration.
+ */
+export interface TextEdit {
+    range: {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+    newText: string;
+}
+export declare function applyEdits(content: string, edits: TextEdit[]): string;
+export declare function fixFile(filePath: string, initialDiags: any[], fileContents: Map<string, string>, version: Map<string, number>, onPass?: (pass: number) => void): Promise<number>;

package/dist/edits.js

@@ -0,0 +1,109 @@
+/**
+ * Text edit application and fix orchestration.
+ */
+import { writeFileSync } from "fs";
+import { send, notify, fileUri, waitForDiagnostic } from "./lsp.js";
+export function applyEdits(content, edits) {
+    if (edits.length === 0)
+        return content;
+    const lineOffsets = [0];
+    for (let i = 0; i < content.length; i++) {
+        if (content[i] === "\n")
+            lineOffsets.push(i + 1);
+    }
+    function toOffset(line, char) {
+        if (line >= lineOffsets.length)
+            return content.length;
+        return Math.min(lineOffsets[line] + char, content.length);
+    }
+    const absolute = edits.map((e) => ({
+        start: toOffset(e.range.start.line, e.range.start.character),
+        end: toOffset(e.range.end.line, e.range.end.character),
+        newText: e.newText,
+    }));
+    absolute.sort((a, b) => a.start - b.start);
+    const parts = [];
+    let cursor = 0;
+    for (const e of absolute) {
+        if (e.start > cursor)
+            parts.push(content.slice(cursor, e.start));
+        parts.push(e.newText);
+        cursor = e.end;
+    }
+    if (cursor < content.length)
+        parts.push(content.slice(cursor));
+    return parts.join("");
+}
+function rangeKey(range) {
+    return `${range.start.line}:${range.start.character}-${range.end.line}:${range.end.character}`;
+}
+function posLte(a, b) {
+    return a.line < b.line || (a.line === b.line && a.character <= b.character);
+}
+function rangeContains(outer, inner) {
+    return posLte(outer.range.start, inner.range.start) && posLte(inner.range.end, outer.range.end);
+}
+function filterContainedEdits(edits) {
+    const result = [];
+    for (const edit of edits) {
+        const containedByAnother = edits.some((other) => other !== edit && rangeContains(other, edit));
+        if (!containedByAnother)
+            result.push(edit);
+    }
+    return result;
+}
+async function waitForFreshDiagnostics(uri) {
+    return waitForDiagnostic(uri);
+}
+export async function fixFile(filePath, initialDiags, fileContents, version, onPass) {
+    const DEBUG = process.env.DEBUG === "1";
+    const uri = fileUri(filePath);
+    let content = fileContents.get(filePath);
+    let ver = version.get(filePath);
+    const issueCount = initialDiags.length;
+    let diags = initialDiags;
+    for (let pass = 0; diags.length > 0; pass++) {
+        onPass?.(pass + 1);
+        if (DEBUG)
+            console.error(`    pass ${pass + 1}: ${diags.length} remaining`);
+        const actionResults = await Promise.all(diags.map((diag) => send("textDocument/codeAction", {
+            textDocument: { uri },
+            range: diag.range,
+            context: { diagnostics: [diag], only: ["quickfix"] },
+        }).catch(() => null)));
+        const editsByRange = new Map();
+        for (let i = 0; i < diags.length; i++) {
+            const actions = actionResults[i];
+            if (!actions || actions.length === 0)
+                continue;
+            const action = actions[0];
+            const edits = action.edit?.changes?.[uri] || action.edit?.documentChanges?.[0]?.edits || [];
+            if (edits.length === 0)
+                continue;
+            for (const e of edits) {
+                const key = rangeKey(e.range);
+                editsByRange.set(key, e);
+            }
+        }
+        let candidates = [...editsByRange.values()];
+        if (candidates.length === 0)
+            break;
+        candidates = filterContainedEdits(candidates);
+        const prev = content;
+        content = applyEdits(content, candidates);
+        if (content === prev)
+            break;
+        ver++;
+        notify("textDocument/didChange", {
+            textDocument: { uri, version: ver },
+            contentChanges: [{ text: content }],
+        });
+        diags = (await waitForFreshDiagnostics(uri)).filter((d) => d.severity === 1 || d.severity === 2);
+    }
+    if (content !== fileContents.get(filePath)) {
+        writeFileSync(filePath, content);
+        fileContents.set(filePath, content);
+        version.set(filePath, ver);
+    }
+    return issueCount;
+}

package/dist/edits.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for applyEdits from tailwint/edits.ts
+ */
+export {};