@runtimestudio/tailwind-sort-php 0.1.0 → 0.2.0

package/dist/init.js

@@ -0,0 +1,171 @@
+/**
+ * tailwind-sort-php init
+ *
+ * Installs the pre-commit hook: writes `.githooks/pre-commit` and points `core.hooksPath` at it.
+ * No-clobber unless `--force`; `--fix` installs the auto-fixing variant; `--dry-run` previews.
+ */
+import { execFileSync } from 'node:child_process';
+import { chmod, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const HOOKS_DIR = '.githooks';
+const HOOK_PATH = `${HOOKS_DIR}/pre-commit`;
+/**
+ * Check-and-fail hook (default): names the unsorted files and blocks the commit; never writes.
+ */
+const HOOK_CHECK = `#!/bin/sh
+# Block commits with unsorted Tailwind classes in staged PHP files.
+# Installed by \`tailwind-sort-php init\`. Note: checks working-tree file
+# contents, so partial staging (git add -p) can mis-report; see README.
+sorter=./node_modules/.bin/tailwind-sort-php
+[ -x "$sorter" ] || exit 0
+git diff --cached --name-only --diff-filter=ACMR -- '*.php' | grep -q . || exit 0
+if git diff --cached --name-only -z --diff-filter=ACMR -- '*.php' | xargs -0 "$sorter" --check; then
+  exit 0
+fi
+echo >&2
+echo "Unsorted Tailwind classes in staged PHP (see above)." >&2
+echo "Fix with: npx tailwind-sort-php (or: bunx tailwind-sort-php), then re-stage." >&2
+exit 1
+`;
+/**
+ * Auto-fix hook (--fix): sorts the staged files in place, then blocks the commit for review.
+ */
+const HOOK_FIX = `#!/bin/sh
+# Sort Tailwind classes in staged PHP files, then abort the commit so the
+# changes can be reviewed and re-staged. Rewrites working-tree files.
+# Installed by \`tailwind-sort-php init --fix\`. Note: with partial staging
+# (git add -p), re-staging can pull in unrelated unstaged hunks; see README.
+sorter=./node_modules/.bin/tailwind-sort-php
+[ -x "$sorter" ] || exit 0
+git diff --cached --name-only --diff-filter=ACMR -- '*.php' | grep -q . || exit 0
+if git diff --cached --name-only -z --diff-filter=ACMR -- '*.php' | xargs -0 "$sorter" --check >/dev/null 2>&1; then
+  exit 0
+fi
+git diff --cached --name-only -z --diff-filter=ACMR -- '*.php' | xargs -0 "$sorter"
+echo >&2
+echo "Sorted Tailwind classes in staged PHP (see above)." >&2
+echo "Review the changes, re-stage, and commit again." >&2
+exit 1
+`;
+/**
+ * Parse `init` subcommand arguments.
+ *
+ * @param argv Arguments after the `init` subcommand name.
+ * @returns Parsed flags with defaults applied.
+ */
+function parseArgs(argv) {
+    const cli = { fix: false, force: false, dryRun: false };
+    for (const a of argv) {
+        if (a === '--fix')
+            cli.fix = true;
+        else if (a === '--force')
+            cli.force = true;
+        else if (a === '--dry-run')
+            cli.dryRun = true;
+        else {
+            console.error(`Unknown init option: ${a}`);
+            process.exit(2);
+        }
+    }
+    return cli;
+}
+/**
+ * Run a git command and capture its output.
+ *
+ * @param args Arguments passed to `git`.
+ * @returns Trimmed stdout, or `null` when git exits non-zero (unset config, not a repo, …).
+ */
+function git(args) {
+    try {
+        return execFileSync('git', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Print an error to stderr and exit with status 1.
+ *
+ * @param message Error text explaining why init refused to proceed.
+ */
+function fail(message) {
+    console.error(message);
+    process.exit(1);
+}
+/**
+ * Run the `init` subcommand: install the pre-commit hook and point `core.hooksPath` at it.
+ *
+ * @param argv Arguments after the `init` subcommand name.
+ */
+export async function runInit(argv) {
+    const cli = parseArgs(argv);
+    const hookBody = cli.fix ? HOOK_FIX : HOOK_CHECK;
+    const variant = cli.fix ? 'fix' : 'check';
+    // Anchor everything at the repository root: a relative `core.hooksPath` resolves there,
+    // and the hook's `./node_modules/...` path assumes hooks run from it (they do, for pre-commit).
+    const top = git(['rev-parse', '--show-toplevel']);
+    if (top === null)
+        fail('Not a git repository (or a bare one) — run init from inside a working tree.');
+    const gitDir = git(['rev-parse', '--absolute-git-dir']);
+    const hookAbs = join(top, HOOK_PATH);
+    // Decide whether `core.hooksPath` needs to change. Repointing it makes git ignore `.git/hooks` entirely,
+    // so refuse to silently disable hooks that already live there.
+    const hooksPath = git(['config', '--get', 'core.hooksPath']);
+    let setConfig = false;
+    if (hooksPath === null) {
+        const live = (await readdir(join(gitDir, 'hooks')).catch(() => [])).filter((f) => !f.endsWith('.sample'));
+        if (live.length > 0 && !cli.force) {
+            fail(`Found existing hook(s) in .git/hooks: ${live.join(', ')}.\n` +
+                `Setting core.hooksPath would disable them. Move them into ${HOOKS_DIR}/ first, ` +
+                'or re-run with --force to proceed anyway.');
+        }
+        setConfig = true;
+    }
+    else if (hooksPath !== HOOKS_DIR) {
+        if (!cli.force) {
+            fail(`core.hooksPath is already set to "${hooksPath}" — add the hook there yourself, or re-run ` +
+                `with --force to repoint it to ${HOOKS_DIR}. Hook body:\n\n${hookBody}`);
+        }
+        setConfig = true;
+    }
+    // Decide whether the hook file needs writing; overwriting a differing hook needs --force.
+    const current = await readFile(hookAbs, 'utf8').catch(() => null);
+    let writeHook = current === null;
+    let repairMode = false;
+    if (current !== null && current !== hookBody) {
+        if (!cli.force) {
+            const installed = current === HOOK_CHECK ? 'the check variant' : current === HOOK_FIX ? 'the --fix variant' : 'a custom hook';
+            fail(`${HOOK_PATH} already exists and differs (${installed} is installed). Re-run with --force to overwrite.`);
+        }
+        writeHook = true;
+    }
+    if (current === hookBody) {
+        // Content is already right; still repair a missing executable bit, or git silently skips the hook.
+        repairMode = ((await stat(hookAbs)).mode & 0o111) === 0;
+    }
+    const done = [];
+    if (writeHook) {
+        if (!cli.dryRun) {
+            await mkdir(join(top, HOOKS_DIR), { recursive: true });
+            await writeFile(hookAbs, hookBody);
+            await chmod(hookAbs, 0o755);
+        }
+        done.push(cli.dryRun ? `would install ${HOOK_PATH} (${variant} variant)` : `installed ${HOOK_PATH} (${variant} variant)`);
+    }
+    if (repairMode) {
+        if (!cli.dryRun)
+            await chmod(hookAbs, 0o755);
+        done.push(cli.dryRun ? `would make ${HOOK_PATH} executable` : `made ${HOOK_PATH} executable`);
+    }
+    if (setConfig) {
+        if (!cli.dryRun)
+            git(['config', 'core.hooksPath', HOOKS_DIR]);
+        done.push(cli.dryRun ? `would set core.hooksPath = ${HOOKS_DIR}` : `set core.hooksPath = ${HOOKS_DIR}`);
+    }
+    if (done.length === 0) {
+        console.log(`Nothing to do — ${HOOK_PATH} (${variant} variant) is already installed.`);
+        return;
+    }
+    for (const line of done)
+        console.log(line);
+}

package/dist/islands.d.ts

@@ -0,0 +1,49 @@
+/**
+ * PHP island detection — the first pass of the two-pass lexer.
+ *
+ * Scans the raw template source and returns the byte ranges of all PHP "islands"
+ * (`<?php ... ?>`, `<?= ... ?>`, and optionally short `<? ... ?>`).
+ *
+ * The closing `?>` is found with a real PHP string/comment lexer, so a `?>` inside a string literal, heredoc/nowdoc,
+ * or block comment does NOT close the island — whereas one inside a `//` or `#` line comment closes it (PHP quirk).
+ *
+ * @see html.ts - second pass; consumes islands via `maskIslands()`.
+ */
+/**
+ * A contiguous region of PHP code within a mixed template source.
+ */
+export interface Island {
+    /**
+     * Inclusive start offset of `<?`.
+     */
+    start: number;
+    /**
+     * Exclusive end offset (just past `?>`, or EOF).
+     */
+    end: number;
+}
+/**
+ * Options controlling PHP open-tag recognition.
+ */
+export interface IslandOptions {
+    /**
+     * Treat bare `<?` as a PHP open tag (short_open_tag).
+     * Default true, with a guard so `<?xml` is never treated as PHP.
+     */
+    shortOpenTags?: boolean;
+}
+/**
+ * Find every PHP island in a mixed PHP/HTML template source.
+ *
+ * Islands are returned in document order and never overlap.
+ * All offsets index into the original (unmodified) source string.
+ *
+ * @param src  Raw template source (mixed PHP/HTML).
+ * @param opts Open-tag recognition options.
+ * @returns Ordered, non-overlapping island ranges.
+ *
+ * @example
+ * const islands = findIslands('<p><?= $x ?></p>');
+ * // [{ start: 3, end: 12 }]
+ */
+export declare function findIslands(src: string, opts?: IslandOptions): Island[];

package/dist/islands.js

@@ -0,0 +1,206 @@
+/**
+ * PHP island detection — the first pass of the two-pass lexer.
+ *
+ * Scans the raw template source and returns the byte ranges of all PHP "islands"
+ * (`<?php ... ?>`, `<?= ... ?>`, and optionally short `<? ... ?>`).
+ *
+ * The closing `?>` is found with a real PHP string/comment lexer, so a `?>` inside a string literal, heredoc/nowdoc,
+ * or block comment does NOT close the island — whereas one inside a `//` or `#` line comment closes it (PHP quirk).
+ *
+ * @see html.ts - second pass; consumes islands via `maskIslands()`.
+ */
+const isIdentStart = (c) => /[A-Za-z_\u0080-\uffff]/.test(c);
+const isIdent = (c) => /[A-Za-z0-9_\u0080-\uffff]/.test(c);
+/**
+ * Find every PHP island in a mixed PHP/HTML template source.
+ *
+ * Islands are returned in document order and never overlap.
+ * All offsets index into the original (unmodified) source string.
+ *
+ * @param src  Raw template source (mixed PHP/HTML).
+ * @param opts Open-tag recognition options.
+ * @returns Ordered, non-overlapping island ranges.
+ *
+ * @example
+ * const islands = findIslands('<p><?= $x ?></p>');
+ * // [{ start: 3, end: 12 }]
+ */
+export function findIslands(src, opts = {}) {
+    const shortTags = opts.shortOpenTags !== false;
+    const islands = [];
+    const len = src.length;
+    let i = 0;
+    while (i < len) {
+        const open = src.indexOf('<?', i);
+        if (open === -1)
+            break;
+        // Classify the open tag.
+        const after = src.slice(open + 2, open + 6).toLowerCase();
+        let bodyStart;
+        if (after.startsWith('php') && (open + 5 >= len || !isIdent(src[open + 5]))) {
+            bodyStart = open + 5;
+        }
+        else if (src[open + 2] === '=') {
+            bodyStart = open + 3;
+        }
+        else if (shortTags && !after.startsWith('xml')) {
+            bodyStart = open + 2;
+        }
+        else {
+            i = open + 2; // not a PHP tag (e.g. `<?xml`) — keep scanning
+            continue;
+        }
+        const end = scanPhpBody(src, bodyStart);
+        islands.push({ start: open, end });
+        i = end;
+    }
+    return islands;
+}
+/**
+ * Scan PHP code starting at `i`, returning the offset just past the closing `?>`,
+ * or `src.length` if the file ends in PHP mode.
+ */
+function scanPhpBody(src, i) {
+    const len = src.length;
+    while (i < len) {
+        const c = src[i];
+        // Possible close tag.
+        if (c === '?' && src[i + 1] === '>')
+            return i + 2;
+        // Single-quoted string.
+        if (c === "'") {
+            i = scanQuoted(src, i + 1, "'");
+            continue;
+        }
+        // Double-quoted string.
+        // Limitation: nested double quotes in complex `{$a["k"]}` interpolation can desync the lexer (documented).
+        if (c === '"') {
+            i = scanQuoted(src, i + 1, '"');
+            continue;
+        }
+        // Backtick (shell exec) string — same escaping rules.
+        if (c === '`') {
+            i = scanQuoted(src, i + 1, '`');
+            continue;
+        }
+        // Comments.
+        if (c === '/' && src[i + 1] === '/') {
+            i = scanLineComment(src, i + 2);
+            if (src.startsWith('?>', i))
+                return i + 2;
+            continue;
+        }
+        if (c === '#') {
+            // PHP 8 attribute `#[...]` is not a comment.
+            if (src[i + 1] === '[') {
+                i += 2;
+                continue;
+            }
+            i = scanLineComment(src, i + 1);
+            if (src.startsWith('?>', i))
+                return i + 2;
+            continue;
+        }
+        if (c === '/' && src[i + 1] === '*') {
+            const close = src.indexOf('*/', i + 2);
+            i = close === -1 ? len : close + 2;
+            continue;
+        }
+        // Heredoc / nowdoc.
+        if (c === '<' && src[i + 1] === '<' && src[i + 2] === '<') {
+            const here = scanHeredoc(src, i + 3);
+            if (here !== -1) {
+                i = here;
+                continue;
+            }
+        }
+        i++;
+    }
+    return len; // file ends while still in PHP mode
+}
+/**
+ * Scan a quoted string body; `i` is just past the open quote.
+ * Returns offset just past the closing quote (or EOF).
+ */
+function scanQuoted(src, i, quote) {
+    const len = src.length;
+    while (i < len) {
+        const c = src[i];
+        if (c === '\\') {
+            i += 2;
+            continue;
+        }
+        if (c === quote)
+            return i + 1;
+        i++;
+    }
+    return len;
+}
+/**
+ * Scan a `//` or `#` line comment body, which ends at a newline or at `?>`.
+ * Returns the offset past a consumed newline, or the offset of an unconsumed `?>`
+ * (left for the caller, since `?>` closes both the comment and the island).
+ */
+function scanLineComment(src, i) {
+    const len = src.length;
+    while (i < len) {
+        if (src[i] === '\n')
+            return i + 1;
+        if (src[i] === '?' && src[i + 1] === '>')
+            return i;
+        i++;
+    }
+    return len;
+}
+/**
+ * Scan a heredoc/nowdoc; `i` is just past `<<<`.
+ * Returns the offset past the closing identifier line, or -1 if `<<<` isn't followed by a valid heredoc identifier.
+ */
+function scanHeredoc(src, i) {
+    const len = src.length;
+    // Optional whitespace (PHP allows spaces/tabs after `<<<`).
+    while (i < len && (src[i] === ' ' || src[i] === '\t'))
+        i++;
+    // Optional quote around the identifier.
+    let quote = '';
+    if (src[i] === "'" || src[i] === '"') {
+        quote = src[i];
+        i++;
+    }
+    if (i >= len || !isIdentStart(src[i]))
+        return -1;
+    const idStart = i;
+    while (i < len && isIdent(src[i]))
+        i++;
+    const id = src.slice(idStart, i);
+    if (quote) {
+        if (src[i] !== quote)
+            return -1;
+        i++;
+    }
+    // After the identifier, the line must end immediately — PHP disallows trailing whitespace,
+    // but we tolerate `\r` so `\r\n` endings still work.
+    while (i < len && src[i] === '\r')
+        i++;
+    if (src[i] !== '\n')
+        return -1;
+    i++;
+    // Find a line that starts with optional indentation,
+    // then the identifier followed by a non-identifier character
+    // (PHP 7.3 flexible syntax).
+    while (i < len) {
+        let j = i;
+        while (j < len && (src[j] === ' ' || src[j] === '\t'))
+            j++;
+        if (src.startsWith(id, j)) {
+            const k = j + id.length;
+            if (k >= len || !isIdent(src[k]))
+                return k;
+        }
+        const nl = src.indexOf('\n', i);
+        if (nl === -1)
+            return len;
+        i = nl + 1;
+    }
+    return len;
+}

package/dist/sorter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Adapter: official Tailwind sorter → core `SortFn`.
+ *
+ * Kept separate from the core so the lexer/transformer stay dependency-free and testable with any injected sorter.
+ *
+ * @see transform.ts - consumes the `SortFn` produced here.
+ */
+import type { SortFn } from './transform.ts';
+/**
+ * Options for constructing the official Tailwind sorter.
+ */
+export interface SorterOptions {
+    /**
+     * Tailwind v4 CSS entry point (`@import "tailwindcss"`, `@theme`, etc.).
+     */
+    stylesheet: string;
+    /**
+     * Base directory for resolving relative paths. Default: `cwd`.
+     */
+    base?: string;
+}
+/**
+ * Create a `SortFn` backed by the official `prettier-plugin-tailwindcss` sorting engine, configured with
+ * the project's Tailwind v4 stylesheet so custom `@theme` tokens and `@utility` classes sort correctly.
+ *
+ * Requires `prettier-plugin-tailwindcss` >= 0.8 (the `/sorter` entrypoint).
+ *
+ * @param opts Stylesheet and path resolution options.
+ * @returns A synchronous `SortFn` for use with `transform()`.
+ */
+export declare function createTailwindSortFn(opts: SorterOptions): Promise<SortFn>;

package/dist/sorter.js

@@ -0,0 +1,26 @@
+/**
+ * Adapter: official Tailwind sorter → core `SortFn`.
+ *
+ * Kept separate from the core so the lexer/transformer stay dependency-free and testable with any injected sorter.
+ *
+ * @see transform.ts - consumes the `SortFn` produced here.
+ */
+/**
+ * Create a `SortFn` backed by the official `prettier-plugin-tailwindcss` sorting engine, configured with
+ * the project's Tailwind v4 stylesheet so custom `@theme` tokens and `@utility` classes sort correctly.
+ *
+ * Requires `prettier-plugin-tailwindcss` >= 0.8 (the `/sorter` entrypoint).
+ *
+ * @param opts Stylesheet and path resolution options.
+ * @returns A synchronous `SortFn` for use with `transform()`.
+ */
+export async function createTailwindSortFn(opts) {
+    // Dynamic import so the core package works without the dependency
+    // installed (e.g., when only running tests with a mock sorter).
+    const { createSorter } = await import('prettier-plugin-tailwindcss/sorter');
+    const sorter = await createSorter({
+        base: opts.base ?? process.cwd(),
+        stylesheetPath: opts.stylesheet,
+    });
+    return (classes) => sorter.sortClassLists([classes])[0];
+}

package/dist/transform.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Core transform: given template source and a sort function,
+ * rewrite all class attribute values with sorted Tailwind classes.
+ *
+ * Island-aware rules inside an attribute value:
+ *   - PHP islands are opaque atoms that never move.
+ *   - Static text is split into runs between islands; each run's classes are sorted independently
+ *     (mirrors how the official Prettier plugin treats `${}` interpolations in template literals).
+ *   - A token with no whitespace between it and an adjacent island is a *fragment* of a dynamically
+ *     built class (`btn-<?= $v ?>`); it is pinned in place and excluded from sorting.
+ *   - Whitespace adjacent to islands is preserved as a single space — never removed
+ *     (removal would concatenate classes at render time) and never invented
+ *     (insertion would split an intentional fragment).
+ *
+ * @see islands.ts - pass 1 (PHP island detection).
+ * @see html.ts    - pass 2 (attribute location).
+ * @see sorter.ts  - adapter producing the injected `SortFn`.
+ */
+import { type IslandOptions } from './islands.ts';
+import { type HtmlScanOptions } from './html.ts';
+/**
+ * Sorting strategy injected by the caller. Receives the class tokens of a single static run;
+ * returns them in sorted order. Must be pure and synchronous; must not add or remove tokens.
+ */
+export type SortFn = (classes: string[]) => string[];
+/**
+ * Combined options for both lexer passes.
+ */
+export interface TransformOptions extends IslandOptions, HtmlScanOptions {
+}
+/**
+ * Rewrite all class attribute values in the template source with sorted classes.
+ * Everything outside class attribute values is byte-identical in the result; the function is idempotent.
+ *
+ * @param src    Raw template source (mixed PHP/HTML).
+ * @param sortFn Injected sorting strategy (see `createTailwindSortFn()`).
+ * @param opts   Lexer options.
+ * @returns The rewritten source.
+ *
+ * @example
+ * transform('<div class="z-10 mt-4 <?= $x ?> b a">', sortFn);
+ * // '<div class="mt-4 z-10 <?= $x ?> a b">'
+ */
+export declare function transform(src: string, sortFn: SortFn, opts?: TransformOptions): string;

package/dist/transform.js

@@ -0,0 +1,108 @@
+/**
+ * Core transform: given template source and a sort function,
+ * rewrite all class attribute values with sorted Tailwind classes.
+ *
+ * Island-aware rules inside an attribute value:
+ *   - PHP islands are opaque atoms that never move.
+ *   - Static text is split into runs between islands; each run's classes are sorted independently
+ *     (mirrors how the official Prettier plugin treats `${}` interpolations in template literals).
+ *   - A token with no whitespace between it and an adjacent island is a *fragment* of a dynamically
+ *     built class (`btn-<?= $v ?>`); it is pinned in place and excluded from sorting.
+ *   - Whitespace adjacent to islands is preserved as a single space — never removed
+ *     (removal would concatenate classes at render time) and never invented
+ *     (insertion would split an intentional fragment).
+ *
+ * @see islands.ts - pass 1 (PHP island detection).
+ * @see html.ts    - pass 2 (attribute location).
+ * @see sorter.ts  - adapter producing the injected `SortFn`.
+ */
+import { findIslands } from "./islands.js";
+import { maskIslands, findClassAttributes } from "./html.js";
+/**
+ * Rewrite all class attribute values in the template source with sorted classes.
+ * Everything outside class attribute values is byte-identical in the result; the function is idempotent.
+ *
+ * @param src    Raw template source (mixed PHP/HTML).
+ * @param sortFn Injected sorting strategy (see `createTailwindSortFn()`).
+ * @param opts   Lexer options.
+ * @returns The rewritten source.
+ *
+ * @example
+ * transform('<div class="z-10 mt-4 <?= $x ?> b a">', sortFn);
+ * // '<div class="mt-4 z-10 <?= $x ?> a b">'
+ */
+export function transform(src, sortFn, opts = {}) {
+    const islands = findIslands(src, opts);
+    const masked = maskIslands(src, islands);
+    const attrs = findClassAttributes(masked, opts);
+    // Apply replacements back-to-front so offsets stay valid.
+    let out = src;
+    for (let a = attrs.length - 1; a >= 0; a--) {
+        const { valueStart, valueEnd } = attrs[a];
+        const original = src.slice(valueStart, valueEnd);
+        const inner = islands.filter((isl) => isl.start >= valueStart && isl.end <= valueEnd);
+        const rewritten = rewriteValue(original, valueStart, inner, sortFn);
+        if (rewritten !== original) {
+            out = out.slice(0, valueStart) + rewritten + out.slice(valueEnd);
+        }
+    }
+    return out;
+}
+function rewriteValue(value, base, islands, sortFn) {
+    // Build alternating static/island parts.
+    const parts = [];
+    let pos = 0;
+    for (const isl of islands) {
+        const s = isl.start - base;
+        const e = isl.end - base;
+        parts.push({ type: 'static', text: value.slice(pos, s) });
+        parts.push({ type: 'island', text: value.slice(s, e) });
+        pos = e;
+    }
+    parts.push({ type: 'static', text: value.slice(pos) });
+    let out = '';
+    for (let p = 0; p < parts.length; p++) {
+        const part = parts[p];
+        if (part.type === 'island') {
+            out += part.text;
+            continue;
+        }
+        const prevIsIsland = p > 0;
+        const nextIsIsland = p < parts.length - 1;
+        const t = part.text;
+        const hasLeadingWs = /^\s/.test(t);
+        const hasTrailingWs = /\s$/.test(t);
+        const tokens = t.split(/\s+/).filter(Boolean);
+        // Whitespace-only run between islands → preserve a single space.
+        if (tokens.length === 0) {
+            if (t.length > 0 && prevIsIsland && nextIsIsland)
+                out += ' ';
+            continue;
+        }
+        const pinStart = prevIsIsland && !hasLeadingWs;
+        const pinEnd = nextIsIsland && !hasTrailingWs;
+        let head = [];
+        let tail = [];
+        let middle;
+        if (pinStart && pinEnd && tokens.length === 1) {
+            // Single fragment glued to islands on both sides.
+            middle = [];
+            head = [tokens[0]];
+        }
+        else {
+            const from = pinStart ? 1 : 0;
+            const to = pinEnd ? tokens.length - 1 : tokens.length;
+            if (pinStart)
+                head = [tokens[0]];
+            if (pinEnd)
+                tail = [tokens[tokens.length - 1]];
+            middle = tokens.slice(from, to);
+        }
+        const sorted = middle.length > 1 ? sortFn(middle) : middle;
+        const joined = [...head, ...sorted, ...tail].join(' ');
+        const prefix = prevIsIsland && hasLeadingWs ? ' ' : '';
+        const suffix = nextIsIsland && hasTrailingWs ? ' ' : '';
+        out += prefix + joined + suffix;
+    }
+    return out;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@runtimestudio/tailwind-sort-php",
-  "version": "0.1.0",
-  "description": "Tailwind CSS class sorting for mixed PHP/HTML templates (WordPress-friendly)",
+  "version": "0.2.0",
+  "description": "Tailwind CSS Class Sorter for PHP",
   "keywords": [
     "class-sorting",
     "formatter",
@@ -15,27 +15,34 @@
   "license": "MIT",
   "author": "Greg Sevastos <greg@runtimestudio.com.au> (https://runtimestudio.com.au)",
   "files": [
+    "dist",
     "src"
   ],
-  "main": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "type": "module",
   "bin": {
-    "tailwind-sort-php": "src/cli.ts"
+    "tailwind-sort-php": "dist/cli.js"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/runtime-studio-au/tailwind-sort-php.git"
   },
   "scripts": {
+    "build": "tsc -p tsconfig.build.json",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
+    "prepublishOnly": "npm test && npm run build",
     "sort": "bun run src/cli.ts",
     "sort:check": "bun run src/cli.ts --check",
     "test": "node --test \"test/*.test.ts\""
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "prettier": "^3.8"
+    "prettier": "^3.8",
+    "prettier-plugin-tailwindcss": "^0.8",
+    "tailwindcss": "^4",
+    "typescript": ">=5.7"
   },
   "peerDependencies": {
     "prettier": ">=3",