/*! © 2026 Yahoo, Inc. UDS Tailwind and Purger v0.0.0-development */
import { getAllowedEntryFileGlobPatterns, stripAllowedEntryFileExtension } from "../../../utils/entryPoints.js";
import { SPRING_MOTION_DEFAULTS } from "../../../motion-tokens/dist/index.js";
import { existsSync } from "node:fs";
import path from "node:path";
import fg from "fast-glob";
import { Node, SyntaxKind } from "ts-morph";

//#region src/purger/optimized/utils/componentAnalyzer.ts
/**
* Known UDS component names (populated by scanning)
*/
let knownComponents = null;
/**
* Map of component name -> file path
*/
let componentPaths = null;
let scannedComponentsDir = null;
const hasImportQuery = (moduleSpecifier) => moduleSpecifier.includes("?");
const scanComponentFilePaths = async (componentsDir) => fg(getAllowedEntryFileGlobPatterns(), {
	cwd: componentsDir,
	absolute: true
});
/**
* Scan src/components to build a map of all component files
*/
const scanComponentFiles = async (componentsDir) => {
	if (componentPaths && scannedComponentsDir === componentsDir) return componentPaths;
	componentPaths = /* @__PURE__ */ new Map();
	knownComponents = /* @__PURE__ */ new Set();
	scannedComponentsDir = componentsDir;
	const nextComponentPaths = componentPaths;
	const nextKnownComponents = knownComponents;
	(await scanComponentFilePaths(componentsDir)).forEach((file) => {
		if (file.includes(".test.") || path.basename(stripAllowedEntryFileExtension(file)) === "index") return;
		const fileName = path.basename(stripAllowedEntryFileExtension(file));
		if (/^[A-Z]/.test(fileName)) {
			nextComponentPaths.set(fileName, file);
			nextKnownComponents.add(fileName);
		}
	});
	return nextComponentPaths;
};
/**
* Analyze an object literal for variant key mappings.
* Handles:
* - Direct property assignments: { fontSize: variant } -> variant maps to fontSize
* - Nullish coalescing: { fontSize: fontSize ?? variant } -> variant maps to fontSize
* - Conditional spreads: ...(condition ? { props } : {}) -> recursively analyze props
*/
const analyzeObjectForVariantMappings = (objLiteral, styleProps, getStylesLiterals, propToVariantKeys, sourceFile) => {
	objLiteral.getProperties().forEach((prop) => {
		if (Node.isPropertyAssignment(prop)) {
			analyzeVariantPropertyAssignment(prop, styleProps, getStylesLiterals, propToVariantKeys);
			return;
		}
		if (Node.isSpreadAssignment(prop)) analyzeVariantSpreadAssignment(prop, styleProps, getStylesLiterals, propToVariantKeys, sourceFile);
	});
};
const addStyleProp = (styleProps, variantKey) => {
	if (!styleProps.includes(variantKey)) styleProps.push(variantKey);
};
const addPropToVariantKeyMapping = (propToVariantKeys, propName, variantKey) => {
	const existing = propToVariantKeys.get(propName) ?? [];
	if (!existing.includes(variantKey)) propToVariantKeys.set(propName, [...existing, variantKey]);
};
const extractFallbackIdentifier = (initializer) => {
	if (!Node.isBinaryExpression(initializer)) return null;
	const operatorKind = initializer.getOperatorToken().getKind();
	if (!(operatorKind === SyntaxKind.QuestionQuestionToken || operatorKind === SyntaxKind.BarBarToken) || !Node.isIdentifier(initializer.getRight())) return null;
	return initializer.getRight().getText();
};
const analyzeVariantPropertyAssignment = (prop, styleProps, getStylesLiterals, propToVariantKeys) => {
	const variantKey = prop.getName();
	addStyleProp(styleProps, variantKey);
	const initializer = prop.getInitializer();
	if (!initializer) return;
	if (Node.isStringLiteral(initializer)) getStylesLiterals.set(variantKey, initializer.getLiteralValue());
	if (Node.isIdentifier(initializer)) addPropToVariantKeyMapping(propToVariantKeys, initializer.getText(), variantKey);
	const fallbackIdentifier = extractFallbackIdentifier(initializer);
	if (fallbackIdentifier) addPropToVariantKeyMapping(propToVariantKeys, fallbackIdentifier, variantKey);
};
const findVariableObjectLiteral = (sourceFile, variableName) => {
	const initializer = sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration).find((candidate) => candidate.getName() === variableName)?.getInitializer();
	return initializer && Node.isObjectLiteralExpression(initializer) ? initializer : null;
};
const analyzeVariantSpreadAssignment = (prop, styleProps, getStylesLiterals, propToVariantKeys, sourceFile) => {
	const spreadExpr = prop.getExpression();
	if (Node.isParenthesizedExpression(spreadExpr)) {
		const conditionalExpr = spreadExpr.getExpression();
		if (Node.isConditionalExpression(conditionalExpr)) {
			const whenTrue = conditionalExpr.getWhenTrue();
			if (!Node.isObjectLiteralExpression(whenTrue)) return;
			analyzeObjectForVariantMappings(whenTrue, styleProps, getStylesLiterals, propToVariantKeys, sourceFile);
		}
	}
	if (Node.isIdentifier(spreadExpr)) {
		const objectLiteral = findVariableObjectLiteral(sourceFile, spreadExpr.getText());
		if (objectLiteral) analyzeObjectForVariantMappings(objectLiteral, styleProps, getStylesLiterals, propToVariantKeys, sourceFile);
	}
};
/**
* Analyzes a UDS component file to extract:
* 1. Default prop values (e.g., display = 'flex')
* 2. Props passed to getStyles()
* 3. Internal UDS component usage
*/
const analyzeComponent = (project, componentPath) => {
	const sourceFile = project.getSourceFile(componentPath);
	if (!sourceFile) return null;
	const componentName = path.basename(stripAllowedEntryFileExtension(componentPath));
	const defaultProps = /* @__PURE__ */ new Map();
	const componentPropNames = /* @__PURE__ */ new Set();
	const styleProps = [];
	const getStylesLiterals = /* @__PURE__ */ new Map();
	const cxLiterals = [];
	const internalComponents = [];
	const internalComponentProps = /* @__PURE__ */ new Map();
	const propToVariantKeys = /* @__PURE__ */ new Map();
	collectComponentDefaultsAndProps(sourceFile, defaultProps, componentPropNames);
	collectGetStylesMetadata(sourceFile, styleProps, getStylesLiterals, propToVariantKeys);
	collectCxLiterals(sourceFile, cxLiterals);
	collectIntrinsicClassNameLiterals(sourceFile, cxLiterals);
	extractInternalComponents(sourceFile, internalComponents, internalComponentProps, propToVariantKeys, componentPropNames);
	return {
		name: componentName,
		filePath: componentPath,
		defaultProps,
		styleProps,
		getStylesLiterals,
		cxLiterals,
		internalComponents,
		internalComponentProps,
		propToVariantKeys,
		motionVarPrefixes: extractMotionVarPrefixes(sourceFile)
	};
};
const getComponentFunctionNodes = (sourceFile) => [...sourceFile.getFunctions(), ...sourceFile.getVariableDeclarations().filter((declaration) => {
	const initializer = declaration.getInitializer();
	return initializer && (Node.isArrowFunction(initializer) || Node.isCallExpression(initializer));
})];
const collectComponentDefaultsAndProps = (sourceFile, defaultProps, componentPropNames) => {
	getComponentFunctionNodes(sourceFile).forEach((fn) => {
		if (Node.isFunctionDeclaration(fn)) {
			extractDefaultsFromFunction(fn, defaultProps);
			extractAllPropNames(fn, componentPropNames);
			return;
		}
		if (!Node.isVariableDeclaration(fn)) return;
		const initializer = fn.getInitializer();
		if (!initializer) return;
		if (Node.isCallExpression(initializer)) initializer.getArguments().forEach((arg) => {
			if (Node.isFunctionExpression(arg) || Node.isArrowFunction(arg)) {
				extractDefaultsFromFunction(arg, defaultProps);
				extractAllPropNames(arg, componentPropNames);
			}
		});
		if (Node.isArrowFunction(initializer)) {
			extractDefaultsFromFunction(initializer, defaultProps);
			extractAllPropNames(initializer, componentPropNames);
		}
	});
};
const extractConditionalStringLiterals = (node) => {
	if (Node.isStringLiteral(node)) return [node.getLiteralValue()];
	if (Node.isConditionalExpression(node)) return [...extractConditionalStringLiterals(node.getWhenTrue()), ...extractConditionalStringLiterals(node.getWhenFalse())];
	return [];
};
const storeVariantLiteralValues = (variantKey, literalValues, getStylesLiterals) => {
	literalValues.forEach((value, index) => {
		const literalKey = index === 0 ? variantKey : `${variantKey}:${index}`;
		getStylesLiterals.set(literalKey, value);
	});
};
const handleGetStylesPropertyAssignment = (prop, styleProps, getStylesLiterals, propToVariantKeys) => {
	const variantKey = prop.getName();
	addStyleProp(styleProps, variantKey);
	const initializer = prop.getInitializer();
	if (!initializer) return;
	if (Node.isStringLiteral(initializer)) getStylesLiterals.set(variantKey, initializer.getLiteralValue());
	if (Node.isIdentifier(initializer)) addPropToVariantKeyMapping(propToVariantKeys, initializer.getText(), variantKey);
	const fallbackIdentifier = extractFallbackIdentifier(initializer);
	if (fallbackIdentifier) addPropToVariantKeyMapping(propToVariantKeys, fallbackIdentifier, variantKey);
	if (Node.isConditionalExpression(initializer)) storeVariantLiteralValues(variantKey, [...extractConditionalStringLiterals(initializer.getWhenTrue()), ...extractConditionalStringLiterals(initializer.getWhenFalse())], getStylesLiterals);
};
const handleGetStylesObjectProperty = (prop, styleProps, getStylesLiterals, propToVariantKeys, sourceFile) => {
	if (Node.isPropertyAssignment(prop)) {
		handleGetStylesPropertyAssignment(prop, styleProps, getStylesLiterals, propToVariantKeys);
		return;
	}
	if (Node.isShorthandPropertyAssignment(prop)) {
		addStyleProp(styleProps, prop.getName());
		return;
	}
	if (Node.isSpreadAssignment(prop) && Node.isIdentifier(prop.getExpression())) {
		const objectLiteral = findVariableObjectLiteral(sourceFile, prop.getExpression().getText());
		if (objectLiteral) analyzeObjectForVariantMappings(objectLiteral, styleProps, getStylesLiterals, propToVariantKeys, sourceFile);
	}
};
const collectGetStylesMetadata = (sourceFile, styleProps, getStylesLiterals, propToVariantKeys) => {
	sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).filter((call) => call.getExpression().getText() === "getStyles").forEach((call) => {
		const args = call.getArguments();
		if (args.length === 0 || !Node.isObjectLiteralExpression(args[0])) return;
		args[0].getProperties().forEach((prop) => {
			handleGetStylesObjectProperty(prop, styleProps, getStylesLiterals, propToVariantKeys, sourceFile);
		});
	});
};
const collectCxLiterals = (sourceFile, cxLiterals) => {
	sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).filter((call) => call.getExpression().getText() === "cx").forEach((call) => {
		call.getArguments().forEach((arg) => extractCxStringLiterals(arg, cxLiterals));
	});
};
const pushUniqueClasses = (target, rawValue) => {
	rawValue.split(/\s+/).filter(Boolean).forEach((className) => {
		if (!target.includes(className)) target.push(className);
	});
};
const collectIntrinsicClassNameLiterals = (sourceFile, cxLiterals) => {
	[...sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement), ...sourceFile.getDescendantsOfKind(SyntaxKind.JsxOpeningElement)].forEach((element) => {
		const tagName = element.getTagNameNode().getText();
		if (!/^[a-z]/.test(tagName)) return;
		element.getAttributes().forEach((attr) => {
			if (!Node.isJsxAttribute(attr) || attr.getNameNode().getText() !== "className") return;
			const initializer = attr.getInitializer();
			if (!initializer) return;
			if (Node.isStringLiteral(initializer)) {
				pushUniqueClasses(cxLiterals, initializer.getLiteralValue());
				return;
			}
			if (!Node.isJsxExpression(initializer)) return;
			const expr = initializer.getExpression();
			if (expr && Node.isStringLiteral(expr)) pushUniqueClasses(cxLiterals, expr.getLiteralValue());
		});
	});
};
/**
* Extract UDS components used internally in the file and their prop values.
* Also detects prop aliasing (e.g., columnGap={gap} means gap -> columnGap).
*/
const extractInternalComponents = (sourceFile, internalComponents, internalComponentProps, propToVariantKeys, componentProps) => {
	collectImportedInternalComponents(sourceFile, internalComponents);
	collectInternalComponentUsages(sourceFile, internalComponents, internalComponentProps, propToVariantKeys, componentProps);
};
const isInternalUdsModule = (moduleSpec) => {
	return (moduleSpec.startsWith("@yahoo/uds") || moduleSpec.startsWith("../") || moduleSpec.startsWith("./")) && (moduleSpec.includes("/components/") || moduleSpec === "@yahoo/uds");
};
const pushUniqueComponentName = (components, name) => {
	if (/^[A-Z]/.test(name) && !components.includes(name)) components.push(name);
};
const collectImportedInternalComponents = (sourceFile, internalComponents) => {
	sourceFile.getImportDeclarations().forEach((importDecl) => {
		if (!isInternalUdsModule(importDecl.getModuleSpecifierValue())) return;
		importDecl.getNamedImports().forEach((namedImport) => pushUniqueComponentName(internalComponents, namedImport.getName()));
	});
};
const getOrCreateComponentPropsMap = (internalComponentProps, componentName) => {
	const existing = internalComponentProps.get(componentName);
	if (existing) return existing;
	const created = /* @__PURE__ */ new Map();
	internalComponentProps.set(componentName, created);
	return created;
};
const extractJsxAttributeLiteralValues = (attr, componentProps, propToVariantKeys) => {
	if (!Node.isJsxAttribute(attr)) return null;
	const propName = attr.getNameNode().getText();
	const initializer = attr.getInitializer();
	if (!initializer) return {
		propName,
		values: []
	};
	if (Node.isStringLiteral(initializer)) return {
		propName,
		values: [initializer.getLiteralValue()]
	};
	if (!Node.isJsxExpression(initializer)) return {
		propName,
		values: []
	};
	const expr = initializer.getExpression();
	if (expr && Node.isStringLiteral(expr)) return {
		propName,
		values: [expr.getLiteralValue()]
	};
	if (expr && Node.isIdentifier(expr)) {
		const identifierName = expr.getText();
		if (componentProps.has(identifierName) && identifierName !== propName) addPropToVariantKeyMapping(propToVariantKeys, identifierName, propName);
	}
	return {
		propName,
		values: []
	};
};
const collectInternalComponentUsages = (sourceFile, internalComponents, internalComponentProps, propToVariantKeys, componentProps) => {
	[...sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement), ...sourceFile.getDescendantsOfKind(SyntaxKind.JsxOpeningElement)].forEach((element) => {
		const tagName = element.getTagNameNode().getText();
		if (!/^[A-Z]/.test(tagName)) return;
		pushUniqueComponentName(internalComponents, tagName);
		element.getAttributes().forEach((attr) => {
			const extracted = extractJsxAttributeLiteralValues(attr, componentProps, propToVariantKeys);
			if (!extracted || extracted.values.length === 0) return;
			const componentPropsMap = getOrCreateComponentPropsMap(internalComponentProps, tagName);
			const existingValues = componentPropsMap.get(extracted.propName) ?? [];
			const mergedValues = [...new Set([...existingValues, ...extracted.values])];
			componentPropsMap.set(extracted.propName, mergedValues);
		});
	});
};
/**
* Extract default prop values from a function's parameter destructuring
*/
const extractDefaultsFromFunction = (fn, defaults) => {
	let params = [];
	if (Node.isFunctionDeclaration(fn) || Node.isFunctionExpression(fn)) params = fn.getParameters();
	else if (Node.isArrowFunction(fn)) params = fn.getParameters();
	params.forEach((param) => {
		if (!Node.isParameterDeclaration(param)) return;
		const nameNode = param.getNameNode();
		if (!nameNode || !Node.isObjectBindingPattern(nameNode)) return;
		nameNode.getElements().forEach((element) => {
			const propName = element.getPropertyNameNode()?.getText() || element.getName();
			const initializer = element.getInitializer();
			if (initializer && Node.isStringLiteral(initializer)) defaults.set(propName, initializer.getLiteralValue());
			else if (initializer && Node.isIdentifier(initializer)) {
				const resolved = resolveIdentifierToStringLiteral(initializer);
				if (resolved) defaults.set(propName, resolved);
			}
		});
	});
};
/**
* Extract ALL prop names from a function's parameter destructuring (not just defaults)
*/
const extractAllPropNames = (fn, propNames) => {
	let params = [];
	if (Node.isFunctionDeclaration(fn) || Node.isFunctionExpression(fn)) params = fn.getParameters();
	else if (Node.isArrowFunction(fn)) params = fn.getParameters();
	params.forEach((param) => {
		if (!Node.isParameterDeclaration(param)) return;
		const nameNode = param.getNameNode();
		if (!nameNode || !Node.isObjectBindingPattern(nameNode)) return;
		nameNode.getElements().forEach((element) => {
			const propName = element.getPropertyNameNode()?.getText() || element.getName();
			propNames.add(propName);
		});
	});
};
/**
* Extract string literals from cx() call arguments.
* Handles:
* - Direct string literals: cx('class1', 'class2')
* - Object keys: cx({ 'class1': condition, 'class2': true })
* - Nested calls and arrays
*/
const extractCxStringLiterals = (node, literals) => {
	if (Node.isStringLiteral(node)) node.getLiteralValue().split(/\s+/).filter(Boolean).forEach((cls) => {
		if (!literals.includes(cls)) literals.push(cls);
	});
	else if (Node.isObjectLiteralExpression(node)) node.getProperties().forEach((prop) => {
		if (Node.isPropertyAssignment(prop)) {
			const nameNode = prop.getNameNode();
			if (Node.isStringLiteral(nameNode)) nameNode.getLiteralValue().split(/\s+/).filter(Boolean).forEach((cls) => {
				if (!literals.includes(cls)) literals.push(cls);
			});
			else if (Node.isIdentifier(nameNode)) {
				const cls = nameNode.getText();
				if (!literals.includes(cls)) literals.push(cls);
			}
		}
	});
	else if (Node.isArrayLiteralExpression(node)) node.getElements().forEach((element) => {
		extractCxStringLiterals(element, literals);
	});
	else if (Node.isConditionalExpression(node)) {
		extractCxStringLiterals(node.getWhenTrue(), literals);
		extractCxStringLiterals(node.getWhenFalse(), literals);
	} else if (Node.isBinaryExpression(node)) {
		extractCxStringLiterals(node.getLeft(), literals);
		extractCxStringLiterals(node.getRight(), literals);
	}
};
/**
* Try to resolve an identifier to its initializer value (for const declarations)
*/
const resolveIdentifierToObject = (sourceFile, identifier) => {
	const decl = sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration).find((candidate) => candidate.getName() === identifier);
	if (!decl) return null;
	let initializer = decl.getInitializer();
	if (!initializer) return null;
	if (Node.isAsExpression(initializer)) initializer = initializer.getExpression();
	if (!Node.isObjectLiteralExpression(initializer)) return null;
	const result = {};
	initializer.getProperties().forEach((prop) => {
		if (!Node.isPropertyAssignment(prop)) return;
		const propName = prop.getName();
		const propInit = prop.getInitializer();
		if (propInit && Node.isStringLiteral(propInit)) result[propName] = propInit.getLiteralValue();
	});
	return result;
};
/**
* Extract motion CSS variable prefixes from SpringMotionConfig usage.
* Returns prefixes like ['--uds-motion-bouncy-4-', '--uds-motion-smooth-3-']
*/
const extractMotionVarPrefixes = (sourceFile) => {
	const prefixes = [];
	[...sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement), ...sourceFile.getDescendantsOfKind(SyntaxKind.JsxOpeningElement)].forEach((element) => {
		if (element.getTagNameNode().getText() !== "SpringMotionConfig") return;
		const props = {
			layoutVariant: null,
			layoutSpeed: null,
			colorVariant: null,
			colorSpeed: null
		};
		element.getAttributes().forEach((attr) => {
			if (Node.isJsxSpreadAttribute(attr)) {
				const expr = attr.getExpression();
				if (Node.isIdentifier(expr)) {
					const spreadObj = resolveIdentifierToObject(sourceFile, expr.getText());
					if (spreadObj) Object.keys(props).forEach((key) => {
						if (key in spreadObj) props[key] = spreadObj[key];
					});
				}
				return;
			}
			if (!Node.isJsxAttribute(attr)) return;
			const propName = attr.getNameNode().getText();
			if (!(propName in props)) return;
			const initializer = attr.getInitializer();
			if (initializer) {
				if (Node.isStringLiteral(initializer)) props[propName] = initializer.getLiteralValue();
				else if (Node.isJsxExpression(initializer)) {
					const expr = initializer.getExpression();
					if (expr && Node.isStringLiteral(expr)) props[propName] = expr.getLiteralValue();
				}
			}
		});
		const layoutPrefix = `--uds-motion-${props.layoutVariant ?? SPRING_MOTION_DEFAULTS.layoutVariant}-${props.layoutSpeed ?? SPRING_MOTION_DEFAULTS.layoutSpeed}-`;
		if (!prefixes.includes(layoutPrefix)) prefixes.push(layoutPrefix);
		const colorPrefix = `--uds-motion-${props.colorVariant ?? SPRING_MOTION_DEFAULTS.colorVariant}-${props.colorSpeed ?? SPRING_MOTION_DEFAULTS.colorSpeed}-`;
		if (!prefixes.includes(colorPrefix)) prefixes.push(colorPrefix);
	});
	return prefixes;
};
const resolveIdentifierToStringLiteral = (identifier) => {
	if (!Node.isIdentifier(identifier)) return null;
	const symbol = identifier.getSymbol();
	if (!symbol) return resolveImportedIdentifier(identifier);
	const resolvedDeclarationValue = symbol.getDeclarations().reduce((resolved, declaration) => {
		if (resolved) return resolved;
		if (Node.isVariableDeclaration(declaration)) {
			let initializer = declaration.getInitializer();
			if (initializer && Node.isAsExpression(initializer)) initializer = initializer.getExpression();
			if (initializer && Node.isStringLiteral(initializer)) return initializer.getLiteralValue();
		}
		if (Node.isEnumMember(declaration)) {
			const initializer = declaration.getInitializer();
			if (initializer && Node.isStringLiteral(initializer)) return initializer.getLiteralValue();
		}
	}, void 0);
	if (resolvedDeclarationValue) return resolvedDeclarationValue;
	return resolveImportedIdentifier(identifier);
};
const resolveImportedIdentifier = (identifier) => {
	if (!Node.isIdentifier(identifier)) return null;
	const name = identifier.getText();
	const sourceFile = identifier.getSourceFile();
	const project = sourceFile.getProject();
	const baseDir = path.dirname(sourceFile.getFilePath());
	const importResolution = sourceFile.getImportDeclarations().reduce((resolvedImport, importDecl) => {
		if (resolvedImport) return resolvedImport;
		if (!importDecl.getNamedImports().find((n) => n.getName() === name)) return;
		const moduleSpec = importDecl.getModuleSpecifierValue();
		if (!moduleSpec.startsWith(".") || hasImportQuery(moduleSpec)) return;
		const resolvedBase = path.resolve(baseDir, moduleSpec);
		return [
			resolvedBase,
			`${resolvedBase}.ts`,
			`${resolvedBase}.tsx`
		].reduce((resolvedCandidate, candidate) => {
			if (resolvedCandidate) return resolvedCandidate;
			if (!existsSync(candidate)) return;
			const importedFile = project.addSourceFileAtPathIfExists(candidate);
			if (!importedFile) return;
			const varDecl = importedFile.getVariableDeclaration(name);
			if (!varDecl) return;
			let initializer = varDecl.getInitializer();
			if (initializer && Node.isAsExpression(initializer)) initializer = initializer.getExpression();
			return initializer && Node.isStringLiteral(initializer) ? initializer.getLiteralValue() : void 0;
		}, void 0);
	}, void 0);
	if (importResolution) return importResolution;
	return null;
};

//#endregion
export { analyzeComponent, scanComponentFiles };
//# sourceMappingURL=componentAnalyzer.js.map