@tachui/modifiers 0.8.0-alpha

package/dist/index.js

@@ -0,0 +1,885 @@
+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