@xaui/native 0.9.1-alpha.0 → 0.9.1-alpha.2

package/dist/chunk-B755PRVJ.cjs

@@ -0,0 +1,274 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkM7P46XKIcjs = require('./chunk-M7P46XKI.cjs');
+
+// src/system/recipe/resolve-tint.ts
+var TINT_SLICE_BY_SUFFIX = [
+  [/SoftForeground$/, "softForeground"],
+  [/SoftPressed$/, "softPressed"],
+  [/Soft$/, "soft"],
+  [/Foreground$/, "foreground"],
+  [/Pressed$/, "pressed"]
+];
+function tintSliceFor(token) {
+  for (const [suffix, slice] of TINT_SLICE_BY_SUFFIX) {
+    if (suffix.test(token)) return slice;
+  }
+  return "base";
+}
+function resolveTint(tokens, color, theme) {
+  const tint = _chunkM7P46XKIcjs.deriveTint.call(void 0, color, theme);
+  const colors = {};
+  for (const [role, token] of Object.entries(_nullishCoalesce(tokens, () => ( {})))) {
+    colors[role] = tint[tintSliceFor(token)];
+  }
+  return colors;
+}
+
+// src/system/recipe/style-cache.ts
+var _reactnative = require('react-native');
+
+// src/system/recipe/variant-map.ts
+var STATE_ORDER = ["focused", "pressed", "disabled"];
+function resolveSelection(defaultVariants, selection) {
+  const resolved = { ...defaultVariants };
+  for (const [axis, value] of Object.entries(_nullishCoalesce(selection, () => ( {})))) {
+    if (value !== void 0) resolved[axis] = value;
+  }
+  return resolved;
+}
+function resolveVariantColors(tokens, theme) {
+  const colors = {};
+  for (const [role, token] of entriesOf(tokens)) {
+    const value = theme.colors[token];
+    if (value === void 0) {
+      throw new Error(
+        `XAUI: the recipe names "${token}" for its "${role}" role, but the theme has no such colour token. Check the spelling against XAUIColors.`
+      );
+    }
+    colors[role] = value;
+  }
+  return colors;
+}
+function activeStateFns(states, active) {
+  const fns = [];
+  for (const state of STATE_ORDER) {
+    const fn = active[state] ? _optionalChain([states, 'optionalAccess', _ => _[state]]) : void 0;
+    if (fn) fns.push(fn);
+  }
+  return fns;
+}
+function collectStyleFns(config, selection, states) {
+  const fns = [];
+  if (config.base) fns.push(config.base);
+  if (config.paint) fns.push(config.paint);
+  for (const [axis, values] of Object.entries(_nullishCoalesce(config.variants, () => ( {})))) {
+    const value = selection[axis];
+    const fn = value === void 0 ? void 0 : values[value];
+    if (fn) fns.push(fn);
+  }
+  for (const compound of _nullishCoalesce(config.compoundVariants, () => ( []))) {
+    if (appliesTo(compound.when, selection)) fns.push(compound.style);
+  }
+  return [...fns, ...activeStateFns(config.states, states)];
+}
+function appliesTo(when, selection) {
+  return Object.entries(when).every(([axis, value]) => selection[axis] === value);
+}
+function entriesOf(tokens) {
+  return Object.entries(_nullishCoalesce(tokens, () => ( {})));
+}
+
+// src/system/recipe/style-cache.ts
+function createStyleCache(slots) {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    read(key, build) {
+      const hit = entries.get(key);
+      if (hit) return hit;
+      const built = build();
+      const complete = {};
+      for (const slot of slots) complete[slot] = _nullishCoalesce(built[slot], () => ( {}));
+      const created = _reactnative.StyleSheet.create(complete);
+      entries.set(key, created);
+      return created;
+    },
+    get size() {
+      return entries.size;
+    },
+    clear() {
+      entries.clear();
+    }
+  };
+}
+function cacheKey(theme, selection, states) {
+  const axes = Object.keys(selection).sort().map((axis) => `${axis}:${_nullishCoalesce(selection[axis], () => ( "-"))}`).join("|");
+  const active = STATE_ORDER.filter((state) => states[state]).join(",");
+  return `${theme.id}|${theme.mode}|${axes}|${active}`;
+}
+
+// src/system/recipe/create-recipe.ts
+function createRecipe(config) {
+  const cache = createStyleCache(config.slots);
+  const tokensFor = (variant) => variant === void 0 ? void 0 : _optionalChain([config, 'access', _2 => _2.variantTokens, 'optionalAccess', _3 => _3[variant]]);
+  return {
+    slots: config.slots,
+    resolve({ theme, selection, states = {} }) {
+      const resolved = resolveSelection(config.defaultVariants, selection);
+      return cache.read(cacheKey(theme, resolved, states), () => {
+        const colors = resolveVariantColors(tokensFor(resolved.variant), theme);
+        return apply(collectStyleFns(config, resolved, states), theme, colors);
+      });
+    },
+    tint({ theme, color, selection, states = {} }) {
+      if (!config.paint) return {};
+      const resolved = resolveSelection(config.defaultVariants, selection);
+      const tokens = tokensFor(resolved.variant);
+      if (!tokens) return {};
+      const colors = resolveTint(tokens, color, theme);
+      const fns = [config.paint, ...activeStateFns(config.states, states)];
+      return apply(fns, theme, colors);
+    }
+  };
+}
+function apply(fns, theme, colors) {
+  const merged = {};
+  for (const fn of fns) {
+    const produced = fn(theme, colors);
+    for (const slot of Object.keys(produced)) {
+      const style = produced[slot];
+      if (!style) continue;
+      const previous = merged[slot];
+      merged[slot] = previous ? { ...previous, ...style } : style;
+    }
+  }
+  return merged;
+}
+
+// src/system/slot/children-to-string.ts
+var _react = require('react');
+function childrenToString(children) {
+  const text = stringify(children);
+  return text === null || text === "" ? null : text;
+}
+function stringify(node) {
+  if (node === null || node === void 0 || typeof node === "boolean") return "";
+  if (typeof node === "string") return node;
+  if (typeof node === "number") return String(node);
+  if (_react.isValidElement.call(void 0, node)) return null;
+  if (Array.isArray(node)) {
+    let text = "";
+    for (const child of node) {
+      const part = stringify(child);
+      if (part === null) return null;
+      text += part;
+    }
+    return text;
+  }
+  return null;
+}
+
+// src/system/slot/create-slot-context.ts
+
+function createSlotContext(name) {
+  const Context = _react.createContext.call(void 0, null);
+  Context.displayName = `XAUI.${name}.Context`;
+  function useSlotContext() {
+    const value = _react.useContext.call(void 0, Context);
+    if (value === null) {
+      const error = new Error(
+        `XAUI: use${name} must be called inside <${name}>. A slot reads the values its root resolved, so it can only be rendered as a child of one.`
+      );
+      _optionalChain([Error, 'access', _4 => _4.captureStackTrace, 'optionalCall', _5 => _5(
+        error,
+        useSlotContext
+      )]);
+      throw error;
+    }
+    return value;
+  }
+  return [Context.Provider, useSlotContext];
+}
+
+// src/system/slot/merge-refs.ts
+function mergeRefs(...refs) {
+  return (value) => {
+    for (const ref of refs) {
+      if (typeof ref === "function") ref(value);
+      else if (ref) ref.current = value;
+    }
+  };
+}
+
+// src/system/slot/merge-props.ts
+var EVENT_HANDLER = /^on[A-Z]/;
+function mergeProps(ours, theirs) {
+  const merged = { ...ours };
+  for (const key of Object.keys(theirs)) {
+    const ourValue = ours[key];
+    const theirValue = theirs[key];
+    if (EVENT_HANDLER.test(key)) {
+      merged[key] = composeHandlers(ourValue, theirValue);
+    } else if (key === "style") {
+      merged[key] = mergeStyles(ourValue, theirValue);
+    } else if (key === "ref") {
+      merged[key] = mergeRefs(
+        ourValue,
+        theirValue
+      );
+    } else {
+      merged[key] = theirValue;
+    }
+  }
+  return merged;
+}
+function composeHandlers(ours, theirs) {
+  if (typeof ours !== "function") return theirs;
+  if (typeof theirs !== "function") return ours;
+  return (...args) => {
+    ;
+    ours(...args);
+    return theirs(...args);
+  };
+}
+function mergeStyles(ours, theirs) {
+  if (typeof ours === "function" || typeof theirs === "function") {
+    return (state) => [
+      resolveStyle(ours, state),
+      resolveStyle(theirs, state)
+    ];
+  }
+  return [ours, theirs];
+}
+function resolveStyle(style, state) {
+  return typeof style === "function" ? style(state) : style;
+}
+
+// src/system/slot/slot.tsx
+
+var Slot = _react.forwardRef.call(void 0, function Slot2({ children, ...ours }, ref) {
+  if (!_react.isValidElement.call(void 0, children)) {
+    throw new Error(
+      "XAUI: asChild expects exactly one React element as its child, and merges the component's props into it. Text, a fragment, several children or none give it nothing to merge into \u2014 drop `asChild` to render the component itself."
+    );
+  }
+  const child = children;
+  const merged = mergeProps(ours, child.props);
+  merged.ref = mergeRefs(ref, refOf(child));
+  return _react.cloneElement.call(void 0, child, merged);
+});
+Slot.displayName = "XAUI.Slot";
+function refOf(element) {
+  const fromProps = element.props.ref;
+  const fromElement = element.ref;
+  return _nullishCoalesce(fromProps, () => ( fromElement));
+}
+
+
+
+
+
+
+
+
+exports.createRecipe = createRecipe; exports.childrenToString = childrenToString; exports.createSlotContext = createSlotContext; exports.mergeRefs = mergeRefs; exports.mergeProps = mergeProps; exports.Slot = Slot;

package/dist/chunk-M7P46XKI.cjs

@@ -0,0 +1,100 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/colors.ts
+var srgbToLinear = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+var linearToSrgb = (c) => c <= 31308e-7 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - 0.055;
+var clamp01 = (n) => Math.min(1, Math.max(0, n));
+var HEX = /^#?(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+function isHex(value) {
+  return HEX.test(value);
+}
+function hexToRgb(hex) {
+  if (!isHex(hex)) {
+    throw new Error(
+      `XAUI: "${hex}" is not a hex colour. Tokens that feed mix() and alpha() must be #rgb or #rrggbb \u2014 named colours and rgb()/rgba() values cannot be blended.`
+    );
+  }
+  const raw = hex.replace("#", "");
+  const full = raw.length === 3 ? raw.split("").map((c) => c + c).join("") : raw;
+  return [
+    parseInt(full.slice(0, 2), 16) / 255,
+    parseInt(full.slice(2, 4), 16) / 255,
+    parseInt(full.slice(4, 6), 16) / 255
+  ];
+}
+function rgbToHex([r, g, b]) {
+  const to = (n) => Math.round(clamp01(n) * 255).toString(16).padStart(2, "0");
+  return `#${to(r)}${to(g)}${to(b)}`;
+}
+function rgbToOklab([r, g, b]) {
+  const R = srgbToLinear(r);
+  const G = srgbToLinear(g);
+  const B = srgbToLinear(b);
+  const l = Math.cbrt(0.4122214708 * R + 0.5363325363 * G + 0.0514459929 * B);
+  const m = Math.cbrt(0.2119034982 * R + 0.6806995451 * G + 0.1073969566 * B);
+  const s = Math.cbrt(0.0883024619 * R + 0.2817188376 * G + 0.6299787005 * B);
+  return [
+    0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
+  ];
+}
+function oklabToRgb([L, a, b]) {
+  const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+  const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+  const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
+  return [
+    clamp01(linearToSrgb(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s)),
+    clamp01(linearToSrgb(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s)),
+    clamp01(linearToSrgb(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s))
+  ];
+}
+function mix(base, other, amount) {
+  const from = rgbToOklab(hexToRgb(base));
+  const to = rgbToOklab(hexToRgb(other));
+  return rgbToHex(
+    oklabToRgb([
+      from[0] + (to[0] - from[0]) * amount,
+      from[1] + (to[1] - from[1]) * amount,
+      from[2] + (to[2] - from[2]) * amount
+    ])
+  );
+}
+function alpha(hex, amount) {
+  const [r, g, b] = hexToRgb(hex).map((v) => Math.round(v * 255));
+  return `rgba(${r}, ${g}, ${b}, ${amount})`;
+}
+function lightnessOf(hex) {
+  return rgbToOklab(hexToRgb(hex))[0];
+}
+function contrastOn(hex, light, dark) {
+  return lightnessOf(hex) > 0.62 ? dark : light;
+}
+
+// src/theme/derive-tint.ts
+var cache = /* @__PURE__ */ new Map();
+function deriveTint(tint, theme) {
+  const key = `${theme.id}|${theme.mode}|${tint}`;
+  const hit = cache.get(key);
+  if (hit) return hit;
+  if (!isHex(tint)) {
+    throw new Error(
+      `XAUI: color="${tint}" must be a hex value (#rgb or #rrggbb). A tint's contrasted, soft and pressed slices are derived in OKLab, which cannot read rgba() or a named colour. Pass the hex here and put the transparency in \`style\`.`
+    );
+  }
+  const foreground = contrastOn(tint, theme.colors.snow, theme.colors.eclipse);
+  const derived = {
+    base: tint,
+    foreground,
+    soft: alpha(tint, 0.15),
+    softForeground: mix(tint, theme.colors.foreground, 0.2),
+    pressed: mix(tint, foreground, 0.1),
+    softPressed: alpha(tint, 0.2)
+  };
+  cache.set(key, derived);
+  return derived;
+}
+
+
+
+
+
+exports.mix = mix; exports.alpha = alpha; exports.deriveTint = deriveTint;

package/dist/{chunk-JDS6KGCM.cjs → chunk-NHPQQQ7P.cjs}

@@ -1,4 +1,9 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/provider/xaui-provider.tsx
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkM7P46XKIcjs = require('./chunk-M7P46XKI.cjs');
+
+// src/provider/xaui-provider.tsx
 var _reactnative = require('react-native');
 
 // src/utils/stable-hash.ts
@@ -18,103 +23,41 @@ function stableHash(value) {
   return hash.toString(36);
 }
 
-// src/utils/colors.ts
-var srgbToLinear = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
-var linearToSrgb = (c) => c <= 31308e-7 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - 0.055;
-var clamp01 = (n) => Math.min(1, Math.max(0, n));
-var HEX = /^#?(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
-function hexToRgb(hex) {
-  if (!HEX.test(hex)) {
-    throw new Error(
-      `XAUI: "${hex}" is not a hex colour. Tokens that feed mix() and alpha() must be #rgb or #rrggbb \u2014 named colours and rgb()/rgba() values cannot be blended.`
-    );
-  }
-  const raw = hex.replace("#", "");
-  const full = raw.length === 3 ? raw.split("").map((c) => c + c).join("") : raw;
-  return [
-    parseInt(full.slice(0, 2), 16) / 255,
-    parseInt(full.slice(2, 4), 16) / 255,
-    parseInt(full.slice(4, 6), 16) / 255
-  ];
-}
-function rgbToHex([r, g, b]) {
-  const to = (n) => Math.round(clamp01(n) * 255).toString(16).padStart(2, "0");
-  return `#${to(r)}${to(g)}${to(b)}`;
-}
-function rgbToOklab([r, g, b]) {
-  const R = srgbToLinear(r);
-  const G = srgbToLinear(g);
-  const B = srgbToLinear(b);
-  const l = Math.cbrt(0.4122214708 * R + 0.5363325363 * G + 0.0514459929 * B);
-  const m = Math.cbrt(0.2119034982 * R + 0.6806995451 * G + 0.1073969566 * B);
-  const s = Math.cbrt(0.0883024619 * R + 0.2817188376 * G + 0.6299787005 * B);
-  return [
-    0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
-    1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
-    0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
-  ];
-}
-function oklabToRgb([L, a, b]) {
-  const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;
-  const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;
-  const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
-  return [
-    clamp01(linearToSrgb(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s)),
-    clamp01(linearToSrgb(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s)),
-    clamp01(linearToSrgb(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s))
-  ];
-}
-function mix(base, other, amount) {
-  const from = rgbToOklab(hexToRgb(base));
-  const to = rgbToOklab(hexToRgb(other));
-  return rgbToHex(
-    oklabToRgb([
-      from[0] + (to[0] - from[0]) * amount,
-      from[1] + (to[1] - from[1]) * amount,
-      from[2] + (to[2] - from[2]) * amount
-    ])
-  );
-}
-function alpha(hex, amount) {
-  const [r, g, b] = hexToRgb(hex).map((v) => Math.round(v * 255));
-  return `rgba(${r}, ${g}, ${b}, ${amount})`;
-}
-
 // src/theme/derive-colors.ts
 function deriveColors(s) {
   return {
-    accentPressed: mix(s.accent, s.accentForeground, 0.1),
-    successPressed: mix(s.success, s.successForeground, 0.1),
-    warningPressed: mix(s.warning, s.warningForeground, 0.1),
-    dangerPressed: mix(s.danger, s.dangerForeground, 0.1),
-    defaultPressed: mix(s.default, s.defaultForeground, 0.04),
-    surfacePressed: mix(s.surface, s.surfaceForeground, 0.08),
-    defaultSoft: alpha(s.default, 0.5),
+    accentPressed: _chunkM7P46XKIcjs.mix.call(void 0, s.accent, s.accentForeground, 0.1),
+    successPressed: _chunkM7P46XKIcjs.mix.call(void 0, s.success, s.successForeground, 0.1),
+    warningPressed: _chunkM7P46XKIcjs.mix.call(void 0, s.warning, s.warningForeground, 0.1),
+    dangerPressed: _chunkM7P46XKIcjs.mix.call(void 0, s.danger, s.dangerForeground, 0.1),
+    defaultPressed: _chunkM7P46XKIcjs.mix.call(void 0, s.default, s.defaultForeground, 0.04),
+    surfacePressed: _chunkM7P46XKIcjs.mix.call(void 0, s.surface, s.surfaceForeground, 0.08),
+    defaultSoft: _chunkM7P46XKIcjs.alpha.call(void 0, s.default, 0.5),
     defaultSoftForeground: s.defaultForeground,
-    defaultSoftPressed: alpha(s.default, 0.6),
-    accentSoft: alpha(s.accent, 0.15),
-    accentSoftForeground: mix(s.accent, s.foreground, 0.2),
-    accentSoftPressed: alpha(s.accent, 0.2),
-    successSoft: alpha(s.success, 0.15),
-    successSoftForeground: mix(s.success, s.foreground, 0.3),
-    successSoftPressed: alpha(s.success, 0.2),
-    warningSoft: alpha(s.warning, 0.15),
-    warningSoftForeground: mix(s.warning, s.foreground, 0.35),
-    warningSoftPressed: alpha(s.warning, 0.2),
-    dangerSoft: alpha(s.danger, 0.15),
-    dangerSoftForeground: mix(s.danger, s.foreground, 0.2),
-    dangerSoftPressed: alpha(s.danger, 0.2),
-    backgroundSecondary: mix(s.background, s.foreground, 0.04),
-    backgroundTertiary: mix(s.background, s.foreground, 0.08),
+    defaultSoftPressed: _chunkM7P46XKIcjs.alpha.call(void 0, s.default, 0.6),
+    accentSoft: _chunkM7P46XKIcjs.alpha.call(void 0, s.accent, 0.15),
+    accentSoftForeground: _chunkM7P46XKIcjs.mix.call(void 0, s.accent, s.foreground, 0.2),
+    accentSoftPressed: _chunkM7P46XKIcjs.alpha.call(void 0, s.accent, 0.2),
+    successSoft: _chunkM7P46XKIcjs.alpha.call(void 0, s.success, 0.15),
+    successSoftForeground: _chunkM7P46XKIcjs.mix.call(void 0, s.success, s.foreground, 0.3),
+    successSoftPressed: _chunkM7P46XKIcjs.alpha.call(void 0, s.success, 0.2),
+    warningSoft: _chunkM7P46XKIcjs.alpha.call(void 0, s.warning, 0.15),
+    warningSoftForeground: _chunkM7P46XKIcjs.mix.call(void 0, s.warning, s.foreground, 0.35),
+    warningSoftPressed: _chunkM7P46XKIcjs.alpha.call(void 0, s.warning, 0.2),
+    dangerSoft: _chunkM7P46XKIcjs.alpha.call(void 0, s.danger, 0.15),
+    dangerSoftForeground: _chunkM7P46XKIcjs.mix.call(void 0, s.danger, s.foreground, 0.2),
+    dangerSoftPressed: _chunkM7P46XKIcjs.alpha.call(void 0, s.danger, 0.2),
+    backgroundSecondary: _chunkM7P46XKIcjs.mix.call(void 0, s.background, s.foreground, 0.04),
+    backgroundTertiary: _chunkM7P46XKIcjs.mix.call(void 0, s.background, s.foreground, 0.08),
     backgroundInverse: s.foreground,
-    borderSecondary: mix(s.surface, s.surfaceForeground, 0.22),
-    borderTertiary: mix(s.surface, s.surfaceForeground, 0.34),
-    separatorSecondary: mix(s.surface, s.surfaceForeground, 0.15),
-    separatorTertiary: mix(s.surface, s.surfaceForeground, 0.19),
-    fieldPressed: mix(s.fieldBackground, s.fieldForeground, 0.1),
+    borderSecondary: _chunkM7P46XKIcjs.mix.call(void 0, s.surface, s.surfaceForeground, 0.22),
+    borderTertiary: _chunkM7P46XKIcjs.mix.call(void 0, s.surface, s.surfaceForeground, 0.34),
+    separatorSecondary: _chunkM7P46XKIcjs.mix.call(void 0, s.surface, s.surfaceForeground, 0.15),
+    separatorTertiary: _chunkM7P46XKIcjs.mix.call(void 0, s.surface, s.surfaceForeground, 0.19),
+    fieldPressed: _chunkM7P46XKIcjs.mix.call(void 0, s.fieldBackground, s.fieldForeground, 0.1),
     fieldFocus: s.fieldBackground,
-    fieldBorderPressed: mix(s.fieldBorder, s.fieldForeground, 0.12),
-    fieldBorderFocus: mix(s.fieldBorder, s.fieldForeground, 0.26)
+    fieldBorderPressed: _chunkM7P46XKIcjs.mix.call(void 0, s.fieldBorder, s.fieldForeground, 0.12),
+    fieldBorderFocus: _chunkM7P46XKIcjs.mix.call(void 0, s.fieldBorder, s.fieldForeground, 0.26)
   };
 }
 

package/dist/{chunk-T3ZI2PZ6.js → chunk-PBVPOX7D.js}

@@ -1,3 +1,8 @@
+import {
+  alpha,
+  mix
+} from "./chunk-RBNCR5KB.js";
+
 // src/provider/xaui-provider.tsx
 import { useColorScheme } from "react-native";
 
@@ -18,68 +23,6 @@ function stableHash(value) {
   return hash.toString(36);
 }
 
-// src/utils/colors.ts
-var srgbToLinear = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
-var linearToSrgb = (c) => c <= 31308e-7 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - 0.055;
-var clamp01 = (n) => Math.min(1, Math.max(0, n));
-var HEX = /^#?(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
-function hexToRgb(hex) {
-  if (!HEX.test(hex)) {
-    throw new Error(
-      `XAUI: "${hex}" is not a hex colour. Tokens that feed mix() and alpha() must be #rgb or #rrggbb \u2014 named colours and rgb()/rgba() values cannot be blended.`
-    );
-  }
-  const raw = hex.replace("#", "");
-  const full = raw.length === 3 ? raw.split("").map((c) => c + c).join("") : raw;
-  return [
-    parseInt(full.slice(0, 2), 16) / 255,
-    parseInt(full.slice(2, 4), 16) / 255,
-    parseInt(full.slice(4, 6), 16) / 255
-  ];
-}
-function rgbToHex([r, g, b]) {
-  const to = (n) => Math.round(clamp01(n) * 255).toString(16).padStart(2, "0");
-  return `#${to(r)}${to(g)}${to(b)}`;
-}
-function rgbToOklab([r, g, b]) {
-  const R = srgbToLinear(r);
-  const G = srgbToLinear(g);
-  const B = srgbToLinear(b);
-  const l = Math.cbrt(0.4122214708 * R + 0.5363325363 * G + 0.0514459929 * B);
-  const m = Math.cbrt(0.2119034982 * R + 0.6806995451 * G + 0.1073969566 * B);
-  const s = Math.cbrt(0.0883024619 * R + 0.2817188376 * G + 0.6299787005 * B);
-  return [
-    0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
-    1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
-    0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
-  ];
-}
-function oklabToRgb([L, a, b]) {
-  const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;
-  const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;
-  const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
-  return [
-    clamp01(linearToSrgb(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s)),
-    clamp01(linearToSrgb(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s)),
-    clamp01(linearToSrgb(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s))
-  ];
-}
-function mix(base, other, amount) {
-  const from = rgbToOklab(hexToRgb(base));
-  const to = rgbToOklab(hexToRgb(other));
-  return rgbToHex(
-    oklabToRgb([
-      from[0] + (to[0] - from[0]) * amount,
-      from[1] + (to[1] - from[1]) * amount,
-      from[2] + (to[2] - from[2]) * amount
-    ])
-  );
-}
-function alpha(hex, amount) {
-  const [r, g, b] = hexToRgb(hex).map((v) => Math.round(v * 255));
-  return `rgba(${r}, ${g}, ${b}, ${amount})`;
-}
-
 // src/theme/derive-colors.ts
 function deriveColors(s) {
   return {