@kbach/react 0.5.46 → 0.5.48

package/README.md

@@ -334,7 +334,7 @@ Opacity modifier: `bg-blue-6/50` (50% alpha), `bg-blue-6/[0.15]` (arbitrary)
 
 Included automatically in `kbach.css` and in runtime injection:
 
-- `*, *::before, *::after { box-sizing: border-box }`
+- `*, *::before, *::after { box-sizing: border-box; border-width: 0; border-style: solid; border-color: currentColor }` — border utilities like `border-2 border-gray-4` work on any element without also needing `border-solid`
 - `body { margin: 0; padding: 0 }`
 - `h1–h6` — margin, font-size, font-weight cleared (inherit from parent)
 - `p`, `ul`, `ol` — margin and list style cleared

package/dist/{chunk-G76344ZQ.mjs → chunk-BKSXIWL7.mjs}

@@ -716,7 +716,12 @@ function resolveColor(value, colors, isArbitrary) {
     }
   }
   if (!hex) return null;
-  if (!opacityPart) return hex;
+  if (!opacityPart) {
+    if (!isWeb && hex.startsWith("#") && hex.length === 9) {
+      return hexToRgba(hex, Math.round(parseInt(hex.slice(7, 9), 16) / 255 * 1e3) / 1e3);
+    }
+    return hex;
+  }
   let alpha;
   if (opacityPart.startsWith("[") && opacityPart.endsWith("]")) {
     const v = parseFloat(opacityPart.slice(1, -1));
@@ -2279,12 +2284,6 @@ var RESOLVERS = {
 function resolveUtility(parsed, theme) {
   if (!parsed.value) {
     if (parsed.utility in PLUGIN_STANDALONE) return PLUGIN_STANDALONE[parsed.utility] ?? null;
-    if (parsed.utility === "grd" || parsed.utility === "grid") {
-      return getEffectiveIsWeb() ? { display: "grid" } : null;
-    }
-    if (parsed.utility === "inline-grid") {
-      return getEffectiveIsWeb() ? { display: "inline-grid" } : null;
-    }
     if (parsed.utility in getStandalone()) return getStandalone()[parsed.utility] ?? null;
   }
   const resolver = PLUGIN_RESOLVERS[parsed.utility] ?? RESOLVERS[parsed.utility];
@@ -2435,16 +2434,18 @@ function findOuterColon(s) {
 
 // src/core/reset.ts
 var BASE_RESET = [
-  "*, *::before, *::after { box-sizing: border-box; }",
+  // border-style: solid means border-N utilities show a visible border without an extra border-solid class.
+  // border-width: 0 keeps all elements borderless by default.
+  "*, *::before, *::after { box-sizing: border-box; border-width: 0; border-style: solid; border-color: currentColor; }",
   "body { margin: 0; padding: 0; }",
   "h1, h2, h3, h4, h5, h6 { margin: 0; font-size: inherit; font-weight: inherit; }",
   "p { margin: 0; }",
   "a { color: inherit; text-decoration: none; }",
   "ul, ol { margin: 0; padding: 0; list-style: none; }",
   "img, video, svg { display: block; max-width: 100%; }",
-  "input, textarea, select { appearance: none; -webkit-appearance: none; background: transparent; border: 0; padding: 0; margin: 0; font: inherit; color: inherit; line-height: inherit; }",
-  "button { appearance: none; -webkit-appearance: none; background: transparent; border: 0; padding: 0; margin: 0; font: inherit; color: inherit; cursor: pointer; line-height: inherit; text-align: inherit; }",
-  "fieldset { border: 0; padding: 0; margin: 0; }",
+  "input, textarea, select { appearance: none; -webkit-appearance: none; background: transparent; padding: 0; margin: 0; font: inherit; color: inherit; line-height: inherit; }",
+  "button { appearance: none; -webkit-appearance: none; background: transparent; padding: 0; margin: 0; font: inherit; color: inherit; cursor: pointer; line-height: inherit; text-align: inherit; }",
+  "fieldset { padding: 0; margin: 0; }",
   "table { border-collapse: collapse; border-spacing: 0; }"
 ].join("\n");
 
@@ -2939,6 +2940,8 @@ function buildConfig(userConfig) {
   };
   clearPluginUtilities();
   clearPluginModifiers();
+  const _store = getConfigStore();
+  for (const k of Object.keys(_store.customVariants)) delete _store.customVariants[k];
   const pluginAPI = makePluginAPI(resolved.theme);
   for (const plugin of resolved.plugins) {
     plugin(pluginAPI);

package/dist/chunk-YZNSWFJT.mjs

@@ -0,0 +1,544 @@
+import {
+  flatten,
+  getActiveBreakpoints,
+  getConfig,
+  getDefaultFontFamily,
+  getGlobalWidth,
+  getInteractiveModifiers,
+  getModeModifiers,
+  getResponsiveModifiers,
+  isNative,
+  isRuntimeCSSDisabled,
+  isWeb,
+  normalizeClassString,
+  resolve,
+  subscribeGlobalWidth
+} from "./chunk-BKSXIWL7.mjs";
+
+// src/jsx-runtime.tsx
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment } from "react";
+
+// src/core/darkModeStore.ts
+var KEY = "__kbach_dark_store__";
+function getStore() {
+  const g = globalThis;
+  if (!g[KEY]) {
+    g[KEY] = { isDark: false, lastNotified: false, subscribers: /* @__PURE__ */ new Set() };
+  }
+  return g[KEY];
+}
+function syncGlobalDarkMode(isDark) {
+  getStore().isDark = isDark;
+}
+function setGlobalDarkMode(isDark) {
+  const store = getStore();
+  store.isDark = isDark;
+  if (store.lastNotified === isDark) return;
+  store.lastNotified = isDark;
+  for (const sub of store.subscribers) sub();
+}
+function getGlobalDarkMode() {
+  return getStore().isDark;
+}
+function subscribeGlobalDarkMode(callback) {
+  const store = getStore();
+  store.subscribers.add(callback);
+  return () => store.subscribers.delete(callback);
+}
+
+// src/InteractiveWrapper.tsx
+import React3, { forwardRef, useState, useCallback, useMemo } from "react";
+
+// src/useGlobalDarkMode.ts
+import React from "react";
+var useSyncExternalStore = React.useSyncExternalStore ?? function useSyncExternalStoreFallback(subscribe, getSnapshot, _getServerSnapshot) {
+  const [, forceUpdate] = React.useReducer((n) => n + 1, 0);
+  React.useEffect(() => subscribe(forceUpdate), [subscribe]);
+  return getSnapshot();
+};
+function useGlobalDarkMode() {
+  return useSyncExternalStore(
+    subscribeGlobalDarkMode,
+    getGlobalDarkMode,
+    () => false
+    // SSR: default light
+  );
+}
+
+// src/useGlobalWidth.ts
+import React2 from "react";
+var useSyncExternalStore2 = React2.useSyncExternalStore ?? function useSyncExternalStoreFallback2(subscribe, getSnapshot, _getServerSnapshot) {
+  const [, forceUpdate] = React2.useReducer((n) => n + 1, 0);
+  React2.useEffect(() => subscribe(forceUpdate), [subscribe]);
+  return getSnapshot();
+};
+var NOOP_SUB = (_) => () => {
+};
+var ZERO_SNAP = () => 0;
+var EMPTY_BREAKPOINTS = /* @__PURE__ */ new Set();
+var _webListeners = null;
+var _webRaf = 0;
+function _webResizeHandler() {
+  cancelAnimationFrame(_webRaf);
+  _webRaf = requestAnimationFrame(() => {
+    if (_webListeners) for (const cb of _webListeners) cb();
+  });
+}
+function subscribeWebWidth(cb) {
+  if (typeof window === "undefined") return () => {
+  };
+  if (!_webListeners) {
+    _webListeners = /* @__PURE__ */ new Set();
+    window.addEventListener("resize", _webResizeHandler);
+  }
+  _webListeners.add(cb);
+  return () => {
+    _webListeners.delete(cb);
+    if (_webListeners.size === 0) {
+      window.removeEventListener("resize", _webResizeHandler);
+      cancelAnimationFrame(_webRaf);
+      _webListeners = null;
+    }
+  };
+}
+function getWebWidth() {
+  return typeof window !== "undefined" ? window.innerWidth : 0;
+}
+function useGlobalWidth() {
+  return useSyncExternalStore2(
+    isWeb ? subscribeWebWidth : subscribeGlobalWidth,
+    isWeb ? getWebWidth : getGlobalWidth,
+    ZERO_SNAP
+  );
+}
+function useConditionalWidth(active) {
+  return useSyncExternalStore2(
+    active ? isWeb ? subscribeWebWidth : subscribeGlobalWidth : NOOP_SUB,
+    active ? isWeb ? getWebWidth : getGlobalWidth : ZERO_SNAP,
+    ZERO_SNAP
+  );
+}
+
+// src/shared-utils.ts
+function hasResponsiveBuckets(resolved) {
+  const responsiveMods = getResponsiveModifiers();
+  for (const key of Object.keys(resolved)) {
+    if (key === "base") continue;
+    for (const mod of key.split(":")) {
+      if (responsiveMods.has(mod)) return true;
+    }
+  }
+  return false;
+}
+function hasInteractiveBuckets(resolved) {
+  const interactiveMods = getInteractiveModifiers();
+  for (const key of Object.keys(resolved)) {
+    if (key === "base") continue;
+    for (const mod of key.split(":")) {
+      if (interactiveMods.has(mod)) return true;
+    }
+  }
+  return false;
+}
+var EMPTY_BREAKPOINTS2 = /* @__PURE__ */ new Set();
+
+// src/InteractiveWrapper.tsx
+function chain(original, extra) {
+  return (...args) => {
+    original?.(...args);
+    extra();
+  };
+}
+var InteractiveWrapper = forwardRef(
+  function InteractiveWrapper2({
+    Component,
+    resolvedStyle,
+    className,
+    style: styleProp,
+    onPressIn,
+    onPressOut,
+    onPointerDown,
+    onPointerUp,
+    onPointerLeave,
+    onMouseEnter,
+    onMouseLeave,
+    onFocus,
+    onBlur,
+    ...rest
+  }, ref) {
+    const isDark = useGlobalDarkMode();
+    const needsWidth = hasResponsiveBuckets(resolvedStyle);
+    const width = useConditionalWidth(needsWidth);
+    const breakpoints = needsWidth ? getActiveBreakpoints(width) : EMPTY_BREAKPOINTS;
+    const [pressed, setPressed] = useState(false);
+    const [hovered, setHovered] = useState(false);
+    const [focused, setFocused] = useState(false);
+    const handlePressIn = useCallback(chain(onPressIn, () => setPressed(true)), [onPressIn]);
+    const handlePressOut = useCallback(chain(onPressOut, () => setPressed(false)), [onPressOut]);
+    const handlePointerDown = useCallback(chain(onPointerDown, () => setPressed(true)), [onPointerDown]);
+    const handlePointerUp = useCallback(chain(onPointerUp, () => setPressed(false)), [onPointerUp]);
+    const handlePointerLeave = useCallback(chain(onPointerLeave, () => setPressed(false)), [onPointerLeave]);
+    const handleMouseEnter = useCallback(chain(onMouseEnter, () => setHovered(true)), [onMouseEnter]);
+    const handleMouseLeave = useCallback(chain(onMouseLeave, () => setHovered(false)), [onMouseLeave]);
+    const handleFocus = useCallback(chain(onFocus, () => setFocused(true)), [onFocus]);
+    const handleBlur = useCallback(chain(onBlur, () => setFocused(false)), [onBlur]);
+    const computedStyle = useMemo(
+      () => {
+        const s = flatten(resolvedStyle, isDark, { pressed, hover: hovered, focus: focused, disabled: !!rest.disabled, checked: !!rest.checked }, breakpoints);
+        delete s.__divideX;
+        delete s.__divideY;
+        delete s.__divideColor;
+        delete s.__divideStyle;
+        delete s.__keyframe;
+        if (typeof Component !== "string") {
+          if (s.display === "grid" || s.display === "inline-grid") delete s.display;
+          delete s.gridTemplateColumns;
+          delete s.gridTemplateRows;
+          delete s.gridColumn;
+          delete s.gridRow;
+          delete s.gridArea;
+          delete s.gridColumnStart;
+          delete s.gridColumnEnd;
+          delete s.gridRowStart;
+          delete s.gridRowEnd;
+          delete s.gridAutoFlow;
+          delete s.gridAutoColumns;
+          delete s.gridAutoRows;
+          delete s.placeItems;
+          delete s.placeContent;
+          delete s.justifyItems;
+          delete s.placeSelf;
+          delete s.justifySelf;
+          if (s.position === "sticky" || s.position === "fixed" || s.position === "static") {
+            delete s.position;
+          }
+        }
+        return s;
+      },
+      [resolvedStyle, isDark, pressed, hovered, focused, width]
+      // eslint-disable-line react-hooks/exhaustive-deps
+    );
+    const skipComputedInline = isWeb || !isNative && typeof Component === "string";
+    const finalStyle = skipComputedInline ? styleProp ?? void 0 : styleProp ? Array.isArray(styleProp) ? Object.assign({}, computedStyle, ...styleProp) : { ...computedStyle, ...styleProp } : computedStyle;
+    const { children, ...restWithoutChildren } = rest;
+    const componentProps = {
+      ref,
+      ...restWithoutChildren,
+      style: finalStyle,
+      ...!isNative && className ? { className } : {},
+      // onPressIn / onPressOut are React Native-only.
+      // On web, onPointerDown/Up drive the pressed state instead (covers mouse + touch).
+      ...!isNative ? { onPointerDown: handlePointerDown, onPointerUp: handlePointerUp, onPointerLeave: handlePointerLeave } : { onPressIn: handlePressIn, onPressOut: handlePressOut },
+      onMouseEnter: handleMouseEnter,
+      onMouseLeave: handleMouseLeave,
+      onFocus: handleFocus,
+      onBlur: handleBlur
+    };
+    return Array.isArray(children) ? React3.createElement(Component, componentProps, ...children) : React3.createElement(Component, componentProps, children);
+  }
+);
+InteractiveWrapper.displayName = "Kbach.InteractiveWrapper";
+
+// src/DarkWrapper.tsx
+import React4, { useMemo as useMemo2 } from "react";
+var DarkWrapper = React4.forwardRef(
+  function DarkWrapper2({ Component, resolvedStyle, style: styleProp, children, ...rest }, ref) {
+    const isDark = useGlobalDarkMode();
+    const needsWidth = hasResponsiveBuckets(resolvedStyle);
+    const width = useConditionalWidth(needsWidth);
+    const breakpoints = needsWidth ? getActiveBreakpoints(width) : EMPTY_BREAKPOINTS2;
+    const isNonStringComponent = typeof Component !== "string";
+    const computedStyle = useMemo2(() => {
+      const s = flatten(resolvedStyle, isDark, {}, breakpoints);
+      stripInternalMarkers(s);
+      if (isNonStringComponent) stripWebOnlyProps(s);
+      return s;
+    }, [resolvedStyle, isDark, width, isNonStringComponent]);
+    const skipComputedInline = isWeb || !isNative && typeof Component === "string";
+    const finalStyle = skipComputedInline ? styleProp ?? void 0 : styleProp ? Array.isArray(styleProp) ? Object.assign({}, computedStyle, ...styleProp) : { ...computedStyle, ...styleProp } : computedStyle;
+    const props = { ref, ...rest, style: finalStyle };
+    return Array.isArray(children) ? React4.createElement(Component, props, ...children) : React4.createElement(Component, props, children);
+  }
+);
+DarkWrapper.displayName = "Kbach.DarkWrapper";
+function stripInternalMarkers(s) {
+  delete s.__divideX;
+  delete s.__divideY;
+  delete s.__divideColor;
+  delete s.__divideStyle;
+  delete s.__keyframe;
+}
+function stripWebOnlyProps(s) {
+  if (s.display === "grid" || s.display === "inline-grid") delete s.display;
+  delete s.gridTemplateColumns;
+  delete s.gridTemplateRows;
+  delete s.gridColumn;
+  delete s.gridRow;
+  delete s.gridArea;
+  delete s.gridColumnStart;
+  delete s.gridColumnEnd;
+  delete s.gridRowStart;
+  delete s.gridRowEnd;
+  delete s.gridAutoFlow;
+  delete s.gridAutoColumns;
+  delete s.gridAutoRows;
+  delete s.placeItems;
+  delete s.placeContent;
+  delete s.justifyItems;
+  delete s.placeSelf;
+  delete s.justifySelf;
+  if (s.position === "sticky" || s.position === "fixed" || s.position === "static") {
+    delete s.position;
+  }
+}
+
+// src/jsx-runtime.tsx
+var _cachedDefaultFont = void 0;
+var _defaultFontVersion = 0;
+var _lastFontVersion = -1;
+function _invalidateDefaultFontCache() {
+  _defaultFontVersion++;
+}
+function getCachedDefaultFont() {
+  if (_lastFontVersion !== _defaultFontVersion) {
+    _cachedDefaultFont = getDefaultFontFamily();
+    _lastFontVersion = _defaultFontVersion;
+  }
+  return _cachedDefaultFont;
+}
+var _bucketModsCache = /* @__PURE__ */ new WeakMap();
+function bucketMods(resolved) {
+  const cached = _bucketModsCache.get(resolved);
+  if (cached) return cached;
+  const interactiveMods = getInteractiveModifiers();
+  const modeMods = getModeModifiers();
+  const responsiveMods = getResponsiveModifiers();
+  let interactive = false;
+  let modeOrResponsive = false;
+  for (const key of Object.keys(resolved)) {
+    if (key === "base") continue;
+    for (const mod of key.split(":")) {
+      if (!interactive && interactiveMods.has(mod)) interactive = true;
+      if (!modeOrResponsive && (modeMods.has(mod) || responsiveMods.has(mod))) modeOrResponsive = true;
+    }
+    if (interactive && modeOrResponsive) break;
+  }
+  const result = { interactive, modeOrResponsive };
+  _bucketModsCache.set(resolved, result);
+  return result;
+}
+var CONSUMED_PROPS = /* @__PURE__ */ new Set(["className", "kb", "__kbachStyles", "__kbachClasses"]);
+function omitConsumed(props) {
+  const out = {};
+  for (const key of Object.keys(props)) {
+    if (!CONSUMED_PROPS.has(key)) out[key] = props[key];
+  }
+  return out;
+}
+function mergeStyle(computed, userStyle) {
+  if (!userStyle) return computed;
+  if (Array.isArray(userStyle)) return Object.assign({}, computed, ...userStyle);
+  return { ...computed, ...userStyle };
+}
+function makeElement(isStaticChildren, type, props, key) {
+  return (isStaticChildren ? _jsxs : _jsx)(type, props, key);
+}
+function stripInternalMarkers2(s) {
+  delete s.__divideX;
+  delete s.__divideY;
+  delete s.__divideColor;
+  delete s.__divideStyle;
+  delete s.__keyframe;
+}
+function stripWebOnlyInlineProps(s) {
+  if (s.display === "grid" || s.display === "inline-grid") delete s.display;
+  delete s.gridTemplateColumns;
+  delete s.gridTemplateRows;
+  delete s.gridColumn;
+  delete s.gridRow;
+  delete s.gridArea;
+  delete s.gridColumnStart;
+  delete s.gridColumnEnd;
+  delete s.gridRowStart;
+  delete s.gridRowEnd;
+  delete s.gridAutoFlow;
+  delete s.gridAutoColumns;
+  delete s.gridAutoRows;
+  delete s.placeItems;
+  delete s.placeContent;
+  delete s.justifyItems;
+  delete s.placeSelf;
+  delete s.justifySelf;
+  if (s.position === "sticky" || s.position === "fixed" || s.position === "static") {
+    delete s.position;
+  }
+}
+var _rnToHtml = {
+  View: "div",
+  SafeAreaView: "div",
+  KeyboardAvoidingView: "div",
+  ScrollView: "div",
+  VirtualizedList: "div",
+  Text: "span",
+  Pressable: "div",
+  TouchableOpacity: "div",
+  TouchableHighlight: "div",
+  TouchableWithoutFeedback: "div",
+  TouchableNativeFeedback: "div"
+};
+var _userWebTypeMap = /* @__PURE__ */ new Map();
+var _webTypeCache = /* @__PURE__ */ new WeakMap();
+function registerWebElement(rnComponent, htmlTag) {
+  if (typeof rnComponent !== "object" && typeof rnComponent !== "function") return;
+  _userWebTypeMap.set(rnComponent, htmlTag);
+  _webTypeCache.delete(rnComponent);
+}
+function getWebTag(type) {
+  if (typeof type === "string") return null;
+  if (type === null || typeof type !== "function" && typeof type !== "object") return null;
+  const obj = type;
+  if (_userWebTypeMap.has(obj)) return _userWebTypeMap.get(obj);
+  if (_webTypeCache.has(obj)) return _webTypeCache.get(obj);
+  const name = obj.displayName ?? obj.name;
+  const tag = name ? _rnToHtml[name] ?? null : null;
+  _webTypeCache.set(obj, tag);
+  return tag;
+}
+var _rnOnlyProps = /* @__PURE__ */ new Set([
+  "onLongPress",
+  "delayLongPress",
+  "activeOpacity",
+  "underlayColor",
+  "hitSlop",
+  "pressRetentionOffset",
+  "accessible",
+  "accessibilityState",
+  "accessibilityLiveRegion",
+  "importantForAccessibility",
+  "nativeID",
+  "collapsable",
+  "needsOffscreenAlphaCompositing",
+  "renderToHardwareTextureAndroid",
+  "shouldRasterizeIOS",
+  "pointerEvents"
+  // RN prop — values differ from HTML pointer-events CSS
+]);
+var _pressableDisplayNames = /* @__PURE__ */ new Set([
+  "Pressable",
+  "TouchableOpacity",
+  "TouchableHighlight",
+  "TouchableWithoutFeedback",
+  "TouchableNativeFeedback"
+]);
+function transformToWebProps(originalName, props) {
+  const out = {};
+  const isPressable = _pressableDisplayNames.has(originalName);
+  for (const [k, v] of Object.entries(props)) {
+    if (_rnOnlyProps.has(k)) continue;
+    if (k === "onPress") {
+      if (!("onClick" in props)) out.onClick = v;
+      continue;
+    }
+    if (k === "accessibilityLabel") {
+      if (out["aria-label"] == null) out["aria-label"] = v;
+      continue;
+    }
+    if (k === "accessibilityRole") {
+      if (out.role == null) out.role = v;
+      continue;
+    }
+    if (k === "testID") {
+      if (out["data-testid"] == null) out["data-testid"] = v;
+      continue;
+    }
+    out[k] = v;
+  }
+  if (isPressable && !out.role) out.role = "button";
+  return out;
+}
+function processElement(type, rawProps, key, isStaticChildren) {
+  if (typeof type === "symbol") return makeElement(isStaticChildren, type, rawProps ?? {}, key);
+  const webTag = isWeb ? getWebTag(type) : null;
+  const effectiveType = webTag ?? type;
+  const originalName = webTag ? type?.displayName ?? type?.name : void 0;
+  if (!rawProps) return _jsx(effectiveType, null, key);
+  const workingProps = webTag && originalName ? transformToWebProps(originalName, rawProps) : rawProps;
+  const { className, kb: kbProp, __kbachStyles, __kbachClasses } = workingProps;
+  const classStr = className ?? kbProp ?? __kbachClasses;
+  if (!isNative && isRuntimeCSSDisabled() && classStr && !__kbachStyles) {
+    const { style: userStyle2, ...passProps2 } = omitConsumed(workingProps);
+    return makeElement(isStaticChildren, effectiveType, {
+      ...passProps2,
+      className: normalizeClassString(classStr),
+      ...userStyle2 !== void 0 ? { style: userStyle2 } : {}
+    }, key);
+  }
+  if (!classStr && !__kbachStyles) {
+    const defaultFont = getCachedDefaultFont();
+    if (!defaultFont) return makeElement(isStaticChildren, effectiveType, workingProps, key);
+    const { style: userStyle2, ...passProps2 } = omitConsumed(workingProps);
+    const finalStyle2 = userStyle2 ? Array.isArray(userStyle2) ? { fontFamily: defaultFont, ...Object.assign({}, ...userStyle2) } : { fontFamily: defaultFont, ...userStyle2 } : { fontFamily: defaultFont };
+    return makeElement(isStaticChildren, effectiveType, { ...passProps2, style: finalStyle2 }, key);
+  }
+  const config = getConfig();
+  const resolved = __kbachStyles ?? (classStr ? resolve(classStr, config.theme, config.darkMode) : {});
+  const { style: userStyle, ...passProps } = omitConsumed(workingProps);
+  const { interactive, modeOrResponsive } = bucketMods(resolved);
+  if (interactive) {
+    return _jsx(InteractiveWrapper, {
+      Component: effectiveType,
+      resolvedStyle: resolved,
+      ...!isNative && classStr ? { className: normalizeClassString(classStr) } : {},
+      style: userStyle,
+      ...passProps
+    }, key);
+  }
+  if (modeOrResponsive) {
+    return _jsx(DarkWrapper, {
+      Component: effectiveType,
+      resolvedStyle: resolved,
+      ...!isNative && classStr ? { className: normalizeClassString(classStr) } : {},
+      style: userStyle,
+      ...passProps
+    }, key);
+  }
+  const skipComputedInline = isWeb || !isNative && typeof effectiveType === "string";
+  let finalStyle;
+  if (!skipComputedInline) {
+    const computedStyle = flatten(resolved, false);
+    stripInternalMarkers2(computedStyle);
+    if (typeof effectiveType !== "string") stripWebOnlyInlineProps(computedStyle);
+    finalStyle = mergeStyle(computedStyle, userStyle);
+  } else {
+    finalStyle = userStyle ?? void 0;
+  }
+  return makeElement(isStaticChildren, effectiveType, {
+    ...passProps,
+    style: finalStyle,
+    ...!isNative && classStr ? { className: normalizeClassString(classStr) } : {}
+  }, key);
+}
+function jsx(type, props, key) {
+  return processElement(type, props, key, false);
+}
+function jsxs(type, props, key) {
+  return processElement(type, props, key, true);
+}
+
+export {
+  syncGlobalDarkMode,
+  setGlobalDarkMode,
+  EMPTY_BREAKPOINTS,
+  useGlobalWidth,
+  useConditionalWidth,
+  hasResponsiveBuckets,
+  hasInteractiveBuckets,
+  useGlobalDarkMode,
+  InteractiveWrapper,
+  Fragment,
+  _invalidateDefaultFontCache,
+  registerWebElement,
+  jsx,
+  jsxs
+};

package/dist/index.d.mts

@@ -2,6 +2,7 @@ import * as React from 'react';
 import React__default, { ReactNode, ComponentType, ForwardRefExoticComponent } from 'react';
 import { T as ThemeColors, a as ThemeConfig, P as ParsedClass, R as ResolvedStyle, S as StyleValue, F as FrameworkConfig, b as ResolvedConfig, c as ThemeMode } from './types-D-24rbXu.mjs';
 export { d as PluginAPI } from './types-D-24rbXu.mjs';
+export { registerWebElement } from './jsx-runtime.mjs';
 
 declare const defaultColors: ThemeColors;
 declare const defaultTheme: ThemeConfig;

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import * as React from 'react';
 import React__default, { ReactNode, ComponentType, ForwardRefExoticComponent } from 'react';
 import { T as ThemeColors, a as ThemeConfig, P as ParsedClass, R as ResolvedStyle, S as StyleValue, F as FrameworkConfig, b as ResolvedConfig, c as ThemeMode } from './types-D-24rbXu.js';
 export { d as PluginAPI } from './types-D-24rbXu.js';
+export { registerWebElement } from './jsx-runtime.js';
 
 declare const defaultColors: ThemeColors;
 declare const defaultTheme: ThemeConfig;