svelte-ag 1.1.17 → 1.2.0

package/dist/bin/build-tailwind-manifest.d.ts

@@ -0,0 +1,15 @@
+//#region dist/bin/build-tailwind-manifest.d.ts
+type GeneratorOptions = {
+  exportFilters: string[];
+};
+/** Build a Tailwind source manifest for one package export map. */
+declare function generateTailwindManifestForPackage(packageDir: string, options: GeneratorOptions): Promise<{
+  didWrite: boolean;
+  outputFile: string;
+  exportCount: number;
+}>;
+/** Run the manifest builder once or in watch mode from the current working directory. */
+declare function main(argv?: string[]): Promise<void>;
+//#endregion
+export { generateTailwindManifestForPackage, main };
+//# sourceMappingURL=build-tailwind-manifest.d.ts.map

package/dist/bin/build-tailwind-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-tailwind-manifest.d.ts","names":["GeneratorOptions","exportFilters","generateTailwindManifestForPackage","Promise","packageDir","options","didWrite","outputFile","exportCount","main","argv"],"sources":["../../home/runner/work/svelte-ag/svelte-ag/dist/bin/build-tailwind-manifest.d.ts"],"mappings":";KAAKA,gBAAAA;EACDC,aAAAA;AAAAA;;iBAGoBC,kCAAAA,CAAmCE,UAAAA,UAAoBC,OAAAA,EAASL,gBAAAA,GAAmBG,OAAAA;EACvGG,QAAAA;EACAC,UAAAA;EACAC,WAAAA;AAAAA;;iBAGoBC,IAAAA,CAAKC,IAAAA,cAAkBP,OAAAA"}

package/dist/bin/build-tailwind-manifest.js

@@ -0,0 +1,581 @@
+import { existsSync, statSync } from 'node:fs';
+import { glob, readFile, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { init, parse as parseEsm } from 'es-module-lexer';
+import { parse as parseSvelte } from 'svelte/compiler';
+import ts from 'typescript';
+import { readPackageJson, writeIfDifferent } from 'ts-ag';
+import { ensureRelativeManifestSourcePath, getTailwindSourcesManifestPath, normalizeManifestExportFilter, serializeTailwindSourceManifest, shouldIncludeManifestExport } from '../vite/tailwind-sources-manifest.js';
+const WATCH_POLL_INTERVAL_MS = 700;
+const CLASS_COLLECTOR_CALLS = new Set(['cn', 'clsx', 'cva', 'tv']);
+const IGNORED_DIRECTORIES = new Set(['.git', '.svelte-kit', 'node_modules']);
+/** Build a Tailwind source manifest for one package export map. */
+export async function generateTailwindManifestForPackage(packageDir, options) {
+    const packageJson = (await readPackageJson(path.join(packageDir, 'package.json')));
+    if (!packageJson) {
+        throw new Error(`No package.json found in ${packageDir}`);
+    }
+    const manifest = {
+        version: 1,
+        exports: {}
+    };
+    const packageExports = packageJson.exports ?? {};
+    const exportEntries = Object.entries(packageExports).filter(([exportKey]) => shouldIncludeManifestExport(exportKey, options.exportFilters));
+    for (const [exportKey, exportTarget] of exportEntries) {
+        if (exportKey.includes('*') || hasWildcardTarget(exportTarget)) {
+            console.warn(`[tailwind-manifest] Skipping wildcard export ${exportKey} in ${packageDir}`);
+            continue;
+        }
+        const entryFiles = collectRuntimeTargets(exportTarget)
+            .map((target) => resolvePackageEntryFile(packageDir, target))
+            .filter((targetPath) => targetPath !== null);
+        if (entryFiles.length === 0) {
+            continue;
+        }
+        const exportScan = await scanFileGraph(entryFiles, packageDir);
+        const manifestEntry = toManifestLeaf(exportScan);
+        const symbols = await collectExportSymbols(entryFiles, packageDir);
+        if (Object.keys(symbols).length > 0) {
+            manifest.exports[exportKey] = {
+                ...manifestEntry,
+                symbols
+            };
+            continue;
+        }
+        manifest.exports[exportKey] = manifestEntry;
+    }
+    const outputFile = getTailwindSourcesManifestPath(packageDir, packageJson);
+    const didWrite = await writeIfDifferent(outputFile, serializeTailwindSourceManifest(manifest));
+    return { didWrite, outputFile, exportCount: Object.keys(manifest.exports).length };
+}
+/** Resolve exported symbols to their own Tailwind class and CSS source sets. */
+async function collectExportSymbols(entryFiles, packageDir) {
+    const symbols = new Map();
+    for (const entryFile of entryFiles) {
+        const symbolTargets = await readEntrySymbolTargets(entryFile);
+        for (const [symbolName, targetFile] of symbolTargets) {
+            const scan = await scanFileGraph([targetFile], packageDir);
+            const existing = symbols.get(symbolName);
+            if (existing) {
+                for (const className of scan.classes)
+                    existing.classes.add(className);
+                for (const sourcePath of scan.sources)
+                    existing.sources.add(sourcePath);
+                continue;
+            }
+            symbols.set(symbolName, {
+                classes: new Set(scan.classes),
+                sources: new Set(scan.sources)
+            });
+        }
+    }
+    return Object.fromEntries([...symbols.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([symbolName, scan]) => [symbolName, toManifestLeaf(scan)]));
+}
+/** Map re-exported symbol names from an entry file back to local source files. */
+async function readEntrySymbolTargets(entryFile, visited = new Set()) {
+    if (visited.has(entryFile)) {
+        return new Map();
+    }
+    visited.add(entryFile);
+    const source = await readFile(entryFile, 'utf8');
+    const importBindings = new Map();
+    const symbolTargets = new Map();
+    for (const snippet of getModuleSnippets(entryFile, source)) {
+        await init;
+        const [imports, exports] = parseEsm(snippet);
+        for (const parsedImport of imports) {
+            const statement = snippet.slice(parsedImport.ss, parsedImport.se).trim();
+            if (statement === '' || /^import\s+type\b/.test(statement) || /^export\s+type\b/.test(statement)) {
+                continue;
+            }
+            if (statement.startsWith('import')) {
+                const specifier = parsedImport.n;
+                if (!specifier || !isRelativeSpecifier(specifier))
+                    continue;
+                for (const localName of readImportBindingNames(statement)) {
+                    importBindings.set(localName, specifier);
+                }
+                continue;
+            }
+            if (!statement.startsWith('export')) {
+                continue;
+            }
+            const specifier = parsedImport.n;
+            if (!specifier || !isRelativeSpecifier(specifier))
+                continue;
+            const targetFile = resolveLocalImportPath(specifier, entryFile);
+            if (!targetFile)
+                continue;
+            if (/^export\s+\*\s+from\b/.test(statement)) {
+                const nestedTargets = await readEntrySymbolTargets(targetFile, visited);
+                for (const [symbolName, nestedTargetFile] of nestedTargets) {
+                    if (!symbolTargets.has(symbolName)) {
+                        symbolTargets.set(symbolName, nestedTargetFile);
+                    }
+                }
+                continue;
+            }
+            const statementExports = exports.filter((exportRecord) => exportRecord.s >= parsedImport.ss && exportRecord.e <= parsedImport.se);
+            for (const exportRecord of statementExports) {
+                symbolTargets.set(exportRecord.n, targetFile);
+            }
+        }
+        for (const exportRecord of exports) {
+            const localName = exportRecord.ln ?? exportRecord.n;
+            const localSpecifier = importBindings.get(localName);
+            if (!localSpecifier)
+                continue;
+            const targetFile = resolveLocalImportPath(localSpecifier, entryFile);
+            if (!targetFile)
+                continue;
+            if (!symbolTargets.has(exportRecord.n)) {
+                symbolTargets.set(exportRecord.n, targetFile);
+            }
+        }
+    }
+    visited.delete(entryFile);
+    return symbolTargets;
+}
+/** Walk local imports reachable from entry files and collect classes plus CSS sources. */
+async function scanFileGraph(entryFiles, packageDir) {
+    const scan = {
+        classes: new Set(),
+        sources: new Set()
+    };
+    const visited = new Set();
+    const visit = async (filePath) => {
+        if (visited.has(filePath) || !isPathInside(packageDir, filePath)) {
+            return;
+        }
+        visited.add(filePath);
+        const source = await readFile(filePath, 'utf8');
+        collectClassNamesFromFile(filePath, source, scan.classes);
+        if (filePath.endsWith('.css')) {
+            scan.sources.add(ensureRelativeManifestSourcePath(toPosixPath(path.relative(packageDir, filePath))));
+        }
+        for (const specifier of await extractLocalSpecifiers(filePath, source)) {
+            const targetFile = resolveLocalImportPath(specifier, filePath);
+            if (!targetFile)
+                continue;
+            await visit(targetFile);
+        }
+    };
+    for (const entryFile of entryFiles) {
+        await visit(entryFile);
+    }
+    return scan;
+}
+/** Extract likely Tailwind class tokens from markup and script expressions. */
+function collectClassNamesFromFile(filePath, source, out) {
+    const markupSource = getClassAttributeSource(filePath, source);
+    for (const match of markupSource.matchAll(/(?:class|className)\s*=\s*(['"`])([\s\S]*?)\1/g)) {
+        addClassTokens(match[2] ?? '', out);
+    }
+    for (const match of markupSource.matchAll(/(?:class|className)\s*=\s*\{([\s\S]*?)\}/g)) {
+        const expression = match[1]?.trim();
+        if (!expression)
+            continue;
+        const sourceFile = createTypeScriptSourceFile(filePath, `(${expression})`);
+        const visit = (node) => {
+            if (ts.isCallExpression(node) && CLASS_COLLECTOR_CALLS.has(getExpressionName(node.expression))) {
+                collectStringLiterals(node, out);
+            }
+            if (ts.isPropertyAssignment(node) && isTailwindTokenPropertyName(node.name)) {
+                collectStringLiterals(node.initializer, out);
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+    }
+    for (const scriptBlock of getModuleSnippets(filePath, source)) {
+        const sourceFile = createTypeScriptSourceFile(filePath, scriptBlock);
+        const visit = (node) => {
+            if (ts.isCallExpression(node) && CLASS_COLLECTOR_CALLS.has(getExpressionName(node.expression))) {
+                collectStringLiterals(node, out);
+            }
+            if (ts.isPropertyAssignment(node) && isTailwindTokenPropertyName(node.name)) {
+                collectStringLiterals(node.initializer, out);
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+    }
+}
+function getClassAttributeSource(filePath, source) {
+    if (!filePath.endsWith('.svelte')) {
+        return source;
+    }
+    return source.replaceAll(/<!--[\s\S]*?-->/g, '');
+}
+function getModuleSnippets(filePath, source) {
+    if (!filePath.endsWith('.svelte')) {
+        return [source];
+    }
+    try {
+        const ast = parseSvelte(source, { filename: filePath, modern: true });
+        const scripts = [ast.module, ast.instance].filter(Boolean);
+        return scripts.map((script) => {
+            const content = script.content;
+            return source.slice(content.start, content.end);
+        });
+    }
+    catch {
+        return [source];
+    }
+}
+/** Recursively collect class tokens from string literal nodes. */
+function collectStringLiterals(node, out) {
+    if (ts.isStringLiteralLike(node)) {
+        addClassTokens(node.text, out);
+    }
+    if (ts.isNoSubstitutionTemplateLiteral(node)) {
+        addClassTokens(node.text, out);
+    }
+    ts.forEachChild(node, (child) => collectStringLiterals(child, out));
+}
+/** Split whitespace-delimited class strings into manifest tokens. */
+function addClassTokens(value, out) {
+    for (const token of value.split(/\s+/)) {
+        const trimmed = token.trim();
+        if (trimmed === '' || trimmed.includes('${'))
+            continue;
+        out.add(trimmed);
+    }
+}
+/** Parse source text with a script kind inferred from the file extension. */
+function createTypeScriptSourceFile(filePath, source) {
+    const scriptKind = filePath.endsWith('.js')
+        ? ts.ScriptKind.JS
+        : filePath.endsWith('.jsx')
+            ? ts.ScriptKind.JSX
+            : filePath.endsWith('.tsx')
+                ? ts.ScriptKind.TSX
+                : ts.ScriptKind.TS;
+    return ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, scriptKind);
+}
+/** Get a stable function name from simple call expressions. */
+function getExpressionName(expression) {
+    if (ts.isIdentifier(expression)) {
+        return expression.text;
+    }
+    if (ts.isPropertyAccessExpression(expression)) {
+        return expression.name.text;
+    }
+    return '';
+}
+/** Match object keys commonly used to hold Tailwind token strings. */
+function isTailwindTokenPropertyName(name) {
+    return (ts.isIdentifier(name) || ts.isStringLiteral(name)) && /class/i.test(name.text);
+}
+/** Find relative imports/exports with module-lexer and CSS imports with a fallback regex. */
+async function extractLocalSpecifiers(filePath, source) {
+    const matches = new Set();
+    await init;
+    const collectEsmSpecifiers = async (snippet) => {
+        const [imports] = parseEsm(snippet);
+        for (const parsedImport of imports) {
+            const specifier = parsedImport.n;
+            if (!specifier || !isRelativeSpecifier(specifier))
+                continue;
+            const statement = snippet.slice(parsedImport.ss, parsedImport.se).trim();
+            if (statement === '' || /^import\s+type\b/.test(statement) || /^export\s+type\b/.test(statement)) {
+                continue;
+            }
+            if (!statement.startsWith('import') && !statement.startsWith('export'))
+                continue;
+            matches.add(specifier);
+        }
+    };
+    if (filePath.endsWith('.svelte')) {
+        for (const snippet of getModuleSnippets(filePath, source)) {
+            await collectEsmSpecifiers(snippet);
+        }
+    }
+    else {
+        await collectEsmSpecifiers(source);
+    }
+    for (const match of source.matchAll(/@import\s+['"]([^'"]+)['"]/g)) {
+        const specifier = match[1];
+        if (specifier && isRelativeSpecifier(specifier)) {
+            matches.add(specifier);
+        }
+    }
+    return [...matches];
+}
+/** Check whether a module specifier resolves to a local file. */
+function isRelativeSpecifier(specifier) {
+    return specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('/');
+}
+/** Resolve a relative import from one file to an on-disk source file. */
+function resolveLocalImportPath(specifier, importerPath) {
+    const cleanSpecifier = specifier.split('?')[0]?.split('#')[0] ?? specifier;
+    const targetPath = path.resolve(path.dirname(importerPath), cleanSpecifier);
+    return resolveFileCandidate(targetPath);
+}
+/** Resolve a package export target to its runtime source file. */
+function resolvePackageEntryFile(packageDir, entryTarget) {
+    const normalizedTarget = entryTarget.startsWith('./') ? entryTarget : `./${entryTarget}`;
+    return resolveFileCandidate(path.resolve(packageDir, normalizedTarget));
+}
+/** Try supported source extensions and index files for a target path. */
+function resolveFileCandidate(targetPath) {
+    const candidates = [...buildBaseCandidates(targetPath), ...buildBaseCandidates(path.join(targetPath, 'index'))];
+    for (const candidate of candidates) {
+        if (existsSync(candidate) && statSync(candidate).isFile()) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function buildBaseCandidates(basePath) {
+    const candidates = new Set();
+    const addCandidatesForBase = (candidateBase) => {
+        candidates.add(candidateBase);
+        candidates.add(`${candidateBase}.js`);
+        candidates.add(`${candidateBase}.mjs`);
+        candidates.add(`${candidateBase}.cjs`);
+        candidates.add(`${candidateBase}.ts`);
+        candidates.add(`${candidateBase}.tsx`);
+        candidates.add(`${candidateBase}.jsx`);
+        candidates.add(`${candidateBase}.svelte`);
+        candidates.add(`${candidateBase}.svelte.ts`);
+        candidates.add(`${candidateBase}.css`);
+    };
+    addCandidatesForBase(basePath);
+    const emittedBasePath = stripEmittedModuleExtension(basePath);
+    if (emittedBasePath !== basePath) {
+        addCandidatesForBase(emittedBasePath);
+    }
+    return [...candidates];
+}
+function stripEmittedModuleExtension(targetPath) {
+    return targetPath.replace(/\.(?:mjs|cjs|js)$/i, '');
+}
+function readImportBindingNames(statement) {
+    const fromMatch = statement.match(/^import\s+([\s\S]*?)\s+from\s*['"][^'"]+['"]\s*;?$/);
+    if (!fromMatch) {
+        return [];
+    }
+    const importClause = fromMatch[1]?.trim();
+    if (!importClause || importClause.startsWith('type ')) {
+        return [];
+    }
+    const bindingNames = [];
+    const namedImportsMatch = importClause.match(/\{([\s\S]*?)\}/);
+    if (namedImportsMatch) {
+        for (const rawImport of namedImportsMatch[1].split(',')) {
+            const trimmedImport = rawImport.trim();
+            if (trimmedImport === '' || trimmedImport.startsWith('type '))
+                continue;
+            const aliasParts = trimmedImport.split(/\s+as\s+/i).map((part) => part.trim());
+            const localName = aliasParts.at(-1);
+            if (localName) {
+                bindingNames.push(localName);
+            }
+        }
+    }
+    const remainingClause = importClause
+        .replace(/\{[\s\S]*?\}/, '')
+        .trim()
+        .replace(/,$/, '')
+        .trim();
+    if (remainingClause !== '') {
+        for (const segment of remainingClause
+            .split(',')
+            .map((part) => part.trim())
+            .filter(Boolean)) {
+            if (segment.startsWith('* as ')) {
+                bindingNames.push(segment.slice(5).trim());
+                continue;
+            }
+            if (!segment.startsWith('type ')) {
+                bindingNames.push(segment);
+            }
+        }
+    }
+    return bindingNames;
+}
+/** Flatten runtime export targets while skipping type-only branches. */
+function collectRuntimeTargets(target) {
+    if (typeof target === 'string') {
+        return target.endsWith('.d.ts') ? [] : [target];
+    }
+    if (Array.isArray(target)) {
+        return target.flatMap(collectRuntimeTargets);
+    }
+    return Object.entries(target).flatMap(([key, value]) => {
+        if (key === 'types') {
+            return [];
+        }
+        return collectRuntimeTargets(value);
+    });
+}
+/** Detect wildcard exports that cannot be resolved to fixed source files. */
+function hasWildcardTarget(target) {
+    if (typeof target === 'string') {
+        return target.includes('*');
+    }
+    if (Array.isArray(target)) {
+        return target.some(hasWildcardTarget);
+    }
+    return Object.values(target).some(hasWildcardTarget);
+}
+/** Convert collected sets into the manifest's sorted JSON shape. */
+function toManifestLeaf(scan) {
+    return {
+        classes: [...scan.classes].sort(),
+        sources: [...scan.sources].sort()
+    };
+}
+/** Guard graph traversal so scans stay inside the current package. */
+function isPathInside(parentPath, childPath) {
+    const relativePath = path.relative(parentPath, childPath);
+    return relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath));
+}
+/** Normalize file paths for manifest stability across platforms. */
+function toPosixPath(filePath) {
+    return filePath.replaceAll('\\', '/');
+}
+/** Resolve package directories from `package.json` globs relative to the working directory. */
+async function discoverPackageDirectories(rootDir, packagePatterns) {
+    const rootPackageJson = path.join(rootDir, 'package.json');
+    if (packagePatterns.length === 0 && existsSync(rootPackageJson)) {
+        return [rootDir];
+    }
+    const packageJsonPaths = new Set();
+    for (const pattern of packagePatterns) {
+        for await (const matchedPath of glob(pattern, { cwd: rootDir })) {
+            const absolutePath = path.resolve(rootDir, matchedPath);
+            if (path.basename(absolutePath) !== 'package.json') {
+                continue;
+            }
+            packageJsonPaths.add(absolutePath);
+        }
+    }
+    return [...packageJsonPaths].map((packageJsonPath) => path.dirname(packageJsonPath)).sort();
+}
+/** Generate manifests for every matching package and report what changed. */
+async function runBuild(rootDir, options) {
+    const packageDirs = await discoverPackageDirectories(rootDir, options.packagePatterns);
+    if (packageDirs.length === 0) {
+        throw new Error('[tailwind-manifest] No matching package.json files found.');
+    }
+    for (const packageDir of packageDirs) {
+        const result = await generateTailwindManifestForPackage(packageDir, {
+            exportFilters: options.exportFilters
+        });
+        const relativeOutputPath = path.relative(rootDir, result.outputFile) || result.outputFile;
+        console.log(`[tailwind-manifest] ${result.didWrite ? 'wrote' : 'unchanged'} ${relativeOutputPath} (${result.exportCount} exports)`);
+    }
+    return packageDirs;
+}
+/** Rebuild manifests when any tracked package directory snapshot changes. */
+async function runWatch(rootDir, options) {
+    const packageDirs = await runBuild(rootDir, options);
+    const snapshots = new Map();
+    for (const packageDir of packageDirs) {
+        snapshots.set(packageDir, await createDirectorySnapshot(packageDir));
+    }
+    console.log(`[tailwind-manifest] watching ${packageDirs.length} package${packageDirs.length === 1 ? '' : 's'}`);
+    const interval = setInterval(async () => {
+        for (const packageDir of packageDirs) {
+            const nextSnapshot = await createDirectorySnapshot(packageDir);
+            if (snapshots.get(packageDir) === nextSnapshot) {
+                continue;
+            }
+            snapshots.set(packageDir, nextSnapshot);
+            try {
+                const result = await generateTailwindManifestForPackage(packageDir, {
+                    exportFilters: options.exportFilters
+                });
+                const relativeOutputPath = path.relative(rootDir, result.outputFile) || result.outputFile;
+                console.log(`[tailwind-manifest] ${result.didWrite ? 'wrote' : 'unchanged'} ${relativeOutputPath} (${result.exportCount} exports)`);
+            }
+            catch (error) {
+                console.error(error);
+            }
+        }
+    }, WATCH_POLL_INTERVAL_MS);
+    process.on('SIGINT', () => {
+        clearInterval(interval);
+        process.exit(0);
+    });
+    await new Promise(() => { });
+}
+/** Hash directory contents into a cheap polling snapshot for watch mode. */
+async function createDirectorySnapshot(packageDir) {
+    const files = [];
+    const queue = [packageDir];
+    while (queue.length > 0) {
+        const currentDir = queue.shift();
+        if (!currentDir)
+            break;
+        const entries = await readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (!IGNORED_DIRECTORIES.has(entry.name)) {
+                    queue.push(path.join(currentDir, entry.name));
+                }
+                continue;
+            }
+            const absolutePath = path.join(currentDir, entry.name);
+            const fileStat = await stat(absolutePath);
+            files.push(`${toPosixPath(path.relative(packageDir, absolutePath))}:${fileStat.size}:${fileStat.mtimeMs}`);
+        }
+    }
+    return files.sort().join('|');
+}
+/** Parse manifest builder CLI flags into runtime options. */
+function parseCliArgs(argv) {
+    const packagePatterns = [];
+    const exportFilters = [];
+    let watch = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '--watch') {
+            watch = true;
+            continue;
+        }
+        if (arg === '--packages') {
+            const value = argv[i + 1];
+            if (!value)
+                throw new Error('--packages requires a value');
+            packagePatterns.push(...value
+                .split(',')
+                .map((part) => part.trim())
+                .filter(Boolean));
+            i += 1;
+            continue;
+        }
+        if (arg === '--exports') {
+            const value = argv[i + 1];
+            if (!value)
+                throw new Error('--exports requires a value');
+            exportFilters.push(...value
+                .split(',')
+                .map((part) => normalizeManifestExportFilter(part))
+                .filter(Boolean));
+            i += 1;
+            continue;
+        }
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+    return { exportFilters, packagePatterns, watch };
+}
+/** Run the manifest builder once or in watch mode from the current working directory. */
+export async function main(argv = process.argv.slice(2)) {
+    const options = parseCliArgs(argv);
+    const rootDir = process.cwd();
+    if (options.watch) {
+        await runWatch(rootDir, options);
+        return;
+    }
+    await runBuild(rootDir, options);
+}
+void main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/dist/bin/build-tailwind-manifest.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build-tailwind-manifest.unit.test.d.ts.map

package/dist/bin/build-tailwind-manifest.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-tailwind-manifest.unit.test.d.ts","sourceRoot":"","sources":["../../src/lib/bin/build-tailwind-manifest.unit.test.ts"],"names":[],"mappings":""}