@tamagui/static 1.88.12 → 1.89.0-1706308641099

package/dist/esm/extractor/getSourceModule.mjs

@@ -0,0 +1,33 @@
+import * as t from "@babel/types";
+function getSourceModule(itemName, itemBinding) {
+  if (!itemBinding.constant) return null;
+  let sourceModule,
+    imported,
+    local,
+    destructured,
+    usesImportSyntax = !1;
+  const itemNode = itemBinding.path.node;
+  if (
+  // import x from 'y';
+  t.isImportDefaultSpecifier(itemNode) ||
+  // import {x} from 'y';
+  t.isImportSpecifier(itemNode)) t.isImportDeclaration(itemBinding.path.parent) && (sourceModule = itemBinding.path.parent.source.value, local = itemNode.local.name, usesImportSyntax = !0, t.isImportSpecifier(itemNode) ? (imported = itemNode.imported.name, destructured = !0) : (imported = itemNode.local.name, destructured = !1));else if (t.isVariableDeclarator(itemNode) && itemNode.init != null && t.isCallExpression(itemNode.init) && t.isIdentifier(itemNode.init.callee) && itemNode.init.callee.name === "require" && itemNode.init.arguments.length === 1) {
+    const firstArg = itemNode.init.arguments[0];
+    if (!t.isStringLiteral(firstArg)) return null;
+    if (sourceModule = firstArg.value, t.isIdentifier(itemNode.id)) local = itemNode.id.name, imported = itemNode.id.name, destructured = !1;else if (t.isObjectPattern(itemNode.id)) {
+      for (const objProp of itemNode.id.properties) if (t.isObjectProperty(objProp) && t.isIdentifier(objProp.value) && objProp.value.name === itemName) {
+        local = objProp.value.name, imported = objProp.key.name, destructured = !0;
+        break;
+      }
+      if (!local || !imported) return console.error("could not find prop with value `%s`", itemName), null;
+    } else return console.error("Unhandled id type: %s", itemNode.id.type), null;
+  } else return null;
+  return {
+    destructured,
+    imported,
+    local,
+    sourceModule,
+    usesImportSyntax
+  };
+}
+export { getSourceModule };

package/dist/esm/extractor/getStaticBindingsForScope.mjs

@@ -0,0 +1,112 @@
+import { fork } from "child_process";
+import { dirname, extname, join, resolve } from "path";
+import * as t from "@babel/types";
+import { evaluateAstNode } from "./evaluateAstNode.mjs";
+import { getSourceModule } from "./getSourceModule.mjs";
+const isLocalImport = path => path.startsWith(".") || path.startsWith("/");
+function resolveImportPath(sourcePath, path) {
+  const sourceDir = dirname(sourcePath);
+  return isLocalImport(path) ? (extname(path) === "" && (path += ".js"), resolve(sourceDir, path)) : path;
+}
+const cache = /* @__PURE__ */new Map(),
+  pending = /* @__PURE__ */new Map(),
+  loadCmd = `${join(__dirname, "loadFile.js")}`;
+let exited = !1,
+  child = null;
+function forkChild() {
+  child = fork(loadCmd, [], {
+    execArgv: ["-r", "esbuild-register"],
+    detached: !1,
+    stdio: "ignore"
+  });
+}
+function cleanupBeforeExit() {
+  exited || child && (child.removeAllListeners(), child.unref(), child.disconnect(), child.kill(), exited = !0);
+}
+process.once("SIGTERM", cleanupBeforeExit);
+process.once("SIGINT", cleanupBeforeExit);
+process.once("beforeExit", cleanupBeforeExit);
+function importModule(path) {
+  if (child || forkChild(), pending.has(path)) return pending.get(path);
+  const promise = new Promise((res, rej) => {
+    if (!child) return;
+    if (cache.size > 2e3 && cache.clear(), cache.has(path)) return cache.get(path);
+    const listener = msg => {
+      if (!child || !msg || typeof msg != "string") return;
+      if (msg[0] === "-") {
+        rej(new Error(msg.slice(1)));
+        return;
+      }
+      child.removeListener("message", listener);
+      const val = JSON.parse(msg);
+      cache.set(path, val), res(val);
+    };
+    child.once("message", listener), child.send(`${path.replace(".js", "")}`);
+  });
+  return pending.set(path, promise), promise;
+}
+async function getStaticBindingsForScope(scope, whitelist = [], sourcePath, bindingCache, shouldPrintDebug) {
+  const bindings = scope.getAllBindings(),
+    ret = {},
+    program = scope.getProgramParent().block;
+  for (const node of program.body) if (t.isImportDeclaration(node)) {
+    const importPath = node.source.value;
+    if (!node.specifiers.length || !isLocalImport(importPath)) continue;
+    const moduleName = resolveImportPath(sourcePath, importPath);
+    if (!whitelist.some(test => moduleName.endsWith(test))) continue;
+    try {
+      const src = await importModule(moduleName);
+      if (!src) continue;
+      for (const specifier of node.specifiers) if (t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported) && typeof src[specifier.imported.name] < "u") {
+        const val = src[specifier.local.name];
+        ret[specifier.local.name] = val;
+      }
+    } catch (err) {
+      shouldPrintDebug ? console.warn(`    | Skipping partial evaluation of constant file: ${moduleName} (DEBUG=tamagui for more)`) : process.env.DEBUG?.startsWith("tamagui") && console.info("Error in partial evaluation", err.message, err.stack);
+    }
+  }
+  if (!bindingCache) throw new Error("BindingCache is a required param");
+  for (const k in bindings) {
+    const binding = bindings[k],
+      sourceModule = getSourceModule(k, binding);
+    if (sourceModule) {
+      if (!sourceModule.sourceModule) continue;
+      const moduleName = resolveImportPath(sourcePath, sourceModule.sourceModule);
+      if (whitelist.some(test => moduleName.endsWith(test))) {
+        const src = importModule(moduleName);
+        if (!src) return console.info(`    | \u26A0\uFE0F Missing file ${moduleName} via ${sourcePath} import ${sourceModule.sourceModule}?`), {};
+        sourceModule.destructured ? sourceModule.imported && (ret[k] = src[sourceModule.imported]) : ret[k] = src;
+      }
+      continue;
+    }
+    const {
+      parent
+    } = binding.path;
+    if (!t.isVariableDeclaration(parent) || parent.kind !== "const") continue;
+    const dec = parent.declarations.find(d => t.isIdentifier(d.id) && d.id.name === k);
+    if (!dec || !dec.init) continue;
+    if (typeof dec.id.start != "number" || typeof dec.id.end != "number") {
+      console.error("dec.id.start/end is not a number");
+      continue;
+    }
+    if (!t.isIdentifier(dec.id)) {
+      console.error("dec is not an identifier");
+      continue;
+    }
+    const cacheKey = `${dec.id.name}_${dec.id.start}-${dec.id.end}`;
+    if (Object.hasOwnProperty.call(bindingCache, cacheKey)) {
+      ret[k] = bindingCache[cacheKey];
+      continue;
+    }
+    if (Object.hasOwnProperty.call(bindingCache, cacheKey)) {
+      ret[k] = bindingCache[cacheKey];
+      continue;
+    }
+    try {
+      ret[k] = evaluateAstNode(dec.init, void 0, shouldPrintDebug), bindingCache[cacheKey] = ret[k];
+      continue;
+    } catch {}
+  }
+  return ret;
+}
+export { cleanupBeforeExit, getStaticBindingsForScope };

package/dist/esm/extractor/getTamaguiConfigPathFromOptionsConfig.mjs

@@ -0,0 +1,5 @@
+import { isAbsolute, join } from "path";
+function getTamaguiConfigPathFromOptionsConfig(config) {
+  return isAbsolute(config) ? config : join(process.cwd(), config);
+}
+export { getTamaguiConfigPathFromOptionsConfig };

package/dist/esm/extractor/hoistClassNames.mjs

@@ -0,0 +1,24 @@
+import * as t from "@babel/types";
+function hoistClassNames(path, existing, expr) {
+  const hoist = hoistClassNames.bind(null, path, existing);
+  if (t.isStringLiteral(expr)) {
+    if (expr.value.trim() === "") return expr;
+    if (existing[expr.value]) return existing[expr.value];
+    const identifier = replaceStringWithVariable(expr);
+    return existing[expr.value] = identifier, identifier;
+  }
+  if (t.isBinaryExpression(expr)) return t.binaryExpression(expr.operator, hoist(expr.left), hoist(expr.right));
+  if (t.isLogicalExpression(expr)) return t.logicalExpression(expr.operator, hoist(expr.left), hoist(expr.right));
+  if (t.isConditionalExpression(expr)) return t.conditionalExpression(expr.test, hoist(expr.consequent), hoist(expr.alternate));
+  return expr;
+  function replaceStringWithVariable(str) {
+    const uid = path.scope.generateUidIdentifier("cn"),
+      parent = path.findParent(path2 => path2.isProgram());
+    if (!parent) throw new Error("no program?");
+    const variable = t.variableDeclaration("const", [
+    // adding a space for extra safety
+    t.variableDeclarator(uid, t.stringLiteral(` ${str.value}`))]);
+    return parent.unshiftContainer("body", variable), uid;
+  }
+}
+export { hoistClassNames };

package/dist/esm/extractor/literalToAst.mjs

@@ -0,0 +1,48 @@
+import * as t from "@babel/types";
+function literalToAst(literal) {
+  if (literal === null) return t.nullLiteral();
+  switch (typeof literal) {
+    case "function":
+      throw new Error("Unsupported");
+    case "number":
+      return t.numericLiteral(literal);
+    case "string":
+      return t.stringLiteral(literal);
+    case "boolean":
+      return t.booleanLiteral(literal);
+    case "undefined":
+      return t.unaryExpression("void", t.numericLiteral(0), !0);
+    default:
+      return Array.isArray(literal) ? t.arrayExpression(literal.map(literalToAst)) : t.objectExpression(Object.keys(literal).filter(k => typeof literal[k] < "u").map(k => t.objectProperty(t.stringLiteral(k), literalToAst(literal[k]))));
+  }
+}
+const easyPeasies = ["BooleanLiteral", "StringLiteral", "NumericLiteral"];
+function astToLiteral(node) {
+  if (node) {
+    if (easyPeasies.includes(node.type)) return node.value;
+    if (!(node.name === "undefined" && !node.value)) {
+      if (t.isNullLiteral(node)) return null;
+      if (t.isObjectExpression(node)) return computeProps(node.properties);
+      if (t.isArrayExpression(node)) return node.elements.reduce(
+      // @ts-ignore
+      (acc, element) => [...acc, ...(element?.type === "SpreadElement" ? astToLiteral(element.argument) : [astToLiteral(element)])], []);
+    }
+  }
+}
+function computeProps(props) {
+  return props.reduce((acc, prop) => {
+    if (prop.type === "SpreadElement") return {
+      ...acc,
+      ...astToLiteral(prop.argument)
+    };
+    if (prop.type !== "ObjectMethod") {
+      const val = astToLiteral(prop.value);
+      if (val !== void 0) return {
+        ...acc,
+        [prop.key.name]: val
+      };
+    }
+    return acc;
+  }, {});
+}
+export { astToLiteral, literalToAst };

package/dist/esm/extractor/loadFile.mjs

@@ -0,0 +1,11 @@
+process.on("message", path => {
+  if (typeof path != "string") throw new Error(`Not a string: ${path}`);
+  try {
+    const out = require(path);
+    process.send?.(JSON.stringify(out));
+  } catch (err) {
+    err instanceof Error ? process.send?.(`-${err.message}
+${err.stack}`) : process.send?.(`-${err}`);
+  }
+});
+setInterval(() => {}, 1e3);

package/dist/esm/extractor/loadTamagui.mjs

@@ -0,0 +1,233 @@
+import { writeFileSync } from "fs";
+import { basename, dirname, extname, join, relative, resolve } from "path";
+import { Color, colorLog } from "@tamagui/cli-color";
+import { getDefaultTamaguiConfig } from "@tamagui/config-default";
+import esbuild from "esbuild";
+import { existsSync, pathExists, readJSON, writeFile } from "fs-extra";
+import { SHOULD_DEBUG } from "../constants.mjs";
+import { requireTamaguiCore } from "../helpers/requireTamaguiCore.mjs";
+import { minifyCSS } from "../minifyCSS.mjs";
+import { getNameToPaths, registerRequire } from "../registerRequire.mjs";
+import { TamaguiProjectInfo, getBundledConfig, hasBundledConfigChanged, loadComponents } from "./bundleConfig.mjs";
+import { generateTamaguiStudioConfig, generateTamaguiStudioConfigSync, generateTamaguiThemes } from "./generateTamaguiStudioConfig.mjs";
+import { getTamaguiConfigPathFromOptionsConfig } from "./getTamaguiConfigPathFromOptionsConfig.mjs";
+const getFilledOptions = propsIn => ({
+  // defaults
+  platform: "web",
+  config: "tamagui.config.ts",
+  components: ["tamagui"],
+  ...propsIn
+});
+async function loadTamagui(propsIn) {
+  const props = getFilledOptions(propsIn),
+    bundleInfo = await getBundledConfig(props);
+  if (!bundleInfo) return console.warn("No bundled config generated, maybe an error in bundling. Set DEBUG=tamagui and re-run to get logs."), null;
+  if (await generateThemesAndLog(props, !0), !hasBundledConfigChanged()) return bundleInfo;
+  if (bundleInfo) {
+    const {
+        createTamagui
+      } = requireTamaguiCore(props.platform),
+      config = createTamagui(bundleInfo.tamaguiConfig);
+    if (props.outputCSS) {
+      colorLog(Color.FgYellow, `    \u27A1 [tamagui] output css: ${props.outputCSS}
+`);
+      const css = props.disableMinifyCSS === !1 ? minifyCSS(config.getCSS()).code : config.getCSS();
+      await writeFile(props.outputCSS, css);
+    }
+  }
+  return process.env.NODE_ENV === "development" && (await generateTamaguiStudioConfig(props, bundleInfo)), bundleInfo;
+}
+let waiting = !1,
+  hasLoggedOnce = !1;
+const generateThemesAndLog = async (options, force = !1) => {
+    if (!waiting && options.themeBuilder) try {
+      waiting = !0, await new Promise(res => setTimeout(res, 30));
+      const didGenerate = await generateTamaguiThemes(options, force);
+      !hasLoggedOnce && didGenerate && (hasLoggedOnce = !0, colorLog(Color.FgYellow, `
+    \u27A1 [tamagui] generated themes: ${relative(process.cwd(), options.themeBuilder.output)}`));
+    } finally {
+      waiting = !1;
+    }
+  },
+  last = {},
+  lastVersion = {};
+function loadTamaguiSync({
+  forceExports,
+  cacheKey,
+  ...propsIn
+}) {
+  const key = JSON.stringify(propsIn);
+  if (last[key] && !hasBundledConfigChanged() && (!lastVersion[key] || lastVersion[key] === cacheKey)) return last[key];
+  lastVersion[key] = cacheKey || "";
+  const props = getFilledOptions(propsIn);
+  process.env.IS_STATIC = "is_static", process.env.TAMAGUI_IS_SERVER = "true";
+  const {
+    unregister
+  } = registerRequire(props.platform, {
+    proxyWormImports: !!forceExports
+  });
+  try {
+    const devValueOG = globalThis.__DEV__;
+    globalThis.__DEV__ = process.env.NODE_ENV === "development";
+    try {
+      let tamaguiConfig = null;
+      if (propsIn.config) {
+        const configPath = getTamaguiConfigPathFromOptionsConfig(propsIn.config),
+          exp = require(configPath);
+        if (tamaguiConfig = exp.default || exp.config || exp, !tamaguiConfig || !tamaguiConfig.parsed) {
+          const confPath = require.resolve(configPath);
+          throw new Error(`Can't find valid config in ${confPath}:
+          
+  Be sure you "export default" or "export const config" the config.`);
+        }
+        if (tamaguiConfig) {
+          const {
+            createTamagui
+          } = requireTamaguiCore(props.platform);
+          createTamagui(tamaguiConfig);
+        }
+      }
+      const components = loadComponents(props, forceExports);
+      if (!components) throw new Error("No components loaded");
+      process.env.DEBUG === "tamagui" && console.info("components", components), process.env.IS_STATIC = void 0, globalThis.__DEV__ = devValueOG;
+      const info = {
+        components,
+        tamaguiConfig,
+        nameToPaths: getNameToPaths()
+      };
+      if (tamaguiConfig) {
+        if (props.outputCSS) {
+          colorLog(Color.FgYellow, `    \u27A1 [tamagui] output css: ${props.outputCSS}
+`);
+          const css = props.disableMinifyCSS === !1 ? minifyCSS(tamaguiConfig.getCSS()).code : tamaguiConfig.getCSS();
+          writeFileSync(props.outputCSS, css);
+        }
+        generateTamaguiStudioConfigSync(props, info);
+      }
+      return last[key] = {
+        ...info,
+        cached: !0
+      }, info;
+    } catch (err) {
+      err instanceof Error ? !SHOULD_DEBUG && !forceExports ? (console.warn("Error loading tamagui.config.ts (set DEBUG=tamagui to see full stack), running tamagui without custom config"), console.info(`
+
+    ${err.message}
+
+`)) : SHOULD_DEBUG && console.error(err) : console.error("Error loading tamagui.config.ts", err);
+      const {
+        createTamagui
+      } = requireTamaguiCore(props.platform);
+      return {
+        components: [],
+        tamaguiConfig: createTamagui(getDefaultTamaguiConfig()),
+        nameToPaths: {}
+      };
+    }
+  } finally {
+    unregister();
+  }
+}
+async function getOptions({
+  root = process.cwd(),
+  tsconfigPath = "tsconfig.json",
+  tamaguiOptions,
+  host,
+  debug
+} = {}) {
+  const dotDir = join(root, ".tamagui");
+  let pkgJson = {};
+  try {
+    pkgJson = await readJSON(join(root, "package.json"));
+  } catch {}
+  return {
+    mode: process.env.NODE_ENV === "production" ? "production" : "development",
+    root,
+    host: host || "127.0.0.1",
+    pkgJson,
+    debug,
+    tsconfigPath,
+    tamaguiOptions: {
+      platform: "web",
+      components: ["tamagui"],
+      ...tamaguiOptions,
+      config: await getDefaultTamaguiConfigPath(root, tamaguiOptions?.config)
+    },
+    paths: {
+      dotDir,
+      conf: join(dotDir, "tamagui.config.json"),
+      types: join(dotDir, "types.json")
+    }
+  };
+}
+function resolveWebOrNativeSpecificEntry(entry) {
+  const workspaceRoot = resolve(),
+    resolved = require.resolve(entry, {
+      paths: [workspaceRoot]
+    }),
+    ext = extname(resolved),
+    fileName = basename(resolved).replace(ext, ""),
+    specificFile = join(dirname(resolved), fileName + "." + "web" + ext);
+  return existsSync(specificFile) ? specificFile : entry;
+}
+const defaultPaths = ["tamagui.config.ts", join("src", "tamagui.config.ts")];
+let hasWarnedOnce = !1;
+async function getDefaultTamaguiConfigPath(root, configPath) {
+  const searchPaths = [...new Set([configPath, ...defaultPaths].filter(Boolean).map(p => join(root, p)))];
+  for (const path of searchPaths) if (await pathExists(path)) return path;
+  hasWarnedOnce || (hasWarnedOnce = !0, console.warn(`Warning: couldn't find tamagui.config.ts in the following paths given configuration "${configPath}":
+    ${searchPaths.join(`
+  `)}
+  `));
+}
+async function watchTamaguiConfig(tamaguiOptions) {
+  const options = await getOptions({
+    tamaguiOptions
+  });
+  if (!options.tamaguiOptions.config) throw new Error("No config");
+  if (process.env.NODE_ENV === "production") return {
+    dispose() {}
+  };
+  const disposeConfigWatcher = await esbuildWatchFiles(options.tamaguiOptions.config, () => {
+      generateTamaguiStudioConfig(options.tamaguiOptions, null, !0);
+    }),
+    themeBuilderInput = options.tamaguiOptions.themeBuilder?.input;
+  let disposeThemesWatcher;
+  if (themeBuilderInput) {
+    let inputPath = themeBuilderInput;
+    try {
+      inputPath = require.resolve(themeBuilderInput);
+    } catch {}
+    disposeThemesWatcher = await esbuildWatchFiles(inputPath, () => {
+      generateThemesAndLog(options.tamaguiOptions);
+    });
+  }
+  return {
+    dispose() {
+      disposeConfigWatcher(), disposeThemesWatcher?.();
+    }
+  };
+}
+async function esbuildWatchFiles(entry, onChanged) {
+  let hasRunOnce = !1;
+  const context = await esbuild.context({
+    bundle: !0,
+    entryPoints: [entry],
+    resolveExtensions: [".ts", ".tsx", ".js", ".jsx", ".mjs"],
+    logLevel: "silent",
+    write: !1,
+    plugins: [{
+      name: "on-rebuild",
+      setup({
+        onEnd
+      }) {
+        onEnd(() => {
+          hasRunOnce ? onChanged() : hasRunOnce = !0;
+        });
+      }
+    }]
+  });
+  return context.watch(), () => {
+    context.dispose();
+  };
+}
+export { TamaguiProjectInfo, getOptions, loadTamagui, loadTamaguiSync, resolveWebOrNativeSpecificEntry, watchTamaguiConfig };

package/dist/esm/extractor/logLines.mjs

@@ -0,0 +1,11 @@
+const prefix = "           ",
+  logLines = (str, singleLine = !1) => {
+    if (singleLine) return prefix + str.split(" ").join(`
+${prefix}`);
+    const lines = [""],
+      items = str.split(" ");
+    for (const item of items) item.length + lines[lines.length - 1].length > 85 && lines.push(""), lines[lines.length - 1] += item + " ";
+    return lines.map((line, i) => prefix + (i == 0 ? "" : " ") + line.trim()).join(`
+`);
+  };
+export { logLines };

package/dist/esm/extractor/normalizeTernaries.mjs

@@ -0,0 +1,33 @@
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+import invariant from "invariant";
+function normalizeTernaries(ternaries) {
+  if (invariant(Array.isArray(ternaries), "extractStaticTernaries expects param 1 to be an array of ternaries"), ternaries.length === 0) return [];
+  const ternariesByKey = {};
+  for (let idx = -1, len = ternaries.length; ++idx < len;) {
+    const {
+      test,
+      consequent,
+      alternate,
+      remove,
+      ...rest
+    } = ternaries[idx];
+    let ternaryTest = test;
+    t.isExpressionStatement(test) && (ternaryTest = test.expression);
+    let shouldSwap = !1;
+    t.isUnaryExpression(test) && test.operator === "!" ? (ternaryTest = test.argument, shouldSwap = !0) : t.isBinaryExpression(test) && (test.operator === "!==" || test.operator === "!=") && (ternaryTest = t.binaryExpression(test.operator.replace("!", "="), test.left, test.right), shouldSwap = !0);
+    const key = generate(ternaryTest).code;
+    ternariesByKey[key] || (ternariesByKey[key] = {
+      ...rest,
+      alternate: {},
+      consequent: {},
+      test: ternaryTest,
+      remove
+    });
+    const altStyle = (shouldSwap ? consequent : alternate) ?? {},
+      consStyle = (shouldSwap ? alternate : consequent) ?? {};
+    Object.assign(ternariesByKey[key].alternate, altStyle), Object.assign(ternariesByKey[key].consequent, consStyle);
+  }
+  return Object.keys(ternariesByKey).map(key => ternariesByKey[key]);
+}
+export { normalizeTernaries };

package/dist/esm/extractor/propsToFontFamilyCache.mjs

@@ -0,0 +1,12 @@
+const cache = /* @__PURE__ */new WeakMap();
+function setPropsToFontFamily(props, ff) {
+  cache.set(props, ff);
+}
+function getPropsToFontFamily(props) {
+  return cache.get(props);
+}
+function getFontFamilyClassNameFromProps(props) {
+  const ff = getPropsToFontFamily(props);
+  if (ff) return ` font_${ff.replace("$", "")}`;
+}
+export { getFontFamilyClassNameFromProps, getPropsToFontFamily, setPropsToFontFamily };

package/dist/esm/extractor/removeUnusedHooks.mjs

@@ -0,0 +1,41 @@
+import * as t from "@babel/types";
+const hooks = {
+  useMedia: !0,
+  useTheme: !0
+};
+function removeUnusedHooks(compFn, shouldPrintDebug) {
+  compFn.scope.crawl();
+  let bodyStatements = compFn?.get("body");
+  if (!bodyStatements) {
+    console.info("no body statemnts?", compFn);
+    return;
+  }
+  if (Array.isArray(bodyStatements) || (bodyStatements.isFunctionExpression() ? bodyStatements = bodyStatements.scope.path.get("body") : bodyStatements = bodyStatements.get("body")), !bodyStatements || !Array.isArray(bodyStatements)) return;
+  const statements = bodyStatements;
+  for (const statement of statements) {
+    if (!statement.isVariableDeclaration()) continue;
+    const declarations = statement.get("declarations");
+    if (!Array.isArray(declarations)) continue;
+    const isBindingReferenced = name => !!statement.scope.getBinding(name)?.referenced;
+    for (const declarator of declarations) {
+      const id = declarator.get("id"),
+        init = declarator.node.init;
+      if (Array.isArray(id) || Array.isArray(init)) continue;
+      (() => {
+        if (!(init && t.isCallExpression(init) && t.isIdentifier(init.callee) && hooks[init.callee.name])) return !1;
+        if (t.isIdentifier(id.node)) {
+          const name = id.node.name;
+          return !isBindingReferenced(name);
+        }
+        return t.isObjectPattern(id.node) ? id.get("properties").every(prop => {
+          if (!prop.isObjectProperty()) return !1;
+          const value = prop.get("value");
+          if (Array.isArray(value) || !value.isIdentifier()) return !1;
+          const name = value.node.name;
+          return !isBindingReferenced(name);
+        }) : !1;
+      })() && (declarator.remove(), shouldPrintDebug && console.info(`  [\u{1FA9D}] removed ${id.node.name ?? ""}`));
+    }
+  }
+}
+export { removeUnusedHooks };

package/dist/esm/extractor/timer.mjs

@@ -0,0 +1,19 @@
+const timer = () => {
+  const start = Date.now();
+  let last = start;
+  return {
+    mark: (name, print = !1) => {
+      if (print) {
+        const took = Date.now() - last;
+        last = Date.now(), console.info(`Time ${name}: ${took}ms`), took > 10 && console.info("  long timer");
+      }
+    },
+    done: (print = !1) => {
+      if (print) {
+        const total = Date.now() - start;
+        console.info(`Total time: ${total}ms`), total > 50 && console.info("  long timer");
+      }
+    }
+  };
+};
+export { timer };

package/dist/esm/extractor/validHTMLAttributes.mjs

@@ -0,0 +1,49 @@
+const validHTMLAttributes = {
+  autocomplete: !0,
+  border: !0,
+  contenteditable: !0,
+  crossorigin: !0,
+  dir: !0,
+  draggable: !0,
+  enctype: !0,
+  formenctype: !0,
+  formmethod: !0,
+  formtarget: !0,
+  inputmode: !0,
+  kind: !0,
+  link: !0,
+  method: !0,
+  preload: !0,
+  referrerpolicy: !0,
+  rel: !0,
+  rev: !0,
+  role: !0,
+  sandbox: !0,
+  shape: !0,
+  spellcheck: !0,
+  target: !0,
+  translate: !0,
+  type: !0,
+  wrap: !0,
+  "aria-autocomplete": !0,
+  "aria-busy": !0,
+  "aria-checked": !0,
+  "aria-current": !0,
+  "aria-disabled": !0,
+  "aria-expanded": !0,
+  "aria-haspopup": !0,
+  "aria-hidden": !0,
+  "aria-invalid": !0,
+  "aria-polite": !0,
+  "aria-modal": !0,
+  "aria-multiline": !0,
+  "aria-multiselectable": !0,
+  "aria-orientation": !0,
+  "aria-pressed": !0,
+  "aria-readonly": !0,
+  "aria-relevant": !0,
+  "aria-required": !0,
+  "aria-selected": !0,
+  "aria-sort": !0
+};
+export { validHTMLAttributes };

package/dist/esm/getPragmaOptions.mjs

@@ -0,0 +1,19 @@
+function getPragmaOptions({
+  source,
+  path,
+  disableCommentCheck
+}) {
+  if (!disableCommentCheck && !source.startsWith("//") && !source.startsWith("/*")) return {
+    shouldPrintDebug: !1,
+    shouldDisable: !1
+  };
+  let shouldPrintDebug = !1,
+    shouldDisable = !1;
+  const firstLine = source.slice(0, 800).split(`
+`)[0];
+  return firstLine.includes("tamagui-ignore") && (shouldDisable = !0), firstLine.includes("debug") && (shouldPrintDebug = !0), firstLine.includes("debug-verbose") && (shouldPrintDebug = "verbose"), process.env.TAMAGUI_DEBUG_FILE && path.includes(process.env.TAMAGUI_DEBUG_FILE) && (shouldPrintDebug = "verbose"), process.env.DEBUG?.includes("tamagui") && (shouldPrintDebug ||= !0), process.env.DEBUG?.includes("tamagui-verbose") && (shouldPrintDebug = "verbose"), {
+    shouldPrintDebug,
+    shouldDisable
+  };
+}
+export { getPragmaOptions };

package/dist/esm/helpers/memoize.mjs

@@ -0,0 +1,13 @@
+function memoize(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") throw new TypeError("Expected a function");
+  const memoized = function (...args) {
+    const key = resolver ? resolver.apply(this, args) : args[0],
+      cache = memoized.cache;
+    if (cache.has(key)) return cache.get(key);
+    const result = func.apply(this, args);
+    return memoized.cache = cache.set(key, result) || cache, result;
+  };
+  return memoized.cache = new (memoize.Cache || Map)(), memoized;
+}
+memoize.Cache = Map;
+export { memoize };