@tamagui/static 1.114.4 → 1.115.0

package/dist/extractor/bundle.cjs

@@ -0,0 +1,146 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var bundle_exports = {};
+__export(bundle_exports, {
+  esbuildIgnoreFilesRegex: () => esbuildIgnoreFilesRegex,
+  esbuildLoaderConfig: () => esbuildLoaderConfig,
+  esbundleTamaguiConfig: () => esbundleTamaguiConfig
+});
+module.exports = __toCommonJS(bundle_exports);
+var import_node_path = require("node:path"),
+  import_esbuild = __toESM(require("esbuild")),
+  FS = __toESM(require("fs-extra")),
+  import_esbuildAliasPlugin = require("./esbuildAliasPlugin.cjs"),
+  import_loadTamagui = require("./loadTamagui.cjs");
+const esbuildLoaderConfig = {
+    ".js": "jsx",
+    ".png": "dataurl",
+    ".jpg": "dataurl",
+    ".jpeg": "dataurl",
+    ".svg": "dataurl",
+    ".gif": "dataurl",
+    ".webp": "dataurl",
+    ".woff2": "dataurl",
+    ".woff": "dataurl",
+    ".eot": "dataurl",
+    ".otf": "dataurl",
+    ".ttf": "dataurl",
+    ".mp4": "file",
+    ".mpeg4": "file",
+    ".mov": "file",
+    ".avif": "file",
+    ".wmv": "file",
+    ".webm": "file",
+    ".wav": "file",
+    ".aac": "file",
+    ".ogg": "file",
+    ".flac": "file"
+  },
+  dataExtensions = Object.keys(esbuildLoaderConfig).filter(k => esbuildLoaderConfig[k] === "file" || esbuildLoaderConfig[k] === "dataurl").map(k => k.slice(1)),
+  esbuildIgnoreFilesRegex = new RegExp(`.(${dataExtensions.join("|")})$`, "i");
+function getESBuildConfig({
+  entryPoints,
+  resolvePlatformSpecificEntries,
+  ...options
+}, platform, aliases) {
+  return process.env.DEBUG?.startsWith("tamagui") && console.info("Building", entryPoints), {
+    bundle: !0,
+    entryPoints: resolvePlatformSpecificEntries ? entryPoints.map(import_loadTamagui.resolveWebOrNativeSpecificEntry) : entryPoints,
+    format: "cjs",
+    target: "node16",
+    jsx: "transform",
+    jsxFactory: "react",
+    allowOverwrite: !0,
+    keepNames: !0,
+    resolveExtensions: [".web.tsx", ".web.ts", ".web.jsx", ".web.js", ".tsx", ".ts", ".jsx", ".js"],
+    platform: "node",
+    tsconfigRaw: {
+      compilerOptions: {
+        jsx: "react-jsx"
+      }
+    },
+    loader: esbuildLoaderConfig,
+    logLevel: "warning",
+    plugins: [{
+      name: "external",
+      setup(build) {
+        build.onResolve({
+          filter: /@tamagui\/core/
+        }, args => ({
+          path: platform === "native" ? "@tamagui/core/native" : "@tamagui/core",
+          external: !0
+        })), build.onResolve({
+          filter: /react-native\/package.json$/
+        }, args => ({
+          path: "react-native/package.json",
+          external: !0
+        })), build.onResolve({
+          filter: /@tamagui\/web/
+        }, args => ({
+          path: platform === "native" ? "@tamagui/core/native" : "@tamagui/core",
+          external: !0
+        })), build.onResolve({
+          filter: /^(react-native|react-native\/.*)$/
+        }, args => ({
+          path: "@tamagui/react-native-web-lite",
+          external: !0
+        })), build.onResolve({
+          filter: /react-native-reanimated/
+        }, args => ({
+          path: "react-native-reanimated",
+          external: !0
+        }));
+      }
+    }, (0, import_esbuildAliasPlugin.esbuildAliasPlugin)({
+      ...aliases
+    })],
+    ...options
+  };
+}
+async function esbundleTamaguiConfig(props, platform, aliases) {
+  await asyncLock(props);
+  const config = getESBuildConfig(props, platform, aliases);
+  return await import_esbuild.default.build(config);
+}
+async function asyncLock(props) {
+  const lockFile = (0, import_node_path.join)((0, import_node_path.dirname)(props.outfile), (0, import_node_path.basename)(props.outfile, ".lock")),
+    lockStat = await FS.stat(lockFile).catch(() => {});
+  if ((lockStat ? (/* @__PURE__ */new Date()).getTime() - new Date(lockStat.mtime).getTime() : Number.POSITIVE_INFINITY) < 500) {
+    process.env.DEBUG?.startsWith("tamagui") && console.info("Waiting for existing build", props.entryPoints);
+    let tries = 5;
+    for (; tries--;) {
+      if (await FS.pathExists(props.outfile)) return;
+      await new Promise(res => setTimeout(res, 50));
+    }
+  }
+  FS.writeFile(lockFile, "");
+}

package/dist/extractor/bundleConfig.cjs

@@ -0,0 +1,322 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var bundleConfig_exports = {};
+__export(bundleConfig_exports, {
+  bundleConfig: () => bundleConfig,
+  esbuildOptions: () => esbuildOptions,
+  getBundledConfig: () => getBundledConfig,
+  getLoadedConfig: () => getLoadedConfig,
+  hasBundledConfigChanged: () => hasBundledConfigChanged,
+  loadComponents: () => loadComponents,
+  loadComponentsInner: () => loadComponentsInner,
+  writeTamaguiCSS: () => writeTamaguiCSS
+});
+module.exports = __toCommonJS(bundleConfig_exports);
+var import_generator = __toESM(require("@babel/generator")),
+  import_traverse = __toESM(require("@babel/traverse")),
+  t = __toESM(require("@babel/types")),
+  import_node_fs = require("node:fs"),
+  import_node_path = require("node:path"),
+  import_cli_color = require("@tamagui/cli-color"),
+  import_esbuild = __toESM(require("esbuild")),
+  FS = __toESM(require("fs-extra")),
+  import_promises = require("node:fs/promises"),
+  import_registerRequire = require("../registerRequire.cjs"),
+  import_babelParse = require("./babelParse.cjs"),
+  import_bundle = require("./bundle.cjs"),
+  import_getTamaguiConfigPathFromOptionsConfig = require("./getTamaguiConfigPathFromOptionsConfig.cjs");
+const external = ["@tamagui/core", "@tamagui/web", "react", "react-dom", "react-native-svg"],
+  esbuildExtraOptions = {
+    define: {
+      __DEV__: `${process.env.NODE_ENV === "development"}`
+    }
+  },
+  esbuildOptions = {
+    target: "es2018",
+    format: "cjs",
+    jsx: "automatic",
+    platform: "node",
+    ...esbuildExtraOptions
+  };
+let currentBundle = null,
+  isBundling = !1,
+  lastBundle = null;
+const waitForBundle = /* @__PURE__ */new Set();
+function hasBundledConfigChanged() {
+  return lastBundle === currentBundle ? !1 : (lastBundle = currentBundle, !0);
+}
+let loadedConfig = null;
+const getLoadedConfig = () => loadedConfig;
+async function getBundledConfig(props, rebuild = !1) {
+  if (isBundling) await new Promise(res => {
+    waitForBundle.add(res);
+  });else if (!currentBundle || rebuild) return await bundleConfig(props);
+  return currentBundle;
+}
+global.tamaguiLastLoaded ||= 0;
+function updateLastLoaded(config) {
+  global.tamaguiLastLoaded = Date.now(), global.tamaguiLastBundledConfig = config;
+}
+let hasBundledOnce = !1;
+async function bundleConfig(props) {
+  if (global.tamaguiLastBundledConfig && Date.now() - global.tamaguiLastLoaded < 3e3) return global.tamaguiLastBundledConfig;
+  try {
+    isBundling = !0;
+    const configEntry = props.config ? (0, import_getTamaguiConfigPathFromOptionsConfig.getTamaguiConfigPathFromOptionsConfig)(props.config) : "",
+      tmpDir = (0, import_node_path.join)(process.cwd(), ".tamagui"),
+      configOutPath = (0, import_node_path.join)(tmpDir, "tamagui.config.cjs"),
+      baseComponents = (props.components || []).filter(x => x !== "@tamagui/core"),
+      componentOutPaths = baseComponents.map(componentModule => (0, import_node_path.join)(tmpDir, `${componentModule.split(import_node_path.sep).join("-").replace(/[^a-z0-9]+/gi, "")}-components.config.cjs`));
+    if (process.env.NODE_ENV === "development" && process.env.DEBUG?.startsWith("tamagui") && console.info("Building config entry", configEntry), !props.disableInitialBuild) {
+      try {
+        await FS.ensureDir(tmpDir);
+      } catch {}
+      const start = Date.now();
+      await Promise.all([props.config ? (0, import_bundle.esbundleTamaguiConfig)({
+        entryPoints: [configEntry],
+        external,
+        outfile: configOutPath,
+        target: "node16",
+        ...esbuildExtraOptions
+      }, props.platform || "web") : null, ...baseComponents.map((componentModule, i) => (0, import_bundle.esbundleTamaguiConfig)({
+        entryPoints: [componentModule],
+        resolvePlatformSpecificEntries: !0,
+        external,
+        outfile: componentOutPaths[i],
+        target: "node16",
+        ...esbuildExtraOptions
+      }, props.platform || "web"))]), (0, import_cli_color.colorLog)(import_cli_color.Color.FgYellow, `
+    \u27A1 [tamagui] built config and components (${Date.now() - start}ms)`), process.env.DEBUG?.startsWith("tamagui") && (0, import_cli_color.colorLog)(import_cli_color.Color.Dim, `
+          Config     .${import_node_path.sep}${(0, import_node_path.relative)(process.cwd(), configOutPath)}
+          Components ${[...componentOutPaths.map(p => `.${import_node_path.sep}${(0, import_node_path.relative)(process.cwd(), p)}`)].join(`
+             `)}
+          `);
+    }
+    let out;
+    const {
+      unregister
+    } = (0, import_registerRequire.registerRequire)(props.platform || "web");
+    try {
+      if (hasBundledOnce) for (const key in require.cache) /(core|web)[\/\\]dist/.test(key) || delete require.cache[key];else hasBundledOnce = !0;
+      out = require(configOutPath);
+    } catch (err) {
+      throw err;
+    } finally {
+      unregister();
+    }
+    let config = out.default || out || out.config;
+    if (config && config.config && !config.tokens && (config = config.config), !config) throw new Error(`No config: ${config}`);
+    loadedConfig = config, props.outputCSS && (await writeTamaguiCSS(props.outputCSS, config));
+    let components = loadComponents({
+      ...props,
+      components: componentOutPaths
+    });
+    if (!components) throw new Error(`No components found: ${componentOutPaths.join(", ")}`);
+    for (const component of components) component.moduleName = baseComponents[componentOutPaths.indexOf(component.moduleName)] || component.moduleName, component.moduleName || (process.env.DEBUG?.includes("tamagui") || process.env.IS_TAMAGUI_DEV) && console.warn(`\u26A0\uFE0F no module name found: ${component.moduleName} ${JSON.stringify(baseComponents)} in ${JSON.stringify(componentOutPaths)}`);
+    process.env.NODE_ENV === "development" && process.env.DEBUG?.startsWith("tamagui") && console.info("Loaded components", components);
+    const res = {
+      components,
+      nameToPaths: {},
+      tamaguiConfig: config
+    };
+    return currentBundle = res, updateLastLoaded(res), res;
+  } catch (err) {
+    console.error(`Error bundling tamagui config: ${err?.message} (run with DEBUG=tamagui to see stack)`), process.env.DEBUG?.includes("tamagui") && console.error(err.stack);
+  } finally {
+    isBundling = !1, waitForBundle.forEach(cb => cb()), waitForBundle.clear();
+  }
+}
+async function writeTamaguiCSS(outputCSS, config) {
+  const flush = async () => {
+      (0, import_cli_color.colorLog)(import_cli_color.Color.FgYellow, `    \u27A1 [tamagui] output css: ${outputCSS}`), await FS.writeFile(outputCSS, css);
+    },
+    css = config.getCSS();
+  try {
+    (0, import_node_fs.existsSync)(outputCSS) && (await (0, import_promises.readFile)(outputCSS, "utf8")) === css || (await flush());
+  } catch (err) {
+    console.info("Error writing themes", err);
+  }
+}
+function loadComponents(props, forceExports = !1) {
+  const coreComponents = getCoreComponents(props),
+    otherComponents = loadComponentsInner(props, forceExports);
+  return [...coreComponents, ...(otherComponents || [])];
+}
+function getCoreComponents(props) {
+  const loaded = loadComponentsInner({
+    ...props,
+    components: ["@tamagui/core"]
+  });
+  if (!loaded) throw new Error("Core should always load");
+  return [{
+    ...loaded[0],
+    moduleName: "@tamagui/core"
+  }];
+}
+function loadComponentsInner(props, forceExports = !1) {
+  const componentsModules = props.components || [],
+    key = componentsModules.join("");
+  if (!forceExports && cacheComponents[key]) return cacheComponents[key];
+  const {
+    unregister
+  } = (0, import_registerRequire.registerRequire)(props.platform || "web", {
+    proxyWormImports: forceExports
+  });
+  try {
+    const info = componentsModules.flatMap(name => {
+      const isDynamic = !!(0, import_node_path.extname)(name) && forceExports,
+        fileContents = isDynamic ? (0, import_node_fs.readFileSync)(name, "utf-8") : "",
+        loadModule = isDynamic ? (0, import_node_path.join)((0, import_node_path.dirname)(name), `.tamagui-dynamic-eval-${(0, import_node_path.basename)(name)}.tsx`) : name;
+      let writtenContents = fileContents,
+        didBabel = !1;
+      function attemptLoad({
+        forceExports: forceExports2 = !1
+      } = {}) {
+        isDynamic && (writtenContents = forceExports2 ? transformAddExports((0, import_babelParse.babelParse)(esbuildit(fileContents, "modern"), name)) : fileContents, FS.writeFileSync(loadModule, writtenContents), import_esbuild.default.buildSync({
+          ...esbuildOptions,
+          entryPoints: [loadModule],
+          outfile: loadModule,
+          alias: {
+            "react-native": require.resolve("@tamagui/react-native-web-lite")
+          },
+          bundle: !0,
+          packages: "external",
+          allowOverwrite: !0,
+          // logLevel: 'silent',
+          sourcemap: !1,
+          loader: import_bundle.esbuildLoaderConfig
+        })), process.env.DEBUG === "tamagui" && console.info("loadModule", loadModule, require.resolve(loadModule));
+        const moduleResult = require(loadModule);
+        forceExports2 || (0, import_registerRequire.setRequireResult)(name, moduleResult);
+        const nameToInfo = getComponentStaticConfigByName(name, interopDefaultExport(moduleResult));
+        return {
+          moduleName: name,
+          nameToInfo
+        };
+      }
+      const dispose = () => {
+        isDynamic && FS.removeSync(loadModule);
+      };
+      try {
+        const res = attemptLoad({
+          forceExports: !0
+        });
+        return didBabel = !0, res;
+      } catch (err) {
+        console.info("babel err", err, writtenContents), writtenContents = fileContents, process.env.DEBUG?.startsWith("tamagui") && console.info("Error parsing babel likely", err);
+      } finally {
+        dispose();
+      }
+      try {
+        return attemptLoad({
+          forceExports: !1
+        });
+      } catch (err) {
+        return process.env.TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD && (console.info(`
+
+Tamagui attempted but failed to dynamically optimize components in:
+  ${name}
+`), console.info(err), console.info(`At: ${loadModule}`, `
+didBabel: ${didBabel}`, `
+In:`, writtenContents, `
+isDynamic: `, isDynamic)), [];
+      } finally {
+        dispose();
+      }
+    });
+    return cacheComponents[key] = info, info;
+  } catch (err) {
+    return console.info("Tamagui error bundling components", err.message, err.stack), null;
+  } finally {
+    unregister();
+  }
+}
+const esbuildit = (src, target) => import_esbuild.default.transformSync(src, {
+  ...esbuildOptions,
+  ...(target === "modern" && {
+    target: "es2022",
+    jsx: "automatic",
+    loader: "tsx",
+    platform: "neutral",
+    format: "esm"
+  })
+}).code;
+function getComponentStaticConfigByName(name, exported) {
+  const components = {};
+  try {
+    if (!exported || typeof exported != "object" || Array.isArray(exported)) throw new Error(`Invalid export from package ${name}: ${typeof exported}`);
+    for (const key in exported) {
+      const found = getTamaguiComponent(key, exported[key]);
+      if (found) {
+        const {
+          Component,
+          ...sc
+        } = found.staticConfig;
+        components[key] = {
+          staticConfig: sc
+        };
+      }
+    }
+  } catch (err) {
+    process.env.TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD && (console.error(`Tamagui failed getting components from ${name} (Disable error by setting environment variable TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD=1)`), console.error(err));
+  }
+  return components;
+}
+function getTamaguiComponent(name, Component) {
+  if (name[0].toUpperCase() !== name[0]) return;
+  if (Component?.staticConfig) return Component;
+}
+function interopDefaultExport(mod) {
+  return mod?.default ?? mod;
+}
+const cacheComponents = {};
+function transformAddExports(ast) {
+  const usedNames = /* @__PURE__ */new Set();
+  return (0, import_traverse.default)(ast, {
+    ExportNamedDeclaration(nodePath) {
+      if (nodePath.node.specifiers) for (const spec of nodePath.node.specifiers) usedNames.add(t.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value);
+    }
+  }), (0, import_traverse.default)(ast, {
+    VariableDeclaration(nodePath) {
+      if (!t.isProgram(nodePath.parent)) return;
+      const decs = nodePath.node.declarations;
+      if (decs.length > 1) return;
+      const [dec] = decs;
+      t.isIdentifier(dec.id) && dec.init && (usedNames.has(dec.id.name) || (usedNames.add(dec.id.name), nodePath.replaceWith(t.exportNamedDeclaration(t.variableDeclaration("let", [dec]), [t.exportSpecifier(t.identifier(dec.id.name), t.identifier(dec.id.name))]))));
+    }
+  }), (0, import_generator.default)(ast, {
+    concise: !1,
+    filename: "test.tsx",
+    retainLines: !1,
+    sourceMaps: !1
+  }).code;
+}

package/dist/extractor/{createEvaluator.js → createEvaluator.cjs}

@@ -2,31 +2,45 @@ var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: !0 });
-}, __copyProps = (to, from, except, desc) => {
-  if (from && typeof from == "object" || typeof from == "function")
-    for (let key of __getOwnPropNames(from))
-      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  return to;
-};
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
   // compatible transform (i.e. "__esModule" has not been set), then set
   // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
-  mod
-)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
 var createEvaluator_exports = {};
 __export(createEvaluator_exports, {
   createEvaluator: () => createEvaluator,
   createSafeEvaluator: () => createSafeEvaluator
 });
 module.exports = __toCommonJS(createEvaluator_exports);
-var import_node_vm = __toESM(require("node:vm")), import_generator = __toESM(require("@babel/generator")), t = __toESM(require("@babel/types")), import_esbuild = __toESM(require("esbuild")), import_constants = require("../constants"), import_evaluateAstNode = require("./evaluateAstNode");
+var import_node_vm = __toESM(require("node:vm")),
+  import_generator = __toESM(require("@babel/generator")),
+  t = __toESM(require("@babel/types")),
+  import_esbuild = __toESM(require("esbuild")),
+  import_constants = require("../constants.cjs"),
+  import_evaluateAstNode = require("./evaluateAstNode.cjs");
 function createEvaluator({
   props,
   staticNamespace,
@@ -34,21 +48,23 @@ function createEvaluator({
   traversePath,
   shouldPrintDebug
 }) {
-  const evalFn = (n) => {
-    if (t.isIdentifier(n) && typeof staticNamespace[n.name] < "u")
-      return staticNamespace[n.name];
-    const evalContext = import_node_vm.default.createContext(staticNamespace), codeWithTypescriptAnnotations = `(${(0, import_generator.default)(n).code})`, code = import_esbuild.default.transformSync(codeWithTypescriptAnnotations, { loader: "tsx" }).code.replace(/;\n$/, "");
+  const evalFn = n => {
+    if (t.isIdentifier(n) && typeof staticNamespace[n.name] < "u") return staticNamespace[n.name];
+    const evalContext = import_node_vm.default.createContext(staticNamespace),
+      codeWithTypescriptAnnotations = `(${(0, import_generator.default)(n).code})`,
+      code = import_esbuild.default.transformSync(codeWithTypescriptAnnotations, {
+        loader: "tsx"
+      }).code.replace(/;\n$/, "");
     return shouldPrintDebug && console.info("evaluating", code), import_node_vm.default.runInContext(code, evalContext);
   };
-  return (n) => (0, import_evaluateAstNode.evaluateAstNode)(n, evalFn);
+  return n => (0, import_evaluateAstNode.evaluateAstNode)(n, evalFn);
 }
 function createSafeEvaluator(attemptEval) {
-  return (n) => {
+  return n => {
     try {
       return attemptEval(n);
     } catch {
       return import_constants.FAILED_EVAL;
     }
   };
-}
-//# sourceMappingURL=createEvaluator.js.map
+}