@pandacss/parser 0.22.1 → 0.24.0

package/dist/index.mjs

@@ -1,8 +1,12 @@
 // src/project.ts
-import { Project as TsProject, ScriptKind } from "ts-morph";
+import {
+  ScriptKind,
+  Project as TsProject
+} from "ts-morph";
 
 // src/parser.ts
-import { extract, unbox, box } from "@pandacss/extractor";
+import { resolveTsPathPattern } from "@pandacss/config/ts-path";
+import { box, extract, unbox } from "@pandacss/extractor";
 import { logger } from "@pandacss/logger";
 import { astish, memo as memo2 } from "@pandacss/shared";
 import { Node } from "ts-morph";
@@ -63,7 +67,14 @@ function getImportDeclarations(file, options) {
 }
 
 // src/parser-result.ts
-var ParserResult = class _ParserResult {
+import { getOrCreateSet } from "@pandacss/shared";
+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();
@@ -71,42 +82,95 @@ var ParserResult = class _ParserResult {
   recipe = /* @__PURE__ */ new Map();
   pattern = /* @__PURE__ */ new Map();
   filePath;
+  encoder;
+  append(result) {
+    this.all.push(result);
+    return result;
+  }
   set(name, result) {
-    this[name].add({ type: "object", ...result });
+    this[name].add(this.append(Object.assign({ type: "object" }, result)));
+    const encoder = this.encoder;
+    if (name == "css") {
+      result.data.forEach((obj) => encoder.processStyleProps(obj));
+      return;
+    }
+    if (name === "cva") {
+      result.data.forEach((data) => encoder.processAtomicRecipe(data));
+      return;
+    }
+    if (name === "sva") {
+      result.data.forEach((data) => encoder.processAtomicSlotRecipe(data));
+      return;
+    }
   }
   setCva(result) {
-    this.cva.add({ type: "cva", ...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({ type: "sva", ...result });
+    this.sva.add(this.append(Object.assign({ type: "sva" }, result)));
+    const encoder = this.encoder;
+    result.data.forEach((data) => encoder.processAtomicSlotRecipe(data));
   }
   setJsx(result) {
-    this.jsx.add({ type: "jsx", ...result });
+    this.jsx.add(this.append(Object.assign({ type: "jsx" }, result)));
+    const encoder = this.encoder;
+    result.data.forEach((obj) => encoder.processStyleProps(obj));
   }
   setPattern(name, result) {
-    this.pattern.get(name) ?? this.pattern.set(name, /* @__PURE__ */ new Set());
-    this.pattern.get(name)?.add({ type: "pattern", 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(name, result) {
-    this.recipe.get(name) ?? this.recipe.set(name, /* @__PURE__ */ new Set());
-    this.recipe.get(name)?.add({ type: "recipe", ...result });
+  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.css.size === 0 && this.cva.size === 0 && this.sva.size === 0 && this.recipe.size === 0 && this.pattern.size === 0 && this.jsx.size === 0;
+    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.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() {
-    const result = [];
-    this.css.forEach((item) => result.push(item));
-    this.cva.forEach((item) => result.push(item));
-    this.sva.forEach((item) => result.push(item));
-    this.jsx.forEach((item) => result.push(item));
-    this.recipe.forEach((items) => items.forEach((item) => result.push(item)));
-    this.pattern.forEach((items) => items.forEach((item) => result.push(item)));
-    return result;
+    return this.all;
   }
   toJSON() {
     return {
@@ -118,41 +182,14 @@ var ParserResult = class _ParserResult {
       pattern: Object.fromEntries(Array.from(this.pattern.entries()).map(([key, value]) => [key, Array.from(value)]))
     };
   }
-  merge(result) {
-    result.css.forEach((item) => this.css.add(item));
-    result.cva.forEach((item) => this.cva.add(item));
-    result.sva.forEach((item) => this.sva.add(item));
-    result.jsx.forEach((item) => this.jsx.add(item));
-    result.recipe.forEach((items, name) => {
-      this.recipe.get(name) ?? this.recipe.set(name, /* @__PURE__ */ new Set());
-      items.forEach((item) => this.recipe.get(name)?.add(item));
-    });
-    result.pattern.forEach((items, name) => {
-      this.pattern.get(name) ?? this.pattern.set(name, /* @__PURE__ */ new Set());
-      items.forEach((item) => this.pattern.get(name)?.add(item));
-    });
-    return this;
-  }
-  static fromJSON(json) {
-    const data = JSON.parse(json);
-    const result = new _ParserResult();
-    result.css = new Set(data.css);
-    result.cva = new Set(data.cva);
-    result.sva = new Set(data.sva);
-    result.jsx = new Set(data.jsx);
-    result.recipe = new Map(Object.entries(data.recipe));
-    result.pattern = new Map(Object.entries(data.pattern));
-    return result;
-  }
 };
-var createParserResult = () => new ParserResult();
 
 // src/parser.ts
-import { resolveTsPathPattern } from "@pandacss/config/ts-path";
 var isNodeRecipe = (node) => node.type === "recipe";
 var isNodePattern = (node) => node.type === "pattern";
 var cvaProps = ["compoundVariants", "defaultVariants", "variants", "base"];
 var isCva = (map) => cvaProps.some((prop) => map.has(prop));
+var noop = (..._args) => void 0;
 function createImportMatcher(mod, values) {
   const regex = values ? new RegExp(`^(${values.join("|")})$`) : /.*/;
   return {
@@ -174,18 +211,22 @@ var fallback = (box2) => ({
 var defaultEnv = { preset: "ECMA" };
 var identityFn = (styles) => styles;
 var evaluateOptions = { environment: defaultEnv };
-function createParser(options) {
-  const { jsx, getRecipesByJsxName, getPatternsByJsxName, tsOptions, join } = options;
-  const importMap = Object.fromEntries(Object.entries(options.importMap).map(([key, value]) => [key, join(...value)]));
+function createParser(context) {
+  const { jsx, isValidProperty, tsOptions, join, syntax } = context;
+  const getRecipesByJsxName = context.recipes.filter;
+  const getPatternsByJsxName = context.patterns.filter;
+  const [recipeKeys, patternKeys] = [context.recipes.keys, context.patterns.keys];
+  const importMap = Object.fromEntries(Object.entries(context.importMap).map(([key, value]) => [key, join(...value)]));
+  const isJsxEnabled = jsx.framework;
   const importRegex = [
     createImportMatcher(importMap.css, ["css", "cva", "sva"]),
     createImportMatcher(importMap.recipe),
     createImportMatcher(importMap.pattern)
   ];
-  if (jsx.framework) {
+  if (isJsxEnabled) {
     importRegex.push(createImportMatcher(importMap.jsx, [jsx.factory, ...jsx.nodes.map((node) => node.jsxName)]));
   }
-  return function parse2(sourceFile) {
+  return function parse2(sourceFile, encoder) {
     if (!sourceFile)
       return;
     const filePath = sourceFile.getFilePath();
@@ -210,36 +251,37 @@ function createParser(options) {
         return found;
       }
     });
-    const collector = createParserResult();
+    const parserResult = new ParserResult(context, encoder);
     logger.debug(
       "ast:import",
       imports.value.length ? `Found import { ${imports} } in ${filePath}` : `No import found in ${filePath}`
     );
+    if (!imports.value.length && !isJsxEnabled) {
+      return parserResult;
+    }
     const [css] = importRegex;
-    const jsxFactoryAlias = jsx ? imports.getAlias(jsx.factory) : "styled";
-    const isValidPattern = imports.createMatch(importMap.pattern, options.patternKeys);
-    const isValidRecipe = imports.createMatch(importMap.recipe, options.recipeKeys);
-    const isValidStyleFn = (name) => name === jsx?.factory;
-    const isFactory = (name) => Boolean(jsx && name.startsWith(jsxFactoryAlias));
+    const jsxFactoryAlias = isJsxEnabled ? imports.getAlias(jsx.factory) : "styled";
+    const isValidPattern = imports.createMatch(importMap.pattern, patternKeys);
+    const isValidRecipe = imports.createMatch(importMap.recipe, recipeKeys);
+    const isValidStyleFn = (name) => name === jsx.factory;
+    const isFactory = (name) => Boolean(isJsxEnabled && name.startsWith(jsxFactoryAlias));
     const isRawFn = (fullName) => {
       const name = fullName.split(".raw")[0] ?? "";
       return name === "css" || isValidPattern(name) || isValidRecipe(name);
     };
-    const patternPropertiesByName = /* @__PURE__ */ new Map();
-    const patternJsxLists = (jsx?.nodes ?? []).filter(isNodePattern).reduce(
-      (acc, pattern) => {
-        patternPropertiesByName.set(pattern.jsxName, new Set(pattern.props ?? []));
-        pattern.jsx?.forEach((jsx2) => {
-          if (typeof jsx2 === "string") {
-            acc.string.add(jsx2);
-          } else if (jsx2) {
-            acc.regex.push(jsx2);
-          }
-        });
-        return acc;
-      },
-      { string: /* @__PURE__ */ new Set(), regex: [] }
-    );
+    const patternPropertiesByJsxName = /* @__PURE__ */ new Map();
+    const initialPatterns = { string: /* @__PURE__ */ new Set(), regex: [] };
+    const patternJsxLists = isJsxEnabled ? (jsx.nodes ?? []).filter(isNodePattern).reduce((acc, pattern) => {
+      patternPropertiesByJsxName.set(pattern.jsxName, new Set(pattern.props ?? []));
+      pattern.jsx.forEach((jsx2) => {
+        if (typeof jsx2 === "string") {
+          acc.string.add(jsx2);
+        } else if (jsx2) {
+          acc.regex.push(jsx2);
+        }
+      });
+      return acc;
+    }, initialPatterns) : initialPatterns;
     const recipes = /* @__PURE__ */ new Set();
     const patterns = /* @__PURE__ */ new Set();
     imports.value.forEach((importDeclaration) => {
@@ -255,25 +297,23 @@ function createParser(options) {
     const components = /* @__PURE__ */ new Map();
     const propertiesMap = /* @__PURE__ */ new Map();
     const recipePropertiesByJsxName = /* @__PURE__ */ new Map();
-    const recipeJsxLists = (jsx?.nodes ?? []).filter(isNodeRecipe).reduce(
-      (acc, recipe) => {
-        recipePropertiesByJsxName.set(recipe.jsxName, new Set(recipe.props ?? []));
-        recipe.jsx?.forEach((jsx2) => {
-          if (typeof jsx2 === "string") {
-            acc.string.add(jsx2);
-          } else {
-            acc.regex.push(jsx2);
-          }
-        });
-        return acc;
-      },
-      { string: /* @__PURE__ */ new Set(), regex: [] }
-    );
+    const initialRecipes = { string: /* @__PURE__ */ new Set(), regex: [] };
+    const recipeJsxLists = isJsxEnabled ? (jsx.nodes ?? []).filter(isNodeRecipe).reduce((acc, recipe) => {
+      recipePropertiesByJsxName.set(recipe.jsxName, new Set(recipe.props ?? []));
+      recipe.jsx.forEach((jsx2) => {
+        if (typeof jsx2 === "string") {
+          acc.string.add(jsx2);
+        } else {
+          acc.regex.push(jsx2);
+        }
+      });
+      return acc;
+    }, initialRecipes) : initialRecipes;
     const cvaAlias = imports.getAlias("cva");
     const cssAlias = imports.getAlias("css");
     const svaAlias = imports.getAlias("sva");
-    if (options.jsx) {
-      options.jsx.nodes.forEach((node) => {
+    if (context.jsx) {
+      context.jsx.nodes.forEach((node) => {
         const alias = imports.getAlias(node.jsxName);
         node.props?.forEach((prop) => propertiesMap.set(prop, true));
         functions.set(node.baseName, propertiesMap);
@@ -281,36 +321,39 @@ function createParser(options) {
         components.set(alias, propertiesMap);
       });
     }
-    const isJsxTagRecipe = memo2(
+    const isJsxTagRecipe = isJsxEnabled ? memo2(
       (tagName) => recipeJsxLists.string.has(tagName) || recipeJsxLists.regex.some((regex) => regex.test(tagName))
-    );
-    const isJsxTagPattern = memo2(
+    ) : noop;
+    const isJsxTagPattern = isJsxEnabled ? memo2(
       (tagName) => patternJsxLists.string.has(tagName) || patternJsxLists.regex.some((regex) => regex.test(tagName))
-    );
-    const matchTag = memo2((tagName) => {
+    ) : noop;
+    const matchTag = isJsxEnabled ? memo2((tagName) => {
       if (!tagName)
         return false;
       return components.has(tagName) || isUpperCase(tagName) || isFactory(tagName) || isJsxTagRecipe(tagName) || isJsxTagPattern(tagName);
-    });
+    }) : noop;
     const isRecipeOrPatternProp = memo2((tagName, propName) => {
-      if (isJsxTagRecipe(tagName)) {
+      if (isJsxEnabled && isJsxTagRecipe(tagName)) {
         const recipeList = getRecipesByJsxName(tagName);
         return recipeList.some((recipe) => recipePropertiesByJsxName.get(recipe.jsxName)?.has(propName));
       }
-      if (isJsxTagPattern(tagName)) {
+      if (isJsxEnabled && isJsxTagPattern(tagName)) {
         const patternList = getPatternsByJsxName(tagName);
-        return patternList.some((pattern) => patternPropertiesByName.get(pattern.baseName)?.has(propName));
+        return patternList.some((pattern) => patternPropertiesByJsxName.get(pattern.jsxName)?.has(propName));
       }
       return false;
     });
-    const matchTagProp = match(jsx?.styleProps).with(
+    const matchTagProp = isJsxEnabled ? match(jsx.styleProps).with(
       "all",
       () => memo2((tagName, propName) => {
-        return Boolean(components.get(tagName)?.has(propName)) || options.jsx?.isStyleProp(propName) || propertiesMap.has(propName) || isRecipeOrPatternProp(tagName, propName);
+        return Boolean(components.get(tagName)?.has(propName)) || isValidProperty(propName) || propertiesMap.has(propName) || isRecipeOrPatternProp(tagName, propName);
+      })
+    ).with(
+      "minimal",
+      () => memo2((tagName, propName) => {
+        return propName === "css" || isRecipeOrPatternProp(tagName, propName);
       })
-    ).with("minimal", () => (tagName, propName) => {
-      return propName === "css" || isRecipeOrPatternProp(tagName, propName);
-    }).otherwise(() => (tagName, propName) => isRecipeOrPatternProp(tagName, propName));
+    ).with("none", () => memo2((tagName, propName) => isRecipeOrPatternProp(tagName, propName))).exhaustive() : noop;
     const matchFn = memo2((fnName) => {
       if (recipes.has(fnName) || patterns.has(fnName))
         return true;
@@ -321,10 +364,10 @@ function createParser(options) {
     const measure = logger.time.debug(`Tokens extracted from ${filePath}`);
     const extractResultByName = extract({
       ast: sourceFile,
-      components: {
-        matchTag: (prop) => matchTag(prop.tagName),
-        matchProp: (prop) => matchTagProp(prop.tagName, prop.propName)
-      },
+      components: isJsxEnabled ? {
+        matchTag: (prop) => !!matchTag(prop.tagName),
+        matchProp: (prop) => !!matchTagProp(prop.tagName, prop.propName)
+      } : void 0,
       functions: {
         matchFn: (prop) => matchFn(prop.fnName),
         matchProp: () => true,
@@ -334,9 +377,7 @@ function createParser(options) {
           return true;
         }
       },
-      taggedTemplates: {
-        matchTaggedTemplate: (tag) => matchFn(tag.fnName)
-      },
+      taggedTemplates: syntax === "template-literal" ? { matchTaggedTemplate: (tag) => matchFn(tag.fnName) } : void 0,
       getEvaluateOptions: (node) => {
         if (!Node.isCallExpression(node))
           return evaluateOptions;
@@ -356,16 +397,17 @@ function createParser(options) {
     });
     measure();
     extractResultByName.forEach((result, alias) => {
-      let name = imports.getName(alias);
+      let name = alias;
       if (isRawFn(name))
         name = name.replace(".raw", "");
+      name = imports.getName(name);
       logger.debug(`ast:${name}`, name !== alias ? { kind: result.kind, alias } : { kind: result.kind });
       if (result.kind === "function") {
         match(name).when(css.match, (name2) => {
           result.queryList.forEach((query) => {
             if (query.kind === "call-expression") {
               if (query.box.value.length > 1) {
-                collector.set(name2, {
+                parserResult.set(name2, {
                   name: name2,
                   box: query.box,
                   data: query.box.value.reduce(
@@ -374,7 +416,7 @@ function createParser(options) {
                   )
                 });
               } else {
-                collector.set(name2, {
+                parserResult.set(name2, {
                   name: name2,
                   box: query.box.value[0] ?? fallback(query.box),
                   data: combineResult(unbox(query.box.value[0]))
@@ -382,7 +424,7 @@ function createParser(options) {
               }
             } else if (query.kind === "tagged-template") {
               const obj = astish(query.box.value);
-              collector.set(name2, {
+              parserResult.set(name2, {
                 name: name2,
                 box: query.box ?? fallback(query.box),
                 data: [obj]
@@ -392,7 +434,7 @@ function createParser(options) {
         }).when(isValidPattern, (name2) => {
           result.queryList.forEach((query) => {
             if (query.kind === "call-expression") {
-              collector.setPattern(name2, {
+              parserResult.setPattern(name2, {
                 name: name2,
                 box: query.box.value[0] ?? fallback(query.box),
                 data: combineResult(unbox(query.box.value[0]))
@@ -402,7 +444,7 @@ function createParser(options) {
         }).when(isValidRecipe, (name2) => {
           result.queryList.forEach((query) => {
             if (query.kind === "call-expression") {
-              collector.setRecipe(name2, {
+              parserResult.setRecipe(name2, {
                 name: name2,
                 box: query.box.value[0] ?? fallback(query.box),
                 data: combineResult(unbox(query.box.value[0]))
@@ -416,27 +458,27 @@ function createParser(options) {
               const boxNode = box.isMap(map) ? map : fallback(query.box);
               const result2 = { name, box: boxNode, data: combineResult(unbox(boxNode)) };
               if (box.isMap(map) && isCva(map.value)) {
-                collector.setCva(result2);
+                parserResult.setCva(result2);
               } else {
-                collector.set("css", result2);
+                parserResult.set("css", result2);
               }
-              const options2 = query.box.value[2];
-              if (box.isUnresolvable(map) && options2 && box.isMap(options2) && options2.value.has("defaultProps")) {
+              const options = query.box.value[2];
+              if (box.isUnresolvable(map) && options && box.isMap(options) && options.value.has("defaultProps")) {
                 const maybeIdentifier = map.getNode();
                 if (Node.isIdentifier(maybeIdentifier)) {
                   const name2 = maybeIdentifier.getText();
                   const recipeName = imports.getName(name2);
-                  collector.setRecipe(recipeName, {
+                  parserResult.setRecipe(recipeName, {
                     type: "jsx-recipe",
                     name: recipeName,
-                    box: options2,
-                    data: combineResult(unbox(options2.value.get("defaultProps")))
+                    box: options,
+                    data: combineResult(unbox(options.value.get("defaultProps")))
                   });
                 }
               }
             } else if (query.kind === "tagged-template") {
               const obj = astish(query.box.value);
-              collector.set("css", {
+              parserResult.set("css", {
                 name,
                 box: query.box ?? fallback(query.box),
                 data: [obj]
@@ -450,13 +492,13 @@ function createParser(options) {
               const boxNode = box.isMap(map) ? map : fallback(query.box);
               const result2 = { name: name2, box: boxNode, data: combineResult(unbox(boxNode)) };
               if (box.isMap(map) && isCva(map.value)) {
-                collector.setCva(result2);
+                parserResult.setCva(result2);
               } else {
-                collector.set("css", result2);
+                parserResult.set("css", result2);
               }
             } else if (query.kind === "tagged-template") {
               const obj = astish(query.box.value);
-              collector.set("css", {
+              parserResult.set("css", {
                 name: name2,
                 box: query.box ?? fallback(query.box),
                 data: [obj]
@@ -465,32 +507,57 @@ function createParser(options) {
           });
         }).otherwise(() => {
         });
-      } else if (result.kind === "component") {
+      } else if (isJsxEnabled && result.kind === "component") {
         result.queryList.forEach((query) => {
           const data = combineResult(unbox(query.box));
           match(name).when(isFactory, (jsxName) => {
-            collector.setJsx({ name: jsxName, box: query.box, type: "jsx-factory", data });
+            parserResult.setJsx({ name: jsxName, box: query.box, type: "jsx-factory", data });
           }).when(isJsxTagPattern, (jsxName) => {
-            collector.setPattern(jsxName, { type: "jsx-pattern", name: jsxName, box: query.box, data });
+            parserResult.setPattern(jsxName, { type: "jsx-pattern", name: jsxName, box: query.box, data });
           }).when(isJsxTagRecipe, (jsxName) => {
             const recipeList = getRecipesByJsxName(jsxName);
             recipeList.map((recipe) => {
-              collector.setRecipe(recipe.baseName, { type: "jsx-recipe", name: jsxName, box: query.box, data });
+              parserResult.setRecipe(recipe.baseName, { type: "jsx-recipe", name: jsxName, box: query.box, data });
             });
           }).otherwise(() => {
-            collector.setJsx({ name, box: query.box, type: "jsx", data });
+            parserResult.setJsx({ name, box: query.box, type: "jsx", data });
           });
         });
       }
     });
-    return collector;
+    return parserResult;
   };
 }
 var isUpperCase = (value) => value[0] === value[0]?.toUpperCase();
 
+// src/svelte-to-tsx.ts
+import MagicString from "magic-string";
+var regex_style_tags = /<!--[^]*?-->|<style(\s[^]*?)?(?:>([^]*?)<\/style>|\/>)/gi;
+var regex_script_tags = /<!--[^]*?-->|<script(\s[^]*?)?(?:>([^]*?)<\/script>|\/>)/gi;
+var svelteToTsx = (code) => {
+  try {
+    const scripts = [];
+    const original = new MagicString(code);
+    let match2;
+    while ((match2 = regex_script_tags.exec(code)) != null) {
+      const [fullMatch, _attributesStr, scriptContent] = match2;
+      if (scriptContent) {
+        scripts.push(scriptContent);
+        original.remove(match2.index, match2.index + fullMatch.length);
+      }
+    }
+    const templateContent = original.toString().trimStart().replace(regex_style_tags, "").replace(regex_style_tags, "");
+    const transformed = `${scripts.join("")}
+const render = <div>${templateContent}</div>`;
+    return transformed.toString().trim();
+  } catch (err) {
+    return "";
+  }
+};
+
 // src/vue-to-tsx.ts
 import { parse } from "@vue/compiler-sfc";
-import MagicString from "magic-string";
+import MagicString2 from "magic-string";
 var NodeTypes = {
   ROOT: 0,
   ELEMENT: 1,
@@ -523,7 +590,7 @@ var NodeTypes = {
 var vueToTsx = (code) => {
   try {
     const parsed = parse(code);
-    const fileStr = new MagicString(`<template>${parsed.descriptor.template?.content}</template>` ?? "");
+    const fileStr = new MagicString2(`<template>${parsed.descriptor.template?.content}</template>` ?? "");
     const rewriteProp = (prop) => {
       if (prop.type === NodeTypes.DIRECTIVE && prop.exp?.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION) {
         fileStr.replace(prop.loc.source, `${prop.arg.content}={${prop.exp.content}}`);
@@ -540,7 +607,7 @@ var vueToTsx = (code) => {
       }
     }
     const scriptContent = (parsed.descriptor.scriptSetup ?? parsed.descriptor.script)?.content + "\n";
-    const transformed = new MagicString(`${scriptContent}
+    const transformed = new MagicString2(`${scriptContent}
 const render = ${fileStr.toString()}`);
     return transformed.toString();
   } catch (err) {
@@ -548,31 +615,6 @@ const render = ${fileStr.toString()}`);
   }
 };
 
-// src/svelte-to-tsx.ts
-import MagicString2 from "magic-string";
-var regex_style_tags = /<!--[^]*?-->|<style(\s[^]*?)?(?:>([^]*?)<\/style>|\/>)/gi;
-var regex_script_tags = /<!--[^]*?-->|<script(\s[^]*?)?(?:>([^]*?)<\/script>|\/>)/gi;
-var svelteToTsx = (code) => {
-  try {
-    const scripts = [];
-    const original = new MagicString2(code);
-    let match2;
-    while ((match2 = regex_script_tags.exec(code)) != null) {
-      const [fullMatch, _attributesStr, scriptContent] = match2;
-      if (scriptContent) {
-        scripts.push(scriptContent);
-        original.remove(match2.index, match2.index + fullMatch.length);
-      }
-    }
-    const templateContent = original.toString().trimStart().replace(regex_style_tags, "").replace(regex_style_tags, "");
-    const transformed = `${scripts.join("")}
-const render = <div>${templateContent}</div>`;
-    return transformed.toString().trim();
-  } catch (err) {
-    return "";
-  }
-};
-
 // src/project.ts
 var createTsProject = (options) => new TsProject({
   skipAddingFilesFromTsConfig: true,
@@ -586,86 +628,100 @@ var createTsProject = (options) => new TsProject({
     ...options.compilerOptions
   }
 });
-var createProject = ({
-  getFiles,
-  readFile,
-  parserOptions,
-  hooks,
-  ...projectOptions
-}) => {
-  const project = createTsProject(projectOptions);
-  const parser = createParser(parserOptions);
-  const getSourceFile = (filePath) => project.getSourceFile(filePath);
-  const removeSourceFile = (filePath) => {
-    const sourceFile = project.getSourceFile(filePath);
-    if (sourceFile)
-      project.removeSourceFile(sourceFile);
+var Project = class {
+  constructor(options) {
+    this.options = options;
+    const { parserOptions } = options;
+    this.project = createTsProject(options);
+    this.parser = createParser(parserOptions);
+    this.createSourceFiles();
+  }
+  project;
+  parser;
+  get files() {
+    return this.options.getFiles();
+  }
+  getSourceFile = (filePath) => {
+    return this.project.getSourceFile(filePath);
   };
-  const createSourceFile = (filePath) => project.createSourceFile(filePath, readFile(filePath), {
-    overwrite: true,
-    scriptKind: ScriptKind.TSX
-  });
-  const addSourceFile = (filePath, content) => project.createSourceFile(filePath, content, {
-    overwrite: true,
-    scriptKind: ScriptKind.TSX
-  });
-  const parseSourceFile = (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(content);
+    const result = new ParserResult(parserOptions);
+    return result.setFilePath(filePath);
+  };
+  parseSourceFile = (filePath, encoder) => {
+    const { hooks } = this.options;
     if (filePath.endsWith(".json")) {
-      const content2 = readFile(filePath);
-      hooks.callHook("parser:before", filePath, content2);
-      const result2 = ParserResult.fromJSON(content2).setFilePath(filePath);
-      hooks.callHook("parser:after", filePath, result2);
-      return result2;
+      return this.parseJson(filePath);
     }
-    const sourceFile = project.getSourceFile(filePath);
+    const sourceFile = this.project.getSourceFile(filePath);
     if (!sourceFile)
       return;
     const content = sourceFile.getText();
-    const transformed = transformFile(filePath, content);
+    const transformed = this.transformFile(filePath, content);
     if (content !== transformed) {
       sourceFile.replaceWithText(transformed);
     }
     hooks.callHook("parser:before", filePath, content);
-    const result = parser(sourceFile)?.setFilePath(filePath);
+    const result = this.parser(sourceFile, encoder)?.setFilePath(filePath);
     hooks.callHook("parser:after", filePath, result);
     return result;
   };
-  const files = getFiles();
-  for (const file of files) {
-    createSourceFile(file);
-  }
-  const reloadSourceFile = (filePath) => getSourceFile(filePath)?.refreshFromFileSystemSync();
-  const reloadSourceFiles = () => {
-    const files2 = getFiles();
-    for (const file of files2) {
-      const source = getSourceFile(file);
-      source?.refreshFromFileSystemSync() ?? project.addSourceFileAtPath(file);
+  transformFile = (filePath, content) => {
+    if (filePath.endsWith(".vue")) {
+      return vueToTsx(content);
     }
+    if (filePath.endsWith(".svelte")) {
+      return svelteToTsx(content);
+    }
+    return content;
   };
-  return {
-    getSourceFile,
-    removeSourceFile,
-    createSourceFile,
-    addSourceFile,
-    parseSourceFile,
-    reloadSourceFile,
-    reloadSourceFiles,
-    files,
-    getFiles,
-    readFile
-  };
-};
-var transformFile = (filePath, content) => {
-  if (filePath.endsWith(".vue")) {
-    return vueToTsx(content);
-  }
-  if (filePath.endsWith(".svelte")) {
-    return svelteToTsx(content);
-  }
-  return content;
 };
 export {
   ParserResult,
-  createParserResult,
-  createProject
+  Project
 };