@jasonshimmy/custom-elements-runtime 3.2.0 → 3.2.1

package/dist/hooks-_3xP4G2N.js

@@ -0,0 +1,1189 @@
+import { r as p, t as M } from "./logger-L25axmB-.js";
+import { d as q, f as G } from "./css-utils-CC43BbEy.js";
+function X() {
+  const e = (() => {
+    try {
+      return globalThis.process?.env?.NODE_ENV;
+    } catch {
+      return;
+    }
+  })(), t = (() => {
+    try {
+      if (typeof window > "u") return {
+        vitest: !1,
+        cypress: !1
+      };
+      const n = window;
+      return {
+        vitest: !!n.__vitest__,
+        cypress: !!n.Cypress
+      };
+    } catch {
+      return {
+        vitest: !1,
+        cypress: !1
+      };
+    }
+  })();
+  return {
+    isTest: e === "test" || t.vitest || t.cypress,
+    isVitest: t.vitest,
+    isCypress: t.cypress
+  };
+}
+var K = class {
+  pendingUpdates = /* @__PURE__ */ new Map();
+  isFlushScheduled = !1;
+  isFlushing = !1;
+  testEnv;
+  lastCleanup = 0;
+  CLEANUP_INTERVAL = 300 * 1e3;
+  MAX_PENDING_SIZE = 1e4;
+  pendingIdleUpdates = /* @__PURE__ */ new Map();
+  idleCallbackHandle = null;
+  constructor() {
+    this.testEnv = X(), this.schedulePeriodicCleanup();
+  }
+  schedule(e, t) {
+    const n = t || e;
+    this.pendingUpdates.size >= this.MAX_PENDING_SIZE && this.performEmergencyCleanup(), this.pendingUpdates.set(n, e), this.isFlushScheduled || this.scheduleFlush();
+  }
+  scheduleFlush() {
+    this.isFlushScheduled = !0, this.testEnv.isTest && !this.isFlushing ? this.flush() : queueMicrotask(() => this.flush());
+  }
+  flush() {
+    if (this.isFlushing) return;
+    this.isFlushing = !0;
+    const e = this.pendingUpdates;
+    this.pendingUpdates = /* @__PURE__ */ new Map(), this.isFlushScheduled = !1;
+    try {
+      for (const t of e.values()) try {
+        t();
+      } catch (n) {
+        M("Error in batched update:", n);
+      }
+    } finally {
+      this.isFlushing = !1;
+    }
+  }
+  flushImmediately() {
+    this.pendingUpdates.size !== 0 && (this.isFlushScheduled = !1, this.flush());
+  }
+  get pendingCount() {
+    return this.pendingUpdates.size;
+  }
+  get hasPendingUpdates() {
+    return this.pendingUpdates.size > 0;
+  }
+  get isFlushingUpdates() {
+    return this.isFlushing;
+  }
+  schedulePeriodicCleanup() {
+    if (this.testEnv.isTest) return;
+    const e = () => {
+      this.performPeriodicCleanup(), this.testEnv.isTest || setTimeout(e, this.CLEANUP_INTERVAL);
+    };
+    setTimeout(e, this.CLEANUP_INTERVAL);
+  }
+  performPeriodicCleanup() {
+    const e = Date.now();
+    e - this.lastCleanup < this.CLEANUP_INTERVAL || (this.pendingUpdates.size > 100 && p(`Scheduler has ${this.pendingUpdates.size} pending updates. Consider investigating.`), this.lastCleanup = e);
+  }
+  performEmergencyCleanup(e = this.pendingUpdates) {
+    p("Scheduler emergency cleanup: too many pending updates, clearing oldest entries");
+    const t = Array.from(e.entries()), n = Math.floor(t.length / 2);
+    for (let r = 0; r < n; r++) e.delete(t[r][0]);
+  }
+  scheduleWithPriority(e, t = "normal", n) {
+    if (t === "immediate") {
+      try {
+        e();
+      } catch (s) {
+        M("Error in immediate update:", s);
+      }
+      return;
+    }
+    if (t === "idle") {
+      const s = n ?? e;
+      this.pendingIdleUpdates.size >= this.MAX_PENDING_SIZE && this.performEmergencyCleanup(this.pendingIdleUpdates), this.pendingIdleUpdates.set(s, e), this.scheduleIdleFlush();
+      return;
+    }
+    const r = n ?? e;
+    this.pendingUpdates.size >= this.MAX_PENDING_SIZE && this.performEmergencyCleanup(), this.pendingUpdates.set(r, e), this.isFlushScheduled || (this.isFlushScheduled = !0, queueMicrotask(() => this.flush()));
+  }
+  scheduleIdleFlush() {
+    if (this.idleCallbackHandle === null) {
+      if (this.testEnv.isTest) {
+        this.idleCallbackHandle = setTimeout(() => {
+          this.idleCallbackHandle = null, this.flushIdleUpdates(null);
+        }, 0);
+        return;
+      }
+      typeof requestIdleCallback < "u" ? this.idleCallbackHandle = requestIdleCallback((e) => {
+        this.idleCallbackHandle = null, this.flushIdleUpdates(e);
+      }, { timeout: 2e3 }) : this.idleCallbackHandle = setTimeout(() => {
+        this.idleCallbackHandle = null;
+        const e = Date.now();
+        this.flushIdleUpdates({
+          timeRemaining: () => Math.max(0, 50 - (Date.now() - e)),
+          didTimeout: !1
+        });
+      }, 5);
+    }
+  }
+  flushIdleUpdates(e) {
+    const t = Array.from(this.pendingIdleUpdates.entries());
+    this.pendingIdleUpdates = /* @__PURE__ */ new Map();
+    for (let n = 0; n < t.length; n++) {
+      if (e && !e.didTimeout && e.timeRemaining() <= 0) {
+        for (let r = n; r < t.length; r++) this.pendingIdleUpdates.set(t[r][0], t[r][1]);
+        this.scheduleIdleFlush();
+        return;
+      }
+      try {
+        t[n][1]();
+      } catch (r) {
+        M("Error in idle update:", r);
+      }
+    }
+  }
+}, k = new K();
+function Z(e, t) {
+  k.schedule(e, t);
+}
+function ae(e, t = "normal", n) {
+  k.scheduleWithPriority(e, t, n);
+}
+function ce() {
+  k.flushImmediately();
+}
+function ue() {
+  return new Promise((e) => {
+    let n = 0;
+    for (; k.hasPendingUpdates && n < 100; )
+      k.flushImmediately(), n++;
+    n >= 100 && p("[nextTick] Maximum flush iterations reached — possible circular update loop. Check for watchers or computed values that unconditionally mutate reactive state."), queueMicrotask(e);
+  });
+}
+var O = /* @__PURE__ */ new WeakSet(), B = class {
+  static cache = /* @__PURE__ */ new WeakMap();
+  static arrayHandlerCache = /* @__PURE__ */ new WeakMap();
+  static objectHandlerCache = /* @__PURE__ */ new WeakMap();
+  static getOrCreateProxy(e, t, n = !1) {
+    const r = this.cache.get(e);
+    if (r) return r;
+    const s = n ? this.getOrCreateArrayHandler(t) : this.getOrCreateObjectHandler(t), o = new Proxy(e, s);
+    try {
+      W.markAsProxy(o);
+    } catch {
+    }
+    return this.cache.set(e, o), o;
+  }
+  static getOrCreateArrayHandler(e) {
+    return this.arrayHandlerCache.has(e) || this.arrayHandlerCache.set(e, {
+      get: (t, n, r) => {
+        const s = Reflect.get(t, n, r);
+        return typeof s == "function" && typeof n == "string" && [
+          "push",
+          "pop",
+          "shift",
+          "unshift",
+          "splice",
+          "sort",
+          "reverse",
+          "fill",
+          "copyWithin"
+        ].includes(n) ? function(...o) {
+          const i = s.apply(t, o);
+          return e.triggerUpdate(), i;
+        } : s !== null && typeof s == "object" && typeof n == "string" ? e.makeReactiveValue(s) : s;
+      },
+      set: (t, n, r) => (t[n] = e.makeReactiveValue(r), e.triggerUpdate(), !0),
+      deleteProperty: (t, n) => (delete t[n], e.triggerUpdate(), !0)
+    }), this.arrayHandlerCache.get(e);
+  }
+  static getOrCreateObjectHandler(e) {
+    return this.objectHandlerCache.has(e) || this.objectHandlerCache.set(e, {
+      get: (t, n, r) => {
+        const s = Reflect.get(t, n, r);
+        return s !== null && typeof s == "object" && typeof n == "string" ? e.makeReactiveValue(s) : s;
+      },
+      set: (t, n, r) => (t[n] = e.makeReactiveValue(r), e.triggerUpdate(), !0),
+      deleteProperty: (t, n) => (delete t[n], e.triggerUpdate(), !0)
+    }), this.objectHandlerCache.get(e);
+  }
+  static hasProxy(e) {
+    return this.cache.has(e);
+  }
+  static clear() {
+    this.cache = /* @__PURE__ */ new WeakMap(), this.arrayHandlerCache = /* @__PURE__ */ new WeakMap(), this.objectHandlerCache = /* @__PURE__ */ new WeakMap();
+  }
+  static getStats() {
+    return { hasCachedProxies: this.cache instanceof WeakMap };
+  }
+}, W = class {
+  static contextCache = /* @__PURE__ */ new WeakMap();
+  static createReactiveProxy(e, t, n) {
+    try {
+      if (O.has(e)) return e;
+    } catch {
+    }
+    const r = Array.isArray(e);
+    let s = this.contextCache.get(t);
+    s || (s = /* @__PURE__ */ new WeakMap(), this.contextCache.set(t, s));
+    let o = s.get(n);
+    return o || (o = {
+      triggerUpdate: t,
+      makeReactiveValue: n
+    }, s.set(n, o)), B.getOrCreateProxy(e, o, r);
+  }
+  static markAsProxy(e) {
+    if (e)
+      try {
+        O.add(e);
+      } catch {
+      }
+  }
+}, N = !1;
+function d() {
+  return N;
+}
+function le() {
+  N && p("[CER] beginDiscoveryRender() called while a discovery render is already active. This usually means a component was registered inside another component's render function. Ensure component() calls are at module top-level."), N = !0;
+}
+function fe() {
+  N = !1;
+}
+var Y = 0;
+function x(e) {
+  return `${e}-${++Y}`;
+}
+var J = class {
+  currentComponentStack = [];
+  componentData = /* @__PURE__ */ new Map();
+  stateStorage = /* @__PURE__ */ new Map();
+  trackingDisabled = !1;
+  setCurrentComponent(e, t) {
+    if (this.currentComponentStack.push(e), !this.componentData.has(e)) this.componentData.set(e, {
+      dependencies: /* @__PURE__ */ new Set(),
+      renderFn: t,
+      stateIndex: 0,
+      lastWarnTime: 0,
+      watchers: /* @__PURE__ */ new Map()
+    });
+    else {
+      const n = this.componentData.get(e);
+      if (n.watchers && n.watchers.size) {
+        for (const r of n.watchers.values()) try {
+          this.cleanup(r);
+        } catch {
+        }
+        n.watchers.clear();
+      }
+      n.renderFn = t, n.stateIndex = 0;
+    }
+  }
+  clearCurrentComponent() {
+    this.currentComponentStack.pop();
+  }
+  getCurrentComponentId() {
+    return this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+  }
+  registerWatcher(e, t) {
+    const n = this.componentData.get(e);
+    n && n.watchers.set(t, t);
+  }
+  disableTracking() {
+    this.trackingDisabled = !0;
+  }
+  enableTracking() {
+    this.trackingDisabled = !1;
+  }
+  isRenderingComponent() {
+    return this.currentComponentStack.length > 0;
+  }
+  shouldEmitRenderWarning() {
+    const e = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+    if (!e) return !0;
+    const t = this.componentData.get(e);
+    if (!t) return !0;
+    const n = Date.now();
+    return n - t.lastWarnTime < 1e3 ? !1 : (t.lastWarnTime = n, !0);
+  }
+  withoutTracking(e) {
+    const t = this.trackingDisabled;
+    this.trackingDisabled = !0;
+    try {
+      return e();
+    } finally {
+      this.trackingDisabled = t;
+    }
+  }
+  getOrCreateState(e) {
+    const t = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+    if (!t) return new A(e);
+    const n = this.componentData.get(t);
+    if (!n) return new A(e);
+    const r = `${t}:${n.stateIndex++}`;
+    let s = this.stateStorage.get(r);
+    return s || (s = new A(e), this.stateStorage.set(r, s)), s;
+  }
+  trackDependency(e) {
+    if (this.trackingDisabled) return;
+    const t = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+    if (!t) return;
+    const n = this.componentData.get(t);
+    n && (n.dependencies.add(e), e.addDependent(t));
+  }
+  propagateDependencies(e) {
+    if (this.trackingDisabled) return;
+    const t = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+    if (!t || t === e) return;
+    const n = this.componentData.get(e);
+    if (!n) return;
+    const r = this.componentData.get(t);
+    if (r)
+      for (const s of n.dependencies)
+        r.dependencies.add(s), s.addDependent(t);
+  }
+  triggerUpdate(e) {
+    const t = e.getDependents();
+    for (const n of t) {
+      const r = this.componentData.get(n);
+      r && Z(r.renderFn, n);
+    }
+  }
+  cleanup(e) {
+    const t = this.componentData.get(e);
+    if (t) {
+      for (const r of t.dependencies) r.removeDependent(e);
+      this.componentData.delete(e);
+    }
+    const n = e + ":";
+    for (const r of this.stateStorage.keys()) r.startsWith(n) && this.stateStorage.delete(r);
+  }
+}, f = new J(), A = class {
+  _value;
+  _rawValue;
+  dependents = /* @__PURE__ */ new Set();
+  constructor(e) {
+    this._rawValue = e, this._value = this.makeReactive(e);
+    try {
+      Object.defineProperty(this, /* @__PURE__ */ Symbol.for("@cer/ReactiveState"), {
+        value: !0,
+        enumerable: !1,
+        configurable: !1
+      });
+    } catch {
+    }
+  }
+  get value() {
+    return f.trackDependency(this), this._value;
+  }
+  set value(e) {
+    Object.is(e, this._rawValue) || (f.isRenderingComponent() && f.shouldEmitRenderWarning() && p(`🚨 State modification detected during render! This can cause infinite loops.
+  • Move state updates to event handlers
+  • Use watchEffect/watch for side effects
+  • Ensure computed properties don't modify state`), this._rawValue = e, this._value = this.makeReactive(e), f.triggerUpdate(this));
+  }
+  peek() {
+    return this._value;
+  }
+  initSilent(e) {
+    this._rawValue = e, this._value = e;
+  }
+  addDependent(e) {
+    this.dependents.add(e);
+  }
+  removeDependent(e) {
+    this.dependents.delete(e);
+  }
+  getDependents() {
+    return this.dependents;
+  }
+  makeReactive(e) {
+    return e === null || typeof e != "object" || typeof Node < "u" && e instanceof Node || typeof Element < "u" && e instanceof Element || typeof HTMLElement < "u" && e instanceof HTMLElement ? e : W.createReactiveProxy(e, () => f.triggerUpdate(this), (t) => this.makeReactive(t));
+  }
+};
+function de(e) {
+  return f.getOrCreateState(e === void 0 ? null : e);
+}
+function y(e) {
+  if (!e || typeof e != "object") return !1;
+  try {
+    const t = /* @__PURE__ */ Symbol.for("@cer/ReactiveState");
+    return Object.prototype.hasOwnProperty.call(e, t);
+  } catch {
+    return !1;
+  }
+}
+function he(e) {
+  let t, n = !0;
+  const r = x("computed"), s = () => {
+    n = !0;
+  };
+  try {
+    const o = f.getCurrentComponentId();
+    o && f.registerWatcher(o, r);
+  } catch {
+  }
+  return f.setCurrentComponent(r, s), t = e(), f.clearCurrentComponent(), n = !1, { get value() {
+    return n && (f.setCurrentComponent(r, s), t = e(), f.clearCurrentComponent(), n = !1), f.propagateDependencies(r), t;
+  } };
+}
+function pe(e) {
+  if (d()) return () => {
+  };
+  const t = x("effect");
+  try {
+    const r = f.getCurrentComponentId();
+    r && f.registerWatcher(r, t);
+  } catch {
+  }
+  const n = () => {
+    f.setCurrentComponent(t, n);
+    try {
+      e();
+    } finally {
+      f.clearCurrentComponent();
+    }
+  };
+  return n(), () => {
+    f.cleanup(t);
+  };
+}
+var I = 50;
+function D(e, t = /* @__PURE__ */ new WeakMap(), n = 0) {
+  if (e === null || typeof e != "object") return e;
+  const r = e;
+  if (t.has(r)) return t.get(r);
+  if (n > I)
+    return p(`[watch] Deep clone exceeded ${I} nesting levels. Returning a reference at this depth instead of cloning further. Consider restructuring your state or switching to a shallow watch.`), e;
+  if (typeof Node < "u" && r instanceof Node) return e;
+  if (r instanceof Date) return new Date(r.getTime());
+  if (Array.isArray(r)) {
+    const o = [];
+    t.set(r, o);
+    for (let i = 0; i < r.length; i++) o.push(D(r[i], t, n + 1));
+    return o;
+  }
+  const s = {};
+  t.set(r, s);
+  for (const o of Object.keys(r)) try {
+    s[o] = D(r[o], t, n + 1);
+  } catch {
+  }
+  return s;
+}
+function ge(e, t, n) {
+  if (d()) return () => {
+  };
+  let r;
+  const s = y(e) ? () => e.value : e, o = x("watch");
+  try {
+    const a = f.getCurrentComponentId();
+    a && f.registerWatcher(a, o);
+  } catch {
+  }
+  const i = () => {
+    f.setCurrentComponent(o, i);
+    const a = s();
+    if (f.clearCurrentComponent(), n?.deep) {
+      const c = f.withoutTracking(() => D(a));
+      t(c, r), r = c;
+    } else a !== r && (t(a, r), r = a);
+  };
+  return f.setCurrentComponent(o, i), r = s(), f.clearCurrentComponent(), n?.deep && (r = f.withoutTracking(() => D(r))), n && n.immediate && t(r, void 0), () => {
+    f.cleanup(o);
+  };
+}
+var me = (e) => {
+  try {
+    e();
+  } catch {
+  }
+}, E = /* @__PURE__ */ new Map(), v = /* @__PURE__ */ new Map(), _ = /* @__PURE__ */ new Map(), P = 500, S, $, j = !1, H = !1, U, Q = !!globalThis.process?.versions?.node;
+function ee(e) {
+  if (E.has(e)) return E.get(e);
+  const t = e.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  return E.size < P && E.set(e, t), t;
+}
+function L(e) {
+  if (v.has(e)) return v.get(e);
+  const t = e.replace(/-([a-z])/g, (n, r) => r.toUpperCase());
+  return v.size < P && v.set(e, t), t;
+}
+function ye(e) {
+  if (typeof e == "string") {
+    if (_.has(e)) return _.get(e);
+    const t = e.replace(/[&<>"']/g, (n) => ({
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;"
+    })[n]);
+    return t !== e && _.size < P && _.set(e, t), t;
+  }
+  return e;
+}
+function g(e) {
+  if (!e) return "";
+  const t = String(e);
+  if (typeof document < "u" && typeof document.createElement == "function") {
+    const a = t.replace(/</g, "").replace(/>/g, ""), c = U || (U = document.createElement("div"));
+    try {
+      g._el = c;
+    } catch {
+    }
+    return c.innerHTML = a, (c.textContent || "").replace(new RegExp("", "g"), "<").replace(new RegExp("", "g"), ">");
+  }
+  const n = {
+    lt: "<",
+    gt: ">",
+    amp: "&",
+    quot: '"',
+    apos: "'",
+    nbsp: " "
+  }, r = S ?? g._namedMap;
+  let s = r;
+  if (!s && Q) try {
+    const o = globalThis.require;
+    if (typeof o == "function") for (const i of [
+      "@jasonshimmy/custom-elements-runtime/entities.json",
+      "../../entities.json",
+      "../../../entities.json",
+      "../entities.json",
+      "./entities.json"
+    ]) try {
+      const a = o(i);
+      if (a && typeof a == "object") {
+        s = a;
+        break;
+      }
+    } catch {
+    }
+  } catch {
+  }
+  if (!s) {
+    s = n, j = !0;
+    try {
+      g._usedFallback = !0;
+    } catch {
+    }
+    const o = g._namedMapLoader ?? $;
+    o && o().then((i) => {
+      S = i;
+      try {
+        g._namedMap = i;
+      } catch {
+      }
+    }).catch(() => {
+    });
+  }
+  if ((j || g._usedFallback) && !(H || g._warnedFallback)) {
+    H = !0;
+    try {
+      g._warnedFallback = !0;
+    } catch {
+    }
+    try {
+      p("decodeEntities: using small SSR fallback entity map. Register the full entities.json via registerEntityMap(entities) on the server to enable full HTML5 named-entity decoding.");
+    } catch {
+    }
+  }
+  return t.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (o, i) => {
+    if (i.charCodeAt(0) === 35) {
+      const c = (i.charAt(1) || "").toLowerCase() === "x" ? parseInt(i.slice(2), 16) : parseInt(i.slice(1), 10);
+      return Number.isNaN(c) ? `&${i};` : String.fromCodePoint(c);
+    }
+    const a = s[i] ?? (r && r[i]);
+    return a !== void 0 ? a : `&${i};`;
+  });
+}
+async function V() {
+  const e = [
+    "@jasonshimmy",
+    "custom-elements-runtime",
+    "entities.json"
+  ].join("/");
+  try {
+    const t = await import(
+      /* @vite-ignore */
+      e
+    );
+    return t && (t.default || t);
+  } catch {
+    try {
+      const t = [
+        e,
+        "./entities.json",
+        "../../entities.json",
+        "../../../entities.json"
+      ];
+      for (const n of t) try {
+        const r = await import(
+          /* @vite-ignore */
+          n
+        );
+        if (r) return r && (r.default || r);
+      } catch {
+      }
+      return {
+        lt: "<",
+        gt: ">",
+        amp: "&",
+        quot: '"',
+        apos: "'",
+        nbsp: " "
+      };
+    } catch {
+      return {
+        lt: "<",
+        gt: ">",
+        amp: "&",
+        quot: '"',
+        apos: "'",
+        nbsp: " "
+      };
+    }
+  }
+}
+$ = V;
+g._namedMapLoader = V;
+function be(e, t) {
+  !e || typeof e != "object" || S && !t?.overwrite || (S = e);
+}
+function Ce() {
+  S = void 0;
+}
+function we(e) {
+  const t = String(e);
+  return {
+    __unsafeHTML: t,
+    __rawHTML: t
+  };
+}
+function ke(e) {
+  return !!e && (typeof e.__unsafeHTML == "string" || typeof e.__rawHTML == "string");
+}
+function Se(e, t) {
+  if (typeof t == "string") {
+    if (t === "") return;
+    const n = t.split(".");
+    let r = e;
+    for (const s of n) {
+      if (r == null || typeof r != "object") {
+        r = void 0;
+        break;
+      }
+      r = r[s];
+    }
+    return y(r) ? r.value : r;
+  }
+  return t;
+}
+function Ee(e, t, n) {
+  const r = String(t).split("."), s = r.pop();
+  if (!s) return;
+  const o = r.reduce((i, a) => (i[a] == null && (i[a] = {}), i[a]), e);
+  y(o[s]) ? o[s].value = n : o[s] = n;
+}
+function te(e) {
+  try {
+    if (e && typeof e == "object") {
+      if (y(e)) return e.value;
+      if ("value" in e) {
+        const t = e.value;
+        return t == null || typeof t == "string" || typeof t == "number" || typeof t == "boolean" ? t : e;
+      }
+    }
+  } catch {
+  }
+  return e;
+}
+function ve(e) {
+  const t = te(e);
+  if (t == null) return null;
+  const n = typeof t;
+  return n === "string" || n === "number" || n === "boolean" ? String(t) : null;
+}
+function _e(e) {
+  if (!e || typeof e != "string") return !1;
+  if (e === "class" || e.endsWith("Class")) return !0;
+  if (e.includes("-")) try {
+    if (e.split("-").some((t) => t === "class")) return !0;
+  } catch {
+  }
+  return !1;
+}
+var b = null;
+function Me() {
+  if (b !== null) throw new Error("[CER] Concurrent SSR render detected: beginSSRGlobalStyleCollection() called while a collection is already active. For concurrent request handling, use worker threads or multiple Node.js processes.");
+  b = [];
+}
+function Ne() {
+  const e = b ?? [];
+  return b = null, e;
+}
+function ne(e) {
+  return b !== null ? (e && !b.includes(e) && b.push(e), !0) : !1;
+}
+var re = 0;
+function De(e, t, n = "unknown", r) {
+  const s = {};
+  for (const [l, m] of Object.entries(t ?? {})) s[L(l)] = m;
+  const o = {
+    getAttribute(l) {
+      const m = L(l);
+      if (s[m] !== void 0 && s[m] !== null) return String(s[m]);
+      const T = (t ?? {})[l];
+      return T != null ? String(T) : null;
+    },
+    hasAttribute(l) {
+      return this.getAttribute(l) !== null;
+    },
+    shadowRoot: null,
+    tagName: "",
+    parentElement: null
+  }, i = {
+    ...s,
+    _componentId: `cer-ssr-${Object.keys(s).join("-") || "root"}-${++re}`,
+    requestRender: () => {
+    },
+    _requestRender: () => {
+    },
+    emit: () => !0,
+    refs: {}
+  };
+  Object.defineProperty(i, "_host", {
+    value: o,
+    writable: !0,
+    enumerable: !1,
+    configurable: !0
+  }), r !== void 0 && Object.defineProperty(i, "_router", {
+    value: r,
+    writable: !1,
+    enumerable: !1,
+    configurable: !0
+  }), R(i);
+  let a = null, c;
+  try {
+    const l = e.render(i);
+    l instanceof Promise ? c = l : a = l;
+  } catch (l) {
+    p(`[SSR] Component "${n}" threw during SSR render. The shadow DOM will be empty. Error:`, l);
+  } finally {
+    z();
+  }
+  const h = String(i._computedStyle ?? "");
+  return {
+    shadowVNode: a,
+    useStyleCSS: h,
+    asyncPromise: c
+  };
+}
+function Te() {
+  return d();
+}
+var u = null, w = /* @__PURE__ */ Symbol("cer:provides");
+function R(e) {
+  u = e;
+}
+function z() {
+  u = null;
+}
+function Ae() {
+  return u;
+}
+function Re() {
+  if (!u) throw new Error("useEmit must be called during component render");
+  if (d()) return () => !1;
+  const e = u.emit;
+  if (typeof e != "function") throw new Error("useEmit requires an emit function on the component context");
+  const t = e;
+  return (n, r, s) => t(n, r, s);
+}
+function C(e) {
+  e._hookCallbacks || Object.defineProperty(e, "_hookCallbacks", {
+    value: {},
+    writable: !0,
+    enumerable: !1,
+    configurable: !0
+  });
+}
+function xe(e) {
+  if (!u) throw new Error("useOnConnected must be called during component render");
+  if (d()) return;
+  C(u);
+  const t = u._hookCallbacks;
+  t.onConnected || (t.onConnected = []), t.onConnected.push(e);
+}
+function Pe(e) {
+  if (!u) throw new Error("useOnDisconnected must be called during component render");
+  if (d()) return;
+  C(u);
+  const t = u._hookCallbacks;
+  t.onDisconnected || (t.onDisconnected = []), t.onDisconnected.push(e);
+}
+function Oe(e) {
+  if (!u) throw new Error("useOnAttributeChanged must be called during component render");
+  if (d()) return;
+  C(u);
+  const t = u._hookCallbacks;
+  t.onAttributeChanged || (t.onAttributeChanged = []), t.onAttributeChanged.push(e);
+}
+function Ie(e) {
+  if (!u) throw new Error("useOnError must be called during component render");
+  if (d()) return;
+  C(u);
+  const t = u._hookCallbacks;
+  t.onError || (t.onError = []), t.onError.push((n) => {
+    try {
+      n instanceof Error ? e(n) : e(new Error(String(n)));
+    } catch (r) {
+      M("[useOnError] The error handler itself threw an exception:", r);
+    }
+  });
+}
+function se(e) {
+  if (!u) throw new Error("useProps must be called during component render");
+  C(u);
+  const t = u._hookCallbacks;
+  t.props = {
+    ...t.props || {},
+    ...e
+  };
+  const n = u;
+  try {
+    const r = Object.keys(e || {});
+    for (const s of r) {
+      if (typeof s != "string" || s.startsWith("_")) continue;
+      const o = Object.getOwnPropertyDescriptor(n, s);
+      if (!(o && !o.configurable))
+        try {
+          let i = Object.prototype.hasOwnProperty.call(n, s) ? n[s] : void 0;
+          Object.defineProperty(n, s, {
+            configurable: !0,
+            enumerable: !0,
+            get() {
+              try {
+                const a = n && n._host;
+                if (a) {
+                  const c = ee(s), h = a.getAttribute(c);
+                  if (h !== null) {
+                    const l = typeof e[s];
+                    return l === "boolean" ? h === "" || h === "true" : l === "number" ? Number(h) : h;
+                  }
+                  if (typeof a[s] < "u") {
+                    const l = a[s];
+                    if (y(l) || l && typeof l == "object" && "value" in l && !(typeof Node < "u" && l instanceof Node)) return l.value;
+                    const m = typeof e[s];
+                    if (!(m === "string" && l && typeof l == "object"))
+                      return m === "boolean" && typeof l == "string" ? l === "" || l === "true" : l;
+                  }
+                }
+              } catch {
+              }
+              return i;
+            },
+            set(a) {
+              i = a;
+            }
+          });
+        } catch {
+        }
+    }
+  } catch {
+  }
+  return new Proxy({}, {
+    get(r, s) {
+      if (typeof s != "string") return;
+      const o = e[s];
+      try {
+        const a = n && n._host;
+        if (a) {
+          if (typeof HTMLElement < "u" && a instanceof HTMLElement || typeof a.getAttribute == "function" && typeof a.hasAttribute == "function") {
+            const h = s.replace(/([A-Z])/g, "-$1").toLowerCase(), l = a.getAttribute(h);
+            if (l !== null)
+              return typeof o == "boolean" ? l === "" || l === "true" : typeof o == "number" ? Number(l) : l;
+          }
+          const c = a[s];
+          if (typeof c < "u" && c !== "") {
+            const h = c && typeof c == "object" && "value" in c && !(typeof Node < "u" && c instanceof Node);
+            if (!(typeof o == "string" && c && typeof c == "object" && !h && !y(c)))
+              return typeof o == "boolean" && o === !1 && c === "" ? o : y(c) || h ? c.value : typeof o == "boolean" && typeof c == "string" ? c === "" || c === "true" : typeof o == "number" && typeof c == "string" && !Number.isNaN(Number(c)) ? Number(c) : c;
+          }
+        }
+      } catch {
+      }
+      const i = n[s];
+      return typeof o == "boolean" && i === "" ? o === !1 ? o : !0 : y(i) || i && typeof i == "object" && "value" in i && !(typeof Node < "u" && i instanceof Node) ? i.value : i != null && i !== "" ? typeof o == "boolean" && typeof i == "string" ? i === "true" : typeof o == "number" && typeof i == "string" && !Number.isNaN(Number(i)) ? Number(i) : i : o;
+    },
+    has(r, s) {
+      return typeof s == "string" && (s in n || s in e);
+    },
+    ownKeys() {
+      return Array.from(/* @__PURE__ */ new Set([...Object.keys(e), ...Object.keys(n || {})]));
+    },
+    getOwnPropertyDescriptor() {
+      return {
+        configurable: !0,
+        enumerable: !0
+      };
+    }
+  });
+}
+function je(e) {
+  if (!u) throw new Error("useStyle must be called during component render");
+  if (!d()) {
+    C(u);
+    try {
+      const t = e();
+      Object.defineProperty(u, "_computedStyle", {
+        value: t,
+        writable: !0,
+        enumerable: !1,
+        configurable: !0
+      });
+    } catch (t) {
+      p("Error in useStyle callback:", t), Object.defineProperty(u, "_computedStyle", {
+        value: "",
+        writable: !0,
+        enumerable: !1,
+        configurable: !0
+      });
+    }
+  }
+}
+var F = /* @__PURE__ */ new Map();
+function He(e) {
+  let t;
+  try {
+    t = e();
+  } catch {
+    return;
+  }
+  if (ne(t) || typeof document > "u" || typeof CSSStyleSheet > "u") return;
+  p("[useGlobalStyle] Injecting global styles from a component. This escapes Shadow DOM encapsulation — use sparingly.");
+  const n = q(G(t));
+  if (!(!n || F.has(n)))
+    try {
+      const r = new CSSStyleSheet();
+      r.replaceSync(n), document.adoptedStyleSheets = [...document.adoptedStyleSheets, r], F.set(n, r);
+    } catch {
+      const r = document.createElement("style");
+      r.textContent = n, (document.head ?? document.documentElement).appendChild(r);
+    }
+}
+function Ue(e) {
+  if (!u) throw new Error("useDesignTokens must be called during component render");
+  if (d()) return;
+  const t = [], n = {
+    primary: "--cer-color-primary-500",
+    secondary: "--cer-color-secondary-500",
+    neutral: "--cer-color-neutral-500",
+    success: "--cer-color-success-500",
+    info: "--cer-color-info-500",
+    warning: "--cer-color-warning-500",
+    error: "--cer-color-error-500"
+  }, r = {
+    fontSans: "--cer-font-sans",
+    fontSerif: "--cer-font-serif",
+    fontMono: "--cer-font-mono"
+  };
+  for (const [a, c] of Object.entries(e))
+    c !== void 0 && (a in n ? t.push(`${n[a]}:${c}`) : a in r ? t.push(`${r[a]}:${c}`) : a.startsWith("--") && t.push(`${a}:${c}`));
+  if (t.length === 0) return;
+  const s = `:host{${t.join(";")}}`, o = u._computedStyle ?? "", i = o ? `${o}
+${s}` : s;
+  Object.defineProperty(u, "_computedStyle", {
+    value: i,
+    writable: !0,
+    enumerable: !1,
+    configurable: !0
+  });
+}
+function Le(e, t) {
+  if (!u) throw new Error("provide must be called during component render");
+  if (d()) return;
+  const n = u;
+  n[w] || Object.defineProperty(n, w, {
+    value: /* @__PURE__ */ new Map(),
+    writable: !1,
+    enumerable: !1,
+    configurable: !0
+  }), n[w].set(e, t);
+}
+function Fe(e, t) {
+  if (!u) throw new Error("inject must be called during component render");
+  if (d()) return t;
+  try {
+    const n = u._host;
+    if (n) {
+      let r = n.parentNode;
+      r || (r = n.getRootNode());
+      let s = 0;
+      const o = 50;
+      for (; r && s < o; )
+        if (s++, typeof ShadowRoot < "u" && r instanceof ShadowRoot) {
+          const i = r.host, a = i.context;
+          if (a) {
+            const c = a[w];
+            if (c?.has(e)) return c.get(e);
+          }
+          if (r = i.parentNode ?? i.getRootNode(), r === document || r === i) break;
+        } else {
+          if (typeof Element < "u" && r instanceof Element) {
+            const a = r.context;
+            if (a) {
+              const c = a[w];
+              if (c?.has(e)) return c.get(e);
+            }
+          }
+          const i = r;
+          if (r = r.parentNode ?? r.getRootNode?.(), r === document || r === i) break;
+        }
+    }
+  } catch {
+  }
+  return t;
+}
+function We(e) {
+  return (t) => {
+    const n = t ?? u;
+    if (!n) throw new Error("createComposable: no component context available. Pass a context explicitly or call inside a render function.");
+    const r = u;
+    R(n);
+    try {
+      return e();
+    } finally {
+      r ? R(r) : z();
+    }
+  };
+}
+function $e(e) {
+  if (!u) throw new Error("useExpose must be called during component render");
+  if (d()) return;
+  C(u);
+  const t = u._hookCallbacks;
+  t.expose = {
+    ...t.expose ?? {},
+    ...e
+  };
+  const n = u._host;
+  if (n) for (const [r, s] of Object.entries(e)) try {
+    n[r] = s;
+  } catch {
+  }
+}
+function Ve() {
+  if (!u) throw new Error("useSlots must be called during component render");
+  if (d()) return {
+    has: () => !1,
+    getNodes: () => [],
+    names: () => []
+  };
+  const e = u._host, t = () => {
+    const n = /* @__PURE__ */ new Map();
+    if (!e) return n;
+    for (const r of e.children) {
+      const s = r.getAttribute("slot") ?? "default", o = n.get(s);
+      o ? o.push(r) : n.set(s, [r]);
+    }
+    return n;
+  };
+  return {
+    has(n) {
+      if (!e) return !1;
+      const r = !n || n === "default" ? "default" : n, s = t().get(r);
+      return s !== void 0 && s.length > 0;
+    },
+    getNodes(n) {
+      if (!e) return [];
+      const r = !n || n === "default" ? "default" : n;
+      return t().get(r) ?? [];
+    },
+    names() {
+      return e ? Array.from(t().keys()) : [];
+    }
+  };
+}
+function ze(...e) {
+  if (!u) throw new Error("defineModel must be called during component render");
+  const t = e.length === 2 ? e[0] : "modelValue", n = e.length === 2 ? e[1] : e.length === 1 ? e[0] : void 0, r = se({ [t]: n }), s = d() ? null : (() => {
+    const i = u.emit;
+    return typeof i != "function" ? null : i;
+  })(), o = {
+    get value() {
+      return r[t];
+    },
+    set value(i) {
+      s && s(`update:${t}`, i);
+    }
+  };
+  try {
+    Object.defineProperty(o, /* @__PURE__ */ Symbol.for("@cer/ReactiveState"), {
+      value: !0,
+      enumerable: !1,
+      configurable: !1
+    });
+  } catch {
+  }
+  return o;
+}
+export {
+  be as A,
+  f as B,
+  Ce as C,
+  _e as D,
+  Se as E,
+  ee as F,
+  fe as G,
+  ge as H,
+  we as I,
+  ce as J,
+  d as K,
+  A as L,
+  ve as M,
+  Ee as N,
+  ke as O,
+  L as P,
+  he as R,
+  De as S,
+  ye as T,
+  pe as U,
+  de as V,
+  le as W,
+  Z as X,
+  ue as Y,
+  ae as Z,
+  se as _,
+  Fe as a,
+  Me as b,
+  R as c,
+  $e as d,
+  He as f,
+  Ie as g,
+  Pe as h,
+  Ae as i,
+  me as j,
+  V as k,
+  Ue as l,
+  xe as m,
+  We as n,
+  Te as o,
+  Oe as p,
+  X as q,
+  ze as r,
+  Le as s,
+  z as t,
+  Re as u,
+  Ve as v,
+  g as w,
+  Ne as x,
+  je as y,
+  y as z
+};
+
+//# sourceMappingURL=hooks-_3xP4G2N.js.map