svelte-ag 1.2.8 → 1.3.1

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

@@ -0,0 +1,405 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { Visitor, parseSync } from 'oxc-parser';
+import { parse as parseSvelte } from 'svelte/compiler';
+import { ensureRelativeManifestSourcePath } from '../../vite/tailwind-sources-manifest.js';
+import { isPathInside, isRelativeSpecifier, resolveLocalImportPath, toPosixPath } from './path-utils.js';
+const CLASS_COLLECTOR_CALLS = new Set(['cn', 'clsx', 'cva', 'tv']);
+export function createGraphScanner(packageDir) {
+    const analysisCache = new Map();
+    const graphScanCache = new Map();
+    const symbolTargetCache = new Map();
+    const resolvedImportCache = new Map();
+    const resolveCachedImportPath = (specifier, importerPath) => {
+        const cacheKey = `${importerPath}\0${specifier}`;
+        const cached = resolvedImportCache.get(cacheKey);
+        if (cached !== undefined)
+            return cached;
+        const resolved = resolveLocalImportPath(specifier, importerPath);
+        resolvedImportCache.set(cacheKey, resolved);
+        return resolved;
+    };
+    const analyzeFile = (filePath) => {
+        let cached = analysisCache.get(filePath);
+        if (!cached) {
+            cached = (async () => {
+                const source = await readFile(filePath, 'utf8');
+                const classes = new Set();
+                const localSpecifiers = new Set();
+                const directLocalExports = new Set();
+                const importBindings = new Map();
+                const indirectExports = [];
+                const importedLocalExports = new Map();
+                collectClassNamesFromSource(filePath, source, classes);
+                for (const statement of getModuleStatements(filePath, source)) {
+                    const specifier = getModuleRequest(statement);
+                    if (statement.type === 'ImportDeclaration') {
+                        if (specifier && isRelativeSpecifier(specifier) && statement.importKind !== 'type') {
+                            localSpecifiers.add(specifier);
+                        }
+                        collectImportBindings(statement, importBindings);
+                        continue;
+                    }
+                    if (specifier && isRelativeSpecifier(specifier) && statement.exportKind !== 'type') {
+                        localSpecifiers.add(specifier);
+                        if (statement.type === 'ExportAllDeclaration' && statement.exported === null) {
+                            indirectExports.push({ kind: 'all', specifier });
+                            continue;
+                        }
+                        if (statement.type === 'ExportAllDeclaration') {
+                            const exportName = getNodeName(statement.exported);
+                            if (exportName) {
+                                indirectExports.push({ kind: 'namespace', exportName, specifier });
+                            }
+                            continue;
+                        }
+                        for (const specifierNode of statement.specifiers) {
+                            if ('exportKind' in specifierNode && specifierNode.exportKind === 'type')
+                                continue;
+                            const exportName = getNodeName(specifierNode.exported) ?? getNodeName(specifierNode.local);
+                            if (exportName) {
+                                indirectExports.push({ kind: 'named', exportName, specifier });
+                            }
+                        }
+                        continue;
+                    }
+                    if (statement.type !== 'ExportNamedDeclaration' || statement.exportKind === 'type') {
+                        continue;
+                    }
+                    collectExportedDeclarationNames(statement.declaration, directLocalExports);
+                    for (const specifierNode of statement.specifiers) {
+                        if ('exportKind' in specifierNode && specifierNode.exportKind === 'type')
+                            continue;
+                        const exportName = getNodeName(specifierNode.exported) ?? getNodeName(specifierNode.local);
+                        const localName = getNodeName(specifierNode.local);
+                        if (exportName && localName) {
+                            importedLocalExports.set(exportName, localName);
+                            directLocalExports.add(exportName);
+                        }
+                    }
+                }
+                for (const match of source.matchAll(/@import\s+['"]([^'"]+)['"]/g)) {
+                    if (match[1] && isRelativeSpecifier(match[1])) {
+                        localSpecifiers.add(match[1]);
+                    }
+                }
+                return {
+                    classes,
+                    manifestSourcePath: filePath.endsWith('.css')
+                        ? ensureRelativeManifestSourcePath(toPosixPath(path.relative(packageDir, filePath)))
+                        : null,
+                    localSpecifiers: [...localSpecifiers],
+                    directLocalExports,
+                    importBindings,
+                    indirectExports,
+                    importedLocalExports
+                };
+            })();
+            analysisCache.set(filePath, cached);
+        }
+        return cached;
+    };
+    const scanFromRoot = async (entryFile, visiting) => {
+        if (visiting.has(entryFile) || !isPathInside(packageDir, entryFile)) {
+            return createEmptyScan();
+        }
+        const cached = graphScanCache.get(entryFile);
+        if (cached) {
+            return cloneGraphScan(cached);
+        }
+        const nextVisiting = new Set(visiting);
+        nextVisiting.add(entryFile);
+        const analysis = await analyzeFile(entryFile);
+        const scan = {
+            classes: new Set(analysis.classes),
+            sources: analysis.manifestSourcePath ? new Set([analysis.manifestSourcePath]) : new Set()
+        };
+        for (const specifier of analysis.localSpecifiers) {
+            const resolvedPath = resolveCachedImportPath(specifier, entryFile);
+            if (!resolvedPath)
+                continue;
+            mergeGraphScan(scan, await scanFromRoot(resolvedPath, nextVisiting));
+        }
+        graphScanCache.set(entryFile, cloneGraphScan(scan));
+        return scan;
+    };
+    const readTargets = async (entryFile, visiting) => {
+        if (visiting.has(entryFile))
+            return new Map();
+        const cached = symbolTargetCache.get(entryFile);
+        if (cached) {
+            return new Map(cached);
+        }
+        const nextVisiting = new Set(visiting);
+        nextVisiting.add(entryFile);
+        const analysis = await analyzeFile(entryFile);
+        const symbolTargets = new Map();
+        for (const exportNode of analysis.indirectExports) {
+            const targetFile = resolveCachedImportPath(exportNode.specifier, entryFile);
+            if (!targetFile)
+                continue;
+            if (exportNode.kind === 'all') {
+                for (const [symbolName, nestedTargetFile] of await readTargets(targetFile, nextVisiting)) {
+                    if (!symbolTargets.has(symbolName)) {
+                        symbolTargets.set(symbolName, nestedTargetFile);
+                    }
+                }
+                continue;
+            }
+            if (!symbolTargets.has(exportNode.exportName)) {
+                symbolTargets.set(exportNode.exportName, targetFile);
+            }
+        }
+        for (const [exportName, localName] of analysis.importedLocalExports) {
+            const specifier = analysis.importBindings.get(localName);
+            if (!specifier || symbolTargets.has(exportName))
+                continue;
+            const targetFile = resolveCachedImportPath(specifier, entryFile);
+            if (targetFile) {
+                symbolTargets.set(exportName, targetFile);
+            }
+        }
+        for (const exportName of analysis.directLocalExports) {
+            if (!symbolTargets.has(exportName)) {
+                symbolTargets.set(exportName, entryFile);
+            }
+        }
+        symbolTargetCache.set(entryFile, new Map(symbolTargets));
+        return symbolTargets;
+    };
+    return {
+        async scanFileGraph(entryFiles) {
+            const scan = createEmptyScan();
+            for (const entryFile of entryFiles) {
+                mergeGraphScan(scan, await scanFromRoot(entryFile, new Set()));
+            }
+            return scan;
+        },
+        async readEntrySymbolTargets(entryFile) {
+            return readTargets(entryFile, new Set());
+        }
+    };
+}
+export async function readEntrySymbolTargets(entryFile, visited = new Set()) {
+    if (visited.has(entryFile))
+        return new Map();
+    void visited;
+    const scanner = createGraphScanner(path.dirname(entryFile));
+    return scanner.readEntrySymbolTargets(entryFile);
+}
+export async function scanFileGraph(entryFiles, packageDir) {
+    return createGraphScanner(packageDir).scanFileGraph(entryFiles);
+}
+function createEmptyScan() {
+    return { classes: new Set(), sources: new Set() };
+}
+function cloneGraphScan(scan) {
+    return { classes: new Set(scan.classes), sources: new Set(scan.sources) };
+}
+function mergeGraphScan(target, source) {
+    for (const className of source.classes)
+        target.classes.add(className);
+    for (const sourcePath of source.sources)
+        target.sources.add(sourcePath);
+}
+function collectClassNamesFromSource(filePath, source, out) {
+    const collectTailwindStrings = (snippet) => {
+        const program = parseSync(filePath, snippet, getOxcParserOptions(filePath)).program;
+        new Visitor({
+            CallExpression(node) {
+                const calleeName = getCallExpressionName(node);
+                if (calleeName !== '' && CLASS_COLLECTOR_CALLS.has(calleeName)) {
+                    collectStringLiteralsFromExpression(node, out);
+                }
+            },
+            Property(node) {
+                if (!isObjectPropertyNode(node))
+                    return;
+                const keyName = getObjectPropertyKeyName(node);
+                if (keyName && /class/i.test(keyName)) {
+                    collectStringLiteralsFromExpression(node.value, out);
+                }
+            }
+        }).visit(program);
+    };
+    const markupSource = filePath.endsWith('.svelte') ? source.replace(/<!--[\s\S]*?-->/g, '') : source;
+    for (const match of markupSource.matchAll(/(?:class|className)\s*=\s*(['"`])([\s\S]*?)\1/g)) {
+        for (const token of (match[2] ?? '').split(/\s+/)) {
+            if (token !== '' && !token.includes('${'))
+                out.add(token);
+        }
+    }
+    for (const match of markupSource.matchAll(/(?:class|className)\s*=\s*\{([\s\S]*?)\}/g)) {
+        const expression = match[1]?.trim();
+        if (expression) {
+            collectTailwindStrings(`(${expression})`);
+        }
+    }
+    for (const scriptBlock of getModuleSnippets(filePath, source)) {
+        collectTailwindStrings(scriptBlock);
+    }
+}
+function getModuleSnippets(filePath, source) {
+    if (!filePath.endsWith('.svelte')) {
+        return [source];
+    }
+    try {
+        const ast = parseSvelte(source, { filename: filePath, modern: true });
+        return [ast.module, ast.instance].filter(Boolean).map((script) => {
+            const content = script.content;
+            return source.slice(content.start, content.end);
+        });
+    }
+    catch {
+        return [source];
+    }
+}
+function getModuleStatements(filePath, source) {
+    return getModuleSnippets(filePath, source).flatMap((snippet) => parseSync(filePath, snippet, getOxcParserOptions(filePath)).program.body.filter(isModuleStatement));
+}
+function getOxcParserOptions(filePath) {
+    return {
+        lang: filePath.endsWith('.js') || filePath.endsWith('.mjs') || filePath.endsWith('.cjs')
+            ? 'js'
+            : filePath.endsWith('.jsx')
+                ? 'jsx'
+                : filePath.endsWith('.tsx')
+                    ? 'tsx'
+                    : filePath.endsWith('.d.ts')
+                        ? 'dts'
+                        : 'ts',
+        sourceType: 'module'
+    };
+}
+function isModuleStatement(statement) {
+    return (statement.type === 'ImportDeclaration' ||
+        statement.type === 'ExportNamedDeclaration' ||
+        statement.type === 'ExportAllDeclaration');
+}
+function collectExportedDeclarationNames(declaration, exportNames) {
+    if (!declaration)
+        return;
+    if ('id' in declaration && declaration.id) {
+        const declarationName = getNodeName(declaration.id);
+        if (declarationName)
+            exportNames.add(declarationName);
+        return;
+    }
+    if (declaration.type !== 'VariableDeclaration')
+        return;
+    for (const declarator of declaration.declarations) {
+        collectBindingNames(declarator.id, exportNames);
+    }
+}
+function collectBindingNames(node, names) {
+    const nodeName = getNodeName(node);
+    if (nodeName) {
+        names.add(nodeName);
+        return;
+    }
+    if ('properties' in node && Array.isArray(node.properties)) {
+        for (const property of node.properties) {
+            if (!property || typeof property !== 'object')
+                continue;
+            if ('value' in property && property.value && typeof property.value === 'object') {
+                collectBindingNames(property.value, names);
+            }
+            else if ('key' in property && property.key && typeof property.key === 'object') {
+                collectBindingNames(property.key, names);
+            }
+        }
+    }
+    if ('elements' in node && Array.isArray(node.elements)) {
+        for (const element of node.elements) {
+            if (element && typeof element === 'object') {
+                collectBindingNames(element, names);
+            }
+        }
+    }
+}
+function collectImportBindings(statement, importBindings) {
+    const specifier = getModuleRequest(statement);
+    if (!specifier || !isRelativeSpecifier(specifier) || statement.importKind === 'type')
+        return;
+    for (const specifierNode of statement.specifiers ?? []) {
+        if (specifierNode.type === 'ImportSpecifier' && specifierNode.importKind === 'type') {
+            continue;
+        }
+        importBindings.set(specifierNode.local.name, specifier);
+    }
+}
+function getModuleRequest(statement) {
+    if (statement.source === null)
+        return null;
+    return typeof statement.source.value === 'string' ? statement.source.value : null;
+}
+function getNodeName(node) {
+    if (node === null)
+        return null;
+    if ('name' in node && typeof node.name === 'string')
+        return node.name;
+    if ('value' in node && typeof node.value === 'string')
+        return node.value;
+    return null;
+}
+function getCallExpressionName(node) {
+    if (node.callee.type === 'Identifier') {
+        return node.callee.name;
+    }
+    if (node.callee.type === 'MemberExpression' && !node.callee.computed && node.callee.property.type === 'Identifier') {
+        return node.callee.property.name;
+    }
+    return '';
+}
+function getObjectPropertyKeyName(node) {
+    if (node.key.type === 'Identifier') {
+        return node.key.name;
+    }
+    if (node.key.type === 'Literal' && typeof node.key.value === 'string') {
+        return node.key.value;
+    }
+    return null;
+}
+function isObjectPropertyNode(node) {
+    return node.type === 'Property' && 'value' in node && 'method' in node;
+}
+function collectStringLiteralsFromExpression(expression, out) {
+    new Visitor({
+        Literal(literal) {
+            if (literal.type === 'Literal' && typeof literal.value === 'string') {
+                addClassTokens(literal, out);
+            }
+        },
+        TemplateLiteral(template) {
+            if (template.expressions.length === 0) {
+                addClassTokens(template, out);
+            }
+        }
+    }).visit(createProgramFromExpression(expression));
+}
+function addClassTokens(node, out) {
+    const rawValue = node.type === 'Literal' ? node.value : node.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw).join('');
+    if (typeof rawValue !== 'string')
+        return;
+    for (const token of rawValue.split(/\s+/)) {
+        if (token !== '' && !token.includes('${'))
+            out.add(token);
+    }
+}
+function createProgramFromExpression(expression) {
+    const statement = {
+        type: 'ExpressionStatement',
+        expression,
+        directive: null,
+        start: expression.start,
+        end: expression.end
+    };
+    return {
+        type: 'Program',
+        body: [statement],
+        sourceType: 'module',
+        hashbang: null,
+        start: expression.start,
+        end: expression.end
+    };
+}

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

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

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

@@ -0,0 +1,6 @@
+import process from 'node:process';
+import { main } from './cli.js';
+void main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});

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

@@ -0,0 +1,7 @@
+import type { GeneratorOptions } from './types.js';
+export declare function generateTailwindManifestForPackage(packageDir: string, options: GeneratorOptions): Promise<{
+    didWrite: boolean;
+    outputFile: string;
+    exportCount: number;
+}>;
+//# sourceMappingURL=manifest-generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-generator.d.ts","sourceRoot":"","sources":["../../../src/lib/bin/build-tailwind-manifest/manifest-generator.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,gBAAgB,EAA6B,MAAM,YAAY,CAAC;AAE9E,wBAAsB,kCAAkC,CACtD,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAiCzE"}

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

@@ -0,0 +1,85 @@
+import path from 'node:path';
+import { readPackageJson, writeIfDifferent } from 'ts-ag';
+import { getTailwindSourcesManifestPath, serializeTailwindSourceManifest, shouldIncludeManifestExport } from '../../vite/tailwind-sources-manifest.js';
+import { createGraphScanner } from './graph.js';
+import { resolvePackageEntryFile } from './path-utils.js';
+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 exports = collectPackageExportEntries(packageJson.exports).filter(([exportKey]) => shouldIncludeManifestExport(exportKey, options.exportFilters));
+    const graphScanner = createGraphScanner(packageDir);
+    await Promise.all(exports.map(async ([exportKey, exportTarget]) => {
+        if (exportKey.includes('*') || hasWildcardTarget(exportTarget)) {
+            console.warn(`[tailwind-manifest] Skipping wildcard export ${exportKey} in ${packageDir}`);
+        }
+        else {
+            const entryFiles = collectRuntimeTargets(exportTarget)
+                .map((target) => resolvePackageEntryFile(packageDir, target))
+                .filter((targetPath) => targetPath !== null);
+            if (entryFiles.length === 0)
+                return;
+            const manifestEntry = toManifestLeaf(await graphScanner.scanFileGraph(entryFiles));
+            const symbols = await collectExportSymbols(entryFiles, graphScanner);
+            manifest.exports[exportKey] = Object.keys(symbols).length > 0 ? { ...manifestEntry, symbols } : manifestEntry;
+        }
+    }));
+    const outputFile = getTailwindSourcesManifestPath(packageDir, packageJson);
+    const didWrite = await writeIfDifferent(outputFile, serializeTailwindSourceManifest(manifest));
+    return { didWrite, outputFile, exportCount: Object.keys(manifest.exports).length };
+}
+async function collectExportSymbols(entryFiles, graphScanner) {
+    const symbols = new Map();
+    for (const entryFile of entryFiles) {
+        const targets = await graphScanner.readEntrySymbolTargets(entryFile);
+        await Promise.all(targets.entries().map(async ([symbolName, targetFile]) => {
+            const scan = await graphScanner.scanFileGraph([targetFile]);
+            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);
+            }
+            else {
+                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)]));
+}
+function toManifestLeaf(scan) {
+    return { classes: [...scan.classes].sort(), sources: [...scan.sources].sort() };
+}
+function collectRuntimeTargets(target) {
+    if (target === null)
+        return [];
+    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]) => (key === 'types' ? [] : collectRuntimeTargets(value)));
+}
+function hasWildcardTarget(target) {
+    if (target === null)
+        return false;
+    return typeof target === 'string'
+        ? target.includes('*')
+        : Array.isArray(target)
+            ? target.some(hasWildcardTarget)
+            : Object.values(target).some(hasWildcardTarget);
+}
+function collectPackageExportEntries(exports) {
+    if (exports === undefined)
+        return [];
+    if (exports === null || typeof exports === 'string' || Array.isArray(exports))
+        return [['.', exports]];
+    const entries = Object.entries(exports);
+    const hasSubpathExports = entries.some(([key]) => key === '.' || key.startsWith('./'));
+    return hasSubpathExports ? entries : [['.', exports]];
+}

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

@@ -0,0 +1,6 @@
+export declare function isRelativeSpecifier(specifier: string): boolean;
+export declare function resolveLocalImportPath(specifier: string, importerPath: string): string | null;
+export declare function resolvePackageEntryFile(packageDir: string, entryTarget: string): string | null;
+export declare function isPathInside(parentPath: string, childPath: string): boolean;
+export declare function toPosixPath(filePath: string): string;
+//# sourceMappingURL=path-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"path-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/bin/build-tailwind-manifest/path-utils.ts"],"names":[],"mappings":"AAGA,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE7F;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI9F;AAED,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAG3E;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEpD"}

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

@@ -0,0 +1,41 @@
+import { existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+export function isRelativeSpecifier(specifier) {
+    return specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('/');
+}
+export function resolveLocalImportPath(specifier, importerPath) {
+    return resolveFileCandidate(path.resolve(path.dirname(importerPath), specifier.split(/[?#]/, 1)[0] ?? specifier));
+}
+export function resolvePackageEntryFile(packageDir, entryTarget) {
+    return resolveFileCandidate(path.resolve(packageDir, entryTarget.startsWith('./') ? entryTarget : `./${entryTarget}`));
+}
+export function isPathInside(parentPath, childPath) {
+    const relativePath = path.relative(parentPath, childPath);
+    return relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath));
+}
+export function toPosixPath(filePath) {
+    return filePath.replaceAll('\\', '/');
+}
+function resolveFileCandidate(targetPath) {
+    for (const candidate of [
+        ...buildBaseCandidates(targetPath),
+        ...buildBaseCandidates(path.join(targetPath, 'index'))
+    ]) {
+        if (existsSync(candidate) && statSync(candidate).isFile()) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function buildBaseCandidates(basePath) {
+    const candidates = new Set([basePath, `${basePath}.js`, `${basePath}.mjs`, `${basePath}.cjs`]);
+    for (const candidateBase of [basePath.replace(/\.(?:mjs|cjs|js)$/i, ''), basePath]) {
+        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`);
+    }
+    return [...candidates];
+}

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

@@ -0,0 +1,15 @@
+import type { TailwindSourceManifestLeaf } from '../../vite/tailwind-sources-manifest.js';
+export type GeneratorOptions = {
+    exportFilters: string[];
+};
+export type GraphScan = {
+    classes: Set<string>;
+    sources: Set<string>;
+};
+export type CliOptions = {
+    exportFilters: string[];
+    packagePatterns: string[];
+    watch: boolean;
+};
+export type SymbolManifest = Record<string, TailwindSourceManifestLeaf>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/bin/build-tailwind-manifest/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AAE1F,MAAM,MAAM,gBAAgB,GAAG;IAC7B,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACrB,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC"}

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

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