@vue-jsx-vapor/macros 2.3.0 → 2.3.1

package/dist/chunk-ZQ4GVJKX.cjs

@@ -1,585 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/core/helper/use-model.ts?raw
-var use_model_default = 'import { customRef, watchSyncEffect } from "vue";\nexport function useModel(props, name, options = {}) {\n  const res = customRef((track, trigger) => {\n    let localValue = options && options.default;\n    let prevEmittedValue;\n    watchSyncEffect(() => {\n      const propValue = props[name];\n      if (!Object.is(prevEmittedValue, propValue)) {\n        localValue = propValue;\n        trigger();\n      }\n    });\n    return {\n      get() {\n        track();\n        return options.get ? options.get(localValue) : localValue;\n      },\n      set(value) {\n        if (Object.is(value, localValue)) return;\n        localValue = value;\n        trigger();\n        const emittedValue = prevEmittedValue = options.set ? options.set(value) : value;\n        for (const emit of [props[`onUpdate:${name}`]].flat()) {\n          if (typeof emit === "function") emit(emittedValue);\n        }\n      }\n    };\n  });\n  res[Symbol.iterator] = () => {\n    let i = 0;\n    return {\n      next() {\n        if (i < 2) {\n          return {\n            value: i++ ? props[`${name}Modifiers`] || {} : res,\n            done: false\n          };\n        } else {\n          return { done: true };\n        }\n      }\n    };\n  };\n  return res;\n}\n';
-
-// src/core/helper/with-defaults.ts?raw
-var with_defaults_default = "function resolveDefaultProps(paths) {\n  const result = {};\n  for (const path of Object.keys(paths)) {\n    const segments = path.split(/[.?[\\]]/).filter(Boolean);\n    let current = result;\n    for (let i = 0; i < segments.length; i++) {\n      const segment = segments[i];\n      if (i === segments.length - 1) {\n        current[segment] = paths[path];\n      } else {\n        if (!current[segment]) {\n          current[segment] = Number.isNaN(Number(segments[i + 1])) ? {} : [];\n        }\n        current = current[segment];\n      }\n    }\n  }\n  return result;\n}\nexport function createPropsDefaultProxy(props, defaults) {\n  const defaultProps = resolveDefaultProps(defaults);\n  const result = {};\n  for (const key of [\n    .../* @__PURE__ */ new Set([...Object.keys(props), ...Object.keys(defaultProps)])\n  ]) {\n    Object.defineProperty(result, key, {\n      enumerable: true,\n      get: () => props[key] === void 0 ? defaultProps[key] : props[key]\n    });\n  }\n  return result;\n}\n";
-
-// src/core/helper/index.ts
-var helperPrefix = "vue-jsx-vapor/macros";
-var useModelHelperId = `${helperPrefix}/use-model`;
-var withDefaultsHelperId = `${helperPrefix}/with-defaults`;
-
-// src/core/restructure.ts
-
-
-
-var _common = require('@vue-macros/common');
-var _compilersfc = require('@vue/compiler-sfc');
-function restructure(s, node, options = {}) {
-  let index = 0;
-  const propList = [];
-  for (const param of node.params) {
-    const path = `${_common.HELPER_PREFIX}props${index++ || ""}`;
-    const props = getProps(param, path, s, [], options);
-    if (props) {
-      const hasDefaultValue = props.some((i) => i.defaultValue);
-      s.overwrite(param.start, param.end, path);
-      propList.push(
-        ...hasDefaultValue ? props.map((i) => ({
-          ...i,
-          path: i.path.replace(_common.HELPER_PREFIX, `${_common.HELPER_PREFIX}default_`)
-        })) : props
-      );
-    }
-  }
-  if (propList.length) {
-    const defaultValues = {};
-    const rests = [];
-    for (const prop of propList) {
-      if (prop.defaultValue) {
-        const basePath = prop.path.split(/\.|\[/)[0];
-        (defaultValues[basePath] ??= []).push(prop);
-      }
-      if (prop.isRest) {
-        rests.push(prop);
-      }
-    }
-    for (const [path, values] of Object.entries(defaultValues)) {
-      const createPropsDefaultProxy = _common.importHelperFn.call(void 0, 
-        s,
-        0,
-        "createPropsDefaultProxy",
-        void 0,
-        _nullishCoalesce(options.withDefaultsFrom, () => ( withDefaultsHelperId))
-      );
-      const resolvedPath = path.replace(
-        `${_common.HELPER_PREFIX}default_`,
-        _common.HELPER_PREFIX
-      );
-      const resolvedValues = values.map(
-        (i) => `'${i.path.replace(path, "")}${i.value}': ${i.defaultValue}`
-      ).join(", ");
-      prependFunctionalNode(
-        node,
-        s,
-        `
-const ${path} = ${createPropsDefaultProxy}(${resolvedPath}, {${resolvedValues}})`
-      );
-    }
-    for (const [index2, rest] of rests.entries()) {
-      prependFunctionalNode(
-        node,
-        s,
-        _nullishCoalesce(_optionalChain([options, 'access', _ => _.generateRestProps, 'optionalCall', _2 => _2(rest.name, index2, rests)]), () => ( `
-const ${rest.name} = ${_common.importHelperFn.call(void 0, 
-          s,
-          0,
-          "createPropsRestProxy"
-        )}(${rest.path}, [${rest.value}])`))
-      );
-    }
-    _compilersfc.walkIdentifiers.call(void 0, 
-      node.body,
-      (id, parent) => {
-        const prop = propList.find((i) => i.name === id.name);
-        if (prop && !prop.isRest) {
-          s.overwrite(
-            id.start,
-            id.end,
-            `${_optionalChain([parent, 'optionalAccess', _3 => _3.type]) === "ObjectProperty" && parent.shorthand ? `${id.name}: ` : ""}${prop.path}${prop.value}`
-          );
-        }
-      },
-      false
-    );
-  }
-  return propList;
-}
-function getProps(node, path = "", s, props = [], options) {
-  const properties = node.type === "ObjectPattern" ? node.properties : node.type === "ArrayPattern" ? node.elements : [];
-  if (!properties.length) return;
-  const propNames = [];
-  properties.forEach((prop, index) => {
-    if (_optionalChain([prop, 'optionalAccess', _4 => _4.type]) === "Identifier") {
-      props.push({ name: prop.name, path, value: `[${index}]` });
-      propNames.push(`'${prop.name}'`);
-    } else if (_optionalChain([prop, 'optionalAccess', _5 => _5.type]) === "AssignmentPattern" && prop.left.type === "Identifier") {
-      props.push({
-        path,
-        name: prop.left.name,
-        value: `[${index}]`,
-        defaultValue: s.slice(prop.right.start, prop.right.end)
-      });
-      propNames.push(`'${prop.left.name}'`);
-    } else if (_optionalChain([prop, 'optionalAccess', _6 => _6.type]) === "ObjectProperty" && prop.key.type === "Identifier") {
-      if (prop.value.type === "AssignmentPattern" && prop.value.left.type === "Identifier") {
-        props.push({
-          path,
-          name: prop.value.left.name,
-          value: `.${prop.key.name}`,
-          defaultValue: s.slice(prop.value.right.start, prop.value.right.end),
-          isRequired: prop.value.right.type === "TSNonNullExpression"
-        });
-      } else if (!getProps(prop.value, `${path}.${prop.key.name}`, s, props, options)) {
-        props.push({
-          path,
-          name: prop.value.type === "Identifier" ? prop.value.name : prop.key.name,
-          value: `.${prop.key.name}`
-        });
-      }
-      propNames.push(`'${prop.key.name}'`);
-    } else if (_optionalChain([prop, 'optionalAccess', _7 => _7.type]) === "RestElement" && prop.argument.type === "Identifier" && !prop.argument.name.startsWith(`${_common.HELPER_PREFIX}props`)) {
-      props.push({
-        path,
-        name: prop.argument.name,
-        value: propNames.join(", "),
-        isRest: true
-      });
-    } else if (prop) {
-      getProps(prop, `${path}[${index}]`, s, props, options);
-    }
-  });
-  return props.length ? props : void 0;
-}
-function prependFunctionalNode(node, s, result) {
-  const isBlockStatement = node.body.type === "BlockStatement";
-  const start = _optionalChain([node, 'access', _8 => _8.body, 'access', _9 => _9.extra, 'optionalAccess', _10 => _10.parenthesized]) ? node.body.extra.parenStart : node.body.start;
-  s.appendRight(
-    start + (isBlockStatement ? 1 : 0),
-    `${result};${!isBlockStatement ? "return " : ""}`
-  );
-  if (!isBlockStatement) {
-    s.appendLeft(start, "{");
-    s.appendRight(node.end, "}");
-  }
-}
-
-// src/core/index.ts
-
-
-
-
-
-
-
-
-
-// src/core/define-component/index.ts
-
-
-
-// src/core/define-component/await.ts
-
-
-
-
-var isFunctionType = (node) => {
-  return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
-};
-function transformAwait(root, s) {
-  if (root.body.type !== "BlockStatement") return;
-  let hasAwait = false;
-  for (const node of root.body.body) {
-    if (node.type === "VariableDeclaration" && !node.declare || node.type.endsWith("Statement")) {
-      const scope = [root.body.body];
-      _common.walkAST.call(void 0, node, {
-        enter(child, parent) {
-          if (isFunctionType(child)) {
-            this.skip();
-          }
-          if (child.type === "BlockStatement") {
-            scope.push(child.body);
-          }
-          if (child.type === "AwaitExpression") {
-            hasAwait = true;
-            const currentScope = scope.at(-1);
-            const needsSemi = !!_optionalChain([currentScope, 'optionalAccess', _11 => _11.some, 'call', _12 => _12((n, i) => {
-              return (scope.length === 1 || i > 0) && n.type === "ExpressionStatement" && n.start === child.start;
-            })]);
-            processAwait(
-              s,
-              child,
-              needsSemi,
-              parent.type === "ExpressionStatement"
-            );
-          }
-        },
-        leave(node2) {
-          if (node2.type === "BlockStatement") scope.pop();
-        }
-      });
-    }
-  }
-  if (hasAwait) {
-    s.prependLeft(root.body.start + 1, `
-let __temp, __restore
-`);
-  }
-}
-function processAwait(s, node, needSemi, isStatement) {
-  const argumentStart = node.argument.extra && node.argument.extra.parenthesized ? node.argument.extra.parenStart : node.argument.start;
-  const argumentStr = s.slice(argumentStart, node.argument.end);
-  const containsNestedAwait = /\bawait\b/.test(argumentStr);
-  s.overwrite(
-    node.start,
-    argumentStart,
-    `${needSemi ? `;` : ``}(
-  ([__temp,__restore] = ${_common.importHelperFn.call(void 0, 
-      s,
-      0,
-      `withAsyncContext`
-    )}(${containsNestedAwait ? `async ` : ``}() => `
-  );
-  s.appendLeft(
-    node.end,
-    `)),
-  ${isStatement ? `` : `__temp = `}await __temp,
-  __restore()${isStatement ? `` : `,
-  __temp`}
-)`
-  );
-}
-
-// src/core/define-component/return.ts
-function transformReturn(root, s) {
-  const node = root.body.type === "BlockStatement" ? _optionalChain([root, 'access', _13 => _13.body, 'access', _14 => _14.body, 'access', _15 => _15.find, 'call', _16 => _16((node2) => node2.type === "ReturnStatement"), 'optionalAccess', _17 => _17.argument]) : root.body;
-  if (!node || isFunctionalNode(node)) return;
-  s.appendRight(
-    _optionalChain([node, 'access', _18 => _18.extra, 'optionalAccess', _19 => _19.parenthesized]) ? node.extra.parenStart : node.start,
-    "() => "
-  );
-}
-
-// src/core/define-component/index.ts
-function transformDefineComponent(root, propsName, map, s, autoReturnFunction = false) {
-  if (!map.defineComponent) return;
-  const defineComponentName = s.sliceNode(map.defineComponent.callee);
-  if (defineComponentName && !["defineComponent", "defineVaporComponent"].includes(defineComponentName)) {
-    _common.importHelperFn.call(void 0, s, 0, "defineComponent", defineComponentName);
-  }
-  let hasRestProp = false;
-  const props = {};
-  if (root.params[0]) {
-    if (root.params[0].type === "Identifier") {
-      getWalkedIds(root, propsName).forEach((id) => props[id] = null);
-    } else {
-      const restructuredProps = restructure(s, root, {
-        generateRestProps: (restPropsName, index, list) => {
-          if (index === list.length - 1) {
-            hasRestProp = true;
-            const useAttrs = _common.importHelperFn.call(void 0, s, 0, "useAttrs");
-            return `const ${restPropsName} = ${useAttrs}()`;
-          }
-        }
-      });
-      for (const prop of restructuredProps) {
-        if (prop.path.endsWith("props") && !prop.isRest) {
-          props[prop.name] = prop.isRequired ? "{ required: true }" : null;
-        }
-      }
-    }
-  }
-  for (const { expression, isRequired } of map.defineModel || []) {
-    const modelOptions = _optionalChain([expression, 'access', _20 => _20.arguments, 'access', _21 => _21[0], 'optionalAccess', _22 => _22.type]) === "ObjectExpression" ? expression.arguments[0] : _optionalChain([expression, 'access', _23 => _23.arguments, 'access', _24 => _24[1], 'optionalAccess', _25 => _25.type]) === "ObjectExpression" ? expression.arguments[1] : void 0;
-    const options = {};
-    if (isRequired) options.required = true;
-    for (const prop of _optionalChain([modelOptions, 'optionalAccess', _26 => _26.properties]) || []) {
-      if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && ["validator", "type", "required"].includes(prop.key.name)) {
-        options[prop.key.name] = s.sliceNode(prop.value);
-      }
-    }
-    const propName = _optionalChain([expression, 'access', _27 => _27.arguments, 'access', _28 => _28[0], 'optionalAccess', _29 => _29.type]) === "StringLiteral" ? expression.arguments[0].value : "modelValue";
-    props[propName] = Object.keys(options).length ? `{ ${Object.entries(options).map(([key, value]) => `${key}: ${value}`).join(", ")} }` : null;
-    props[`onUpdate:${propName}`] = null;
-    props[`${propName === "modelValue" ? "model" : propName}Modifiers`] = null;
-  }
-  const propsString = Object.entries(props).map(([key, value]) => `'${key}': ${value}`).join(", ");
-  if (propsString) {
-    const argument = map.defineComponent.arguments[1];
-    if (!argument) {
-      s.appendRight(
-        root.end,
-        `, {${hasRestProp ? "inheritAttrs: false," : ""} props: { ${propsString} } }`
-      );
-    } else if (argument.type === "ObjectExpression") {
-      prependObjectExpression(argument, "props", `{ ${propsString} }`, s);
-      if (hasRestProp) {
-        prependObjectExpression(argument, "inheritAttrs", "false", s);
-      }
-    }
-  }
-  transformAwait(root, s);
-  if (autoReturnFunction) {
-    transformReturn(root, s);
-  }
-}
-function prependObjectExpression(argument, name, value, s) {
-  if (!_optionalChain([argument, 'access', _30 => _30.properties, 'optionalAccess', _31 => _31.find, 'call', _32 => _32(
-    (prop) => prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === name
-  )])) {
-    s.appendRight(argument.start + 1, `${name}: ${value},`);
-  }
-}
-function getWalkedIds(root, propsName) {
-  const walkedIds = /* @__PURE__ */ new Set();
-  _compilersfc.walkIdentifiers.call(void 0, 
-    root.body,
-    (id, parent) => {
-      if (id.name === propsName && (_optionalChain([parent, 'optionalAccess', _33 => _33.type]) === "MemberExpression" || _optionalChain([parent, 'optionalAccess', _34 => _34.type]) === "OptionalMemberExpression")) {
-        const prop = parent.property.type === "Identifier" ? parent.property.name : parent.property.type === "StringLiteral" ? parent.property.value : "";
-        if (prop) walkedIds.add(prop);
-      }
-    },
-    false
-  );
-  return walkedIds;
-}
-
-// src/core/define-expose.ts
-
-function transformDefineExpose(node, s, version) {
-  s.overwriteNode(node.callee, ";");
-  s.appendRight(
-    _optionalChain([node, 'access', _35 => _35.arguments, 'access', _36 => _36[0], 'optionalAccess', _37 => _37.start]) || node.end - 1,
-    version >= 3.6 ? `${_common.importHelperFn.call(void 0, s, 0, "currentInstance")}.exposed = ` : `${_common.importHelperFn.call(void 0, s, 0, "getCurrentInstance")}().exposed = `
-  );
-}
-
-// src/core/define-model.ts
-
-function transformDefineModel(node, propsName, s) {
-  s.overwriteNode(
-    node.callee,
-    _common.importHelperFn.call(void 0, s, 0, "useModel", void 0, useModelHelperId)
-  );
-  s.appendRight(
-    _optionalChain([node, 'access', _38 => _38.arguments, 'access', _39 => _39[0], 'optionalAccess', _40 => _40.start]) || node.end - 1,
-    `${propsName}, ${_optionalChain([node, 'access', _41 => _41.arguments, 'access', _42 => _42[0], 'optionalAccess', _43 => _43.type]) !== "StringLiteral" ? `'modelValue',` : ""}`
-  );
-}
-
-// src/core/define-slots.ts
-
-function transformDefineSlots(node, s) {
-  s.overwrite(
-    node.start,
-    _optionalChain([node, 'access', _44 => _44.arguments, 'access', _45 => _45[0], 'optionalAccess', _46 => _46.start]) && node.arguments[0].start - 1 || _optionalChain([node, 'access', _47 => _47.typeArguments, 'optionalAccess', _48 => _48.end]) || node.callee.end,
-    `Object.assign`
-  );
-  const slots = `${_common.importHelperFn.call(void 0, s, 0, "useSlots")}()`;
-  s.appendLeft(node.end - 1, `${node.arguments[0] ? "," : "{}, "}${slots}`);
-}
-
-// src/core/define-style.ts
-
-var _hashsum = require('hash-sum'); var _hashsum2 = _interopRequireDefault(_hashsum);
-function transformDefineStyle(defineStyle, index, root, s, importMap) {
-  const { expression, lang, isDeclaration } = defineStyle;
-  if (_optionalChain([expression, 'access', _49 => _49.arguments, 'access', _50 => _50[0], 'optionalAccess', _51 => _51.type]) !== "TemplateLiteral") return;
-  let css = s.sliceNode(expression.arguments[0]).slice(1, -1);
-  const scopeId = _hashsum2.default.call(void 0, css);
-  const vars = /* @__PURE__ */ new Map();
-  expression.arguments[0].expressions.forEach((exp) => {
-    const cssVar = s.sliceNode(exp);
-    const cssVarId = toCssVarId(cssVar, `--${scopeId}-`);
-    s.overwrite(exp.start - 2, exp.end + 1, `var(${cssVarId})`);
-    vars.set(cssVarId, cssVar);
-  });
-  let returnExpression = root && getReturnStatement(root);
-  if (isFunctionalNode(returnExpression)) {
-    returnExpression = getReturnStatement(returnExpression);
-  }
-  if (vars.size && returnExpression) {
-    const children = returnExpression.type === "JSXElement" ? [returnExpression] : returnExpression.type === "JSXFragment" ? returnExpression.children : [];
-    const varString = Array.from(vars.entries()).map(([key, value]) => `'${key}': ${value}`).join(", ");
-    for (const child of children) {
-      if (child.type === "JSXElement") {
-        s.appendRight(
-          child.openingElement.name.end,
-          ` {...{style:{${varString}}}}`
-        );
-      }
-    }
-  }
-  let scoped = !!root;
-  if (_optionalChain([expression, 'access', _52 => _52.arguments, 'access', _53 => _53[1], 'optionalAccess', _54 => _54.type]) === "ObjectExpression") {
-    for (const prop of expression.arguments[1].properties) {
-      if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "scoped" && prop.value.type === "BooleanLiteral") {
-        scoped = prop.value.value;
-      }
-    }
-  }
-  if (scoped && returnExpression) {
-    _common.walkAST.call(void 0, returnExpression, {
-      enter(node) {
-        if (node.type === "JSXElement" && s.sliceNode(node.openingElement.name) !== "template") {
-          s.appendRight(node.openingElement.name.end, ` data-v-${scopeId}=""`);
-        }
-      }
-    });
-  }
-  css = s.sliceNode(expression.arguments[0]).slice(1, -1).replaceAll(/\/\/(.*)(?=\n)/g, "/*$1*/");
-  const module = isDeclaration ? "module." : "";
-  const importId = `${helperPrefix}/define-style/${index}?scopeId=${scopeId}&scoped=${scoped}&lang.${module}${lang}`;
-  importMap.set(importId, css);
-  s.appendLeft(
-    0,
-    isDeclaration ? `import style${index} from "${importId}";` : `import "${importId}";`
-  );
-  s.overwriteNode(expression, isDeclaration ? `style${index}` : "");
-}
-function getReturnStatement(root) {
-  if (root.body.type === "BlockStatement") {
-    const returnStatement = root.body.body.find(
-      (node) => node.type === "ReturnStatement"
-    );
-    if (returnStatement) {
-      return returnStatement.argument;
-    }
-  } else {
-    return root.body;
-  }
-}
-function toCssVarId(name, prefix = "") {
-  return prefix + name.replaceAll(/\W/g, (searchValue, replaceValue) => {
-    return searchValue === "." ? "-" : name.charCodeAt(replaceValue).toString();
-  });
-}
-
-// src/core/index.ts
-function transformJsxMacros(code, id, importMap, options) {
-  const s = new (0, _common.MagicStringAST)(code);
-  const ast = _common.babelParse.call(void 0, s.original, _common.getLang.call(void 0, id));
-  const rootMap = getRootMap(ast, s, options);
-  let defineStyleIndex = 0;
-  for (const [root, map] of rootMap) {
-    _optionalChain([map, 'access', _55 => _55.defineStyle, 'optionalAccess', _56 => _56.forEach, 'call', _57 => _57((defineStyle) => {
-      transformDefineStyle(defineStyle, defineStyleIndex++, root, s, importMap);
-    })]);
-    if (root === void 0) continue;
-    let propsName = `${_common.HELPER_PREFIX}props`;
-    if (root.params[0]) {
-      if (root.params[0].type === "Identifier") {
-        propsName = root.params[0].name;
-      } else if (root.params[0].type === "ObjectPattern") {
-        const lastProp = root.params[0].properties.at(-1);
-        if (!map.defineComponent && _optionalChain([lastProp, 'optionalAccess', _58 => _58.type]) === "RestElement" && lastProp.argument.type === "Identifier") {
-          propsName = lastProp.argument.name;
-        } else {
-          s.appendRight(
-            _optionalChain([root, 'access', _59 => _59.params, 'access', _60 => _60[0], 'access', _61 => _61.extra, 'optionalAccess', _62 => _62.trailingComma]) ? _optionalChain([root, 'access', _63 => _63.params, 'access', _64 => _64[0], 'access', _65 => _65.extra, 'optionalAccess', _66 => _66.trailingComma]) + 1 : _optionalChain([lastProp, 'optionalAccess', _67 => _67.end]) || root.params[0].end - 1,
-            `${!_optionalChain([root, 'access', _68 => _68.params, 'access', _69 => _69[0], 'access', _70 => _70.extra, 'optionalAccess', _71 => _71.trailingComma]) && root.params[0].properties.length ? "," : ""} ...${_common.HELPER_PREFIX}props`
-          );
-        }
-      }
-    } else {
-      s.appendRight(getParamsStart(root, s.original), propsName);
-    }
-    if (map.defineComponent) {
-      transformDefineComponent(
-        root,
-        propsName,
-        map,
-        s,
-        _optionalChain([options, 'access', _72 => _72.defineComponent, 'optionalAccess', _73 => _73.autoReturnFunction])
-      );
-    }
-    if (_optionalChain([map, 'access', _74 => _74.defineModel, 'optionalAccess', _75 => _75.length])) {
-      map.defineModel.forEach(({ expression }) => {
-        transformDefineModel(expression, propsName, s);
-      });
-    }
-    if (map.defineSlots) {
-      transformDefineSlots(map.defineSlots, s);
-    }
-    if (map.defineExpose) {
-      transformDefineExpose(map.defineExpose, s, options.version);
-    }
-  }
-  return _common.generateTransform.call(void 0, s, id);
-}
-function getRootMap(ast, s, options) {
-  const parents = [];
-  const rootMap = /* @__PURE__ */ new Map();
-  _common.walkAST.call(void 0, ast, {
-    enter(node, parent) {
-      parents.unshift(parent);
-      const root = isFunctionalNode(parents[1]) ? parents[1] : void 0;
-      if (root && _optionalChain([parents, 'access', _76 => _76[2], 'optionalAccess', _77 => _77.type]) === "CallExpression" && options.defineComponent.alias.includes(s.sliceNode(parents[2].callee))) {
-        if (!rootMap.has(root)) rootMap.set(root, {});
-        if (!rootMap.get(root).defineComponent) {
-          rootMap.get(root).defineComponent = parents[2];
-        }
-      }
-      const expression = node.type === "VariableDeclaration" ? _optionalChain([node, 'access', _78 => _78.declarations, 'access', _79 => _79[0], 'access', _80 => _80.init, 'optionalAccess', _81 => _81.type]) === "CallExpression" && s.sliceNode(node.declarations[0].init.callee) === "$" ? node.declarations[0].init.arguments[0] : node.declarations[0].init : node.type === "ExpressionStatement" ? node.expression : void 0;
-      if (!expression) return;
-      const macroExpression = getMacroExpression(expression, options);
-      if (!macroExpression) return;
-      if (!rootMap.has(root)) rootMap.set(root, {});
-      const macroName = s.sliceNode(
-        macroExpression.callee.type === "MemberExpression" ? macroExpression.callee.object : macroExpression.callee
-      );
-      if (macroName) {
-        if (options.defineModel.alias.includes(macroName)) {
-          ;
-          (rootMap.get(root).defineModel ??= []).push({
-            expression: macroExpression,
-            isRequired: expression.type === "TSNonNullExpression"
-          });
-        } else if (options.defineStyle.alias.includes(macroName)) {
-          const lang = macroExpression.callee.type === "MemberExpression" && macroExpression.callee.property.type === "Identifier" ? macroExpression.callee.property.name : "css";
-          (rootMap.get(root).defineStyle ??= []).push({
-            expression: macroExpression,
-            isDeclaration: node.type === "VariableDeclaration",
-            lang
-          });
-        } else if (options.defineSlots.alias.includes(macroName)) {
-          rootMap.get(root).defineSlots = macroExpression;
-        } else if (options.defineExpose.alias.includes(macroName)) {
-          rootMap.get(root).defineExpose = macroExpression;
-        }
-      }
-    },
-    leave() {
-      parents.shift();
-    }
-  });
-  return rootMap;
-}
-function isFunctionalNode(node) {
-  return !!(node && (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression"));
-}
-function getMacroExpression(node, options) {
-  if (node.type === "TSNonNullExpression") {
-    node = node.expression;
-  }
-  if (node.type === "CallExpression") {
-    if (node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "defineStyle") {
-      return node;
-    } else if (node.callee.type === "Identifier" && [
-      ...options.defineComponent.alias,
-      ...options.defineSlots.alias,
-      ...options.defineModel.alias,
-      ...options.defineExpose.alias,
-      ...options.defineStyle.alias
-    ].includes(node.callee.name)) {
-      return node;
-    }
-  }
-}
-function getParamsStart(node, code) {
-  return node.params[0] ? node.params[0].start : node.start + (_optionalChain([code, 'access', _82 => _82.slice, 'call', _83 => _83(node.start, node.body.start), 'access', _84 => _84.match, 'call', _85 => _85(/\(\s*\)/), 'optionalAccess', _86 => _86.index]) || 0) + 1;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-exports.use_model_default = use_model_default; exports.with_defaults_default = with_defaults_default; exports.helperPrefix = helperPrefix; exports.useModelHelperId = useModelHelperId; exports.withDefaultsHelperId = withDefaultsHelperId; exports.restructure = restructure; exports.transformJsxMacros = transformJsxMacros; exports.isFunctionalNode = isFunctionalNode; exports.getMacroExpression = getMacroExpression; exports.getParamsStart = getParamsStart;

package/dist/chunk-ZXJQCFZZ.js

@@ -1,10 +0,0 @@
-import {
-  index_default
-} from "./chunk-AUE5EAQA.js";
-
-// src/vite.ts
-var vite_default = index_default.vite;
-
-export {
-  vite_default
-};