babel-plugin-essor 0.0.14-beta.6 → 0.0.14

package/dist/index.cjs

@@ -78,7 +78,7 @@ var capitalize = cacheStringFunction(
 var import_core = require("@babel/core");
 var imports = /* @__PURE__ */ new Set();
 var defaultOption = {
-  ssg: false,
+  server: false,
   symbol: "$",
   props: true
 };
@@ -90,9 +90,10 @@ var transformProgram = {
       h: path.scope.generateUidIdentifier("h$"),
       template: path.scope.generateUidIdentifier("template$"),
       ssg: path.scope.generateUidIdentifier("ssg$"),
-      useSignal: path.scope.generateUidIdentifier("signal$"),
-      useComputed: path.scope.generateUidIdentifier("computed$"),
-      useReactive: path.scope.generateUidIdentifier("reactive$"),
+      Fragment: path.scope.generateUidIdentifier("fragment$"),
+      useSignal: path.scope.generateUidIdentifier("useSignal$"),
+      useComputed: path.scope.generateUidIdentifier("useComputed$"),
+      useReactive: path.scope.generateUidIdentifier("useReactive$"),
       tmplDeclaration: import_core.types.variableDeclaration("const", []),
       opts: state.opts
     };
@@ -121,8 +122,26 @@ function createImport(state, from) {
   return import_core.types.importDeclaration(ImportSpecifier, importSource);
 }
 
-// src/shared.ts
+// src/jsx/shared.ts
 var import_core2 = require("@babel/core");
+function createClientResult() {
+  return {
+    index: 1,
+    isLastChild: false,
+    parentIndex: 0,
+    props: {},
+    template: ""
+  };
+}
+function createServerResult() {
+  return {
+    index: 1,
+    isLastChild: false,
+    parentIndex: 0,
+    props: {},
+    template: []
+  };
+}
 function hasSiblingElement(path) {
   const siblings = path.getAllPrevSiblings().concat(path.getAllNextSiblings());
   const hasSibling = siblings.some(
@@ -152,7 +171,7 @@ function jsxElementNameToString(node) {
   }
   return `${node.namespace.name}:${node.name.name}`;
 }
-function isComponent(tagName) {
+function isComponentName(tagName) {
   return tagName[0] && tagName[0].toLowerCase() !== tagName[0] || tagName.includes(".") || /[^a-z]/i.test(tagName[0]);
 }
 function isTextChild(path) {
@@ -178,10 +197,45 @@ function setNodeText(path, text) {
     }
   }
 }
-function isSymbolStart(path, name) {
-  const state = path.state;
-  const { symbol } = (state == null ? void 0 : state.opts) || "$";
-  return startsWith(name, symbol);
+function replaceSpace(node) {
+  return node.value.replaceAll(/\s+/g, " ").trim();
+}
+function isValidChild(path) {
+  const regex = /^\s*$/;
+  if (path.isStringLiteral() || path.isJSXText()) {
+    return !regex.test(path.node.value);
+  }
+  return Object.keys(path.node).length > 0;
+}
+function hasObjectExpression(prop, value, props, state, isCt = false) {
+  let ct = "";
+  const hasConditional = value.properties.some(
+    (property) => import_core2.types.isObjectProperty(property) && import_core2.types.isConditionalExpression(property.value)
+  );
+  if (hasConditional) {
+    imports.add("useComputed");
+    props[prop] = import_core2.types.callExpression(state.useComputed, [import_core2.types.arrowFunctionExpression([], value)]);
+  } else if (isCt) {
+    value.properties.forEach((property) => {
+      if (import_core2.types.isObjectProperty(property)) {
+        ct += `${property.key.name || property.key.value}:${property.value.value};`;
+      }
+    });
+    delete props[prop];
+  }
+  return ct;
+}
+function getNodeText(path) {
+  if (path.isJSXText()) {
+    return replaceSpace(path.node);
+  }
+  if (path.isJSXExpressionContainer()) {
+    const expression = path.get("expression");
+    if (expression.isStringLiteral() || expression.isNumericLiteral()) {
+      return String(expression.node.value);
+    }
+  }
+  return "";
 }
 
 // src/jsx/constants.ts
@@ -224,282 +278,116 @@ var svgTags = [
 ];
 
 // src/jsx/index.ts
-var isSSG = false;
-function addToTemplate(result, content, join = false) {
-  if (isSSG) {
-    if (join && result.template.length > 0) {
-      result.template[result.template.length - 1] += content;
+var currentResult;
+var isServer = false;
+function addTemplate(content, join = false) {
+  if (isServer) {
+    if (join && currentResult.template.length > 0) {
+      currentResult.template[currentResult.template.length - 1] += content;
     } else {
-      result.template.push(content);
+      currentResult.template.push(content);
     }
   } else {
-    result.template += content;
+    currentResult.template += content;
   }
 }
 function transformJSX(path) {
+  var _a, _b;
+  isServer = (_b = (_a = path.state) == null ? void 0 : _a.opts) == null ? void 0 : _b.server;
+  const preCurrentResult = currentResult;
+  currentResult = isServer ? createServerResult() : createClientResult();
+  transformJSXElement(path, isServer, true);
+  path.replaceWith(isServer ? createServerNode(path) : createClientNode(path));
+  currentResult = preCurrentResult;
+}
+function createClientNode(path) {
+  var _a, _b;
   const state = path.state;
-  isSSG = state.opts.ssg;
-  const result = {
-    index: 1,
-    isLastChild: false,
-    parentIndex: 0,
-    props: {},
-    template: isSSG ? [] : ""
-  };
-  transformJSXElement(path, result, true);
-  path.replaceWith(createEssorNode(path, result));
-}
-function replaceSpace(node) {
-  return node.value.replaceAll(/\s+/g, " ").trim();
+  const isJSXFragment = path.isJSXFragment();
+  const isComponent = path.isJSXElement() && isComponentName(getTagName(path.node));
+  const tmpl = isComponent ? import_core3.types.identifier(getTagName(path.node)) : path.scope.generateUidIdentifier("_tmpl$");
+  let templateNode;
+  if (!isComponent) {
+    templateNode = import_core3.types.callExpression(state.template, [
+      import_core3.types.stringLiteral(currentResult.template)
+    ]);
+    state.tmplDeclaration.declarations.push(import_core3.types.variableDeclarator(tmpl, templateNode));
+    imports.add("template");
+  }
+  const key = (_b = currentResult.props.key) != null ? _b : (_a = currentResult.props[0]) == null ? void 0 : _a.key;
+  const propsArg = createProps(currentResult.props);
+  const args = isComponent && getTagName(path.node) === "Fragment" ? [import_core3.types.stringLiteral(""), propsArg] : [tmpl, propsArg];
+  if (key) {
+    args.push(key);
+  }
+  const fnName = isJSXFragment || isComponent && getTagName(path.node) === "Fragment" ? "Fragment" : "h";
+  imports.add(fnName);
+  return import_core3.types.callExpression(state[fnName], args);
 }
-function createEssorNode(path, result) {
+function createServerNode(path) {
+  var _a, _b;
   const state = path.state;
-  const isComponent2 = path.isJSXElement() && isComponent(getTagName(path.node));
-  const tmpl = isComponent2 ? import_core3.types.identifier(getTagName(path.node)) : path.scope.generateUidIdentifier("_tmpl$");
-  if (!isComponent2) {
-    const template = isSSG ? import_core3.types.arrayExpression(result.template.map(import_core3.types.stringLiteral)) : import_core3.types.callExpression(state.template, [import_core3.types.stringLiteral(result.template)]);
-    state.tmplDeclaration.declarations.push(import_core3.types.variableDeclarator(tmpl, template));
-    if (!isSSG) {
-      imports.add("template");
-    }
-  }
-  const key = result.props.key;
-  delete result.props.key;
-  const args = [tmpl, createProps(result.props)];
+  const isComponent = path.isJSXElement() && isComponentName(getTagName(path.node));
+  const tmpl = isComponent ? import_core3.types.identifier(getTagName(path.node)) : path.scope.generateUidIdentifier("_tmpl$");
+  let templateNode;
+  if (!isComponent) {
+    templateNode = import_core3.types.arrayExpression(currentResult.template.map(import_core3.types.stringLiteral));
+    state.tmplDeclaration.declarations.push(import_core3.types.variableDeclarator(tmpl, templateNode));
+  }
+  const key = (_b = currentResult.props.key) != null ? _b : (_a = currentResult.props[0]) == null ? void 0 : _a.key;
+  const propsArg = createProps(currentResult.props);
+  const args = isComponent && getTagName(path.node) === "Fragment" ? [import_core3.types.stringLiteral(""), propsArg] : [tmpl, propsArg];
   if (key) {
     args.push(key);
   }
-  const fnName = isSSG ? "ssg" : "h";
+  const fnName = "ssg";
   imports.add(fnName);
   return import_core3.types.callExpression(state[fnName], args);
 }
-function createProps(props) {
-  const toAstNode = (value) => {
-    if (isArray(value)) {
-      return import_core3.types.arrayExpression(value.map(toAstNode));
-    }
-    if (value && typeof value === "object" && !import_core3.types.isNode(value)) {
-      return createProps(value);
-    }
-    switch (typeof value) {
-      case "string":
-        return import_core3.types.stringLiteral(value);
-      case "number":
-        return import_core3.types.numericLiteral(value);
-      case "boolean":
-        return import_core3.types.booleanLiteral(value);
-      case "undefined":
-      case void 0:
-        return import_core3.types.tsUndefinedKeyword();
-      case null:
-        return import_core3.types.nullLiteral();
-      default:
-        return value;
-    }
-  };
-  const result = Object.entries(props).map(
-    ([prop, value]) => prop === "_$spread$" ? import_core3.types.spreadElement(toAstNode(value)) : import_core3.types.objectProperty(import_core3.types.stringLiteral(prop), toAstNode(value))
-  );
-  return import_core3.types.objectExpression(result);
-}
-function transformJSXElement(path, result, isRoot = false) {
+function transformJSXElement(path, isServer2 = false, isRoot = false) {
+  const state = path.state;
   if (path.isJSXElement()) {
     const tagName = getTagName(path.node);
-    const tagIsComponent = isComponent(tagName);
+    const tagIsComponent = isComponentName(tagName);
     const isSelfClose = !tagIsComponent && selfClosingTags.includes(tagName);
-    const isSvg = svgTags.includes(tagName) && result.index === 1;
-    const { props, hasExpression } = getAttrProps(path);
-    if (props.key) {
-      result.props.key = props.key;
-      delete props.key;
-    }
+    const isSvg = svgTags.includes(tagName) && currentResult.index === 1;
+    const { props, hasExpression } = getAttrProps(path, state);
     if (tagIsComponent) {
-      handleComponentElement(path, result, isRoot, props);
-    } else {
-      handleHTMLElement(path, result, tagName, isSelfClose, isSvg, props, hasExpression);
-    }
-  } else {
-    result.index--;
-    transformChildren(path, result);
-  }
-}
-function handleComponentElement(path, result, isRoot, props) {
-  if (isRoot) {
-    result.props = props;
-    const children = getChildren(path);
-    if (children.length > 0) {
-      const childrenGenerator = children.length === 1 ? children[0] : import_core3.types.arrayExpression(children);
-      result.props.children = childrenGenerator;
-    }
-  } else {
-    transformJSX(path);
-    replaceChild(path.node, result);
-  }
-}
-function handleHTMLElement(path, result, tagName, isSelfClose, isSvg, props, hasExpression) {
-  if (isSvg) {
-    result.template = isSSG ? [`<svg _svg_  data-hk="${result.index}">`] : `<svg _svg_ >`;
-  }
-  addToTemplate(result, `<${tagName}${isSSG ? ` data-hk="${result.index}"` : ""}`, true);
-  handleAttributes(props, result);
-  addToTemplate(result, isSelfClose ? "/>" : ">", !hasExpression);
-  if (!isSelfClose) {
-    transformChildren(path, result);
-    if (hasSiblingElement(path) || isSSG) {
-      addToTemplate(result, `</${tagName}>`);
-    }
-  }
-}
-function transformChildren(path, result) {
-  const parentIndex = result.index;
-  path.get("children").reduce((pre, cur) => {
-    if (isValidChild(cur)) {
-      const lastChild = pre.at(-1);
-      if (lastChild && isTextChild(cur) && isTextChild(lastChild)) {
-        setNodeText(lastChild, getNodeText(lastChild) + getNodeText(cur));
+      if (isRoot) {
+        currentResult.props = props;
+        const children = getChildren(path);
+        if (children.length > 0) {
+          const childrenGenerator = children.length === 1 ? children[0] : import_core3.types.arrayExpression(children);
+          if (import_core3.types.isConditionalExpression(childrenGenerator)) {
+            currentResult.props.children = import_core3.types.arrowFunctionExpression([], childrenGenerator);
+          } else {
+            currentResult.props.children = childrenGenerator;
+          }
+        }
       } else {
-        pre.push(cur);
+        transformJSX(path);
+        replaceChild(path.node);
       }
-    }
-    return pre;
-  }, []).forEach((child, i, arr) => {
-    result.parentIndex = parentIndex;
-    result.isLastChild = i === arr.length - 1;
-    transformChild(child, result);
-  });
-}
-function transformChild(child, result) {
-  result.index++;
-  if (child.isJSXElement() || child.isJSXFragment()) {
-    transformJSXElement(child, result, false);
-  } else if (child.isJSXExpressionContainer()) {
-    const expression = child.get("expression");
-    if (expression.isStringLiteral() || expression.isNumericLiteral()) {
-      addToTemplate(result, `${expression.node.value}`, true);
-    } else if (expression.isExpression()) {
-      replaceChild(expression.node, result);
-    } else if (import_core3.types.isJSXEmptyExpression(expression.node)) {
     } else {
-      throw new Error("Unsupported child type");
-    }
-  } else if (child.isJSXText()) {
-    addToTemplate(result, replaceSpace(child.node), true);
-  } else {
-    throw new Error("Unsupported child type");
-  }
-}
-function getNodeText(path) {
-  if (path.isJSXText()) {
-    return replaceSpace(path.node);
-  }
-  if (path.isJSXExpressionContainer()) {
-    const expression = path.get("expression");
-    if (expression.isStringLiteral() || expression.isNumericLiteral()) {
-      return String(expression.node.value);
-    }
-  }
-  return "";
-}
-function isStyleClassName(name) {
-  return name === "class" || name === "style";
-}
-function handleAttributes(props, result) {
-  let klass = "";
-  let style = "";
-  for (const [prop, value] of Object.entries(props)) {
-    if (prop === "class" && typeof value === "string") {
-      klass += ` ${value}`;
-      delete props[prop];
-    } else if (prop === "style" && typeof value === "string") {
-      style += `${value}${value.at(-1) === ";" ? "" : ";"}`;
-      delete props[prop];
-    } else if (value === true) {
-      addToTemplate(result, ` ${prop}`);
-      delete props[prop];
-    } else if (value === false) {
-      delete props[prop];
-    } else if (typeof value === "string" || typeof value === "number") {
-      addToTemplate(result, ` ${prop}="${value}"`);
-      delete props[prop];
-    } else if (import_core3.types.isConditionalExpression(value)) {
-      props[prop] = import_core3.types.arrowFunctionExpression([], value);
-    } else if (import_core3.types.isObjectExpression(value)) {
-      const val = handleObjectExpression(prop, value, props, isStyleClassName(prop));
-      if (val) {
-        if (prop === "class") {
-          klass += ` ${val}`;
-        }
-        if (prop === "style") {
-          style += `${val}${val.at(-1) === ";" ? "" : ";"}`;
+      if (isSvg) {
+        currentResult.template = isServer2 ? [`<svg _svg_  data-hk="${currentResult.index}">`] : `<svg _svg_ >`;
+      }
+      addTemplate(`<${tagName}${isServer2 ? ` data-hk="${currentResult.index}"` : ""}`, true);
+      handleAttributes(props, state);
+      addTemplate(isSelfClose ? "/>" : ">", !hasExpression);
+      if (!isSelfClose) {
+        transformChildren(path);
+        if (hasSiblingElement(path) || isServer2) {
+          addTemplate(`</${tagName}>`);
         }
       }
     }
-  }
-  if (Object.keys(props).length > 0) {
-    result.props[result.index] = props;
-  }
-  if (klass.trim()) {
-    addToTemplate(result, ` class="${klass.trim()}"`);
-  }
-  if (style.trim()) {
-    addToTemplate(result, ` style="${style.trim()}"`);
-  }
-}
-function handleObjectExpression(prop, value, props, isCt = false) {
-  let ct = "";
-  const hasConditional = value.properties.some(
-    (property) => import_core3.types.isObjectProperty(property) && import_core3.types.isConditionalExpression(property.value)
-  );
-  if (hasConditional) {
-    props[prop] = import_core3.types.arrowFunctionExpression([], value);
-  } else if (isCt) {
-    value.properties.forEach((property) => {
-      if (import_core3.types.isObjectProperty(property)) {
-        ct += `${property.key.name || property.key.value}:${property.value.value};`;
-      }
-    });
-    delete props[prop];
-  }
-  return ct;
-}
-function replaceChild(node, result) {
-  var _a, _b, _c, _d, _e;
-  if (result.isLastChild) {
-    result.index--;
   } else {
-    addToTemplate(result, "<!>");
-  }
-  (_c = (_a = result.props)[_b = result.parentIndex]) != null ? _c : _a[_b] = {};
-  (_e = (_d = result.props[result.parentIndex]).children) != null ? _e : _d.children = [];
-  result.props[result.parentIndex].children.push(
-    import_core3.types.arrayExpression([
-      import_core3.types.arrowFunctionExpression([], node),
-      result.isLastChild ? import_core3.types.nullLiteral() : import_core3.types.identifier(String(result.index))
-    ])
-  );
-}
-function getChildren(path) {
-  return path.get("children").filter((child) => isValidChild(child)).map((child) => {
-    if (child.isJSXElement() || child.isJSXFragment()) {
-      transformJSX(child);
-    } else if (child.isJSXExpressionContainer()) {
-      child.replaceWith(child.get("expression"));
-    } else if (child.isJSXText()) {
-      child.replaceWith(import_core3.types.stringLiteral(replaceSpace(child.node)));
-    } else {
-      throw new Error("Unsupported child type");
-    }
-    return child.node;
-  });
-}
-function isValidChild(path) {
-  const regex = /^\s*$/;
-  if (path.isStringLiteral() || path.isJSXText()) {
-    return !regex.test(path.node.value);
+    currentResult.index--;
+    transformChildren(path);
   }
-  return Object.keys(path.node).length > 0;
 }
-function getAttrProps(path) {
+function getAttrProps(path, state) {
   const props = {};
   let hasExpression = false;
   path.get("openingElement").get("attributes").forEach((attribute) => {
@@ -534,7 +422,10 @@ function getAttrProps(path) {
               );
             } else {
               if (expression.isConditionalExpression()) {
-                props[name] = import_core3.types.arrowFunctionExpression([], expression.node);
+                imports.add("useComputed");
+                props[name] = import_core3.types.callExpression(state.useComputed, [
+                  import_core3.types.arrowFunctionExpression([], expression.node)
+                ]);
               } else {
                 props[name] = expression.node;
               }
@@ -557,16 +448,179 @@ function getAttrProps(path) {
     hasExpression
   };
 }
+function getChildren(path) {
+  return path.get("children").filter((child) => isValidChild(child)).map((child) => {
+    if (child.isJSXElement() || child.isJSXFragment()) {
+      transformJSX(child);
+    } else if (child.isJSXExpressionContainer()) {
+      child.replaceWith(child.get("expression"));
+    } else if (child.isJSXText()) {
+      child.replaceWith(import_core3.types.stringLiteral(replaceSpace(child.node)));
+    } else {
+      throw new Error("Unsupported child type");
+    }
+    return child.node;
+  });
+}
+function replaceChild(node) {
+  var _a, _b, _c, _d, _e;
+  if (currentResult.isLastChild) {
+    currentResult.index--;
+  } else {
+    addTemplate("<!>");
+  }
+  (_c = (_a = currentResult.props)[_b = currentResult.parentIndex]) != null ? _c : _a[_b] = {};
+  (_e = (_d = currentResult.props[currentResult.parentIndex]).children) != null ? _e : _d.children = [];
+  currentResult.props[currentResult.parentIndex].children.push(
+    import_core3.types.arrayExpression([
+      import_core3.types.arrowFunctionExpression([], node),
+      currentResult.isLastChild ? import_core3.types.nullLiteral() : import_core3.types.identifier(String(currentResult.index))
+    ])
+  );
+}
+function handleAttributes(props, state) {
+  let klass = "";
+  let style = "";
+  for (const [prop, value] of Object.entries(props)) {
+    if (prop === "class" && typeof value === "string") {
+      klass += ` ${value}`;
+      delete props[prop];
+    } else if (prop === "style" && typeof value === "string") {
+      style += `${value}${value.at(-1) === ";" ? "" : ";"}`;
+      delete props[prop];
+    } else if (value === true) {
+      addTemplate(` ${prop}`);
+      delete props[prop];
+    } else if (value === false) {
+      delete props[prop];
+    } else if (typeof value === "string" || typeof value === "number") {
+      addTemplate(` ${prop}="${value}"`);
+      delete props[prop];
+    } else if (import_core3.types.isConditionalExpression(value)) {
+      imports.add("useComputed");
+      props[prop] = import_core3.types.callExpression(state.useComputed, [import_core3.types.arrowFunctionExpression([], value)]);
+    } else if (import_core3.types.isObjectExpression(value)) {
+      const val = hasObjectExpression(
+        prop,
+        value,
+        props,
+        state,
+        prop === "class" || prop === "style"
+      );
+      if (val) {
+        if (prop === "class") {
+          klass += ` ${val}`;
+        }
+        if (prop === "style") {
+          style += `${val}${val.at(-1) === ";" ? "" : ";"}`;
+        }
+      }
+    }
+  }
+  if (Object.keys(props).length > 0) {
+    currentResult.props[currentResult.index] = props;
+  }
+  if (klass.trim()) {
+    addTemplate(` class="${klass.trim()}"`);
+  }
+  if (style.trim()) {
+    addTemplate(` style="${style.trim()}"`);
+  }
+}
+function transformChildren(path) {
+  const parentIndex = currentResult.index;
+  path.get("children").reduce((pre, cur) => {
+    if (isValidChild(cur)) {
+      const lastChild = pre.at(-1);
+      if (lastChild && isTextChild(cur) && isTextChild(lastChild)) {
+        setNodeText(lastChild, getNodeText(lastChild) + getNodeText(cur));
+      } else {
+        pre.push(cur);
+      }
+    }
+    return pre;
+  }, []).forEach((child, i, arr) => {
+    currentResult.parentIndex = parentIndex;
+    currentResult.isLastChild = i === arr.length - 1;
+    transformChild(child);
+  });
+}
+function transformChild(child) {
+  currentResult.index++;
+  if (child.isJSXElement() || child.isJSXFragment()) {
+    transformJSXElement(child, false);
+  } else if (child.isJSXExpressionContainer()) {
+    const expression = child.get("expression");
+    if (expression.isStringLiteral() || expression.isNumericLiteral()) {
+      addTemplate(`${expression.node.value}`, true);
+    } else if (expression.isExpression()) {
+      replaceChild(expression.node);
+    } else if (import_core3.types.isJSXEmptyExpression(expression.node)) {
+    } else {
+      throw new Error("Unsupported child type");
+    }
+  } else if (child.isJSXText()) {
+    addTemplate(replaceSpace(child.node), true);
+  } else {
+    throw new Error("Unsupported child type");
+  }
+}
+function createProps(props) {
+  const result = [];
+  for (const prop in props) {
+    let value = props[prop];
+    if (prop === "key") {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      value = import_core3.types.arrayExpression(value);
+    }
+    if (typeof value === "object" && value !== null && !import_core3.types.isNode(value)) {
+      value = createProps(value);
+    }
+    if (typeof value === "string") {
+      value = import_core3.types.stringLiteral(value);
+    }
+    if (typeof value === "number") {
+      value = import_core3.types.numericLiteral(value);
+    }
+    if (typeof value === "boolean") {
+      value = import_core3.types.booleanLiteral(value);
+    }
+    if (value === void 0) {
+      value = import_core3.types.tsUndefinedKeyword();
+    }
+    if (value === null) {
+      value = import_core3.types.nullLiteral();
+    }
+    if (prop === "_$spread$") {
+      result.push(import_core3.types.spreadElement(value));
+    } else {
+      result.push(import_core3.types.objectProperty(import_core3.types.stringLiteral(prop), value));
+    }
+  }
+  return import_core3.types.objectExpression(result);
+}
 
 // src/signal/symbol.ts
+var import_core5 = require("@babel/core");
+
+// src/shared.ts
 var import_core4 = require("@babel/core");
+function isSymbolStart(path, name) {
+  const state = path.state;
+  const { symbol } = (state == null ? void 0 : state.opts) || "$";
+  return startsWith(name, symbol);
+}
+
+// src/signal/symbol.ts
 function replaceSymbol(path) {
   const { init, id } = path.node;
   const variableName = id.name;
-  if (import_core4.types.isObjectPattern(id) || import_core4.types.isArrayPattern(id) || !isSymbolStart(path, variableName)) return;
-  const isComputed = init && (import_core4.types.isFunctionExpression(init) || import_core4.types.isArrowFunctionExpression(init)) && path.parent.kind === "const";
+  if (import_core5.types.isObjectPattern(id) || import_core5.types.isArrayPattern(id) || !isSymbolStart(path, variableName)) return;
+  const isComputed = init && (import_core5.types.isFunctionExpression(init) || import_core5.types.isArrowFunctionExpression(init)) && path.parent.kind === "const";
   const hookName = isComputed ? "useComputed" : "useSignal";
-  const newInit = import_core4.types.callExpression(import_core4.types.identifier(path.state[hookName].name), init ? [init] : []);
+  const newInit = import_core5.types.callExpression(import_core5.types.identifier(path.state[hookName].name), init ? [init] : []);
   imports.add(hookName);
   path.node.init = newInit;
 }
@@ -576,31 +630,31 @@ function symbolIdentifier(path) {
   const { node } = path;
   if (!isSymbolStart(path, node.name)) return;
   if (!path.findParent((p) => p.isMemberExpression() && p.node.property.name === "value")) {
-    path.replaceWith(import_core4.types.memberExpression(import_core4.types.identifier(node.name), import_core4.types.identifier("value")));
+    path.replaceWith(import_core5.types.memberExpression(import_core5.types.identifier(node.name), import_core5.types.identifier("value")));
   }
 }
 function shouldProcessIdentifier(parentPath) {
-  return parentPath && !import_core4.types.isVariableDeclarator(parentPath) && !import_core4.types.isImportSpecifier(parentPath) && !import_core4.types.isObjectProperty(parentPath) && !import_core4.types.isArrayPattern(parentPath) && !import_core4.types.isObjectPattern(parentPath);
+  return parentPath && !import_core5.types.isVariableDeclarator(parentPath) && !import_core5.types.isImportSpecifier(parentPath) && !import_core5.types.isObjectProperty(parentPath) && !import_core5.types.isArrayPattern(parentPath) && !import_core5.types.isObjectPattern(parentPath);
 }
 function symbolObjectPattern(path) {
   path.node.properties.forEach((property) => {
-    if (import_core4.types.isObjectProperty(property) && import_core4.types.isIdentifier(property.key) && isSymbolStart(path, property.key.name)) {
-      property.key = import_core4.types.identifier(property.key.name);
+    if (import_core5.types.isObjectProperty(property) && import_core5.types.isIdentifier(property.key) && isSymbolStart(path, property.key.name)) {
+      property.key = import_core5.types.identifier(property.key.name);
     }
   });
 }
 function symbolArrayPattern(path) {
   path.node.elements.forEach((element) => {
-    if (import_core4.types.isIdentifier(element) && element.name.startsWith("$")) {
-      element.name = import_core4.types.identifier(element.name).name;
-    } else if (import_core4.types.isObjectPattern(element)) {
+    if (import_core5.types.isIdentifier(element) && element.name.startsWith("$")) {
+      element.name = import_core5.types.identifier(element.name).name;
+    } else if (import_core5.types.isObjectPattern(element)) {
       symbolObjectPattern({ node: element });
     }
   });
 }
 
 // src/signal/import.ts
-var import_core5 = require("@babel/core");
+var import_core6 = require("@babel/core");
 function replaceImportDeclaration(path) {
   path.node.specifiers.forEach((specifier) => {
     const variableName = specifier.local.name;
@@ -614,11 +668,11 @@ function isVariableUsedAsObject(path, variableName) {
   var _a;
   const binding = path.scope.getBinding(variableName);
   return ((_a = binding == null ? void 0 : binding.referencePaths) == null ? void 0 : _a.some((referencePath) => {
-    if (import_core5.types.isMemberExpression(referencePath.parent)) {
+    if (import_core6.types.isMemberExpression(referencePath.parent)) {
       const { object, property } = referencePath.parent;
-      if (import_core5.types.isIdentifier(object, { name: variableName })) {
+      if (import_core6.types.isIdentifier(object, { name: variableName })) {
         referencePath.parentPath.replaceWith(
-          import_core5.types.memberExpression(import_core5.types.memberExpression(object, import_core5.types.identifier("value")), property)
+          import_core6.types.memberExpression(import_core6.types.memberExpression(object, import_core6.types.identifier("value")), property)
         );
         return true;
       }
@@ -628,28 +682,30 @@ function isVariableUsedAsObject(path, variableName) {
 }
 
 // src/signal/props.ts
-var import_core6 = require("@babel/core");
+var import_core7 = require("@babel/core");
 function replaceProps(path) {
   var _a;
   const state = path.state;
   const firstParam = path.node.params[0];
-  if (!firstParam || !import_core6.types.isObjectPattern(firstParam)) return;
+  if (!firstParam || !import_core7.types.isObjectPattern(firstParam)) return;
   const returnStatement = path.get("body").get("body").find((statement) => statement.isReturnStatement());
-  if (!returnStatement || !import_core6.types.isJSXElement((_a = returnStatement.node) == null ? void 0 : _a.argument)) return;
+  if (!returnStatement || !import_core7.types.isJSXElement((_a = returnStatement.node) == null ? void 0 : _a.argument)) return;
   const replaceProperties = (properties2, parentPath) => {
     properties2.forEach((property) => {
-      if (import_core6.types.isObjectProperty(property) && import_core6.types.isIdentifier(property.key)) {
+      if (import_core7.types.isObjectProperty(property) && import_core7.types.isIdentifier(property.key)) {
         const keyName = property.key.name;
-        if (import_core6.types.isIdentifier(property.value)) {
+        if (import_core7.types.isIdentifier(property.value)) {
           path.scope.rename(property.value.name, `${parentPath}${keyName}`);
-        } else if (import_core6.types.isObjectPattern(property.value)) {
+        } else if (import_core7.types.isObjectPattern(property.value)) {
           replaceProperties(property.value.properties, `${parentPath}${keyName}.`);
         }
       }
     });
   };
   const properties = firstParam.properties;
-  const notRestProperties = properties.filter((property) => !import_core6.types.isRestElement(property));
+  const notRestProperties = properties.filter(
+    (property) => !import_core7.types.isRestElement(property)
+  );
   replaceProperties(notRestProperties, "__props.");
   const notRestNames = notRestProperties.map((property) => property.key.name);
   if (notRestNames.some((name) => startsWith(name, "$"))) {
@@ -659,12 +715,12 @@ function replaceProps(path) {
   handleRestElement(path, state, properties, notRestNames);
 }
 function handleRestElement(path, state, properties, notRestNames) {
-  const restElement = properties.find((property) => import_core6.types.isRestElement(property));
-  path.node.params[0] = import_core6.types.identifier("__props");
+  const restElement = properties.find((property) => import_core7.types.isRestElement(property));
+  path.node.params[0] = import_core7.types.identifier("__props");
   if (restElement) {
     const restName = restElement.argument.name;
     if (notRestNames.length === 0) {
-      path.node.params[0] = import_core6.types.identifier(restName);
+      path.node.params[0] = import_core7.types.identifier(restName);
     } else {
       const restVariableDeclaration = createRestVariableDeclaration(state, restName, notRestNames);
       imports.add("useReactive");
@@ -673,12 +729,12 @@ function handleRestElement(path, state, properties, notRestNames) {
   }
 }
 function createRestVariableDeclaration(state, restName, notRestNames) {
-  return import_core6.types.variableDeclaration("const", [
-    import_core6.types.variableDeclarator(
-      import_core6.types.identifier(restName),
-      import_core6.types.callExpression(state.useReactive, [
-        import_core6.types.identifier("__props"),
-        import_core6.types.arrayExpression(notRestNames.map((name) => import_core6.types.stringLiteral(name)))
+  return import_core7.types.variableDeclaration("const", [
+    import_core7.types.variableDeclarator(
+      import_core7.types.identifier(restName),
+      import_core7.types.callExpression(state.useReactive, [
+        import_core7.types.identifier("__props"),
+        import_core7.types.arrayExpression(notRestNames.map((name) => import_core7.types.stringLiteral(name)))
       ])
     )
   ]);