@tachui/modifiers/dist/index.js

Essential styling modifiers for tachUI framework

var x = Object.defineProperty;
var v = (r, o, e) => o in r ? x(r, o, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[o] = e;
var s = (r, o, e) => v(r, typeof o != "symbol" ? o + "" : o, e);
import { globalModifierRegistry as A } from "@tachui/core/modifiers/registry";
import { B as u } from "./base-CkGf4b9G.js";
import { a as yt, A as It, I as xt, L as vt, b as At } from "./base-CkGf4b9G.js";
import { ModifierPriority as St } from "@tachui/core/modifiers/types";
import { l as w, n as S, o as M, r as T, p as C, s as $, z as P } from "./overlay-DDiSLprp.js";
import { A as Tt, m as Ct, F as $t, O as Pt, q as Rt, P as Et, S as Bt, Z as Vt, d as kt, e as zt, c as Dt, h as Ot, a as Lt, b as Nt, i as Ut, f as Ht, k as jt, g as Wt, j as Ft } from "./overlay-DDiSLprp.js";
import { f as R, g as E, h as B, u as V } from "./css-CJEXRr6H.js";
import { C as qt, U as Gt, i as Zt, c as _t, d as Xt, b as Yt, e as Jt, a as Qt, o as er } from "./css-CJEXRr6H.js";
import { b as k, i as z, y as D, A as O, v as L } from "./clipped-CCW8gJqJ.js";
import { a as rr, B as ir, h as or, x as ar, z as nr, C as sr, F as dr, c as lr, d as cr, e as fr, l as pr, q as ur, n as mr, m as gr, k as br, j as hr, p as yr, t as Ir, u as xr, w as vr, f as Ar, g as wr, o as Sr, r as Mr, s as Tr } from "./clipped-CCW8gJqJ.js";
import { t as N, a as U, j as H } from "./font-3qM2Z97N.js";
import { T as $r, k as Pr, i as Rr, f as Er, d as Br, e as Vr, l as kr, o as zr, s as Dr, h as Or, c as Lr, g as Nr, b as Ur, w as Hr } from "./font-3qM2Z97N.js";
import { lineClamp as j, wordBreak as W } from "./typography/text.js";
import { HyphensModifier as Wr, LineClampModifier as Fr, OverflowWrapModifier as Kr, WordBreakModifier as qr, hyphens as Gr, overflowWrap as Zr } from "./typography/text.js";
import { u as F, l as K, m as q, n as G, i as Z, k as _, q as X, g as Y, s as J, a as Q, o as ee, b as te, c as re, d as ie, e as oe, f as ae } from "./allows-hit-testing-DscPrcOw.js";
import { A as Xr, j as Yr, F as Jr, K as Qr, p as ei, O as ti, S as ri, w as ii, v as oi, h as ai, t as ni, r as si } from "./allows-hit-testing-DscPrcOw.js";
import { padding as ne, paddingTop as se, paddingBottom as de, paddingLeft as le, paddingRight as ce, paddingLeading as fe, paddingTrailing as pe, paddingHorizontal as ue, paddingVertical as me } from "./basic/padding.js";
import { PaddingModifier as li, paddingPresets as ci } from "./basic/padding.js";
import { margin as ge, marginTop as be, marginBottom as he, marginLeft as ye, marginRight as Ie, marginLeading as xe, marginTrailing as ve, marginHorizontal as Ae, marginVertical as we } from "./basic/margin.js";
import { MarginModifier as pi, marginPresets as ui } from "./basic/margin.js";
import { size as Se, width as Me, height as Te, maxWidth as Ce, maxHeight as $e, minWidth as Pe, minHeight as Re } from "./basic/size.js";
import { SizeModifier as gi } from "./basic/size.js";
import { BaseModifier as Ee } from "./base.js";
const c = class c extends Ee {
  constructor() {
    super(...arguments);
    s(this, "type", "pseudoElement");
    s(this, "priority", 50);
  }
  apply(e, t) {
    if (!t.element) return;
    const i = `tachui-pseudo-${++c.elementCount}`;
    t.element.classList.add(i), this.properties.before && this.addPseudoElementRule(i, "before", this.properties.before), this.properties.after && this.addPseudoElementRule(i, "after", this.properties.after);
  }
  addPseudoElementRule(e, t, i) {
    const a = this.getOrCreateStyleSheet(), n = this.generatePseudoElementCSS(e, t, i);
    try {
      a.insertRule(n);
    } catch (d) {
      (typeof process > "u" || process.env.NODE_ENV !== "test") && console.warn("Failed to add pseudo-element rule:", d);
    }
  }
  generatePseudoElementCSS(e, t, i) {
    const a = `.${e}::${t}`, n = [];
    return i.content || (i.content = '""'), Object.entries(i).forEach(([d, l]) => {
      if (l !== void 0) {
        const y = this.toCSSProperty(d), I = this.formatCSSValue(d, l);
        n.push(`${y}: ${I}`);
      }
    }), `${a} { ${n.join("; ")} }`;
  }
  formatCSSValue(e, t) {
    return e === "content" ? typeof t == "string" ? !t.startsWith('"') && !t.startsWith("'") ? `"${t.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : t : '""' : typeof t == "number" ? [
      "opacity",
      "z-index",
      "line-height",
      "flex-grow",
      "flex-shrink",
      "order",
      "column-count",
      "font-weight"
    ].includes(this.toCSSProperty(e)) ? String(t) : `${t}px` : String(t);
  }
  getOrCreateStyleSheet() {
    const e = document.getElementById(
      c.styleSheetId
    );
    if (e && e instanceof HTMLStyleElement)
      return e.sheet;
    const t = document.createElement("style");
    t.id = c.styleSheetId;
    try {
      document.head.appendChild(t);
    } catch (i) {
      (typeof process > "u" || process.env.NODE_ENV !== "test") && console.warn("Failed to append stylesheet to document.head:", i);
    }
    return t.sheet;
  }
  toCSSProperty(e) {
    return e.replace(/([A-Z])/g, "-$1").toLowerCase();
  }
};
// High priority to ensure pseudo-elements are applied last
s(c, "styleSheetId", "tachui-pseudo-elements"), s(c, "elementCount", 0);
let f = c;
function p(r) {
  return new f({ before: r });
}
function m(r) {
  return new f({ after: r });
}
function Be(r) {
  return new f(r);
}
function Ve(r, o = {}) {
  return p({
    content: r,
    display: "inline-block",
    ...o
  });
}
function ke(r, o = {}) {
  return m({
    content: r,
    display: "inline-block",
    ...o
  });
}
function ze(r = "#ddd", o = 1, e = 16) {
  return p({
    content: "",
    display: "inline-block",
    width: e,
    height: o,
    backgroundColor: r,
    marginRight: 8,
    verticalAlign: "middle"
  });
}
function De(r = "#ddd", o = 1, e = 16) {
  return m({
    content: "",
    display: "inline-block",
    width: e,
    height: o,
    backgroundColor: r,
    marginLeft: 8,
    verticalAlign: "middle"
  });
}
function Oe(r = '"', o = '"') {
  return new f({
    before: {
      content: r,
      fontSize: "1.2em",
      color: "#666",
      marginRight: 4
    },
    after: {
      content: o,
      fontSize: "1.2em",
      color: "#666",
      marginLeft: 4
    }
  });
}
function Le(r = "currentColor", o = 1, e = 1) {
  return m({
    content: "",
    position: "absolute",
    bottom: 0,
    left: 0,
    right: 0,
    height: o,
    backgroundColor: r,
    opacity: e
  });
}
function Ne(r = "#ff3b30", o = 6, e = "") {
  return m({
    content: e,
    position: "absolute",
    top: -2,
    right: -2,
    width: e ? "auto" : o,
    height: o,
    minWidth: o,
    backgroundColor: r,
    borderRadius: "50%",
    fontSize: 10,
    color: "white",
    textAlign: "center",
    lineHeight: e ? o / 10 : 1,
    padding: e ? "2px 4px" : 0,
    display: "flex",
    alignItems: "center",
    justifyContent: "center"
  });
}
function Ue(r, o = "top", e = "#333", t = "white") {
  return p({
    content: r,
    position: "absolute",
    backgroundColor: e,
    color: t,
    padding: "4px 8px",
    borderRadius: 4,
    fontSize: 12,
    whiteSpace: "nowrap",
    zIndex: 1e3,
    opacity: 0,
    pointerEvents: "none",
    transition: "opacity 0.2s ease",
    ...{
      top: {
        bottom: "100%",
        left: "50%",
        transform: "translateX(-50%)",
        marginBottom: 5
      },
      bottom: {
        top: "100%",
        left: "50%",
        transform: "translateX(-50%)",
        marginTop: 5
      },
      left: {
        right: "100%",
        top: "50%",
        transform: "translateY(-50%)",
        marginRight: 5
      },
      right: {
        left: "100%",
        top: "50%",
        transform: "translateY(-50%)",
        marginLeft: 5
      }
    }[o]
  });
}
function He(r, o = "#ff3b30", e = "white") {
  return p({
    content: r,
    position: "absolute",
    top: 8,
    right: -8,
    backgroundColor: o,
    color: e,
    padding: "2px 12px",
    fontSize: 11,
    fontWeight: "bold",
    textTransform: "uppercase",
    transform: "rotate(45deg)",
    transformOrigin: "center",
    zIndex: 10
  });
}
function je(r = 20, o = "#007AFF", e = 2) {
  if (!document.getElementById("tachui-spinner-animation")) {
    const t = document.createElement("style");
    t.id = "tachui-spinner-animation", t.textContent = `
      @keyframes spin {
        0% { transform: rotate(0deg); }
        100% { transform: rotate(360deg); }
      }
    `, document.head.appendChild(t);
  }
  return p({
    content: "",
    display: "inline-block",
    width: r,
    height: r,
    border: `${e}px solid transparent`,
    borderTop: `${e}px solid ${o}`,
    borderRadius: "50%",
    animation: "spin 1s linear infinite"
  });
}
class We extends u {
  // High priority for HTML attributes
  constructor(e) {
    super(e);
    s(this, "type", "id");
    s(this, "priority", 85);
  }
  apply(e, t) {
    if (!t.element) return;
    const { id: i } = this.properties;
    typeof process < "u" && process.env.NODE_ENV === "development" && this.validateId(i), t.element.setAttribute("id", i);
  }
  validateId(e) {
    if (!e || typeof e != "string") {
      console.warn("TachUI ID Modifier: ID must be a non-empty string");
      return;
    }
    /^[a-zA-Z][a-zA-Z0-9_:-]*$/.test(e) || console.warn(
      `TachUI ID Modifier: Invalid ID format "${e}". IDs must start with a letter and contain only letters, digits, hyphens, underscores, colons, and periods.`
    ), typeof document < "u" && document.getElementById && document.getElementById(e) && console.warn(
      `TachUI ID Modifier: Duplicate ID "${e}" detected. IDs should be unique within the document.`
    );
  }
}
function Fe(r) {
  return new We({ id: r });
}
class Ke extends u {
  // High priority for HTML attributes
  constructor(e) {
    super(e);
    s(this, "type", "data");
    s(this, "priority", 80);
  }
  apply(e, t) {
    if (!t.element) return;
    const { data: i } = this.properties;
    typeof process < "u" && process.env.NODE_ENV === "development" && this.validateDataAttributes(i), Object.entries(i).forEach(([a, n]) => {
      const d = this.formatDataAttributeName(a), l = this.formatDataAttributeValue(n);
      t.element.setAttribute(d, l);
    });
  }
  formatDataAttributeName(e) {
    const t = e.replace(/[A-Z]/g, (i) => `-${i.toLowerCase()}`);
    return t.startsWith("data-") ? t : `data-${t}`;
  }
  formatDataAttributeValue(e) {
    return typeof e == "boolean" ? e ? "true" : "false" : String(e);
  }
  validateDataAttributes(e) {
    Object.entries(e).forEach(([t, i]) => {
      if (!t || typeof t != "string") {
        console.warn(
          "TachUI Data Modifier: Data attribute keys must be non-empty strings"
        );
        return;
      }
      const a = t.replace(/^data-/, "");
      /^[a-zA-Z][a-zA-Z0-9-_]*$/.test(a) || console.warn(
        `TachUI Data Modifier: Invalid data attribute key "${t}". Keys should start with a letter and contain only letters, numbers, hyphens, and underscores.`
      ), i != null && typeof i != "string" && typeof i != "number" && typeof i != "boolean" && console.warn(
        `TachUI Data Modifier: Data attribute "${t}" has invalid value type "${typeof i}". Only strings, numbers, and booleans are supported.`
      );
    });
  }
}
function qe(r) {
  return new Ke({ data: r });
}
class Ge extends u {
  // High priority for accessibility
  constructor(e) {
    super(e);
    s(this, "type", "tabIndex");
    s(this, "priority", 75);
  }
  apply(e, t) {
    if (!t.element) return;
    const { tabIndex: i } = this.properties;
    typeof process < "u" && process.env.NODE_ENV === "development" && this.validateTabIndex(i), t.element.setAttribute("tabindex", String(i));
  }
  validateTabIndex(e) {
    if (typeof e != "number" || !Number.isInteger(e)) {
      console.warn("TachUI TabIndex Modifier: tabIndex must be an integer");
      return;
    }
    e > 0 && console.info(
      'TachUI TabIndex Modifier: Positive tabIndex values can disrupt natural tab order. Consider using tabIndex="0" for focusable elements and tabIndex="-1" for programmatically focusable elements.'
    ), e < -1 && console.warn(
      "TachUI TabIndex Modifier: tabIndex values less than -1 are not recommended. Use -1 to remove from tab order or 0+ for tab order."
    );
  }
}
function Ze(r) {
  return new Ge({ tabIndex: r });
}
const b = class b extends u {
  constructor(e) {
    super(e);
    s(this, "type", "aria");
    s(this, "priority", 90);
  }
  apply(e, t) {
    if (!t.element) return;
    const { aria: i } = this.properties;
    typeof process < "u" && process.env.NODE_ENV === "development" && this.validateAriaAttributes(i), Object.entries(i).forEach(([a, n]) => {
      if (n != null) {
        const d = this.formatAriaAttributeName(a), l = this.formatAriaAttributeValue(n);
        t.element.setAttribute(d, l);
      }
    });
  }
  formatAriaAttributeName(e) {
    if (e === "role")
      return "role";
    e === "labeledby" && (e = "labelledby");
    const t = e.replace(/[A-Z]/g, (i) => `-${i.toLowerCase()}`);
    return t.startsWith("aria-") ? t : `aria-${t}`;
  }
  formatAriaAttributeValue(e) {
    return typeof e == "boolean" ? e ? "true" : "false" : String(e);
  }
  validateAriaAttributes(e) {
    Object.entries(e).forEach(([t, i]) => {
      if (!t || typeof t != "string") {
        console.warn(
          "TachUI ARIA Modifier: ARIA attribute keys must be non-empty strings"
        );
        return;
      }
      const a = t.replace(/^aria-/, "");
      !b.KNOWN_ATTRIBUTES.has(a) && !t.startsWith("aria-") && console.warn(
        `TachUI ARIA Modifier: Unknown ARIA attribute "${t}". This may not be a valid ARIA attribute. Did you mean "${this.suggestCorrection(a)}"?`
      ), this.validateSpecificAriaAttribute(t, i);
    });
  }
  validateSpecificAriaAttribute(e, t) {
    const i = e.replace(/^aria-/, "");
    switch (i) {
      case "live":
        ["off", "polite", "assertive"].includes(t) || console.warn(
          `TachUI ARIA Modifier: Invalid value "${t}" for aria-live. Valid values are: "off", "polite", "assertive"`
        );
        break;
      case "haspopup":
        const a = [
          "false",
          "true",
          "menu",
          "listbox",
          "tree",
          "grid",
          "dialog"
        ];
        typeof t == "string" && !a.includes(t) && console.warn(
          `TachUI ARIA Modifier: Invalid value "${t}" for aria-haspopup. Valid values are: ${a.join(", ")}`
        );
        break;
      case "current":
        const n = ["page", "step", "location", "date", "time"];
        typeof t == "string" && !n.includes(t) && console.warn(
          `TachUI ARIA Modifier: Invalid value "${t}" for aria-current. Valid values are: false, true, ${n.join(", ")}`
        );
        break;
      case "invalid":
        const d = ["false", "true", "grammar", "spelling"];
        typeof t == "string" && !d.includes(t) && console.warn(
          `TachUI ARIA Modifier: Invalid value "${t}" for aria-invalid. Valid values are: ${d.join(", ")}`
        );
        break;
      case "orientation":
        ["horizontal", "vertical"].includes(t) || console.warn(
          `TachUI ARIA Modifier: Invalid value "${t}" for aria-orientation. Valid values are: "horizontal", "vertical"`
        );
        break;
      case "sort":
        ["none", "ascending", "descending", "other"].includes(
          t
        ) || console.warn(
          `TachUI ARIA Modifier: Invalid value "${t}" for aria-sort. Valid values are: "none", "ascending", "descending", "other"`
        );
        break;
      case "pressed":
        const l = ["true", "false", "mixed"];
        typeof t == "string" && !l.includes(t) && console.warn(
          `TachUI ARIA Modifier: Invalid value "${t}" for aria-pressed. Valid values are: ${l.join(", ")}`
        );
        break;
      // Numeric attributes validation
      case "level":
      case "posinset":
      case "setsize":
      case "valuemax":
      case "valuemin":
      case "valuenow":
        typeof t == "number" && (t < 0 || !Number.isInteger(t)) && console.warn(
          `TachUI ARIA Modifier: Invalid value "${t}" for aria-${i}. Must be a non-negative integer.`
        );
        break;
    }
  }
  suggestCorrection(e) {
    return {
      lable: "label",
      labeledby: "labelledby",
      descripedby: "describedby",
      described: "describedby",
      controled: "controls",
      controles: "controls",
      expaned: "expanded",
      expandd: "expanded",
      hiden: "hidden",
      hidde: "hidden",
      disbled: "disabled",
      disable: "disabled",
      requird: "required",
      require: "required",
      selectd: "selected",
      select: "selected",
      orientaton: "orientation"
    }[e] || e;
  }
};
// Highest priority for accessibility
s(b, "KNOWN_ATTRIBUTES", /* @__PURE__ */ new Set([
  "label",
  "labelledby",
  "describedby",
  "expanded",
  "hidden",
  "live",
  "atomic",
  "busy",
  "controls",
  "current",
  "disabled",
  "grabbed",
  "haspopup",
  "invalid",
  "level",
  "multiline",
  "multiselectable",
  "orientation",
  "owns",
  "placeholder",
  "posinset",
  "pressed",
  "readonly",
  "relevant",
  "required",
  "selected",
  "setsize",
  "sort",
  "valuemax",
  "valuemin",
  "valuenow",
  "valuetext",
  "role"
]));
let h = b;
function _e(r) {
  return new h({ aria: r });
}
class g extends u {
  // Early application for CSS variables
  constructor(e) {
    super(e);
    s(this, "type", "customProperties");
    s(this, "priority", 5);
  }
  apply(e, t) {
    if (!t.element) return;
    const i = this.computeCustomPropertyStyles(this.properties);
    this.applyStyles(t.element, i);
  }
  computeCustomPropertyStyles(e) {
    const t = {};
    return Object.entries(e.properties).forEach(([i, a]) => {
      const n = i.startsWith("--") ? i : `--${i}`;
      t[n] = this.formatPropertyValue(a);
    }), t;
  }
  formatPropertyValue(e) {
    return typeof e == "number" ? e.toString() : String(e);
  }
}
function Xe(r) {
  return new g({
    properties: r.properties,
    scope: r.scope || "local"
  });
}
function Ye(r, o, e) {
  return new g({
    properties: { [r]: o },
    scope: e || "local"
  });
}
function Je(r) {
  return new g({
    properties: r,
    scope: "local"
  });
}
function mt(r) {
  const o = {};
  return Object.entries(r).forEach(([e, t]) => {
    if (t !== void 0) {
      const i = e.replace(
        /[A-Z]/g,
        (a) => `-${a.toLowerCase()}`
      );
      o[`--theme-color-${i}`] = t;
    }
  }), new g({
    properties: o,
    scope: "local"
  });
}
function gt(r) {
  const o = {};
  return Object.entries(r).forEach(([e, t]) => {
    t !== void 0 && (o[`--token-${e}`] = t);
  }), new g({
    properties: o,
    scope: "local"
  });
}
const Qe = [
  // Basic layout modifiers
  ["padding", ne],
  ["paddingTop", se],
  ["paddingBottom", de],
  ["paddingLeft", le],
  ["paddingRight", ce],
  ["paddingLeading", fe],
  ["paddingTrailing", pe],
  ["paddingHorizontal", ue],
  ["paddingVertical", me],
  ["margin", ge],
  ["marginTop", be],
  ["marginBottom", he],
  ["marginLeft", ye],
  ["marginRight", Ie],
  ["marginLeading", xe],
  ["marginTrailing", ve],
  ["marginHorizontal", Ae],
  ["marginVertical", we],
  ["size", Se],
  ["width", Me],
  ["height", Te],
  ["maxWidth", Ce],
  ["maxHeight", $e],
  ["minWidth", Pe],
  ["minHeight", Re],
  // Advanced layout modifiers - only core functions that exist
  ["aspectRatio", w],
  ["fixedSize", S],
  ["offset", M],
  ["overlay", T],
  ["position", C],
  ["scaleEffect", $],
  ["zIndex", P],
  // Appearance modifiers - core functions only
  ["backgroundColor", k],
  ["border", z],
  ["clipShape", D],
  ["clipped", O],
  ["foregroundColor", L],
  // Typography modifiers - core functions only
  ["typography", N],
  ["textAlign", U],
  ["font", H],
  ["lineClamp", j],
  ["wordBreak", W],
  // Interaction modifiers
  ["allowsHitTesting", F],
  ["focusable", K],
  ["activatable", q],
  ["editable", G],
  ["focused", Z],
  ["keyboardShortcut", _],
  ["onContinuousHover", X],
  ["onLongPressGesture", Y],
  ["scroll", J],
  ["scrollBehavior", Q],
  ["overscrollBehavior", ee],
  ["overscrollBehaviorX", te],
  ["overscrollBehaviorY", re],
  ["scrollMargin", ie],
  ["scrollPadding", oe],
  ["scrollSnap", ae],
  // Utility modifiers
  ["css", R],
  ["cssProperty", E],
  ["cssVariable", B],
  ["utility", V],
  // Attribute modifiers
  ["aria", _e],
  ["customProperties", Xe],
  ["customProperty", Ye],
  ["cssVariables", Je],
  ["id", Fe],
  ["data", qe],
  ["tabIndex", Ze],
  // Element modifiers
  ["before", p],
  ["after", m],
  ["pseudoElements", Be],
  ["iconBefore", Ve],
  ["iconAfter", ke],
  ["lineBefore", ze],
  ["lineAfter", De],
  ["quotes", Oe],
  ["underline", Le],
  ["badge", Ne],
  ["tooltip", Ue],
  ["cornerRibbon", He],
  ["spinner", je]
];
function et() {
  let r = 0, o = 0;
  Qe.forEach(([e, t]) => {
    try {
      A.register(e, t), r++;
    } catch (i) {
      console.warn(`Failed to register modifier '${e}':`, i), o++;
    }
  }), console.log(
    `@tachui/modifiers: Registered ${r} modifiers${o > 0 ? `, ${o} failed` : ""}`
  );
}
et();
export {
  Xr as AllowsHitTestingModifier,
  yt as AnimationModifier,
  It as AppearanceModifier,
  h as AriaModifier,
  Tt as AspectRatioModifier,
  rr as BackgroundClipModifier,
  ir as BackgroundModifier,
  u as BaseModifier,
  or as BorderModifier,
  qt as CSSModifier,
  ar as ClipShapeModifier,
  nr as ClippedModifier,
  sr as CornerRadiusModifier,
  g as CustomPropertiesModifier,
  Ke as DataModifier,
  Ct as FixedSizeModifier,
  $t as FlexboxModifier,
  Yr as FocusableModifier,
  Jr as FocusedModifier,
  dr as ForegroundModifier,
  Wr as HyphensModifier,
  We as IdModifier,
  xt as InteractionModifier,
  Qr as KeyboardShortcutModifier,
  vt as LayoutModifier,
  At as LifecycleModifier,
  Fr as LineClampModifier,
  pi as MarginModifier,
  St as ModifierPriority,
  Pt as OffsetModifier,
  ei as OnContinuousHoverModifier,
  ti as OnLongPressGestureModifier,
  Kr as OverflowWrapModifier,
  Rt as OverlayModifier,
  li as PaddingModifier,
  Et as PositionModifier,
  f as PseudoElementModifier,
  Bt as ScaleEffectModifier,
  ri as ScrollModifier,
  gi as SizeModifier,
  Ge as TabIndexModifier,
  $r as TypographyModifier,
  Gt as UtilityModifier,
  qr as WordBreakModifier,
  Vt as ZIndexModifier,
  q as activatable,
  m as after,
  kt as alignItems,
  zt as alignSelf,
  F as allowsHitTesting,
  _e as aria,
  w as aspectRatio,
  lr as background,
  cr as backgroundClip,
  k as backgroundColor,
  Ne as badge,
  p as before,
  fr as blueGradientText,
  z as border,
  pr as borderBottom,
  ur as borderHorizontal,
  mr as borderLeading,
  gr as borderLeft,
  br as borderRight,
  hr as borderTop,
  yr as borderTrailing,
  Ir as borderVertical,
  D as clipShape,
  O as clipped,
  xr as cornerRadius,
  He as cornerRibbon,
  R as css,
  E as cssProperty,
  B as cssVariable,
  Je as cssVariables,
  Zt as cssVendor,
  _t as cursor,
  Pr as custom,
  Xe as customProperties,
  Ye as customProperty,
  qe as data,
  gt as designTokens,
  ii as disableHitTesting,
  Xt as display,
  G as editable,
  oi as enableHitTesting,
  S as fixedSize,
  Dt as flexBasis,
  Ot as flexDirection,
  Lt as flexGrow,
  Nt as flexShrink,
  Ut as flexWrap,
  Ht as flexbox,
  jt as flexboxPresets,
  K as focusable,
  Z as focused,
  H as font,
  Rr as fontFamily,
  Er as fontSize,
  Br as fontWeight,
  vr as foreground,
  L as foregroundColor,
  Wt as gap,
  Ar as goldGradientText,
  wr as gradientText,
  Te as height,
  Gr as hyphens,
  ke as iconAfter,
  Ve as iconBefore,
  Fe as id,
  Ft as justifyContent,
  _ as keyboardShortcut,
  ai as keyboardShortcutBuilder,
  Vr as letterSpacing,
  De as lineAfter,
  ze as lineBefore,
  j as lineClamp,
  kr as lineHeight,
  ge as margin,
  he as marginBottom,
  Ae as marginHorizontal,
  xe as marginLeading,
  ye as marginLeft,
  ui as marginPresets,
  Ie as marginRight,
  be as marginTop,
  ve as marginTrailing,
  we as marginVertical,
  $e as maxHeight,
  Ce as maxWidth,
  Re as minHeight,
  Pe as minWidth,
  Sr as oceanGradientText,
  M as offset,
  X as onContinuousHover,
  ni as onContinuousHoverGlobal,
  si as onContinuousHoverLocal,
  Y as onLongPressGesture,
  Yt as outline,
  Jt as outlineOffset,
  zr as overflow,
  Zr as overflowWrap,
  Qt as overflowX,
  er as overflowY,
  T as overlay,
  ee as overscrollBehavior,
  te as overscrollBehaviorX,
  re as overscrollBehaviorY,
  ne as padding,
  de as paddingBottom,
  ue as paddingHorizontal,
  fe as paddingLeading,
  le as paddingLeft,
  ci as paddingPresets,
  ce as paddingRight,
  se as paddingTop,
  pe as paddingTrailing,
  me as paddingVertical,
  C as position,
  Be as pseudoElements,
  Oe as quotes,
  Mr as rainbowGradientText,
  $ as scaleEffect,
  J as scroll,
  Q as scrollBehavior,
  ie as scrollMargin,
  oe as scrollPadding,
  ae as scrollSnap,
  Se as size,
  je as spinner,
  Tr as sunsetGradientText,
  Dr as system,
  Ze as tabIndex,
  U as textAlign,
  Or as textCase,
  Lr as textDecoration,
  Nr as textOverflow,
  Ur as textTransform,
  mt as themeColors,
  Ue as tooltip,
  N as typography,
  Le as underline,
  V as utility,
  Hr as whiteSpace,
  Me as width,
  W as wordBreak,
  P as zIndex
};
//# sourceMappingURL=index.js.map