@bamboocss/parser 1.11.1 → 1.11.3

package/dist/index.mjs

@@ -1,1025 +1,975 @@
-// src/project.ts
-import {
-  ScriptKind,
-  Project as TsProject,
-  ts
-} from "ts-morph";
-
-// src/classify.ts
-import { box } from "@bamboocss/extractor";
-import { compact, patternFns } from "@bamboocss/shared";
+import { Node, Project as Project$1, ScriptKind, ts } from "ts-morph";
+import { box, extract, unbox } from "@bamboocss/extractor";
+import { BambooError, astish, compact, getOrCreateSet, patternFns } from "@bamboocss/shared";
+import { logger } from "@bamboocss/logger";
+import { match } from "ts-pattern";
+import { resolveTsPathPattern } from "@bamboocss/config/ts-path";
+//#region src/classify.ts
 function addTo(map, key, value) {
-  const set = map.get(key) ?? /* @__PURE__ */ new Set();
-  set.add(value);
-  map.set(key, set);
+	const set = map.get(key) ?? /* @__PURE__ */ new Set();
+	set.add(value);
+	map.set(key, set);
 }
 function classifyProject(ctx, resultMap) {
-  const byId = /* @__PURE__ */ new Map();
-  const byComponentIndex = /* @__PURE__ */ new Map();
-  const byFilepath = /* @__PURE__ */ new Map();
-  const byComponentInFilepath = /* @__PURE__ */ new Map();
-  const globalMaps = createReportMaps();
-  const byFilePathMaps = /* @__PURE__ */ new Map();
-  const conditions = new Map(Object.entries(ctx.conditions.values));
-  const { groupByProp } = getPropertyGroupMap(ctx);
-  let id = 0;
-  let componentIndex = 0;
-  const isKnownUtility = (reportItem, componentReportItem) => {
-    const { propName, value, tokenType } = reportItem;
-    const utility = ctx.utility.config[propName];
-    if (utility) {
-      if (ctx.tokens.getByName(`${tokenType}.${value}`)) return true;
-      if (ctx.tokens.getReferences(String(value)).length > 0) return true;
-      if (ctx.utility.resolveColorMix(String(value)).color) return true;
-      return false;
-    }
-    if (componentReportItem.reportItemType === "pattern") {
-      const pattern = ctx.patterns.getConfig(componentReportItem.componentName.toLowerCase());
-      const patternProp = pattern?.properties?.[propName];
-      if (!patternProp) return false;
-      if (patternProp.type === "boolean" || patternProp.type === "number") {
-        return true;
-      }
-      if (patternProp.type === "property" && patternProp.value) {
-        return Boolean(ctx.utility.config[patternProp.value]);
-      }
-      if (patternProp.type === "enum" && patternProp.value) {
-        return Boolean(patternProp.value.includes(String(value)));
-      }
-      if (patternProp.type === "token") {
-        return Boolean(ctx.tokens.getByName(`${patternProp.value}.${value}`));
-      }
-      return false;
-    }
-    return false;
-  };
-  const processPattern = (opts) => {
-    const { boxNode, data, item, filepath, localMaps } = opts;
-    const name = item.componentName;
-    const pattern = ctx.patterns.details.find((p) => p.match.test(name) || p.baseName === name);
-    if (!pattern) return;
-    const cssObj = pattern.config.transform?.(data || {}, patternFns) ?? {};
-    const newItem = {
-      name: "css",
-      type: "css",
-      box: box.objectToMap(compact(cssObj), boxNode.getNode(), boxNode.getStack()),
-      data: [cssObj]
-    };
-    Object.assign(newItem, { debug: true });
-    return processResultItem({ item: newItem, kind: "function", localMaps, filepath });
-  };
-  const processResultItem = (opts) => {
-    const { item, kind, filepath, localMaps } = opts;
-    if (!item.box || box.isUnresolvable(item.box)) {
-      return;
-    }
-    if (!item.data) {
-      return;
-    }
-    const componentReportItem = {
-      componentIndex: String(componentIndex++),
-      componentName: item.name,
-      reportItemType: item.type,
-      kind,
-      filepath,
-      value: item.data,
-      range: item.box.getRange(),
-      contains: [],
-      debug: Reflect.has(item, "debug")
-    };
-    if (item.type === "pattern" || item.type === "jsx-pattern") {
-      return processPattern({ boxNode: item.box, data: item.data[0], item: componentReportItem, filepath, localMaps });
-    }
-    if (box.isArray(item.box)) {
-      addTo(byComponentInFilepath, filepath, componentReportItem.componentIndex);
-      return componentReportItem;
-    }
-    if (box.isMap(item.box)) {
-      addTo(byComponentInFilepath, filepath, componentReportItem.componentIndex);
-      processMap({ map: item.box, current: [], componentReportItem, filepath, localMaps });
-      return componentReportItem;
-    }
-    if (item.type === "recipe") {
-      addTo(byComponentInFilepath, filepath, componentReportItem.componentIndex);
-      return componentReportItem;
-    }
-  };
-  const processResultItemFn = (opts) => {
-    const { item, filepath, localMaps, type } = opts;
-    const componentReportItem = processResultItem({ item, kind: type, filepath, localMaps });
-    if (!componentReportItem) return;
-    addTo(globalMaps.byComponentOfKind, type, componentReportItem.componentIndex);
-    addTo(localMaps.byComponentOfKind, type, componentReportItem.componentIndex);
-    byComponentIndex.set(componentReportItem.componentIndex, componentReportItem);
-  };
-  const processMap = (opts) => {
-    const { map, current, componentReportItem, filepath, localMaps, skipRange } = opts;
-    const { reportItemType: type, kind, componentName: name } = componentReportItem;
-    map.value.forEach((attrNode, attrName) => {
-      if (box.isLiteral(attrNode) || box.isEmptyInitializer(attrNode)) {
-        const value = box.isLiteral(attrNode) ? attrNode.value : true;
-        const propReportItem = {
-          index: String(id++),
-          componentIndex: String(componentReportItem.componentIndex),
-          componentName: name,
-          tokenType: void 0,
-          propName: attrName,
-          reportItemKind: "utility",
-          reportItemType: type,
-          kind,
-          filepath,
-          path: current.concat(attrName),
-          value,
-          isKnownValue: false,
-          range: skipRange ? null : map.getRange()
-        };
-        componentReportItem.contains.push(propReportItem.index);
-        if (conditions.has(attrName)) {
-          addTo(globalMaps.byConditionName, attrName, propReportItem.index);
-          addTo(localMaps.byConditionName, attrName, propReportItem.index);
-          propReportItem.propName = current[0] ?? attrName;
-          propReportItem.isKnownValue = isKnownUtility(propReportItem, componentReportItem);
-          propReportItem.conditionName = attrName;
-        } else {
-          if (current.length && conditions.has(current[0])) {
-            propReportItem.conditionName = current[0];
-            addTo(globalMaps.byConditionName, current[0], propReportItem.index);
-            addTo(localMaps.byConditionName, current[0], propReportItem.index);
-          }
-          const propName = ctx.utility.resolveShorthand(attrName);
-          const tokenType = ctx.utility.getTokenType(propName);
-          if (tokenType) {
-            propReportItem.reportItemKind = "token";
-            propReportItem.tokenType = tokenType;
-          }
-          propReportItem.propName = propName;
-          propReportItem.isKnownValue = isKnownUtility(propReportItem, componentReportItem);
-          addTo(globalMaps.byPropertyName, propName, propReportItem.index);
-          addTo(localMaps.byPropertyName, propName, propReportItem.index);
-          if (tokenType) {
-            addTo(globalMaps.byTokenType, tokenType, propReportItem.index);
-            addTo(localMaps.byTokenType, tokenType, propReportItem.index);
-          }
-          if (propName.toLowerCase().includes("color") || groupByProp.get(propName) === "Color" || tokenType === "colors") {
-            addTo(globalMaps.colorsUsed, value, propReportItem.index);
-            addTo(localMaps.colorsUsed, value, propReportItem.index);
-          }
-          if (ctx.utility.shorthands.has(attrName)) {
-            addTo(globalMaps.byShorthand, attrName, propReportItem.index);
-            addTo(localMaps.byShorthand, attrName, propReportItem.index);
-          }
-        }
-        if (current.length) {
-          addTo(globalMaps.byPropertyPath, propReportItem.path.join("."), propReportItem.index);
-          addTo(localMaps.byPropertyPath, propReportItem.path.join("."), propReportItem.index);
-        }
-        addTo(globalMaps.byTokenName, String(value), propReportItem.index);
-        addTo(localMaps.byTokenName, String(value), propReportItem.index);
-        addTo(globalMaps.byType, type, propReportItem.index);
-        addTo(localMaps.byType, type, propReportItem.index);
-        addTo(globalMaps.byComponentName, name, propReportItem.index);
-        addTo(localMaps.byComponentName, name, propReportItem.index);
-        addTo(globalMaps.fromKind, kind, propReportItem.index);
-        addTo(localMaps.fromKind, kind, propReportItem.index);
-        addTo(byFilepath, filepath, propReportItem.index);
-        byId.set(propReportItem.index, propReportItem);
-        return;
-      }
-      if (box.isMap(attrNode) && attrNode.value.size) {
-        return processMap({
-          map: attrNode,
-          current: current.concat(attrName),
-          componentReportItem,
-          filepath,
-          localMaps
-        });
-      }
-    });
-  };
-  resultMap.forEach((parserResult, filepath) => {
-    if (parserResult.isEmpty()) return;
-    const localMaps = createReportMaps();
-    const componentFn = (item) => {
-      processResultItemFn({ item, filepath, localMaps, type: "component" });
-    };
-    const functionFn = (item) => {
-      processResultItemFn({ item, filepath, localMaps, type: "function" });
-    };
-    parserResult.jsx.forEach(componentFn);
-    parserResult.css.forEach(functionFn);
-    parserResult.cva.forEach(functionFn);
-    parserResult.pattern.forEach((itemList) => {
-      itemList.forEach(functionFn);
-    });
-    parserResult.recipe.forEach((itemList) => {
-      itemList.forEach(functionFn);
-    });
-    byFilePathMaps.set(filepath, localMaps);
-  });
-  const pickCount = 10;
-  const filesWithMostComponent = Object.fromEntries(
-    Array.from(byComponentInFilepath.entries()).map(([filepath, list]) => [filepath, list.size]).sort((a, b) => b[1] - a[1]).slice(0, pickCount)
-  );
-  Object.entries(ctx.recipes.config).forEach(([key, recipe]) => {
-    const localMaps = createReportMaps();
-    const functionFn = (styleObject) => {
-      if (!styleObject) return;
-      const componentReportItem = {
-        componentIndex: "0",
-        componentName: `recipes.${key}.base`,
-        reportItemType: "css",
-        kind: "function",
-        filepath: `theme/recipes/${key}`,
-        value: styleObject,
-        range: null,
-        contains: []
-      };
-      processMap({
-        // @ts-expect-error
-        map: box.objectToMap(styleObject, null, []),
-        current: [],
-        filepath: `@config/theme/recipes/${key}`,
-        skipRange: true,
-        localMaps,
-        componentReportItem
-      });
-    };
-    const isSlotRecipe = (_v) => ctx.recipes.isSlotRecipe(key);
-    if (isSlotRecipe(recipe)) {
-      Object.values(recipe.base ?? {}).forEach(functionFn);
-      Object.values(recipe.variants ?? {}).forEach((variants) => {
-        Object.values(variants).forEach((v) => {
-          Object.values(v).forEach(functionFn);
-        });
-      });
-      recipe.compoundVariants?.forEach((v) => {
-        Object.values(v.css).forEach(functionFn);
-      });
-    } else {
-      functionFn(recipe.base);
-      Object.values(recipe.variants ?? {}).forEach((variants) => {
-        Object.values(variants).forEach(functionFn);
-      });
-      recipe.compoundVariants?.forEach((v) => functionFn(v.css));
-    }
-  });
-  Object.values(ctx.config.globalCss ?? {}).forEach((styleObject) => {
-    if (!styleObject) return;
-    processMap({
-      // @ts-expect-error
-      map: box.objectToMap(styleObject, null, []),
-      current: [],
-      filepath: "@config/globalCss",
-      skipRange: true,
-      localMaps: createReportMaps(),
-      componentReportItem: {
-        componentIndex: "0",
-        componentName: "global",
-        reportItemType: "css",
-        kind: "function",
-        filepath: "global",
-        value: styleObject,
-        range: null,
-        contains: []
-      }
-    });
-  });
-  return {
-    propById: byId,
-    componentById: byComponentIndex,
-    details: {
-      counts: {
-        filesWithTokens: byFilepath.size,
-        propNameUsed: globalMaps.byPropertyName.size,
-        tokenUsed: globalMaps.byTokenName.size,
-        shorthandUsed: globalMaps.byShorthand.size,
-        propertyPathUsed: globalMaps.byPropertyPath.size,
-        typeUsed: globalMaps.byType.size,
-        componentNameUsed: globalMaps.byComponentName.size,
-        kindUsed: globalMaps.fromKind.size,
-        componentOfKindUsed: globalMaps.byComponentOfKind.size,
-        colorsUsed: globalMaps.colorsUsed.size
-      },
-      stats: {
-        filesWithMostComponent,
-        mostUseds: getXMostUseds(globalMaps, 10)
-      }
-    },
-    derived: {
-      byFilepath,
-      byComponentInFilepath,
-      globalMaps,
-      byFilePathMaps
-    }
-  };
+	const byId = /* @__PURE__ */ new Map();
+	const byComponentIndex = /* @__PURE__ */ new Map();
+	const byFilepath = /* @__PURE__ */ new Map();
+	const byComponentInFilepath = /* @__PURE__ */ new Map();
+	const globalMaps = createReportMaps();
+	const byFilePathMaps = /* @__PURE__ */ new Map();
+	const conditions = new Map(Object.entries(ctx.conditions.values));
+	const { groupByProp } = getPropertyGroupMap(ctx);
+	let id = 0;
+	let componentIndex = 0;
+	const isKnownUtility = (reportItem, componentReportItem) => {
+		const { propName, value, tokenType } = reportItem;
+		if (ctx.utility.config[propName]) {
+			if (ctx.tokens.getByName(`${tokenType}.${value}`)) return true;
+			if (ctx.tokens.getReferences(String(value)).length > 0) return true;
+			if (ctx.utility.resolveColorMix(String(value)).color) return true;
+			return false;
+		}
+		if (componentReportItem.reportItemType === "pattern") {
+			const patternProp = ctx.patterns.getConfig(componentReportItem.componentName.toLowerCase())?.properties?.[propName];
+			if (!patternProp) return false;
+			if (patternProp.type === "boolean" || patternProp.type === "number") return true;
+			if (patternProp.type === "property" && patternProp.value) return Boolean(ctx.utility.config[patternProp.value]);
+			if (patternProp.type === "enum" && patternProp.value) return Boolean(patternProp.value.includes(String(value)));
+			if (patternProp.type === "token") return Boolean(ctx.tokens.getByName(`${patternProp.value}.${value}`));
+			return false;
+		}
+		return false;
+	};
+	const processPattern = (opts) => {
+		const { boxNode, data, item, filepath, localMaps } = opts;
+		const name = item.componentName;
+		const pattern = ctx.patterns.details.find((p) => p.match.test(name) || p.baseName === name);
+		if (!pattern) return;
+		const cssObj = pattern.config.transform?.(data || {}, patternFns) ?? {};
+		const newItem = {
+			name: "css",
+			type: "css",
+			box: box.objectToMap(compact(cssObj), boxNode.getNode(), boxNode.getStack()),
+			data: [cssObj]
+		};
+		Object.assign(newItem, { debug: true });
+		return processResultItem({
+			item: newItem,
+			kind: "function",
+			localMaps,
+			filepath
+		});
+	};
+	const processResultItem = (opts) => {
+		const { item, kind, filepath, localMaps } = opts;
+		if (!item.box || box.isUnresolvable(item.box)) return;
+		if (!item.data) return;
+		const componentReportItem = {
+			componentIndex: String(componentIndex++),
+			componentName: item.name,
+			reportItemType: item.type,
+			kind,
+			filepath,
+			value: item.data,
+			range: item.box.getRange(),
+			contains: [],
+			debug: Reflect.has(item, "debug")
+		};
+		if (item.type === "pattern" || item.type === "jsx-pattern") return processPattern({
+			boxNode: item.box,
+			data: item.data[0],
+			item: componentReportItem,
+			filepath,
+			localMaps
+		});
+		if (box.isArray(item.box)) {
+			addTo(byComponentInFilepath, filepath, componentReportItem.componentIndex);
+			return componentReportItem;
+		}
+		if (box.isMap(item.box)) {
+			addTo(byComponentInFilepath, filepath, componentReportItem.componentIndex);
+			processMap({
+				map: item.box,
+				current: [],
+				componentReportItem,
+				filepath,
+				localMaps
+			});
+			return componentReportItem;
+		}
+		if (item.type === "recipe") {
+			addTo(byComponentInFilepath, filepath, componentReportItem.componentIndex);
+			return componentReportItem;
+		}
+	};
+	const processResultItemFn = (opts) => {
+		const { item, filepath, localMaps, type } = opts;
+		const componentReportItem = processResultItem({
+			item,
+			kind: type,
+			filepath,
+			localMaps
+		});
+		if (!componentReportItem) return;
+		addTo(globalMaps.byComponentOfKind, type, componentReportItem.componentIndex);
+		addTo(localMaps.byComponentOfKind, type, componentReportItem.componentIndex);
+		byComponentIndex.set(componentReportItem.componentIndex, componentReportItem);
+	};
+	const processMap = (opts) => {
+		const { map, current, componentReportItem, filepath, localMaps, skipRange } = opts;
+		const { reportItemType: type, kind, componentName: name } = componentReportItem;
+		map.value.forEach((attrNode, attrName) => {
+			if (box.isLiteral(attrNode) || box.isEmptyInitializer(attrNode)) {
+				const value = box.isLiteral(attrNode) ? attrNode.value : true;
+				const propReportItem = {
+					index: String(id++),
+					componentIndex: String(componentReportItem.componentIndex),
+					componentName: name,
+					tokenType: void 0,
+					propName: attrName,
+					reportItemKind: "utility",
+					reportItemType: type,
+					kind,
+					filepath,
+					path: current.concat(attrName),
+					value,
+					isKnownValue: false,
+					range: skipRange ? null : map.getRange()
+				};
+				componentReportItem.contains.push(propReportItem.index);
+				if (conditions.has(attrName)) {
+					addTo(globalMaps.byConditionName, attrName, propReportItem.index);
+					addTo(localMaps.byConditionName, attrName, propReportItem.index);
+					propReportItem.propName = current[0] ?? attrName;
+					propReportItem.isKnownValue = isKnownUtility(propReportItem, componentReportItem);
+					propReportItem.conditionName = attrName;
+				} else {
+					if (current.length && conditions.has(current[0])) {
+						propReportItem.conditionName = current[0];
+						addTo(globalMaps.byConditionName, current[0], propReportItem.index);
+						addTo(localMaps.byConditionName, current[0], propReportItem.index);
+					}
+					const propName = ctx.utility.resolveShorthand(attrName);
+					const tokenType = ctx.utility.getTokenType(propName);
+					if (tokenType) {
+						propReportItem.reportItemKind = "token";
+						propReportItem.tokenType = tokenType;
+					}
+					propReportItem.propName = propName;
+					propReportItem.isKnownValue = isKnownUtility(propReportItem, componentReportItem);
+					addTo(globalMaps.byPropertyName, propName, propReportItem.index);
+					addTo(localMaps.byPropertyName, propName, propReportItem.index);
+					if (tokenType) {
+						addTo(globalMaps.byTokenType, tokenType, propReportItem.index);
+						addTo(localMaps.byTokenType, tokenType, propReportItem.index);
+					}
+					if (propName.toLowerCase().includes("color") || groupByProp.get(propName) === "Color" || tokenType === "colors") {
+						addTo(globalMaps.colorsUsed, value, propReportItem.index);
+						addTo(localMaps.colorsUsed, value, propReportItem.index);
+					}
+					if (ctx.utility.shorthands.has(attrName)) {
+						addTo(globalMaps.byShorthand, attrName, propReportItem.index);
+						addTo(localMaps.byShorthand, attrName, propReportItem.index);
+					}
+				}
+				if (current.length) {
+					addTo(globalMaps.byPropertyPath, propReportItem.path.join("."), propReportItem.index);
+					addTo(localMaps.byPropertyPath, propReportItem.path.join("."), propReportItem.index);
+				}
+				addTo(globalMaps.byTokenName, String(value), propReportItem.index);
+				addTo(localMaps.byTokenName, String(value), propReportItem.index);
+				addTo(globalMaps.byType, type, propReportItem.index);
+				addTo(localMaps.byType, type, propReportItem.index);
+				addTo(globalMaps.byComponentName, name, propReportItem.index);
+				addTo(localMaps.byComponentName, name, propReportItem.index);
+				addTo(globalMaps.fromKind, kind, propReportItem.index);
+				addTo(localMaps.fromKind, kind, propReportItem.index);
+				addTo(byFilepath, filepath, propReportItem.index);
+				byId.set(propReportItem.index, propReportItem);
+				return;
+			}
+			if (box.isMap(attrNode) && attrNode.value.size) return processMap({
+				map: attrNode,
+				current: current.concat(attrName),
+				componentReportItem,
+				filepath,
+				localMaps
+			});
+		});
+	};
+	resultMap.forEach((parserResult, filepath) => {
+		if (parserResult.isEmpty()) return;
+		const localMaps = createReportMaps();
+		const componentFn = (item) => {
+			processResultItemFn({
+				item,
+				filepath,
+				localMaps,
+				type: "component"
+			});
+		};
+		const functionFn = (item) => {
+			processResultItemFn({
+				item,
+				filepath,
+				localMaps,
+				type: "function"
+			});
+		};
+		parserResult.jsx.forEach(componentFn);
+		parserResult.css.forEach(functionFn);
+		parserResult.cva.forEach(functionFn);
+		parserResult.pattern.forEach((itemList) => {
+			itemList.forEach(functionFn);
+		});
+		parserResult.recipe.forEach((itemList) => {
+			itemList.forEach(functionFn);
+		});
+		byFilePathMaps.set(filepath, localMaps);
+	});
+	const filesWithMostComponent = Object.fromEntries(Array.from(byComponentInFilepath.entries()).map(([filepath, list]) => [filepath, list.size]).sort((a, b) => b[1] - a[1]).slice(0, 10));
+	Object.entries(ctx.recipes.config).forEach(([key, recipe]) => {
+		const localMaps = createReportMaps();
+		const functionFn = (styleObject) => {
+			if (!styleObject) return;
+			const componentReportItem = {
+				componentIndex: "0",
+				componentName: `recipes.${key}.base`,
+				reportItemType: "css",
+				kind: "function",
+				filepath: `theme/recipes/${key}`,
+				value: styleObject,
+				range: null,
+				contains: []
+			};
+			processMap({
+				map: box.objectToMap(styleObject, null, []),
+				current: [],
+				filepath: `@config/theme/recipes/${key}`,
+				skipRange: true,
+				localMaps,
+				componentReportItem
+			});
+		};
+		const isSlotRecipe = (_v) => ctx.recipes.isSlotRecipe(key);
+		if (isSlotRecipe(recipe)) {
+			Object.values(recipe.base ?? {}).forEach(functionFn);
+			Object.values(recipe.variants ?? {}).forEach((variants) => {
+				Object.values(variants).forEach((v) => {
+					Object.values(v).forEach(functionFn);
+				});
+			});
+			recipe.compoundVariants?.forEach((v) => {
+				Object.values(v.css).forEach(functionFn);
+			});
+		} else {
+			functionFn(recipe.base);
+			Object.values(recipe.variants ?? {}).forEach((variants) => {
+				Object.values(variants).forEach(functionFn);
+			});
+			recipe.compoundVariants?.forEach((v) => functionFn(v.css));
+		}
+	});
+	Object.values(ctx.config.globalCss ?? {}).forEach((styleObject) => {
+		if (!styleObject) return;
+		processMap({
+			map: box.objectToMap(styleObject, null, []),
+			current: [],
+			filepath: "@config/globalCss",
+			skipRange: true,
+			localMaps: createReportMaps(),
+			componentReportItem: {
+				componentIndex: "0",
+				componentName: "global",
+				reportItemType: "css",
+				kind: "function",
+				filepath: "global",
+				value: styleObject,
+				range: null,
+				contains: []
+			}
+		});
+	});
+	return {
+		propById: byId,
+		componentById: byComponentIndex,
+		details: {
+			counts: {
+				filesWithTokens: byFilepath.size,
+				propNameUsed: globalMaps.byPropertyName.size,
+				tokenUsed: globalMaps.byTokenName.size,
+				shorthandUsed: globalMaps.byShorthand.size,
+				propertyPathUsed: globalMaps.byPropertyPath.size,
+				typeUsed: globalMaps.byType.size,
+				componentNameUsed: globalMaps.byComponentName.size,
+				kindUsed: globalMaps.fromKind.size,
+				componentOfKindUsed: globalMaps.byComponentOfKind.size,
+				colorsUsed: globalMaps.colorsUsed.size
+			},
+			stats: {
+				filesWithMostComponent,
+				mostUseds: getXMostUseds(globalMaps, 10)
+			}
+		},
+		derived: {
+			byFilepath,
+			byComponentInFilepath,
+			globalMaps,
+			byFilePathMaps
+		}
+	};
 }
-var getXMostUseds = (globalMaps, pickCount) => {
-  return {
-    propNames: getMostUsedInMap(globalMaps.byPropertyName, pickCount),
-    tokens: getMostUsedInMap(globalMaps.byTokenName, pickCount),
-    shorthands: getMostUsedInMap(globalMaps.byShorthand, pickCount),
-    conditions: getMostUsedInMap(globalMaps.byConditionName, pickCount),
-    propertyPaths: getMostUsedInMap(globalMaps.byPropertyPath, pickCount),
-    categories: getMostUsedInMap(globalMaps.byTokenType, pickCount),
-    types: getMostUsedInMap(globalMaps.byType, pickCount),
-    componentNames: getMostUsedInMap(globalMaps.byComponentName, pickCount),
-    fromKinds: getMostUsedInMap(globalMaps.fromKind, pickCount),
-    componentOfKinds: getMostUsedInMap(globalMaps.byComponentOfKind, pickCount),
-    colors: getMostUsedInMap(globalMaps.colorsUsed, pickCount)
-  };
+const getXMostUseds = (globalMaps, pickCount) => {
+	return {
+		propNames: getMostUsedInMap(globalMaps.byPropertyName, pickCount),
+		tokens: getMostUsedInMap(globalMaps.byTokenName, pickCount),
+		shorthands: getMostUsedInMap(globalMaps.byShorthand, pickCount),
+		conditions: getMostUsedInMap(globalMaps.byConditionName, pickCount),
+		propertyPaths: getMostUsedInMap(globalMaps.byPropertyPath, pickCount),
+		categories: getMostUsedInMap(globalMaps.byTokenType, pickCount),
+		types: getMostUsedInMap(globalMaps.byType, pickCount),
+		componentNames: getMostUsedInMap(globalMaps.byComponentName, pickCount),
+		fromKinds: getMostUsedInMap(globalMaps.fromKind, pickCount),
+		componentOfKinds: getMostUsedInMap(globalMaps.byComponentOfKind, pickCount),
+		colors: getMostUsedInMap(globalMaps.colorsUsed, pickCount)
+	};
 };
-var getMostUsedInMap = (map, pickCount) => {
-  return Array.from(map.entries()).map(([key, list]) => [key, list.size]).sort((a, b) => b[1] - a[1]).slice(0, pickCount).map(([key, count]) => ({ key, count }));
+const getMostUsedInMap = (map, pickCount) => {
+	return Array.from(map.entries()).map(([key, list]) => [key, list.size]).sort((a, b) => b[1] - a[1]).slice(0, pickCount).map(([key, count]) => ({
+		key,
+		count
+	}));
 };
-var defaultGroupNames = [
-  "System",
-  "Container",
-  "Display",
-  "Visibility",
-  "Position",
-  "Transform",
-  "Flex Layout",
-  "Grid Layout",
-  "Layout",
-  "Border",
-  "Border Radius",
-  "Width",
-  "Height",
-  "Margin",
-  "Padding",
-  "Color",
-  "Typography",
-  "Background",
-  "Shadow",
-  "Table",
-  "List",
-  "Scroll",
-  "Interactivity",
-  "Transition",
-  "Effect",
-  "Other",
-  "Focus Ring"
+const defaultGroupNames = [
+	"System",
+	"Container",
+	"Display",
+	"Visibility",
+	"Position",
+	"Transform",
+	"Flex Layout",
+	"Grid Layout",
+	"Layout",
+	"Border",
+	"Border Radius",
+	"Width",
+	"Height",
+	"Margin",
+	"Padding",
+	"Color",
+	"Typography",
+	"Background",
+	"Shadow",
+	"Table",
+	"List",
+	"Scroll",
+	"Interactivity",
+	"Transition",
+	"Effect",
+	"Other",
+	"Focus Ring"
 ];
 function getPropertyGroupMap(ctx) {
-  const groups = new Map(defaultGroupNames.map((name) => [name, /* @__PURE__ */ new Set()]));
-  const groupByProp = /* @__PURE__ */ new Map();
-  const systemGroup = groups.get("System");
-  systemGroup.add("base");
-  systemGroup.add("colorPalette");
-  const otherStyleProps = groups.get("Other");
-  Object.entries(ctx.utility.config).map(([key, value]) => {
-    const group = value?.group;
-    if (!group) {
-      otherStyleProps.add(key);
-      return;
-    }
-    if (!groups.has(group)) {
-      groups.set(group, /* @__PURE__ */ new Set());
-    }
-    const set = groups.get(group);
-    if (value.shorthand) {
-      if (Array.isArray(value.shorthand)) {
-        value.shorthand.forEach((shorthand) => {
-          set.add(shorthand);
-          groupByProp.set(shorthand, group);
-        });
-      } else {
-        set.add(value.shorthand);
-        groupByProp.set(value.shorthand, group);
-      }
-    }
-    set.add(key);
-    groupByProp.set(key, group);
-  });
-  return { groups, groupByProp };
+	const groups = new Map(defaultGroupNames.map((name) => [name, /* @__PURE__ */ new Set()]));
+	const groupByProp = /* @__PURE__ */ new Map();
+	const systemGroup = groups.get("System");
+	systemGroup.add("base");
+	systemGroup.add("colorPalette");
+	const otherStyleProps = groups.get("Other");
+	Object.entries(ctx.utility.config).map(([key, value]) => {
+		const group = value?.group;
+		if (!group) {
+			otherStyleProps.add(key);
+			return;
+		}
+		if (!groups.has(group)) groups.set(group, /* @__PURE__ */ new Set());
+		const set = groups.get(group);
+		if (value.shorthand) if (Array.isArray(value.shorthand)) value.shorthand.forEach((shorthand) => {
+			set.add(shorthand);
+			groupByProp.set(shorthand, group);
+		});
+		else {
+			set.add(value.shorthand);
+			groupByProp.set(value.shorthand, group);
+		}
+		set.add(key);
+		groupByProp.set(key, group);
+	});
+	return {
+		groups,
+		groupByProp
+	};
 }
 function createReportMaps() {
-  return {
-    byComponentOfKind: /* @__PURE__ */ new Map(),
-    byPropertyName: /* @__PURE__ */ new Map(),
-    byTokenType: /* @__PURE__ */ new Map(),
-    byConditionName: /* @__PURE__ */ new Map(),
-    byShorthand: /* @__PURE__ */ new Map(),
-    byTokenName: /* @__PURE__ */ new Map(),
-    byPropertyPath: /* @__PURE__ */ new Map(),
-    fromKind: /* @__PURE__ */ new Map(),
-    byType: /* @__PURE__ */ new Map(),
-    byComponentName: /* @__PURE__ */ new Map(),
-    colorsUsed: /* @__PURE__ */ new Map()
-  };
+	return {
+		byComponentOfKind: /* @__PURE__ */ new Map(),
+		byPropertyName: /* @__PURE__ */ new Map(),
+		byTokenType: /* @__PURE__ */ new Map(),
+		byConditionName: /* @__PURE__ */ new Map(),
+		byShorthand: /* @__PURE__ */ new Map(),
+		byTokenName: /* @__PURE__ */ new Map(),
+		byPropertyPath: /* @__PURE__ */ new Map(),
+		fromKind: /* @__PURE__ */ new Map(),
+		byType: /* @__PURE__ */ new Map(),
+		byComponentName: /* @__PURE__ */ new Map(),
+		colorsUsed: /* @__PURE__ */ new Map()
+	};
 }
-
-// src/parser.ts
-import { box as box2, extract, unbox } from "@bamboocss/extractor";
-import { logger } from "@bamboocss/logger";
-import { astish } from "@bamboocss/shared";
-import { Node } from "ts-morph";
-import { match } from "ts-pattern";
-
-// src/get-import-declarations.ts
-import { resolveTsPathPattern } from "@bamboocss/config/ts-path";
-
-// src/get-module-specifier-value.ts
-var getModuleSpecifierValue = (node) => {
-  try {
-    return node.getModuleSpecifierValue();
-  } catch {
-    return;
-  }
+//#endregion
+//#region src/get-module-specifier-value.ts
+const getModuleSpecifierValue = (node) => {
+	try {
+		return node.getModuleSpecifierValue();
+	} catch {
+		return;
+	}
 };
-
-// src/get-import-declarations.ts
+//#endregion
+//#region src/get-import-declarations.ts
 function getImportDeclarations(context, sourceFile) {
-  const { imports, tsOptions } = context;
-  const importDeclarations = [];
-  sourceFile.getImportDeclarations().forEach((node) => {
-    const mod = getModuleSpecifierValue(node);
-    if (!mod) return;
-    node.getNamedImports().forEach((specifier) => {
-      const name = specifier.getNameNode().getText();
-      const alias = specifier.getAliasNode()?.getText() || name;
-      const result = { name, alias, mod, kind: "named" };
-      const found = imports.match(result, (mod2) => {
-        if (!tsOptions?.pathMappings) return;
-        return resolveTsPathPattern(tsOptions.pathMappings, mod2);
-      });
-      if (!found) return;
-      importDeclarations.push(result);
-    });
-    const namespace = node.getNamespaceImport();
-    if (namespace) {
-      const name = namespace.getText();
-      const result = { name, alias: name, mod, kind: "namespace" };
-      const found = imports.match(result, (mod2) => {
-        if (!tsOptions?.pathMappings) return;
-        return resolveTsPathPattern(tsOptions.pathMappings, mod2);
-      });
-      if (!found) return;
-      importDeclarations.push(result);
-    }
-  });
-  return importDeclarations;
+	const { imports, tsOptions } = context;
+	const importDeclarations = [];
+	sourceFile.getImportDeclarations().forEach((node) => {
+		const mod = getModuleSpecifierValue(node);
+		if (!mod) return;
+		node.getNamedImports().forEach((specifier) => {
+			const name = specifier.getNameNode().getText();
+			const result = {
+				name,
+				alias: specifier.getAliasNode()?.getText() || name,
+				mod,
+				kind: "named"
+			};
+			if (!imports.match(result, (mod) => {
+				if (!tsOptions?.pathMappings) return;
+				return resolveTsPathPattern(tsOptions.pathMappings, mod);
+			})) return;
+			importDeclarations.push(result);
+		});
+		const namespace = node.getNamespaceImport();
+		if (namespace) {
+			const name = namespace.getText();
+			const result = {
+				name,
+				alias: name,
+				mod,
+				kind: "namespace"
+			};
+			if (!imports.match(result, (mod) => {
+				if (!tsOptions?.pathMappings) return;
+				return resolveTsPathPattern(tsOptions.pathMappings, mod);
+			})) return;
+			importDeclarations.push(result);
+		}
+	});
+	return importDeclarations;
 }
-
-// src/parser-result.ts
-import { BambooError, getOrCreateSet } from "@bamboocss/shared";
+//#endregion
+//#region src/parser-result.ts
 function cartesian(arrays) {
-  if (arrays.length === 0) return [[]];
-  const [first, ...rest] = arrays;
-  const restProduct = cartesian(rest);
-  return first.flatMap((item) => restProduct.map((combo) => [item, ...combo]));
+	if (arrays.length === 0) return [[]];
+	const [first, ...rest] = arrays;
+	const restProduct = cartesian(rest);
+	return first.flatMap((item) => restProduct.map((combo) => [item, ...combo]));
 }
 var ParserResult = class {
-  constructor(context, encoder) {
-    this.context = context;
-    this.encoder = encoder ?? context.encoder;
-  }
-  /** Ordered list of all ResultItem */
-  all = [];
-  jsx = /* @__PURE__ */ new Set();
-  css = /* @__PURE__ */ new Set();
-  cva = /* @__PURE__ */ new Set();
-  sva = /* @__PURE__ */ new Set();
-  token = /* @__PURE__ */ new Set();
-  recipe = /* @__PURE__ */ new Map();
-  pattern = /* @__PURE__ */ new Map();
-  filePath;
-  encoder;
-  append(result) {
-    this.all.push(result);
-    return result;
-  }
-  set(name, result) {
-    switch (name) {
-      case "css":
-        this.setCss(result);
-        break;
-      case "cva":
-        this.setCva(result);
-        break;
-      case "sva":
-        this.setSva(result);
-        break;
-      case "token":
-        this.setToken(result);
-        break;
-      default:
-        throw new BambooError(
-          "UNKNOWN_RESULT_TYPE",
-          `Unknown parser result type: "${name}". Expected one of: css, cva, sva, token`
-        );
-    }
-  }
-  setCss(result) {
-    this.css.add(this.append(Object.assign({ type: "css" }, result)));
-    const encoder = this.encoder;
-    const grouped = this.context.config.cssMode === "grouped";
-    if (!grouped || result.data.length <= 1) {
-      result.data.forEach((obj) => grouped ? encoder.processGrouped(obj) : encoder.processAtomic(obj));
-      return;
-    }
-    const keyCounts = /* @__PURE__ */ new Map();
-    for (const obj of result.data) {
-      for (const key of Object.keys(obj)) {
-        keyCounts.set(key, (keyCounts.get(key) || 0) + 1);
-      }
-    }
-    const hasOverlap = Array.from(keyCounts.values()).some((c) => c > 1);
-    if (!hasOverlap) {
-      encoder.processGrouped(Object.assign({}, ...result.data));
-      return;
-    }
-    const overlappingKeys = /* @__PURE__ */ new Set();
-    keyCounts.forEach((count, key) => {
-      if (count > 1) overlappingKeys.add(key);
-    });
-    const base = {};
-    const branchEntries = [];
-    for (const obj of result.data) {
-      if (Object.keys(obj).some((k) => overlappingKeys.has(k))) {
-        branchEntries.push(obj);
-      } else {
-        Object.assign(base, obj);
-      }
-    }
-    const branchGroups = /* @__PURE__ */ new Map();
-    for (const entry of branchEntries) {
-      const keySet = Object.keys(entry).sort().join("\0");
-      const group = branchGroups.get(keySet) || [];
-      group.push(entry);
-      branchGroups.set(keySet, group);
-    }
-    const groupArrays = Array.from(branchGroups.values());
-    const totalCombinations = groupArrays.reduce((acc, g) => acc * g.length, 1);
-    if (totalCombinations > 32) {
-      result.data.forEach((obj) => encoder.processGrouped(obj));
-      return;
-    }
-    for (const combo of cartesian(groupArrays)) {
-      encoder.processGrouped(Object.assign({}, base, ...combo));
-    }
-  }
-  setCva(result) {
-    this.cva.add(this.append(Object.assign({ type: "cva" }, result)));
-    const encoder = this.encoder;
-    result.data.forEach((data) => encoder.processAtomicRecipe(data));
-  }
-  setSva(result) {
-    this.sva.add(this.append(Object.assign({ type: "sva" }, result)));
-    const encoder = this.encoder;
-    result.data.forEach((data) => encoder.processAtomicSlotRecipe(data));
-  }
-  setToken(result) {
-    this.token.add(this.append(Object.assign({ type: "token" }, result)));
-  }
-  setJsx(result) {
-    this.jsx.add(this.append(Object.assign({ type: "jsx" }, result)));
-    const encoder = this.encoder;
-    const grouped = this.context.config.cssMode === "grouped";
-    result.data.forEach((obj) => encoder.processStyleProps(obj, grouped));
-  }
-  setPattern(name, result) {
-    const set = getOrCreateSet(this.pattern, name);
-    set.add(this.append(Object.assign({ type: "pattern", name }, result)));
-    const encoder = this.encoder;
-    result.data.forEach(
-      (obj) => encoder.processPattern(name, obj, result.type ?? "pattern", result.name)
-    );
-  }
-  setRecipe(recipeName, result) {
-    const set = getOrCreateSet(this.recipe, recipeName);
-    set.add(this.append(Object.assign({ type: "recipe" }, result)));
-    const encoder = this.encoder;
-    const recipes = this.context.recipes;
-    const recipeConfig = recipes.getConfig(recipeName);
-    if (!recipeConfig) return;
-    const recipe = result;
-    if (result.type) {
-      recipe.data.forEach((data) => {
-        const [recipeProps, styleProps] = recipes.splitProps(recipeName, data);
-        encoder.processStyleProps(styleProps);
-        encoder.processRecipe(recipeName, recipeProps);
-      });
-    } else {
-      recipe.data.forEach((data) => {
-        encoder.processRecipe(recipeName, data);
-      });
-    }
-  }
-  isEmpty() {
-    return this.all.length === 0;
-  }
-  setFilePath(filePath) {
-    this.filePath = filePath;
-    return this;
-  }
-  merge(result) {
-    result.css.forEach((item) => this.css.add(this.append(item)));
-    result.cva.forEach((item) => this.cva.add(this.append(item)));
-    result.sva.forEach((item) => this.sva.add(this.append(item)));
-    result.token.forEach((item) => this.token.add(this.append(item)));
-    result.jsx.forEach((item) => this.jsx.add(this.append(item)));
-    result.recipe.forEach((items, name) => {
-      const set = getOrCreateSet(this.recipe, name);
-      items.forEach((item) => set.add(this.append(item)));
-    });
-    result.pattern.forEach((items, name) => {
-      const set = getOrCreateSet(this.pattern, name);
-      items.forEach((item) => set.add(this.append(item)));
-    });
-    return this;
-  }
-  toArray() {
-    return this.all;
-  }
-  toJSON() {
-    return {
-      css: Array.from(this.css),
-      cva: Array.from(this.cva),
-      sva: Array.from(this.sva),
-      token: Array.from(this.token),
-      jsx: Array.from(this.jsx),
-      recipe: Object.fromEntries(Array.from(this.recipe.entries()).map(([key, value]) => [key, Array.from(value)])),
-      pattern: Object.fromEntries(Array.from(this.pattern.entries()).map(([key, value]) => [key, Array.from(value)]))
-    };
-  }
-};
-
-// src/parser.ts
-var combineResult = (unboxed) => {
-  return [...unboxed.conditions, unboxed.raw, ...unboxed.spreadConditions];
+	context;
+	/** Ordered list of all ResultItem */
+	all = [];
+	jsx = /* @__PURE__ */ new Set();
+	css = /* @__PURE__ */ new Set();
+	cva = /* @__PURE__ */ new Set();
+	sva = /* @__PURE__ */ new Set();
+	token = /* @__PURE__ */ new Set();
+	recipe = /* @__PURE__ */ new Map();
+	pattern = /* @__PURE__ */ new Map();
+	filePath;
+	encoder;
+	constructor(context, encoder) {
+		this.context = context;
+		this.encoder = encoder ?? context.encoder;
+	}
+	append(result) {
+		this.all.push(result);
+		return result;
+	}
+	set(name, result) {
+		switch (name) {
+			case "css":
+				this.setCss(result);
+				break;
+			case "cva":
+				this.setCva(result);
+				break;
+			case "sva":
+				this.setSva(result);
+				break;
+			case "token":
+				this.setToken(result);
+				break;
+			default: throw new BambooError("UNKNOWN_RESULT_TYPE", `Unknown parser result type: "${name}". Expected one of: css, cva, sva, token`);
+		}
+	}
+	setCss(result) {
+		this.css.add(this.append(Object.assign({ type: "css" }, result)));
+		const encoder = this.encoder;
+		const grouped = this.context.config.cssMode === "grouped";
+		if (!grouped || result.data.length <= 1) {
+			result.data.forEach((obj) => grouped ? encoder.processGrouped(obj) : encoder.processAtomic(obj));
+			return;
+		}
+		const keyCounts = /* @__PURE__ */ new Map();
+		for (const obj of result.data) for (const key of Object.keys(obj)) keyCounts.set(key, (keyCounts.get(key) || 0) + 1);
+		if (!Array.from(keyCounts.values()).some((c) => c > 1)) {
+			encoder.processGrouped(Object.assign({}, ...result.data));
+			return;
+		}
+		const overlappingKeys = /* @__PURE__ */ new Set();
+		keyCounts.forEach((count, key) => {
+			if (count > 1) overlappingKeys.add(key);
+		});
+		const base = {};
+		const branchEntries = [];
+		for (const obj of result.data) if (Object.keys(obj).some((k) => overlappingKeys.has(k))) branchEntries.push(obj);
+		else Object.assign(base, obj);
+		const branchGroups = /* @__PURE__ */ new Map();
+		for (const entry of branchEntries) {
+			const keySet = Object.keys(entry).sort().join("\0");
+			const group = branchGroups.get(keySet) || [];
+			group.push(entry);
+			branchGroups.set(keySet, group);
+		}
+		const groupArrays = Array.from(branchGroups.values());
+		if (groupArrays.reduce((acc, g) => acc * g.length, 1) > 32) {
+			result.data.forEach((obj) => encoder.processGrouped(obj));
+			return;
+		}
+		for (const combo of cartesian(groupArrays)) encoder.processGrouped(Object.assign({}, base, ...combo));
+	}
+	setCva(result) {
+		this.cva.add(this.append(Object.assign({ type: "cva" }, result)));
+		const encoder = this.encoder;
+		result.data.forEach((data) => encoder.processAtomicRecipe(data));
+	}
+	setSva(result) {
+		this.sva.add(this.append(Object.assign({ type: "sva" }, result)));
+		const encoder = this.encoder;
+		result.data.forEach((data) => encoder.processAtomicSlotRecipe(data));
+	}
+	setToken(result) {
+		this.token.add(this.append(Object.assign({ type: "token" }, result)));
+	}
+	setJsx(result) {
+		this.jsx.add(this.append(Object.assign({ type: "jsx" }, result)));
+		const encoder = this.encoder;
+		const grouped = this.context.config.cssMode === "grouped";
+		result.data.forEach((obj) => encoder.processStyleProps(obj, grouped));
+	}
+	setPattern(name, result) {
+		getOrCreateSet(this.pattern, name).add(this.append(Object.assign({
+			type: "pattern",
+			name
+		}, result)));
+		const encoder = this.encoder;
+		result.data.forEach((obj) => encoder.processPattern(name, obj, result.type ?? "pattern", result.name));
+	}
+	setRecipe(recipeName, result) {
+		getOrCreateSet(this.recipe, recipeName).add(this.append(Object.assign({ type: "recipe" }, result)));
+		const encoder = this.encoder;
+		const recipes = this.context.recipes;
+		if (!recipes.getConfig(recipeName)) return;
+		const recipe = result;
+		if (result.type) recipe.data.forEach((data) => {
+			const [recipeProps, styleProps] = recipes.splitProps(recipeName, data);
+			encoder.processStyleProps(styleProps);
+			encoder.processRecipe(recipeName, recipeProps);
+		});
+		else recipe.data.forEach((data) => {
+			encoder.processRecipe(recipeName, data);
+		});
+	}
+	isEmpty() {
+		return this.all.length === 0;
+	}
+	setFilePath(filePath) {
+		this.filePath = filePath;
+		return this;
+	}
+	merge(result) {
+		result.css.forEach((item) => this.css.add(this.append(item)));
+		result.cva.forEach((item) => this.cva.add(this.append(item)));
+		result.sva.forEach((item) => this.sva.add(this.append(item)));
+		result.token.forEach((item) => this.token.add(this.append(item)));
+		result.jsx.forEach((item) => this.jsx.add(this.append(item)));
+		result.recipe.forEach((items, name) => {
+			const set = getOrCreateSet(this.recipe, name);
+			items.forEach((item) => set.add(this.append(item)));
+		});
+		result.pattern.forEach((items, name) => {
+			const set = getOrCreateSet(this.pattern, name);
+			items.forEach((item) => set.add(this.append(item)));
+		});
+		return this;
+	}
+	toArray() {
+		return this.all;
+	}
+	toJSON() {
+		return {
+			css: Array.from(this.css),
+			cva: Array.from(this.cva),
+			sva: Array.from(this.sva),
+			token: Array.from(this.token),
+			jsx: Array.from(this.jsx),
+			recipe: Object.fromEntries(Array.from(this.recipe.entries()).map(([key, value]) => [key, Array.from(value)])),
+			pattern: Object.fromEntries(Array.from(this.pattern.entries()).map(([key, value]) => [key, Array.from(value)]))
+		};
+	}
 };
-var defaultEnv = {
-  preset: "ECMA"
-};
-var evaluateOptions = {
-  environment: defaultEnv
+//#endregion
+//#region src/parser.ts
+const combineResult = (unboxed) => {
+	return [
+		...unboxed.conditions,
+		unboxed.raw,
+		...unboxed.spreadConditions
+	];
 };
+const defaultEnv = { preset: "ECMA" };
+const evaluateOptions = { environment: defaultEnv };
 function createParser(context) {
-  const { jsx, imports, recipes, config } = context;
-  const syntax = config.syntax;
-  return function parse(sourceFile, encoder, options) {
-    if (!sourceFile) return;
-    const importDeclarations = getImportDeclarations(context, sourceFile);
-    const file = imports.file(importDeclarations);
-    const filePath = sourceFile.getFilePath();
-    logger.debug(
-      "ast:import",
-      !file.isEmpty() ? `Found import { ${file.toString()} } in ${filePath}` : `No import found in ${filePath}`
-    );
-    const parserResult = new ParserResult(context, encoder);
-    if (file.isEmpty() && !jsx.isEnabled) {
-      return parserResult;
-    }
-    const extractResultByName = extract({
-      ast: sourceFile,
-      tokens: context.tokens ? {
-        view: context.tokens.view,
-        isTokenFn: (fnName) => file.isTokenAlias(fnName)
-      } : void 0,
-      components: jsx.isEnabled ? {
-        matchTag: (prop) => {
-          if (options?.matchTag) {
-            const isBambooComponent = file.isBambooComponent(prop.tagName);
-            const matchTagMode = options.matchTagMode ?? "extend";
-            const isCustomMatch = options.matchTag(prop.tagName, isBambooComponent);
-            if (matchTagMode === "override") {
-              return isCustomMatch;
-            }
-            return isBambooComponent || isCustomMatch;
-          }
-          return !!file.matchTag(prop.tagName);
-        },
-        matchProp: (prop) => {
-          const isBambooProp = file.matchTagProp(prop.tagName, prop.propName);
-          if (options?.matchTagProp) {
-            return isBambooProp && options.matchTagProp(prop.tagName, prop.propName);
-          }
-          return isBambooProp;
-        }
-      } : void 0,
-      functions: {
-        matchFn: (prop) => file.matchFn(prop.fnName),
-        matchProp: () => true,
-        matchArg: (prop) => {
-          if (file.isJsxFactory(prop.fnName) && prop.index === 1 && Node.isIdentifier(prop.argNode)) return false;
-          return true;
-        }
-      },
-      taggedTemplates: syntax === "template-literal" ? {
-        matchTaggedTemplate: (tag) => file.matchFn(tag.fnName)
-      } : void 0,
-      getEvaluateOptions: (node) => {
-        if (!Node.isCallExpression(node)) return evaluateOptions;
-        const propAccessExpr = node.getExpression();
-        if (!Node.isPropertyAccessExpression(propAccessExpr)) return evaluateOptions;
-        let name = propAccessExpr.getText();
-        if (!file.isRawFn(name)) {
-          return evaluateOptions;
-        }
-        name = name.replace(".raw", "");
-        return {
-          environment: Object.assign({}, defaultEnv, {
-            extra: {
-              [name]: { raw: (v) => v }
-            }
-          })
-        };
-      },
-      flags: { skipTraverseFiles: true }
-    });
-    extractResultByName.forEach((result, alias) => {
-      const name = file.getName(file.normalizeFnName(alias));
-      logger.debug(`ast:${name}`, name !== alias ? { kind: result.kind, alias } : { kind: result.kind });
-      if (result.kind === "function") {
-        match(name).when(imports.matchers.css.match, (name2) => {
-          result.queryList.forEach((query) => {
-            if (query.kind === "call-expression") {
-              if (query.box.value.length > 1) {
-                parserResult.set(name2, {
-                  name: name2,
-                  box: query.box,
-                  data: query.box.value.reduce(
-                    (acc, value) => [...acc, ...combineResult(unbox(value))],
-                    []
-                  )
-                });
-              } else {
-                parserResult.set(name2, {
-                  name: name2,
-                  box: query.box.value[0] ?? box2.fallback(query.box),
-                  data: combineResult(unbox(query.box.value[0]))
-                });
-              }
-            } else if (query.kind === "tagged-template") {
-              const obj = astish(query.box.value);
-              parserResult.set(name2, {
-                name: name2,
-                box: query.box ?? box2.fallback(query.box),
-                data: [obj]
-              });
-            }
-          });
-        }).when(imports.matchers.tokens.match, (name2) => {
-          result.queryList.forEach((query) => {
-            if (query.kind === "call-expression") {
-              parserResult.setToken({
-                name: name2,
-                box: query.box.value[0] ?? box2.fallback(query.box),
-                data: combineResult(unbox(query.box.value[0]))
-              });
-            }
-          });
-        }).when(file.isValidPattern, (name2) => {
-          result.queryList.forEach((query) => {
-            if (query.kind === "call-expression") {
-              parserResult.setPattern(name2, {
-                name: name2,
-                box: query.box.value[0] ?? box2.fallback(query.box),
-                data: combineResult(unbox(query.box.value[0]))
-              });
-            }
-          });
-        }).when(file.isValidRecipe, (name2) => {
-          result.queryList.forEach((query) => {
-            if (query.kind === "call-expression") {
-              parserResult.setRecipe(name2, {
-                name: name2,
-                box: query.box.value[0] ?? box2.fallback(query.box),
-                data: combineResult(unbox(query.box.value[0]))
-              });
-            }
-          });
-        }).when(jsx.isJsxFactory, () => {
-          result.queryList.forEach((query) => {
-            if (query.kind === "call-expression" && query.box.value[1]) {
-              const map = query.box.value[1];
-              const boxNode = box2.isMap(map) ? map : box2.fallback(query.box);
-              const combined = combineResult(unbox(boxNode));
-              const transformed = options?.transform?.({ type: "jsx-factory", data: combined });
-              const result2 = { name, box: boxNode, data: transformed ?? combined };
-              if (box2.isRecipe(map)) {
-                parserResult.setCva(result2);
-              } else {
-                parserResult.set("css", result2);
-              }
-              const recipeOptions = query.box.value[2];
-              if (box2.isUnresolvable(map) && recipeOptions && box2.isMap(recipeOptions) && recipeOptions.value.has("defaultProps")) {
-                const maybeIdentifier = map.getNode();
-                if (Node.isIdentifier(maybeIdentifier)) {
-                  const name2 = maybeIdentifier.getText();
-                  const recipeName = file.getName(name2);
-                  parserResult.setRecipe(recipeName, {
-                    type: "jsx-recipe",
-                    name: recipeName,
-                    box: recipeOptions,
-                    data: combineResult(unbox(recipeOptions.value.get("defaultProps")))
-                  });
-                }
-              }
-            } else if (query.kind === "tagged-template") {
-              const obj = astish(query.box.value);
-              parserResult.set("css", {
-                name,
-                box: query.box ?? box2.fallback(query.box),
-                data: [obj]
-              });
-            }
-          });
-        }).when(file.isJsxFactory, (name2) => {
-          result.queryList.forEach((query) => {
-            if (query.kind === "call-expression") {
-              const map = query.box.value[0];
-              const boxNode = box2.isMap(map) ? map : box2.fallback(query.box);
-              const combined = combineResult(unbox(boxNode));
-              const transformed = options?.transform?.({ type: "jsx-factory", data: combined });
-              const result2 = { name: name2, box: boxNode, data: transformed ?? combined };
-              if (box2.isRecipe(map)) {
-                parserResult.setCva(result2);
-              } else {
-                parserResult.set("css", result2);
-              }
-            } else if (query.kind === "tagged-template") {
-              const obj = astish(query.box.value);
-              parserResult.set("css", {
-                name: name2,
-                box: query.box ?? box2.fallback(query.box),
-                data: [obj]
-              });
-            }
-          });
-        }).otherwise(() => {
-        });
-      } else if (jsx.isEnabled && result.kind === "component") {
-        result.queryList.forEach((query) => {
-          const data = combineResult(unbox(query.box));
-          switch (true) {
-            case (file.isJsxFactory(name) || file.isJsxFactory(alias)): {
-              parserResult.setJsx({ type: "jsx-factory", name, box: query.box, data });
-              break;
-            }
-            case (jsx.isJsxTagPattern(name) || jsx.isJsxTagPattern(alias)): {
-              parserResult.setPattern(name, { type: "jsx-pattern", name, box: query.box, data });
-              break;
-            }
-            // name: Trigger
-            case jsx.isJsxTagRecipe(name): {
-              const matchingRecipes = recipes.filter(name);
-              matchingRecipes.map((recipe) => {
-                parserResult.setRecipe(recipe.baseName, { type: "jsx-recipe", name, box: query.box, data });
-              });
-              break;
-            }
-            // alias: Tabs.Trigger
-            case jsx.isJsxTagRecipe(alias): {
-              const matchingRecipes = recipes.filter(alias);
-              matchingRecipes.map((recipe) => {
-                parserResult.setRecipe(recipe.baseName, { type: "jsx-recipe", name: alias, box: query.box, data });
-              });
-              break;
-            }
-            default: {
-              parserResult.setJsx({ type: "jsx", name, box: query.box, data });
-            }
-          }
-        });
-      }
-    });
-    return parserResult;
-  };
+	const { jsx, imports, recipes, config } = context;
+	const syntax = config.syntax;
+	return function parse(sourceFile, encoder, options) {
+		if (!sourceFile) return;
+		const importDeclarations = getImportDeclarations(context, sourceFile);
+		const file = imports.file(importDeclarations);
+		const filePath = sourceFile.getFilePath();
+		logger.debug("ast:import", !file.isEmpty() ? `Found import { ${file.toString()} } in ${filePath}` : `No import found in ${filePath}`);
+		const parserResult = new ParserResult(context, encoder);
+		if (file.isEmpty() && !jsx.isEnabled) return parserResult;
+		extract({
+			ast: sourceFile,
+			tokens: context.tokens ? {
+				view: context.tokens.view,
+				isTokenFn: (fnName) => file.isTokenAlias(fnName)
+			} : void 0,
+			components: jsx.isEnabled ? {
+				matchTag: (prop) => {
+					if (options?.matchTag) {
+						const isBambooComponent = file.isBambooComponent(prop.tagName);
+						const matchTagMode = options.matchTagMode ?? "extend";
+						const isCustomMatch = options.matchTag(prop.tagName, isBambooComponent);
+						if (matchTagMode === "override") return isCustomMatch;
+						return isBambooComponent || isCustomMatch;
+					}
+					return !!file.matchTag(prop.tagName);
+				},
+				matchProp: (prop) => {
+					const isBambooProp = file.matchTagProp(prop.tagName, prop.propName);
+					if (options?.matchTagProp) return isBambooProp && options.matchTagProp(prop.tagName, prop.propName);
+					return isBambooProp;
+				}
+			} : void 0,
+			functions: {
+				matchFn: (prop) => file.matchFn(prop.fnName),
+				matchProp: () => true,
+				matchArg: (prop) => {
+					if (file.isJsxFactory(prop.fnName) && prop.index === 1 && Node.isIdentifier(prop.argNode)) return false;
+					return true;
+				}
+			},
+			taggedTemplates: syntax === "template-literal" ? { matchTaggedTemplate: (tag) => file.matchFn(tag.fnName) } : void 0,
+			getEvaluateOptions: (node) => {
+				if (!Node.isCallExpression(node)) return evaluateOptions;
+				const propAccessExpr = node.getExpression();
+				if (!Node.isPropertyAccessExpression(propAccessExpr)) return evaluateOptions;
+				let name = propAccessExpr.getText();
+				if (!file.isRawFn(name)) return evaluateOptions;
+				name = name.replace(".raw", "");
+				return { environment: Object.assign({}, defaultEnv, { extra: { [name]: { raw: (v) => v } } }) };
+			},
+			flags: { skipTraverseFiles: true }
+		}).forEach((result, alias) => {
+			const name = file.getName(file.normalizeFnName(alias));
+			logger.debug(`ast:${name}`, name !== alias ? {
+				kind: result.kind,
+				alias
+			} : { kind: result.kind });
+			if (result.kind === "function") match(name).when(imports.matchers.css.match, (name) => {
+				result.queryList.forEach((query) => {
+					if (query.kind === "call-expression") if (query.box.value.length > 1) parserResult.set(name, {
+						name,
+						box: query.box,
+						data: query.box.value.reduce((acc, value) => [...acc, ...combineResult(unbox(value))], [])
+					});
+					else parserResult.set(name, {
+						name,
+						box: query.box.value[0] ?? box.fallback(query.box),
+						data: combineResult(unbox(query.box.value[0]))
+					});
+					else if (query.kind === "tagged-template") {
+						const obj = astish(query.box.value);
+						parserResult.set(name, {
+							name,
+							box: query.box ?? box.fallback(query.box),
+							data: [obj]
+						});
+					}
+				});
+			}).when(imports.matchers.tokens.match, (name) => {
+				result.queryList.forEach((query) => {
+					if (query.kind === "call-expression") parserResult.setToken({
+						name,
+						box: query.box.value[0] ?? box.fallback(query.box),
+						data: combineResult(unbox(query.box.value[0]))
+					});
+				});
+			}).when(file.isValidPattern, (name) => {
+				result.queryList.forEach((query) => {
+					if (query.kind === "call-expression") parserResult.setPattern(name, {
+						name,
+						box: query.box.value[0] ?? box.fallback(query.box),
+						data: combineResult(unbox(query.box.value[0]))
+					});
+				});
+			}).when(file.isValidRecipe, (name) => {
+				result.queryList.forEach((query) => {
+					if (query.kind === "call-expression") parserResult.setRecipe(name, {
+						name,
+						box: query.box.value[0] ?? box.fallback(query.box),
+						data: combineResult(unbox(query.box.value[0]))
+					});
+				});
+			}).when(jsx.isJsxFactory, () => {
+				result.queryList.forEach((query) => {
+					if (query.kind === "call-expression" && query.box.value[1]) {
+						const map = query.box.value[1];
+						const boxNode = box.isMap(map) ? map : box.fallback(query.box);
+						const combined = combineResult(unbox(boxNode));
+						const result = {
+							name,
+							box: boxNode,
+							data: options?.transform?.({
+								type: "jsx-factory",
+								data: combined
+							}) ?? combined
+						};
+						if (box.isRecipe(map)) parserResult.setCva(result);
+						else parserResult.set("css", result);
+						const recipeOptions = query.box.value[2];
+						if (box.isUnresolvable(map) && recipeOptions && box.isMap(recipeOptions) && recipeOptions.value.has("defaultProps")) {
+							const maybeIdentifier = map.getNode();
+							if (Node.isIdentifier(maybeIdentifier)) {
+								const name = maybeIdentifier.getText();
+								const recipeName = file.getName(name);
+								parserResult.setRecipe(recipeName, {
+									type: "jsx-recipe",
+									name: recipeName,
+									box: recipeOptions,
+									data: combineResult(unbox(recipeOptions.value.get("defaultProps")))
+								});
+							}
+						}
+					} else if (query.kind === "tagged-template") {
+						const obj = astish(query.box.value);
+						parserResult.set("css", {
+							name,
+							box: query.box ?? box.fallback(query.box),
+							data: [obj]
+						});
+					}
+				});
+			}).when(file.isJsxFactory, (name) => {
+				result.queryList.forEach((query) => {
+					if (query.kind === "call-expression") {
+						const map = query.box.value[0];
+						const boxNode = box.isMap(map) ? map : box.fallback(query.box);
+						const combined = combineResult(unbox(boxNode));
+						const result = {
+							name,
+							box: boxNode,
+							data: options?.transform?.({
+								type: "jsx-factory",
+								data: combined
+							}) ?? combined
+						};
+						if (box.isRecipe(map)) parserResult.setCva(result);
+						else parserResult.set("css", result);
+					} else if (query.kind === "tagged-template") {
+						const obj = astish(query.box.value);
+						parserResult.set("css", {
+							name,
+							box: query.box ?? box.fallback(query.box),
+							data: [obj]
+						});
+					}
+				});
+			}).otherwise(() => {});
+			else if (jsx.isEnabled && result.kind === "component") result.queryList.forEach((query) => {
+				const data = combineResult(unbox(query.box));
+				switch (true) {
+					case file.isJsxFactory(name) || file.isJsxFactory(alias):
+						parserResult.setJsx({
+							type: "jsx-factory",
+							name,
+							box: query.box,
+							data
+						});
+						break;
+					case jsx.isJsxTagPattern(name) || jsx.isJsxTagPattern(alias):
+						parserResult.setPattern(name, {
+							type: "jsx-pattern",
+							name,
+							box: query.box,
+							data
+						});
+						break;
+					case jsx.isJsxTagRecipe(name):
+						recipes.filter(name).map((recipe) => {
+							parserResult.setRecipe(recipe.baseName, {
+								type: "jsx-recipe",
+								name,
+								box: query.box,
+								data
+							});
+						});
+						break;
+					case jsx.isJsxTagRecipe(alias):
+						recipes.filter(alias).map((recipe) => {
+							parserResult.setRecipe(recipe.baseName, {
+								type: "jsx-recipe",
+								name: alias,
+								box: query.box,
+								data
+							});
+						});
+						break;
+					default: parserResult.setJsx({
+						type: "jsx",
+						name,
+						box: query.box,
+						data
+					});
+				}
+			});
+		});
+		return parserResult;
+	};
 }
-
-// src/project.ts
-var normalizeCompilerOptions = (raw) => {
-  if (!raw) return {};
-  const { options } = ts.convertCompilerOptionsFromJson(raw, process.cwd());
-  return options;
+//#endregion
+//#region src/project.ts
+const normalizeCompilerOptions = (raw) => {
+	if (!raw) return {};
+	const { options } = ts.convertCompilerOptionsFromJson(raw, process.cwd());
+	return options;
 };
-var createTsProject = (options) => new TsProject({
-  skipAddingFilesFromTsConfig: true,
-  skipFileDependencyResolution: true,
-  skipLoadingLibFiles: true,
-  ...options,
-  compilerOptions: {
-    allowJs: true,
-    strictNullChecks: false,
-    skipLibCheck: true,
-    ...normalizeCompilerOptions(options.compilerOptions)
-  }
+const createTsProject = (options) => new Project$1({
+	skipAddingFilesFromTsConfig: true,
+	skipFileDependencyResolution: true,
+	skipLoadingLibFiles: true,
+	...options,
+	compilerOptions: {
+		allowJs: true,
+		strictNullChecks: false,
+		skipLibCheck: true,
+		...normalizeCompilerOptions(options.compilerOptions)
+	}
 });
 var Project = class {
-  constructor(options) {
-    this.options = options;
-    const { parserOptions } = options;
-    this.project = createTsProject(options);
-    this.parser = createParser(parserOptions);
-    this.createSourceFiles();
-  }
-  project;
-  parser;
-  get parserOptions() {
-    return this.options.parserOptions;
-  }
-  get files() {
-    return this.options.getFiles();
-  }
-  getSourceFile = (filePath) => {
-    return this.project.getSourceFile(filePath);
-  };
-  createSourceFile = (filePath) => {
-    const { readFile } = this.options;
-    return this.project.createSourceFile(filePath, readFile(filePath), {
-      overwrite: true,
-      scriptKind: ScriptKind.TSX
-    });
-  };
-  createSourceFiles = () => {
-    const files = this.getFiles();
-    for (const file of files) {
-      this.createSourceFile(file);
-    }
-  };
-  addSourceFile = (filePath, content) => {
-    return this.project.createSourceFile(filePath, content, {
-      overwrite: true,
-      scriptKind: ScriptKind.TSX
-    });
-  };
-  removeSourceFile = (filePath) => {
-    const sourceFile = this.project.getSourceFile(filePath);
-    if (sourceFile) {
-      return this.project.removeSourceFile(sourceFile);
-    }
-    return false;
-  };
-  reloadSourceFile = (filePath) => {
-    return this.getSourceFile(filePath)?.refreshFromFileSystemSync();
-  };
-  reloadSourceFiles = () => {
-    const files = this.getFiles();
-    for (const file of files) {
-      const source = this.getSourceFile(file);
-      source?.refreshFromFileSystemSync() ?? this.project.addSourceFileAtPath(file);
-    }
-  };
-  get readFile() {
-    return this.options.readFile;
-  }
-  get getFiles() {
-    return this.options.getFiles;
-  }
-  parseJson = (filePath) => {
-    const { readFile, parserOptions } = this.options;
-    const content = readFile(filePath);
-    parserOptions.encoder.fromJSON(JSON.parse(content));
-    const result = new ParserResult(parserOptions);
-    return result.setFilePath(filePath);
-  };
-  parseSourceFile = (filePath, encoder) => {
-    const { hooks } = this.options;
-    if (filePath.endsWith(".json")) {
-      return this.parseJson(filePath);
-    }
-    const sourceFile = this.project.getSourceFile(filePath);
-    if (!sourceFile) return;
-    const original = sourceFile.getText();
-    const options = {};
-    const custom = hooks["parser:before"]?.({
-      filePath,
-      content: original,
-      configure(opts) {
-        const { matchTag, matchTagMode, matchTagProp } = opts;
-        if (matchTag) {
-          options.matchTag = matchTag;
-        }
-        if (matchTagMode) {
-          options.matchTagMode = matchTagMode;
-        }
-        if (matchTagProp) {
-          options.matchTagProp = matchTagProp;
-        }
-      }
-    });
-    const transformed = custom ?? this.transformFile(filePath, original);
-    if (original !== transformed) {
-      sourceFile.replaceWithText(transformed);
-    }
-    if (hooks["parser:preprocess"]) {
-      options.transform = hooks["parser:preprocess"];
-    }
-    const result = this.parser(sourceFile, encoder, options)?.setFilePath(filePath);
-    hooks["parser:after"]?.({ filePath, result });
-    return result;
-  };
-  transformFile = (_filePath, content) => {
-    return content;
-  };
-  classify = (fileMap) => {
-    const { parserOptions } = this.options;
-    return classifyProject(parserOptions, fileMap);
-  };
-};
-export {
-  ParserResult,
-  Project
+	options;
+	project;
+	parser;
+	get parserOptions() {
+		return this.options.parserOptions;
+	}
+	constructor(options) {
+		this.options = options;
+		const { parserOptions } = options;
+		this.project = createTsProject(options);
+		this.parser = createParser(parserOptions);
+		this.createSourceFiles();
+	}
+	get files() {
+		return this.options.getFiles();
+	}
+	getSourceFile = (filePath) => {
+		return this.project.getSourceFile(filePath);
+	};
+	createSourceFile = (filePath) => {
+		const { readFile } = this.options;
+		return this.project.createSourceFile(filePath, readFile(filePath), {
+			overwrite: true,
+			scriptKind: ScriptKind.TSX
+		});
+	};
+	createSourceFiles = () => {
+		const files = this.getFiles();
+		for (const file of files) this.createSourceFile(file);
+	};
+	addSourceFile = (filePath, content) => {
+		return this.project.createSourceFile(filePath, content, {
+			overwrite: true,
+			scriptKind: ScriptKind.TSX
+		});
+	};
+	removeSourceFile = (filePath) => {
+		const sourceFile = this.project.getSourceFile(filePath);
+		if (sourceFile) return this.project.removeSourceFile(sourceFile);
+		return false;
+	};
+	reloadSourceFile = (filePath) => {
+		return this.getSourceFile(filePath)?.refreshFromFileSystemSync();
+	};
+	reloadSourceFiles = () => {
+		const files = this.getFiles();
+		for (const file of files) this.getSourceFile(file)?.refreshFromFileSystemSync() ?? this.project.addSourceFileAtPath(file);
+	};
+	get readFile() {
+		return this.options.readFile;
+	}
+	get getFiles() {
+		return this.options.getFiles;
+	}
+	parseJson = (filePath) => {
+		const { readFile, parserOptions } = this.options;
+		const content = readFile(filePath);
+		parserOptions.encoder.fromJSON(JSON.parse(content));
+		return new ParserResult(parserOptions).setFilePath(filePath);
+	};
+	parseSourceFile = (filePath, encoder) => {
+		const { hooks } = this.options;
+		if (filePath.endsWith(".json")) return this.parseJson(filePath);
+		const sourceFile = this.project.getSourceFile(filePath);
+		if (!sourceFile) return;
+		const original = sourceFile.getText();
+		const options = {};
+		const transformed = hooks["parser:before"]?.({
+			filePath,
+			content: original,
+			configure(opts) {
+				const { matchTag, matchTagMode, matchTagProp } = opts;
+				if (matchTag) options.matchTag = matchTag;
+				if (matchTagMode) options.matchTagMode = matchTagMode;
+				if (matchTagProp) options.matchTagProp = matchTagProp;
+			}
+		}) ?? this.transformFile(filePath, original);
+		if (original !== transformed) sourceFile.replaceWithText(transformed);
+		if (hooks["parser:preprocess"]) options.transform = hooks["parser:preprocess"];
+		const result = this.parser(sourceFile, encoder, options)?.setFilePath(filePath);
+		hooks["parser:after"]?.({
+			filePath,
+			result
+		});
+		return result;
+	};
+	transformFile = (_filePath, content) => {
+		return content;
+	};
+	classify = (fileMap) => {
+		const { parserOptions } = this.options;
+		return classifyProject(parserOptions, fileMap);
+	};
 };
+//#endregion
+export { ParserResult, Project };