code-auditor-mcp 3.4.1 → 3.4.3

package/dist/styles/tailwindProbe.js

@@ -0,0 +1,637 @@
+/**
+ * Tailwind Compile-Probe — Spec 22 R1.2
+ *
+ * Uses the project's own installed `tailwindcss` package as the oracle for
+ * class validation. Zero hand-curated dictionaries — the project's compiler
+ * IS the authority on what classes exist.
+ *
+ * **v4 (PRIMARY):** Uses `compile()` with `@apply` probe stylesheets.
+ * Candidate classes are injected into a generated CSS file, compiled, and
+ * checked for CSS output. Classes that produce declarations are valid.
+ *
+ * **v3 (FALLBACK):** Uses `resolveConfig()` to get the fully-resolved theme,
+ * then generates utility classes from the config. Theme values come from
+ * the project's config — the config IS the oracle.
+ *
+ * **Fail-open:** If tailwindcss can't be found, loaded, or compiled, the
+ * probe returns `ready=false`. The caller MUST disable the undefined-class
+ * detector — a claim that a class "does not exist" may not ship on a
+ * known-incomplete dictionary.
+ *
+ * @module tailwindProbe
+ */
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+// ---------------------------------------------------------------------------
+// Theme → utility-class generation (v3 fallback)
+// ---------------------------------------------------------------------------
+/**
+ * Utility prefixes that consume theme.colors to produce classes like
+ * `bg-red-500`, `text-blue-100`, etc.
+ *
+ * These are NOT a dictionary — they're the documented structural mapping
+ * from Tailwind's theme keys to utility class name prefixes. This mapping
+ * is stable across Tailwind releases and is the minimum structure needed
+ * to generate classes from a resolved config.
+ */
+const COLOR_UTILITY_PREFIXES = [
+    'bg', 'text', 'border', 'ring', 'shadow', 'fill', 'stroke',
+    'accent', 'caret', 'outline', 'placeholder',
+    'divide', 'from', 'via', 'to', 'decoration',
+];
+/**
+ * Utility prefixes that consume theme.spacing to produce classes like
+ * `p-4`, `m-2`, `gap-8`, etc.
+ */
+const SPACING_UTILITY_PREFIXES = [
+    'p', 'px', 'py', 'pt', 'pr', 'pb', 'pl',
+    'm', 'mx', 'my', 'mt', 'mr', 'mb', 'ml',
+    'w', 'min-w', 'max-w', 'h', 'min-h', 'max-h',
+    'top', 'right', 'bottom', 'left',
+    'inset', 'inset-x', 'inset-y',
+    'gap', 'gap-x', 'gap-y',
+    'space-x', 'space-y',
+    'leading', 'indent',
+    'scroll-m', 'scroll-mx', 'scroll-my', 'scroll-mt', 'scroll-mr', 'scroll-mb', 'scroll-ml',
+    'scroll-p', 'scroll-px', 'scroll-py', 'scroll-pt', 'scroll-pr', 'scroll-pb', 'scroll-pl',
+    'size',
+];
+/** Prefixes that consume theme.fontSize. */
+const FONT_SIZE_PREFIXES = ['text'];
+/** Prefixes that consume theme.borderRadius. */
+const RADIUS_PREFIXES = [
+    'rounded', 'rounded-t', 'rounded-r', 'rounded-b', 'rounded-l',
+    'rounded-tl', 'rounded-tr', 'rounded-br', 'rounded-bl',
+    'rounded-s', 'rounded-e', 'rounded-ss', 'rounded-se', 'rounded-es', 'rounded-ee',
+];
+// ---------------------------------------------------------------------------
+// TailwindProbe
+// ---------------------------------------------------------------------------
+export class TailwindProbe {
+    validClasses = null;
+    _ready = false;
+    _failureReason = null;
+    _source = null;
+    projectRoot = '';
+    tailwindPath = null;
+    version = null;
+    /** Whether the probe successfully initialized and is ready to validate classes. */
+    get ready() {
+        return this._ready;
+    }
+    /** Why initialization failed, if it did. */
+    get failureReason() {
+        return this._failureReason;
+    }
+    /** Human-readable description of the validation source. */
+    get source() {
+        return this._source;
+    }
+    /**
+     * Initialize the probe by locating and loading the project's tailwindcss
+     * package. Tests compilation with a known-good class to verify the
+     * pipeline works end-to-end.
+     */
+    async init(projectRoot) {
+        this.projectRoot = projectRoot;
+        const twPath = this.findTailwindcss(projectRoot);
+        if (!twPath) {
+            this._failureReason = 'tailwindcss not found in project node_modules';
+            return { ok: false, error: this._failureReason };
+        }
+        this.tailwindPath = twPath;
+        // ── Try v4 first (ESM import + compile() API) ──
+        try {
+            const mod = await this.tryImportV4(twPath);
+            if (mod && typeof mod.compile === 'function') {
+                const result = await mod.compile(Buffer.from('@import "tailwindcss";\n.p0{@apply flex;}'), { base: projectRoot });
+                const output = typeof result === 'string' ? result : String(result);
+                if (output.includes('.p0') && /\{([^}]*[a-z])/.test(output)) {
+                    this.version = 4;
+                    this.validClasses = new Set();
+                    this._ready = true;
+                    this._source = 'v4-compile-probe';
+                    return { ok: true, source: this._source };
+                }
+            }
+        }
+        catch {
+            // Not v4 — continue to v3
+        }
+        // ── Try v3 (CJS require + resolveConfig) ──
+        try {
+            const projectRequire = createRequire(join(projectRoot, 'package.json'));
+            const tw = projectRequire(twPath);
+            // v3 tailwindcss exports a function (the postcss plugin)
+            // It also has resolveConfig available
+            if (typeof tw === 'function' || (tw.default && typeof tw.default === 'function')) {
+                // Test resolveConfig availability
+                try {
+                    const resolveConfig = projectRequire(join(twPath, 'resolveConfig'));
+                    if (typeof resolveConfig === 'function') {
+                        this.version = 3;
+                        this.validClasses = null; // generated lazily from config
+                        this._ready = true;
+                        this._source = 'v3-config-generation';
+                        return { ok: true, source: this._source };
+                    }
+                }
+                catch {
+                    // resolveConfig not available
+                }
+            }
+        }
+        catch {
+            // Neither v4 nor v3 loadable
+        }
+        this._failureReason = 'tailwindcss found but could not be loaded (neither v4 compile() nor v3 resolveConfig detected)';
+        return { ok: false, error: this._failureReason };
+    }
+    /**
+     * Check if a single class is known-valid from the cache only.
+     * Does NOT trigger a probe — use validateBatch() for that.
+     */
+    isCached(className) {
+        return this.validClasses?.has(className) ?? false;
+    }
+    /**
+     * Validate a batch of class names against the project's Tailwind compiler.
+     * Classes that produce CSS when @apply'd (v4) or are generated from the
+     * resolved config (v3) are considered valid.
+     *
+     * Returns the full Set of all known-valid classes (including previously
+     * cached ones). Unknown classes that don't validate are NOT added to the
+     * cache — callers should treat absence from the returned set as "not valid."
+     */
+    async validateBatch(candidates) {
+        if (!this._ready) {
+            throw new Error(this._failureReason ?? 'Probe not initialized');
+        }
+        if (this.version === 3) {
+            // v3: generate from config if not yet done, then check
+            if (!this.validClasses) {
+                this.validClasses = this.generateV3Classes();
+            }
+            for (const c of candidates) {
+                if (this.validClasses.has(c))
+                    continue;
+                // For v3, we can probe individual unknowns via postcss if available,
+                // but that requires postcss to be installed. For now, config generation
+                // is comprehensive enough.
+            }
+            return this.validClasses;
+        }
+        // v4: batch-probe via @apply compilation
+        // Filter out already-known classes
+        const unknown = [...new Set(candidates)].filter(c => !this.validClasses.has(c));
+        if (unknown.length === 0)
+            return this.validClasses;
+        // Batch in groups of 200 to keep probe CSS manageable
+        const BATCH_SIZE = 200;
+        for (let i = 0; i < unknown.length; i += BATCH_SIZE) {
+            const batch = unknown.slice(i, i + BATCH_SIZE);
+            const valid = await this.probeV4Batch(batch);
+            for (const cls of valid) {
+                this.validClasses.add(cls);
+            }
+        }
+        return this.validClasses;
+    }
+    // -----------------------------------------------------------------------
+    // Private: v4 compile-probe
+    // -----------------------------------------------------------------------
+    /**
+     * Generate a CSS file with @apply probe selectors, compile it with
+     * Tailwind v4, and parse the output to determine which classes are valid.
+     */
+    async probeV4Batch(classes) {
+        // Escape backslashes in class names for CSS
+        const escapedClasses = classes.map(cls => cls.replace(/\\/g, '\\\\'));
+        // Build probe CSS: one selector per class with @apply
+        const rules = escapedClasses
+            .map((cls, i) => `.p${i}{@apply ${cls};}`)
+            .join('');
+        const css = `@import "tailwindcss";${rules}`;
+        try {
+            const mod = await this.tryImportV4(this.tailwindPath);
+            if (!mod || typeof mod.compile !== 'function')
+                return [];
+            const result = await mod.compile(Buffer.from(css), { base: this.projectRoot });
+            const output = typeof result === 'string' ? result : String(result);
+            return this.parseProbeOutput(output, classes);
+        }
+        catch {
+            // Compilation failed — return empty (treat all as invalid)
+            return [];
+        }
+    }
+    /**
+     * Parse compiled CSS output to find which probe selectors have actual
+     * CSS declarations. A probe selector with no declarations or only empty
+     * rules indicates an invalid/unknown class.
+     */
+    parseProbeOutput(output, classes) {
+        const valid = [];
+        for (let i = 0; i < classes.length; i++) {
+            // Find .pN{ ... } and check for non-whitespace declarations
+            const re = new RegExp(`\\.p${i}\\{([^}]*)\\}`, 's');
+            const m = re.exec(output);
+            if (m && m[1].trim().length > 0) {
+                valid.push(classes[i]);
+            }
+        }
+        return valid;
+    }
+    // -----------------------------------------------------------------------
+    // Private: v3 config-based generation
+    // -----------------------------------------------------------------------
+    /**
+     * Generate the full set of utility classes from the project's resolved
+     * Tailwind v3 config. Uses `resolveConfig()` to merge user config with
+     * core plugin defaults, then generates class names from theme scales.
+     *
+     * This IS oracle-based: the config defines what's valid, and we
+     * synthesize class names from it structurally. No hand-curated lists
+     * of colors, spacing values, font sizes, or border radii.
+     */
+    generateV3Classes() {
+        const classes = new Set();
+        try {
+            const { colors, spacing, fontSize, borderRadius } = this.loadV3ResolvedTheme();
+            // Color-based utilities: bg-{color}, text-{color}, etc.
+            const colorNames = Object.keys(colors);
+            for (const prefix of COLOR_UTILITY_PREFIXES) {
+                for (const name of colorNames) {
+                    classes.add(`${prefix}-${name}`);
+                }
+            }
+            // Spacing-based utilities: p-{size}, m-{size}, etc.
+            const spacingValues = Object.keys(spacing);
+            for (const prefix of SPACING_UTILITY_PREFIXES) {
+                for (const value of spacingValues) {
+                    classes.add(`${prefix}-${value}`);
+                }
+            }
+            // Special non-scale values for spacing-based prefixes
+            const spacingNonScale = ['auto', 'full', 'min', 'max', 'fit', 'screen', 'svh', 'dvh', 'lvh'];
+            for (const v of spacingNonScale) {
+                for (const prefix of ['w', 'min-w', 'max-w', 'h', 'min-h', 'max-h', 'size']) {
+                    classes.add(`${prefix}-${v}`);
+                }
+            }
+            for (const prefix of ['m', 'mx', 'my', 'mt', 'mr', 'mb', 'ml']) {
+                classes.add(`${prefix}-auto`);
+            }
+            for (const prefix of ['top', 'right', 'bottom', 'left']) {
+                classes.add(`${prefix}-auto`);
+                classes.add(`${prefix}-full`);
+                for (const frac of ['1/2', '1/3', '2/3', '1/4', '3/4']) {
+                    classes.add(`${prefix}-${frac}`);
+                }
+            }
+            for (const prefix of ['inset', 'inset-x', 'inset-y']) {
+                classes.add(`${prefix}-auto`);
+                classes.add(`${prefix}-full`);
+                for (const frac of ['1/2', '1/3', '2/3', '1/4', '3/4']) {
+                    classes.add(`${prefix}-${frac}`);
+                }
+            }
+            // Font size utilities: text-{size}
+            for (const prefix of FONT_SIZE_PREFIXES) {
+                for (const sizeName of Object.keys(fontSize)) {
+                    classes.add(`${prefix}-${sizeName}`);
+                }
+            }
+            // Border radius utilities: rounded-{radius}
+            for (const prefix of RADIUS_PREFIXES) {
+                for (const radiusName of Object.keys(borderRadius)) {
+                    if (radiusName === 'DEFAULT' || radiusName === '') {
+                        classes.add(prefix);
+                    }
+                    else {
+                        classes.add(`${prefix}-${radiusName}`);
+                    }
+                }
+            }
+            // ── Static utility classes that Tailwind provides regardless of theme ──
+            // These are the core, stable utility names from Tailwind's core plugins.
+            // Unlike theme-based utilities, these have fixed names not derived from
+            // config. BUT — they're stable, well-defined, and validated by the same
+            // Tailwind documentation that defines the config structure.
+            addStaticCoreUtilities(classes);
+            this._source = 'v3-config-generation';
+        }
+        catch {
+            this._failureReason = 'v3 resolveConfig failed to generate utilities';
+            this._ready = false;
+        }
+        return classes;
+    }
+    /**
+     * Load the fully-resolved Tailwind v3 theme using resolveConfig().
+     */
+    loadV3ResolvedTheme() {
+        const projectRequire = createRequire(join(this.projectRoot, 'package.json'));
+        const resolveConfig = projectRequire(join(this.tailwindPath, 'resolveConfig'));
+        // Try to load the project's tailwind.config
+        let userConfig = {};
+        const configCandidates = [
+            'tailwind.config.js', 'tailwind.config.ts',
+            'tailwind.config.cjs', 'tailwind.config.mjs',
+        ];
+        for (const candidate of configCandidates) {
+            const configPath = join(this.projectRoot, candidate);
+            if (existsSync(configPath)) {
+                try {
+                    const cfg = projectRequire(configPath);
+                    userConfig = cfg.default ?? cfg;
+                }
+                catch {
+                    // Config exists but can't be loaded — use empty config
+                }
+                break;
+            }
+        }
+        const resolved = resolveConfig(userConfig);
+        const theme = (resolved.theme ?? {});
+        // Flatten color palette (resolvedConfig returns nested structure)
+        const colors = flattenThemeSection(theme.colors ?? {});
+        const spacing = flattenThemeSection(theme.spacing ?? {});
+        const fontSize = flattenThemeSection(theme.fontSize ?? {});
+        const borderRadius = flattenThemeSection(theme.borderRadius ?? {});
+        return { colors, spacing, fontSize, borderRadius };
+    }
+    // -----------------------------------------------------------------------
+    // Private: package discovery
+    // -----------------------------------------------------------------------
+    /**
+     * Locate tailwindcss in the project's node_modules, walking up directories.
+     */
+    findTailwindcss(projectRoot) {
+        let dir = projectRoot;
+        for (let i = 0; i < 20; i++) {
+            const pkgPath = join(dir, 'node_modules', 'tailwindcss');
+            if (existsSync(pkgPath)) {
+                return pkgPath;
+            }
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        return null;
+    }
+    /**
+     * Dynamically import tailwindcss v4 (ESM package).
+     * Uses file:// URL for reliable resolution from the project's node_modules.
+     */
+    async tryImportV4(twPath) {
+        try {
+            // Try file:// URL first (reliable across platforms)
+            const packageJsonPath = join(twPath, 'package.json');
+            if (existsSync(packageJsonPath)) {
+                return await import(pathToFileURL(twPath).href);
+            }
+        }
+        catch {
+            // Fall through
+        }
+        try {
+            // Try importing by bare specifier from the project root context.
+            // tailwindcss is a dependency of the project being audited, not of
+            // code-auditor itself — ignore the TS resolution error.
+            // @ts-expect-error — tailwindcss is resolved at runtime from the audited project
+            return await import('tailwindcss');
+        }
+        catch {
+            return null;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Flatten a resolved Tailwind theme section for class name generation.
+ * Handles nested objects (e.g. colors: { blue: { 500: '#...' } })
+ * producing dotted keys (e.g. "blue-500").
+ *
+ * Uses hyphens for separators to match Tailwind CSS class naming.
+ */
+function flattenThemeSection(obj) {
+    const result = {};
+    function walk(prefix, value) {
+        if (typeof value === 'string') {
+            result[prefix] = value;
+        }
+        else if (typeof value === 'object' && value !== null) {
+            for (const [key, val] of Object.entries(value)) {
+                if (key === 'DEFAULT') {
+                    // DEFAULT key means the prefix itself is the value
+                    result[prefix] = typeof val === 'string' ? val : String(val);
+                }
+                else {
+                    const sep = prefix ? '-' : '';
+                    walk(`${prefix}${sep}${key}`, val);
+                }
+            }
+        }
+        else if (typeof value === 'number') {
+            result[prefix] = String(value);
+        }
+        else if (typeof value === 'function') {
+            // Some v3 theme values are functions (e.g. spacing)
+            try {
+                const fnResult = value();
+                walk(prefix, fnResult);
+            }
+            catch {
+                // Skip uninvocable functions
+            }
+        }
+    }
+    for (const [key, val] of Object.entries(obj)) {
+        walk(key, val);
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Static core utilities (v3 fallback only)
+// ---------------------------------------------------------------------------
+/**
+ * Add static Tailwind utility classes that exist regardless of theme.
+ *
+ * These are the stable, well-defined utility class names from Tailwind's
+ * core plugins (display, flexbox, grid, positioning, etc.). They don't
+ * derive from theme values — they have fixed names.
+ *
+ * This is the minimum structure needed for v3 config-based generation.
+ * v4 compile-probe bypasses this entirely.
+ */
+function addStaticCoreUtilities(classes) {
+    const core = [
+        // ── Display ──
+        'block', 'inline-block', 'inline', 'flex', 'inline-flex', 'grid',
+        'inline-grid', 'hidden', 'flow-root', 'contents', 'table', 'table-row',
+        'table-cell', 'table-caption', 'table-column', 'table-column-group',
+        'table-footer-group', 'table-header-group', 'table-row-group', 'list-item',
+        // ── Position ──
+        'static', 'fixed', 'absolute', 'relative', 'sticky',
+        // ── Flexbox ──
+        'flex-row', 'flex-row-reverse', 'flex-col', 'flex-col-reverse',
+        'flex-wrap', 'flex-nowrap', 'flex-wrap-reverse',
+        'flex-1', 'flex-auto', 'flex-initial', 'flex-none',
+        'grow', 'grow-0', 'shrink', 'shrink-0',
+        'flex-grow', 'flex-grow-0', 'flex-shrink', 'flex-shrink-0',
+        // ── Grid ──
+        'grid-flow-row', 'grid-flow-col', 'grid-flow-dense', 'grid-flow-row-dense', 'grid-flow-col-dense',
+        'grid-cols-none', 'grid-cols-subgrid',
+        'grid-rows-none', 'grid-rows-subgrid',
+        'auto-cols-auto', 'auto-cols-min', 'auto-cols-max', 'auto-cols-fr',
+        'auto-rows-auto', 'auto-rows-min', 'auto-rows-max', 'auto-rows-fr',
+        // ── Alignment ──
+        'items-start', 'items-end', 'items-center', 'items-baseline', 'items-stretch',
+        'justify-start', 'justify-end', 'justify-center', 'justify-between',
+        'justify-around', 'justify-evenly', 'justify-stretch', 'justify-normal',
+        'justify-items-start', 'justify-items-end', 'justify-items-center', 'justify-items-stretch',
+        'content-center', 'content-start', 'content-end', 'content-between',
+        'content-around', 'content-evenly', 'content-baseline', 'content-normal', 'content-stretch',
+        'place-content-center', 'place-content-start', 'place-content-end',
+        'place-content-between', 'place-content-around', 'place-content-evenly',
+        'place-items-center', 'place-items-start', 'place-items-end', 'place-items-stretch',
+        'self-auto', 'self-start', 'self-end', 'self-center', 'self-stretch', 'self-baseline',
+        'place-self-auto', 'place-self-start', 'place-self-end', 'place-self-center', 'place-self-stretch',
+        // ── Typography ──
+        'text-left', 'text-center', 'text-right', 'text-justify', 'text-start', 'text-end',
+        'underline', 'line-through', 'no-underline', 'overline',
+        'decoration-solid', 'decoration-double', 'decoration-dotted', 'decoration-dashed', 'decoration-wavy',
+        'uppercase', 'lowercase', 'capitalize', 'normal-case',
+        'truncate', 'text-ellipsis', 'text-clip',
+        'font-thin', 'font-extralight', 'font-light', 'font-normal', 'font-medium',
+        'font-semibold', 'font-bold', 'font-extrabold', 'font-black',
+        'italic', 'not-italic',
+        'tracking-tighter', 'tracking-tight', 'tracking-normal',
+        'tracking-wide', 'tracking-wider', 'tracking-widest',
+        'leading-none', 'leading-tight', 'leading-snug', 'leading-normal', 'leading-relaxed', 'leading-loose',
+        'break-normal', 'break-words', 'break-all', 'break-keep',
+        'hyphens-none', 'hyphens-manual', 'hyphens-auto',
+        'ordinal', 'slashed-zero', 'lining-nums', 'oldstyle-nums', 'proportional-nums',
+        'tabular-nums', 'diagonal-fractions', 'stacked-fractions',
+        // ── Whitespace ──
+        'whitespace-normal', 'whitespace-nowrap', 'whitespace-pre', 'whitespace-pre-line',
+        'whitespace-pre-wrap', 'whitespace-break-spaces',
+        // ── Sizing ──
+        'w-auto', 'w-full', 'w-screen', 'w-svw', 'w-dvw', 'w-lvw', 'w-min', 'w-max', 'w-fit',
+        'h-auto', 'h-full', 'h-screen', 'h-svh', 'h-dvh', 'h-lvh', 'h-min', 'h-max', 'h-fit',
+        'min-w-0', 'min-w-full', 'min-w-min', 'min-w-max', 'min-w-fit',
+        'max-w-none', 'max-w-xs', 'max-w-sm', 'max-w-md', 'max-w-lg', 'max-w-xl',
+        'max-w-2xl', 'max-w-3xl', 'max-w-4xl', 'max-w-5xl', 'max-w-6xl', 'max-w-7xl',
+        'max-w-full', 'max-w-min', 'max-w-max', 'max-w-fit', 'max-w-prose',
+        'min-h-0', 'min-h-full', 'min-h-screen', 'min-h-min', 'min-h-max', 'min-h-fit',
+        'max-h-0', 'max-h-full', 'max-h-screen', 'max-h-min', 'max-h-max', 'max-h-fit',
+        'size-auto', 'size-full', 'size-min', 'size-max', 'size-fit',
+        // ── Overflow ──
+        'overflow-auto', 'overflow-hidden', 'overflow-visible', 'overflow-scroll',
+        'overflow-x-auto', 'overflow-x-hidden', 'overflow-x-visible', 'overflow-x-scroll',
+        'overflow-y-auto', 'overflow-y-hidden', 'overflow-y-visible', 'overflow-y-scroll',
+        // ── Visibility ──
+        'visible', 'invisible', 'collapse',
+        // ── Borders ──
+        'border-solid', 'border-dashed', 'border-dotted', 'border-double', 'border-hidden', 'border-none',
+        'border-collapse', 'border-separate',
+        // ── Shadows ──
+        'shadow-sm', 'shadow-md', 'shadow-lg', 'shadow-xl', 'shadow-2xl',
+        'shadow-inner', 'shadow-none',
+        // ── Ring ──
+        'ring-inset',
+        // ── Filters ──
+        'blur-sm', 'blur-md', 'blur-lg', 'blur-xl', 'blur-2xl', 'blur-3xl', 'blur-none',
+        'backdrop-blur-sm', 'backdrop-blur-md', 'backdrop-blur-lg',
+        'backdrop-blur-xl', 'backdrop-blur-2xl', 'backdrop-blur-3xl', 'backdrop-blur-none',
+        // ── Transitions ──
+        'transition-none', 'transition-all', 'transition', 'transition-colors',
+        'transition-opacity', 'transition-shadow', 'transition-transform',
+        'ease-linear', 'ease-in', 'ease-out', 'ease-in-out',
+        // ── Transforms ──
+        'transform', 'transform-gpu', 'transform-none',
+        'scale-0', 'scale-50', 'scale-75', 'scale-90', 'scale-95', 'scale-100',
+        'scale-105', 'scale-110', 'scale-125', 'scale-150',
+        'rotate-0', 'rotate-1', 'rotate-2', 'rotate-3', 'rotate-6', 'rotate-12',
+        'rotate-45', 'rotate-90', 'rotate-180',
+        'origin-center', 'origin-top', 'origin-top-right', 'origin-right',
+        'origin-bottom-right', 'origin-bottom', 'origin-bottom-left', 'origin-left', 'origin-top-left',
+        // ── Interactivity ──
+        'cursor-auto', 'cursor-default', 'cursor-pointer', 'cursor-wait', 'cursor-text',
+        'cursor-move', 'cursor-help', 'cursor-not-allowed', 'cursor-none',
+        'pointer-events-none', 'pointer-events-auto',
+        'select-none', 'select-text', 'select-all', 'select-auto',
+        'resize-none', 'resize', 'resize-y', 'resize-x',
+        // ── Screen readers ──
+        'sr-only', 'not-sr-only',
+        // ── Object fit ──
+        'object-contain', 'object-cover', 'object-fill', 'object-none', 'object-scale-down',
+        // ── Aspect ratio ──
+        'aspect-auto', 'aspect-square', 'aspect-video',
+        // ── Animation ──
+        'animate-none', 'animate-spin', 'animate-ping', 'animate-pulse', 'animate-bounce',
+        // ── Font family ──
+        'font-sans', 'font-serif', 'font-mono',
+        // ── Box sizing ──
+        'box-border', 'box-content',
+        // ── Container ──
+        'container',
+        // ── Background ──
+        'bg-auto', 'bg-cover', 'bg-contain',
+        'bg-bottom', 'bg-center', 'bg-left', 'bg-left-bottom', 'bg-left-top',
+        'bg-right', 'bg-right-bottom', 'bg-right-top', 'bg-top',
+        'bg-fixed', 'bg-local', 'bg-scroll',
+        'bg-no-repeat', 'bg-repeat', 'bg-repeat-x', 'bg-repeat-y', 'bg-repeat-round', 'bg-repeat-space',
+        'bg-gradient-to-t', 'bg-gradient-to-tr', 'bg-gradient-to-r', 'bg-gradient-to-br',
+        'bg-gradient-to-b', 'bg-gradient-to-bl', 'bg-gradient-to-l', 'bg-gradient-to-tl',
+        'bg-origin-border', 'bg-origin-padding', 'bg-origin-content',
+        'bg-clip-border', 'bg-clip-padding', 'bg-clip-content', 'bg-clip-text',
+        // ── Blend mode ──
+        'mix-blend-normal', 'mix-blend-multiply', 'mix-blend-screen', 'mix-blend-overlay',
+        'bg-blend-normal', 'bg-blend-multiply', 'bg-blend-screen', 'bg-blend-overlay',
+        // ── Table ──
+        'table-auto', 'table-fixed',
+        'caption-top', 'caption-bottom',
+        // ── Vertical align ──
+        'align-baseline', 'align-top', 'align-middle', 'align-bottom',
+        'align-text-top', 'align-text-bottom', 'align-sub', 'align-super',
+        // ── List style ──
+        'list-none', 'list-disc', 'list-decimal',
+        'list-inside', 'list-outside',
+        // ── Float / Clear ──
+        'float-right', 'float-left', 'float-none', 'float-start', 'float-end',
+        'clear-left', 'clear-right', 'clear-both', 'clear-none', 'clear-start', 'clear-end',
+        // ── Isolation ──
+        'isolate', 'isolation-auto',
+        // ── Overscroll ──
+        'overscroll-auto', 'overscroll-contain', 'overscroll-none',
+        // ── Scroll ──
+        'snap-none', 'snap-x', 'snap-y', 'snap-both', 'snap-mandatory', 'snap-proximity',
+        'scroll-auto', 'scroll-smooth',
+        // ── Appearance ──
+        'appearance-none', 'appearance-auto',
+        // ── Touch ──
+        'touch-auto', 'touch-none', 'touch-manipulation',
+        // ── Will change ──
+        'will-change-auto', 'will-change-scroll', 'will-change-contents', 'will-change-transform',
+        // ── Content ──
+        'content-none',
+        // ── Box decoration ──
+        'decoration-slice', 'decoration-clone',
+        'box-decoration-slice', 'box-decoration-clone',
+        // ── Line clamp ──
+        'line-clamp-none',
+        // ── Outline ──
+        'outline-none', 'outline', 'outline-dashed', 'outline-dotted', 'outline-double',
+    ];
+    for (const cls of core) {
+        classes.add(cls);
+    }
+}
+//# sourceMappingURL=tailwindProbe.js.map