@tamagui/static 1.88.13 → 1.89.0-1706360676826

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 };

package/dist/esm/helpers/requireTamaguiCore.mjs

@@ -0,0 +1,5 @@
+function requireTamaguiCore(platform, ogRequire = require) {
+  if (!platform) throw new Error("No platform given to requireTamaguiCore");
+  return ogRequire(platform === "native" ? "@tamagui/core/native" : "@tamagui/core");
+}
+export { requireTamaguiCore };

package/dist/esm/index.mjs

@@ -0,0 +1,3 @@
+import "./setup.mjs";
+export * from "./static.mjs";
+export * from "./minifyCSS.mjs";

package/dist/esm/minifyCSS.mjs

@@ -0,0 +1,12 @@
+import browserslist from "browserslist";
+import { browserslistToTargets, transform } from "lightningcss";
+function minifyCSS(input) {
+  return transform({
+    filename: "style.css",
+    code: Buffer.from(input),
+    minify: !0,
+    targets: browserslistToTargets(browserslist(">= 0.5%")),
+    sourceMap: !0
+  });
+}
+export { minifyCSS };

package/dist/esm/registerRequire.mjs

@@ -0,0 +1,74 @@
+import { register } from "esbuild-register/dist/node";
+import { requireTamaguiCore } from "./helpers/requireTamaguiCore.mjs";
+const nameToPaths = {},
+  Module = require("module"),
+  getNameToPaths = () => nameToPaths,
+  proxyWorm = require("@tamagui/proxy-worm"),
+  rnw = require("react-native-web");
+let isRegistered = !1,
+  og;
+const whitelisted = {
+    react: !0
+  },
+  compiled = {};
+function setRequireResult(name, result) {
+  compiled[name] = result;
+}
+function registerRequire(platform, {
+  proxyWormImports
+} = {
+  proxyWormImports: !1
+}) {
+  if (isRegistered) return {
+    tamaguiRequire: require,
+    unregister: () => {}
+  };
+  const {
+    unregister
+  } = register({
+    hookIgnoreNodeModules: !1
+  });
+  og || (og = Module.prototype.require), isRegistered = !0, Module.prototype.require = tamaguiRequire;
+  function tamaguiRequire(path) {
+    if (path === "tamagui" && platform === "native") return og.apply(this, ["tamagui/native"]);
+    if (path === "@tamagui/core" || path === "@tamagui/web") return requireTamaguiCore(platform, path2 => og.apply(this, [path2]));
+    if (path in compiled) return compiled[path];
+    if (/\.(gif|jpe?g|png|svg|ttf|otf|woff2?|bmp|webp)$/i.test(path)) return {};
+    if (path === "@gorhom/bottom-sheet" || path.startsWith("react-native-reanimated") || path === "expo-linear-gradient" || path === "@expo/vector-icons" || path === "tamagui/linear-gradient" || path === "react-native-svg") return proxyWorm;
+    if (path === "react-native/package.json") return packageJson;
+    if (path === "react-native-web-lite" || path.startsWith("react-native")) return rnw;
+    if (path in knownIgnorableModules) return proxyWorm;
+    if (!whitelisted[path] && proxyWormImports && !path.includes(".tamagui-dynamic-eval")) return path === "tamagui" ? og.apply(this, [path]) : proxyWorm;
+    try {
+      return og.apply(this, arguments);
+    } catch (err) {
+      return !process.env.TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD && path.includes("tamagui-dynamic-eval") ? void 0 : (allowedIgnores[path] || IGNORES === "true" || (!process.env.TAMAGUI_SHOW_FULL_BUNDLE_ERRORS && !process.env.DEBUG ? hasWarnedForModules.has(path) || (hasWarnedForModules.add(path), console.info(`  tamagui: skipping ${path} tamagui.dev/docs/intro/errors#warning-001`)) : console.error(`Tamagui failed loading "${path}"
+  
+  ${err.message}
+  ${err.stack}
+
+  `)), proxyWorm);
+    }
+  }
+  return {
+    tamaguiRequire,
+    unregister: () => {
+      unregister(), isRegistered = !1, Module.prototype.require = og;
+    }
+  };
+}
+const packageJson = require("react-native-web/package.json"),
+  IGNORES = process.env.TAMAGUI_IGNORE_BUNDLE_ERRORS,
+  extraIgnores = IGNORES === "true" ? [] : process.env.TAMAGUI_IGNORE_BUNDLE_ERRORS?.split(","),
+  knownIgnorableModules = {
+    "expo-modules": !0,
+    solito: !0,
+    ...Object.fromEntries(extraIgnores?.map(k => [k, !0]) || [])
+  },
+  hasWarnedForModules = /* @__PURE__ */new Set(),
+  allowedIgnores = {
+    "expo-constants": !0,
+    "./ExpoHaptics": !0,
+    "./js/MaskedView": !0
+  };
+export { getNameToPaths, registerRequire, setRequireResult };

package/dist/esm/server.mjs

@@ -0,0 +1,40 @@
+import net from "node:net";
+async function startServer(options) {
+  const port = await getAvailablePort(),
+    server = net.createServer();
+  server.unref(), await new Promise((resolve, reject) => {
+    server.on("error", reject), server.on("connection", conn => {
+      conn.on("data", data => {
+        console.info("got", data.toString());
+      });
+    }), server.listen({
+      port
+    }, () => {
+      const {
+        port: port2
+      } = server.address();
+      server.close(() => {
+        resolve(port2);
+      });
+    });
+  });
+}
+async function getAvailablePort(port = 8089) {
+  return checkAvailablePort(port).catch(() => getAvailablePort(port + 1));
+}
+function checkAvailablePort(port) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref(), server.on("error", reject), server.listen({
+      port
+    }, () => {
+      const {
+        port: port2
+      } = server.address();
+      server.close(() => {
+        resolve(port2);
+      });
+    });
+  });
+}
+export { startServer };

package/dist/esm/setup.mjs

@@ -0,0 +1 @@
+process.env.IS_STATIC = "is_static";