babel-plugin-essor 0.0.10-beta.21 → 0.0.10-beta.22

package/dist/index.cjs

@@ -1,720 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  default: () => src_default
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/jsx/index.ts
-var import_core3 = require("@babel/core");
-
-// ../shared/dist/essor-shared.js
-var isArray = Array.isArray;
-function isString(val) {
-  return typeof val === "string";
-}
-var noop = Function.prototype;
-function startsWith(str, searchString) {
-  if (!isString(str)) {
-    return false;
-  }
-  return str.indexOf(searchString) === 0;
-}
-var capitalizeFirstLetter = (inputString) => {
-  return inputString.charAt(0).toUpperCase() + inputString.slice(1);
-};
-
-// src/program.ts
-var import_core = require("@babel/core");
-var imports = /* @__PURE__ */ new Set();
-var defaultOption = {
-  ssg: false,
-  symbol: "$",
-  props: true
-};
-var transformProgram = {
-  enter(path, state) {
-    imports.clear();
-    state.opts = __spreadValues(__spreadValues({}, defaultOption), state.opts);
-    path.state = {
-      h: path.scope.generateUidIdentifier("h$"),
-      renderTemplate: path.scope.generateUidIdentifier("renderTemplate$"),
-      template: path.scope.generateUidIdentifier("template$"),
-      useSignal: path.scope.generateUidIdentifier("signal$"),
-      useComputed: path.scope.generateUidIdentifier("computed$"),
-      useReactive: path.scope.generateUidIdentifier("reactive$"),
-      tmplDeclaration: import_core.types.variableDeclaration("const", []),
-      opts: state.opts
-    };
-  },
-  exit(path) {
-    const state = path.state;
-    if (state.tmplDeclaration.declarations.length > 0) {
-      const index = path.node.body.findIndex(
-        (node) => !import_core.types.isImportDeclaration(node) && !import_core.types.isExportDeclaration(node)
-      );
-      path.node.body.splice(index, 0, state.tmplDeclaration);
-    }
-    if (imports.size > 0) {
-      path.node.body.unshift(createImport(state, "essor"));
-    }
-  }
-};
-function createImport(state, from) {
-  const ImportSpecifier = [];
-  imports.forEach((name) => {
-    const local = import_core.types.identifier(state[name].name);
-    const imported = import_core.types.identifier(name);
-    ImportSpecifier.push(import_core.types.importSpecifier(local, imported));
-  });
-  const importSource = import_core.types.stringLiteral(from);
-  return import_core.types.importDeclaration(ImportSpecifier, importSource);
-}
-
-// src/shared.ts
-var import_core2 = require("@babel/core");
-function hasSiblingElement(path) {
-  const siblings = path.getAllPrevSiblings().concat(path.getAllNextSiblings());
-  const hasSibling = siblings.some(
-    (siblingPath) => siblingPath.isJSXElement() || siblingPath.isJSXExpressionContainer()
-  );
-  return hasSibling;
-}
-function getAttrName(attribute) {
-  if (import_core2.types.isJSXIdentifier(attribute.name)) {
-    return attribute.name.name;
-  }
-  if (import_core2.types.isJSXNamespacedName(attribute.name)) {
-    return `${attribute.name.namespace.name}:${attribute.name.name.name}`;
-  }
-  throw new Error("Unsupported attribute type");
-}
-function getTagName(node) {
-  const tag = node.openingElement.name;
-  return jsxElementNameToString(tag);
-}
-function jsxElementNameToString(node) {
-  if (import_core2.types.isJSXMemberExpression(node)) {
-    return `${jsxElementNameToString(node.object)}.${jsxElementNameToString(node.property)}`;
-  }
-  if (import_core2.types.isJSXIdentifier(node) || import_core2.types.isIdentifier(node)) {
-    return node.name;
-  }
-  return `${node.namespace.name}:${node.name.name}`;
-}
-function isComponent(tagName) {
-  return tagName[0] && tagName[0].toLowerCase() !== tagName[0] || tagName.includes(".") || /[^a-z]/i.test(tagName[0]);
-}
-function isTextChild(path) {
-  if (path.isJSXExpressionContainer()) {
-    const expression = path.get("expression");
-    if (expression.isJSXText() || expression.isStringLiteral() || expression.isNumericLiteral()) {
-      return true;
-    }
-  }
-  if (path.isJSXText() || path.isStringLiteral() || path.isNullLiteral()) {
-    return true;
-  }
-  return false;
-}
-function setNodeText(path, text) {
-  if (path.isJSXText()) {
-    path.node.value = text;
-  }
-  if (path.isJSXExpressionContainer()) {
-    const expression = path.get("expression");
-    if (expression.isStringLiteral() || expression.isNumericLiteral()) {
-      expression.replaceWith(import_core2.types.stringLiteral(text));
-    }
-  }
-}
-function isSymbolStart(path, name) {
-  const state = path.state;
-  const { symbol } = state.opts;
-  return startsWith(name, symbol);
-}
-
-// src/jsx/constants.ts
-var selfClosingTags = [
-  "area",
-  "base",
-  "br",
-  "col",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
-];
-var svgTags = [
-  "circle",
-  "clipPath",
-  "defs",
-  "ellipse",
-  "filter",
-  "g",
-  "line",
-  "linearGradient",
-  "mask",
-  "path",
-  "pattern",
-  "polygon",
-  "polyline",
-  "radialGradient",
-  "rect",
-  "stop",
-  "symbol",
-  "text",
-  "use"
-];
-
-// src/jsx/index.ts
-var isSsg = false;
-function addToTemplate(result, content) {
-  if (isSsg) {
-    result.template.push(content);
-  } else {
-    result.template += content;
-  }
-}
-function transformJSX(path) {
-  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 createEssorNode(path, result) {
-  var _a;
-  const state = path.state;
-  let tmpl;
-  if (path.isJSXElement() && isComponent(getTagName(path.node))) {
-    tmpl = import_core3.types.identifier(getTagName(path.node));
-  } else {
-    tmpl = path.scope.generateUidIdentifier("_tmpl$");
-    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)]);
-    const declarator = import_core3.types.variableDeclarator(tmpl, template);
-    state.tmplDeclaration.declarations.push(declarator);
-    if (!isSsg) {
-      imports.add("template");
-    }
-  }
-  const args = [tmpl, createProps(result.props)];
-  const key = result.props.key || ((_a = result.props[0]) == null ? void 0 : _a.key);
-  if (key) {
-    args.push(key);
-  }
-  imports.add(isSsg ? "renderTemplate" : "h");
-  return import_core3.types.callExpression(isSsg ? state.renderTemplate : state.h, args);
-}
-function createProps(props) {
-  const toAstNode = (value) => {
-    if (Array.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":
-        return import_core3.types.tsUndefinedKeyword();
-      case void 0:
-        return import_core3.types.tsUndefinedKeyword();
-      case null:
-        return import_core3.types.nullLiteral();
-      default:
-        return value;
-    }
-  };
-  const result = Object.keys(props).filter((prop) => prop !== "key").map((prop) => {
-    const value = toAstNode(props[prop]);
-    return prop === "_$spread$" ? import_core3.types.spreadElement(value) : import_core3.types.objectProperty(import_core3.types.stringLiteral(prop), value);
-  });
-  return import_core3.types.objectExpression(result);
-}
-function transformJSXElement(path, result, isRoot = false) {
-  if (path.isJSXElement()) {
-    const tagName = getTagName(path.node);
-    const tagIsComponent = isComponent(tagName);
-    const isSelfClose = !tagIsComponent && selfClosingTags.includes(tagName);
-    const isSvg = svgTags.includes(tagName) && result.index === 1;
-    const props = getAttrProps(path);
-    if (tagIsComponent) {
-      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);
-      }
-    } else {
-      if (isSvg) {
-        result.template = isSsg ? ["<svg _svg_>"] : "<svg _svg_>";
-      }
-      addToTemplate(result, `<${tagName}`);
-      handleAttributes(props, result);
-      addToTemplate(result, isSelfClose ? "/>" : ">");
-      if (!isSelfClose) {
-        transformChildren(path, result);
-        if (hasSiblingElement(path)) {
-          addToTemplate(result, `</${tagName}>`);
-        }
-      }
-    }
-  } else {
-    result.index--;
-    transformChildren(path, result);
-  }
-}
-function transformChildren(path, result) {
-  const parentIndex = isSsg ? result.template.length : 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));
-      } else {
-        pre.push(cur);
-      }
-    }
-    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, String(expression.node.value));
-    } 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, String(child.node.value));
-  } else {
-    throw new Error("Unsupported child type");
-  }
-}
-function getNodeText(path) {
-  if (path.isJSXText()) {
-    return path.node.value;
-  }
-  if (path.isJSXExpressionContainer()) {
-    const expression = path.get("expression");
-    if (expression.isStringLiteral() || expression.isNumericLiteral()) {
-      return String(expression.node.value);
-    }
-  }
-  return "";
-}
-function handleAttributes(props, result) {
-  let klass = "";
-  let style = "";
-  for (const prop in props) {
-    let value = props[prop];
-    if (prop === "class" && typeof value === "string") {
-      klass += ` ${value}`;
-      delete props[prop];
-      continue;
-    }
-    if (prop === "style" && typeof value === "string") {
-      style += `${value}${value.at(-1) === ";" ? "" : ";"}`;
-      delete props[prop];
-      continue;
-    }
-    if (value === true) {
-      addToTemplate(result, ` ${prop}`);
-      delete props[prop];
-    }
-    if (value === false) {
-      delete props[prop];
-    }
-    if (typeof value === "string" || typeof value === "number") {
-      addToTemplate(result, ` ${prop}="${value}"`);
-      delete props[prop];
-    }
-    if (import_core3.types.isConditionalExpression(value)) {
-      const { test, consequent, alternate } = value;
-      value = import_core3.types.arrowFunctionExpression([], import_core3.types.conditionalExpression(test, consequent, alternate));
-      props[prop] = value;
-    }
-    if (import_core3.types.isObjectExpression(value)) {
-      let hasConditional = false;
-      value.properties.forEach((property) => {
-        if (import_core3.types.isObjectProperty(property) && import_core3.types.isConditionalExpression(property.value)) {
-          hasConditional = true;
-        }
-      });
-      if (hasConditional) {
-        value = import_core3.types.arrowFunctionExpression([], value);
-        props[prop] = value;
-      } else {
-        if (prop === "style") {
-          value.properties.forEach((property) => {
-            if (import_core3.types.isObjectProperty(property)) {
-              style += `${property.key.name}:${property.value.value};`;
-            }
-          });
-          delete props[prop];
-        }
-      }
-    }
-  }
-  if (Object.keys(props).length > 0) {
-    result.props[result.index] = props;
-  }
-  klass = klass.trim();
-  style = style.trim();
-  if (klass) {
-    addToTemplate(result, ` class="${klass}"`);
-  }
-  if (style) {
-    addToTemplate(result, ` style="${style}"`);
-  }
-}
-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(child.node.value));
-    } 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);
-  }
-  return Object.keys(path.node).length > 0;
-}
-function getAttrProps(path) {
-  const props = {};
-  path.get("openingElement").get("attributes").forEach((attribute) => {
-    if (attribute.isJSXAttribute()) {
-      const name = getAttrName(attribute.node);
-      const value = attribute.get("value");
-      if (!value.node) {
-        props[name] = true;
-      } else if (value.isStringLiteral()) {
-        props[name] = value.node.value;
-      } else {
-        if (value.isJSXExpressionContainer()) {
-          const expression = value.get("expression");
-          if (expression.isStringLiteral()) {
-            props[name] = expression.node.value;
-          } else if (expression.isNumericLiteral()) {
-            props[name] = expression.node.value;
-          } else if (expression.isJSXElement() || expression.isJSXFragment()) {
-            transformJSX(expression);
-            props[name] = expression.node;
-          } else if (expression.isExpression()) {
-            if (/^key|ref|on.+$/.test(name)) {
-              props[name] = expression.node;
-            } else if (/^bind:.+/.test(name)) {
-              const value2 = path.scope.generateUidIdentifier("value");
-              const bindName = name.slice(5).toLocaleLowerCase();
-              props[bindName] = expression.node;
-              props[`update${capitalizeFirstLetter(bindName)}`] = import_core3.types.arrowFunctionExpression(
-                [value2],
-                import_core3.types.assignmentExpression("=", expression.node, value2)
-              );
-            } else {
-              if (expression.isConditionalExpression()) {
-                props[name] = import_core3.types.arrowFunctionExpression([], expression.node);
-              } else {
-                props[name] = expression.node;
-              }
-            }
-          }
-        } else if (value.isJSXElement() || value.isJSXFragment()) {
-          transformJSX(value);
-          props[name] = value.node;
-        }
-      }
-    } else if (attribute.isJSXSpreadAttribute()) {
-      props._$spread$ = attribute.get("argument").node;
-    } else {
-      throw new Error("Unsupported attribute type");
-    }
-  });
-  return props;
-}
-
-// src/signal/symbol.ts
-var import_core4 = require("@babel/core");
-function replaceSymbol(path) {
-  const init = path.node.init;
-  const variableName = path.node.id.name;
-  if (import_core4.types.isObjectPattern(path.node.id) || import_core4.types.isArrayPattern(path.node.id)) {
-    return;
-  }
-  if (!isSymbolStart(path, variableName)) {
-    return;
-  }
-  if (init && (import_core4.types.isFunctionExpression(init) || import_core4.types.isArrowFunctionExpression(init)) && path.parent.kind === "const") {
-    const newInit = import_core4.types.callExpression(import_core4.types.identifier(path.state.useComputed.name), init ? [init] : []);
-    imports.add("useComputed");
-    path.node.init = newInit;
-  } else {
-    const newInit = import_core4.types.callExpression(import_core4.types.identifier(path.state.useSignal.name), init ? [init] : []);
-    imports.add("useSignal");
-    path.node.init = newInit;
-  }
-}
-function symbolIdentifier(path) {
-  const parentPath = path.parentPath;
-  if (!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;
-  }
-  const { node } = path;
-  if (isSymbolStart(path, node.name)) {
-    let currentPath = path;
-    while (currentPath.parentPath && !currentPath.parentPath.isProgram()) {
-      if (currentPath.parentPath.isMemberExpression() && currentPath.parentPath.node.property.name === "value") {
-        return;
-      }
-      currentPath = currentPath.parentPath;
-    }
-    const newNode = import_core4.types.memberExpression(import_core4.types.identifier(node.name), import_core4.types.identifier("value"));
-    path.replaceWith(newNode);
-  }
-}
-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)) {
-      const newKey = import_core4.types.identifier(property.key.name);
-      property.key = newKey;
-    }
-  });
-}
-function symbolArrayPattern(path) {
-  path.node.elements.forEach((element) => {
-    if (import_core4.types.isIdentifier(element) && element.name.startsWith("$")) {
-      const newElement = import_core4.types.identifier(element.name);
-      element.name = newElement.name;
-    } else if (import_core4.types.isObjectPattern(element)) {
-      element.properties.forEach((property) => {
-        if (import_core4.types.isObjectProperty(property) && import_core4.types.isIdentifier(property.key) && isSymbolStart(path, property.key.name)) {
-          const newKey = import_core4.types.identifier(property.key.name);
-          property.key = newKey;
-        }
-      });
-    }
-  });
-}
-
-// src/signal/import.ts
-var import_core5 = require("@babel/core");
-function replaceImportDeclaration(path) {
-  const imports2 = path.node.specifiers;
-  imports2.forEach((specifier) => {
-    const variableName = specifier.local.name;
-    if (startsWith(variableName, "$") && !isVariableUsedAsObject(path, variableName)) {
-      path.scope.rename(variableName, `${variableName}.value`);
-      specifier.local.name = `${variableName}`;
-    }
-  });
-}
-function isVariableUsedAsObject(path, variableName) {
-  const binding = path.scope.getBinding(variableName);
-  let isUsedObject = false;
-  if (!binding || !binding.referencePaths) {
-    return isUsedObject;
-  }
-  for (const referencePath of binding.referencePaths) {
-    if (import_core5.types.isMemberExpression(referencePath.parent)) {
-      const memberExprParent = referencePath.parent;
-      if (import_core5.types.isIdentifier(memberExprParent.object, { name: variableName })) {
-        const newMemberExpr = import_core5.types.memberExpression(
-          import_core5.types.memberExpression(memberExprParent.object, import_core5.types.identifier("value")),
-          memberExprParent.property
-        );
-        referencePath.parentPath.replaceWith(newMemberExpr);
-        isUsedObject = true;
-      }
-    }
-  }
-  return isUsedObject;
-}
-
-// src/signal/props.ts
-var import_core6 = 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;
-  }
-  const returnStatement = path.get("body").get("body").find((statement) => statement.isReturnStatement());
-  if (!returnStatement) {
-    return;
-  }
-  const returnValue = (_a = returnStatement.node) == null ? void 0 : _a.argument;
-  if (!import_core6.types.isJSXElement(returnValue)) {
-    return;
-  }
-  function replaceProperties(properties2, parentPath) {
-    properties2.forEach((property) => {
-      if (import_core6.types.isObjectProperty(property)) {
-        const keyName = property.key.name;
-        if (import_core6.types.isIdentifier(property.value)) {
-          const propertyName = property.value.name;
-          const newName = `${parentPath}${keyName}`;
-          path.scope.rename(propertyName, newName);
-        } else if (import_core6.types.isObjectPattern(property.value)) {
-          replaceProperties(property.value.properties, `${parentPath}${keyName}.`);
-        }
-      }
-    });
-  }
-  const properties = firstParam.properties;
-  replaceProperties(
-    properties.filter((property) => !import_core6.types.isRestElement(property)),
-    "__props."
-  );
-  const notRestProperties = properties.filter((property) => !import_core6.types.isRestElement(property));
-  const notRestNames = notRestProperties.map(
-    (property) => property.key.name
-  );
-  if (notRestNames.some((name) => startsWith(name, "$"))) {
-    console.warn("props name can not start with $");
-    return;
-  }
-  const restElement = properties.find((property) => import_core6.types.isRestElement(property));
-  path.node.params[0] = import_core6.types.identifier("__props");
-  if (restElement) {
-    const restName = restElement.argument.name;
-    if (notRestProperties.length === 0) {
-      path.node.params[0] = import_core6.types.identifier(restName);
-    } else {
-      const restVariableDeclaration = 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)))
-          ])
-        )
-      ]);
-      imports.add("useReactive");
-      path.node.body.body.unshift(restVariableDeclaration);
-    }
-  }
-}
-
-// src/index.ts
-function src_default() {
-  return {
-    name: "babel-plugin-essor",
-    manipulateOptions({ filename }, parserOpts) {
-      if (filename.endsWith(".ts") || filename.endsWith(".tsx")) {
-        parserOpts.plugins.push("typescript");
-      }
-      parserOpts.plugins.push("jsx");
-    },
-    visitor: {
-      Program: transformProgram,
-      FunctionDeclaration: replaceProps,
-      ArrowFunctionExpression: replaceProps,
-      VariableDeclarator: replaceSymbol,
-      ImportDeclaration: replaceImportDeclaration,
-      Identifier: symbolIdentifier,
-      ObjectPattern: symbolObjectPattern,
-      ArrayPattern: symbolArrayPattern,
-      JSXElement: transformJSX,
-      JSXFragment: transformJSX
-    }
-  };
-}
-/**
-* @estjs/shared v0.0.10-beta.20
-* (c) 2023-Present jiangxd <jiangxd2016@gmail.com>
-* @license MIT
-**/
-//# sourceMappingURL=index.cjs.map