@jasonshimmy/custom-elements-runtime 3.0.0 → 3.1.0

package/dist/helpers-CweFZFWU.js

@@ -1,987 +0,0 @@
-import { a as d, d as w } from "./logger-BvkEbVM4.js";
-function N() {
-  const s = (() => {
-    try {
-      return globalThis.process?.env?.NODE_ENV;
-    } catch {
-      return;
-    }
-  })(), e = (() => {
-    try {
-      if (typeof window > "u")
-        return { vitest: !1, cypress: !1 };
-      const t = window;
-      return {
-        vitest: !!t.__vitest__,
-        cypress: !!t.Cypress
-      };
-    } catch {
-      return { vitest: !1, cypress: !1 };
-    }
-  })();
-  return {
-    isTest: s === "test" || e.vitest || e.cypress,
-    isVitest: e.vitest,
-    isCypress: e.cypress
-  };
-}
-class L {
-  pendingUpdates = /* @__PURE__ */ new Map();
-  isFlushScheduled = !1;
-  isFlushing = !1;
-  testEnv;
-  lastCleanup = 0;
-  CLEANUP_INTERVAL = 300 * 1e3;
-  // 5 minutes
-  MAX_PENDING_SIZE = 1e4;
-  // Prevent memory bloat
-  // Idle / time-sliced priority support
-  pendingIdleUpdates = /* @__PURE__ */ new Map();
-  idleCallbackHandle = null;
-  constructor() {
-    this.testEnv = N(), this.schedulePeriodicCleanup();
-  }
-  /**
-   * Schedule an update to be executed in the next microtask
-   * Uses component identity to deduplicate multiple render requests for the same component
-   */
-  schedule(e, n) {
-    const t = n || e;
-    this.pendingUpdates.size >= this.MAX_PENDING_SIZE && this.performEmergencyCleanup(), this.pendingUpdates.set(t, e), this.isFlushScheduled || this.scheduleFlush();
-  }
-  /**
-   * Schedule the flush operation based on environment
-   */
-  scheduleFlush() {
-    this.isFlushScheduled = !0, this.testEnv.isTest && !this.isFlushing ? this.flush() : queueMicrotask(() => this.flush());
-  }
-  /**
-   * Execute all pending updates with priority ordering
-   */
-  flush() {
-    if (this.isFlushing)
-      return;
-    this.isFlushing = !0;
-    const e = this.pendingUpdates;
-    this.pendingUpdates = /* @__PURE__ */ new Map(), this.isFlushScheduled = !1;
-    try {
-      for (const n of e.values())
-        try {
-          n();
-        } catch (t) {
-          w("Error in batched update:", t);
-        }
-    } finally {
-      this.isFlushing = !1;
-    }
-  }
-  /**
-   * Force flush any pending DOM updates immediately. This is useful in
-   * test environments or callers that require synchronous guarantees after
-   * state changes. Prefer relying on the scheduler's automatic flush when
-   * possible; use this only when a caller needs to synchronously observe
-   * rendered DOM changes.
-   */
-  flushImmediately() {
-    this.pendingUpdates.size !== 0 && (this.isFlushScheduled = !1, this.flush());
-  }
-  /**
-   * Get the number of pending updates
-   */
-  get pendingCount() {
-    return this.pendingUpdates.size;
-  }
-  /**
-   * Check if there are pending updates
-   */
-  get hasPendingUpdates() {
-    return this.pendingUpdates.size > 0;
-  }
-  /**
-   * Check if currently flushing updates
-   */
-  get isFlushingUpdates() {
-    return this.isFlushing;
-  }
-  /**
-   * Schedule periodic cleanup to prevent memory leaks
-   */
-  schedulePeriodicCleanup() {
-    if (this.testEnv.isTest) return;
-    const e = () => {
-      this.performPeriodicCleanup(), this.testEnv.isTest || setTimeout(e, this.CLEANUP_INTERVAL);
-    };
-    setTimeout(e, this.CLEANUP_INTERVAL);
-  }
-  /**
-   * Perform periodic cleanup of stale entries
-   */
-  performPeriodicCleanup() {
-    const e = Date.now();
-    e - this.lastCleanup < this.CLEANUP_INTERVAL || (this.pendingUpdates.size > 100 && d(
-      `Scheduler has ${this.pendingUpdates.size} pending updates. Consider investigating.`
-    ), this.lastCleanup = e);
-  }
-  /**
-   * Emergency cleanup when pending updates exceed safe limits.
-   * @param queue - The specific map to trim; defaults to the normal queue.
-   */
-  performEmergencyCleanup(e = this.pendingUpdates) {
-    d(
-      "Scheduler emergency cleanup: too many pending updates, clearing oldest entries"
-    );
-    const n = Array.from(e.entries()), t = Math.floor(n.length / 2);
-    for (let r = 0; r < t; r++)
-      e.delete(n[r][0]);
-  }
-  /**
-   * Schedule an update with an explicit priority level.
-   *
-   * - `'immediate'` — Runs synchronously before returning.
-   * - `'normal'`    — Default microtask batching (same as `schedule()`).
-   * - `'idle'`      — Deferred to browser idle time via `requestIdleCallback`
-   *                    with time-slicing to avoid blocking the main thread.
-   *                    Falls back to a 5 ms `setTimeout` when
-   *                    `requestIdleCallback` is unavailable (e.g. Safari < 16).
-   *
-   * @example Defer a low-priority analytics flush
-   * ```ts
-   * scheduleWithPriority(() => flushAnalytics(), 'idle');
-   * ```
-   */
-  scheduleWithPriority(e, n = "normal", t) {
-    if (n === "immediate") {
-      try {
-        e();
-      } catch (i) {
-        w("Error in immediate update:", i);
-      }
-      return;
-    }
-    if (n === "idle") {
-      const i = t ?? e;
-      this.pendingIdleUpdates.size >= this.MAX_PENDING_SIZE && this.performEmergencyCleanup(this.pendingIdleUpdates), this.pendingIdleUpdates.set(i, e), this.scheduleIdleFlush();
-      return;
-    }
-    const r = t ?? e;
-    this.pendingUpdates.size >= this.MAX_PENDING_SIZE && this.performEmergencyCleanup(), this.pendingUpdates.set(r, e), this.isFlushScheduled || (this.isFlushScheduled = !0, queueMicrotask(() => this.flush()));
-  }
-  /**
-   * Schedule a flush of idle-priority updates.
-   * Uses `requestIdleCallback` when available; falls back to a short `setTimeout`.
-   */
-  scheduleIdleFlush() {
-    if (this.idleCallbackHandle === null) {
-      if (this.testEnv.isTest) {
-        this.idleCallbackHandle = setTimeout(() => {
-          this.idleCallbackHandle = null, this.flushIdleUpdates(null);
-        }, 0);
-        return;
-      }
-      if (typeof requestIdleCallback < "u") {
-        const e = requestIdleCallback(
-          (n) => {
-            this.idleCallbackHandle = null, this.flushIdleUpdates(n);
-          },
-          { timeout: 2e3 }
-        );
-        this.idleCallbackHandle = e;
-      } else
-        this.idleCallbackHandle = setTimeout(() => {
-          this.idleCallbackHandle = null;
-          const e = Date.now();
-          this.flushIdleUpdates({
-            timeRemaining: () => Math.max(0, 50 - (Date.now() - e)),
-            didTimeout: !1
-          });
-        }, 5);
-    }
-  }
-  /**
-   * Process pending idle-priority updates in a time-sliced manner.
-   * Yields back to the browser when the deadline's `timeRemaining()` reaches
-   * zero and reschedules any unprocessed work.
-   */
-  flushIdleUpdates(e) {
-    const n = Array.from(this.pendingIdleUpdates.entries());
-    this.pendingIdleUpdates = /* @__PURE__ */ new Map();
-    for (let t = 0; t < n.length; t++) {
-      if (e && !e.didTimeout && e.timeRemaining() <= 0) {
-        for (let r = t; r < n.length; r++)
-          this.pendingIdleUpdates.set(n[r][0], n[r][1]);
-        this.scheduleIdleFlush();
-        return;
-      }
-      try {
-        n[t][1]();
-      } catch (r) {
-        w("Error in idle update:", r);
-      }
-    }
-  }
-}
-const p = new L();
-function x(s, e) {
-  p.schedule(s, e);
-}
-function V(s, e = "normal", n) {
-  p.scheduleWithPriority(s, e, n);
-}
-function q() {
-  p.flushImmediately();
-}
-function $() {
-  return new Promise((s) => {
-    let n = 0;
-    for (; p.hasPendingUpdates && n < 100; )
-      p.flushImmediately(), n++;
-    n >= 100 && d(
-      "[nextTick] Maximum flush iterations reached — possible circular update loop. Check for watchers or computed values that unconditionally mutate reactive state."
-    ), queueMicrotask(s);
-  });
-}
-const T = /* @__PURE__ */ new WeakSet();
-class P {
-  static cache = /* @__PURE__ */ new WeakMap();
-  static arrayHandlerCache = /* @__PURE__ */ new WeakMap();
-  static objectHandlerCache = /* @__PURE__ */ new WeakMap();
-  /**
-   * Get or create a reactive proxy for an object
-   */
-  static getOrCreateProxy(e, n, t = !1) {
-    const r = this.cache.get(e);
-    if (r)
-      return r;
-    const i = t ? this.getOrCreateArrayHandler(n) : this.getOrCreateObjectHandler(n), a = new Proxy(e, i);
-    try {
-      A.markAsProxy(a);
-    } catch {
-    }
-    return this.cache.set(e, a), a;
-  }
-  /**
-   * Get or create a cached array handler
-   */
-  static getOrCreateArrayHandler(e) {
-    if (!this.arrayHandlerCache.has(e)) {
-      const n = {
-        get: (t, r, i) => {
-          const a = Reflect.get(t, r, i);
-          return typeof a == "function" && typeof r == "string" && [
-            "push",
-            "pop",
-            "shift",
-            "unshift",
-            "splice",
-            "sort",
-            "reverse",
-            "fill",
-            "copyWithin"
-          ].includes(r) ? function(...l) {
-            const h = a.apply(t, l);
-            return e.triggerUpdate(), h;
-          } : a !== null && typeof a == "object" && typeof r == "string" ? e.makeReactiveValue(a) : a;
-        },
-        set: (t, r, i) => (t[r] = e.makeReactiveValue(i), e.triggerUpdate(), !0),
-        deleteProperty: (t, r) => (delete t[r], e.triggerUpdate(), !0)
-      };
-      this.arrayHandlerCache.set(e, n);
-    }
-    return this.arrayHandlerCache.get(e);
-  }
-  /**
-   * Get or create a cached object handler
-   */
-  static getOrCreateObjectHandler(e) {
-    if (!this.objectHandlerCache.has(e)) {
-      const n = {
-        get: (t, r, i) => {
-          const a = Reflect.get(t, r, i);
-          return a !== null && typeof a == "object" && typeof r == "string" ? e.makeReactiveValue(a) : a;
-        },
-        set: (t, r, i) => (t[r] = e.makeReactiveValue(i), e.triggerUpdate(), !0),
-        deleteProperty: (t, r) => (delete t[r], e.triggerUpdate(), !0)
-      };
-      this.objectHandlerCache.set(e, n);
-    }
-    return this.objectHandlerCache.get(e);
-  }
-  /**
-   * Check if an object already has a cached proxy
-   */
-  static hasProxy(e) {
-    return this.cache.has(e);
-  }
-  /**
-   * Clear all cached proxies (useful for testing)
-   */
-  static clear() {
-    this.cache = /* @__PURE__ */ new WeakMap(), this.arrayHandlerCache = /* @__PURE__ */ new WeakMap(), this.objectHandlerCache = /* @__PURE__ */ new WeakMap();
-  }
-  /**
-   * Get cache statistics (for debugging)
-   * Note: WeakMap doesn't provide size, so this is limited
-   */
-  static getStats() {
-    return {
-      hasCachedProxies: this.cache instanceof WeakMap
-    };
-  }
-}
-class A {
-  // Cache a stable reactiveContext object keyed by onUpdate -> makeReactive
-  // This allows handler caches in ReactiveProxyCache to reuse handlers
-  // for identical reactive contexts instead of creating a new context object
-  // on each createReactiveProxy call.
-  static contextCache = /* @__PURE__ */ new WeakMap();
-  /**
-   * Create an optimized reactive proxy with minimal overhead
-   */
-  static createReactiveProxy(e, n, t) {
-    try {
-      if (T.has(e)) return e;
-    } catch {
-    }
-    const r = Array.isArray(e);
-    let i = this.contextCache.get(n);
-    i || (i = /* @__PURE__ */ new WeakMap(), this.contextCache.set(n, i));
-    let a = i.get(t);
-    return a || (a = {
-      triggerUpdate: n,
-      makeReactiveValue: t
-    }, i.set(t, a)), P.getOrCreateProxy(e, a, r);
-  }
-  /**
-   * Mark an object as a proxy (for optimization)
-   */
-  static markAsProxy(e) {
-    if (e)
-      try {
-        T.add(e);
-      } catch {
-      }
-  }
-}
-let C = !1;
-function R() {
-  return C;
-}
-function X() {
-  C && d(
-    "[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."
-  ), C = !0;
-}
-function G() {
-  C = !1;
-}
-let F = 0;
-function S(s) {
-  return `${s}-${++F}`;
-}
-class W {
-  // Use a stack to support nested callers (component render -> watcher)
-  // so that watchers can temporarily become the "current component" while
-  // establishing dependencies without clobbering the outer component id.
-  currentComponentStack = [];
-  // Consolidated component data: stores dependencies, render function, state index, and last warning time
-  componentData = /* @__PURE__ */ new Map();
-  // Flat storage: compound key `${componentId}:${stateIndex}` -> ReactiveState
-  stateStorage = /* @__PURE__ */ new Map();
-  trackingDisabled = !1;
-  /**
-   * Set the current component being rendered for dependency tracking
-   */
-  setCurrentComponent(e, n) {
-    if (this.currentComponentStack.push(e), !this.componentData.has(e))
-      this.componentData.set(e, {
-        dependencies: /* @__PURE__ */ new Set(),
-        renderFn: n,
-        stateIndex: 0,
-        lastWarnTime: 0,
-        watchers: /* @__PURE__ */ new Map()
-      });
-    else {
-      const t = this.componentData.get(e);
-      if (t.watchers && t.watchers.size) {
-        for (const r of t.watchers.values())
-          try {
-            this.cleanup(r);
-          } catch {
-          }
-        t.watchers.clear();
-      }
-      t.renderFn = n, t.stateIndex = 0;
-    }
-  }
-  /**
-   * Clear the current component after rendering
-   */
-  clearCurrentComponent() {
-    this.currentComponentStack.pop();
-  }
-  /**
-   * Get the current component id (top of stack) or null
-   */
-  getCurrentComponentId() {
-    return this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
-  }
-  /**
-   * Register a watcher id under a component so it can be cleaned up on re-render
-   */
-  registerWatcher(e, n) {
-    const t = this.componentData.get(e);
-    t && t.watchers.set(n, n);
-  }
-  /**
-   * Temporarily disable dependency tracking
-   */
-  disableTracking() {
-    this.trackingDisabled = !0;
-  }
-  /**
-   * Re-enable dependency tracking
-   */
-  enableTracking() {
-    this.trackingDisabled = !1;
-  }
-  /**
-   * Check if a component is currently rendering
-   */
-  isRenderingComponent() {
-    return this.currentComponentStack.length > 0;
-  }
-  /**
-   * Return whether we should emit a render-time warning for the current component.
-   * This throttles warnings to avoid spamming the console for legitimate rapid updates.
-   */
-  shouldEmitRenderWarning() {
-    const e = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
-    if (!e) return !0;
-    const n = this.componentData.get(e);
-    if (!n) return !0;
-    const t = Date.now();
-    return t - n.lastWarnTime < 1e3 ? !1 : (n.lastWarnTime = t, !0);
-  }
-  /**
-   * Execute a function with tracking disabled
-   */
-  withoutTracking(e) {
-    const n = this.trackingDisabled;
-    this.trackingDisabled = !0;
-    try {
-      return e();
-    } finally {
-      this.trackingDisabled = n;
-    }
-  }
-  /**
-   * Get or create a state instance for the current component
-   */
-  getOrCreateState(e) {
-    const n = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
-    if (!n)
-      return new _(e);
-    const t = this.componentData.get(n);
-    if (!t)
-      return new _(e);
-    const r = `${n}:${t.stateIndex++}`;
-    let i = this.stateStorage.get(r);
-    return i || (i = new _(e), this.stateStorage.set(r, i)), i;
-  }
-  /**
-   * Track a dependency for the current component
-   */
-  trackDependency(e) {
-    if (this.trackingDisabled) return;
-    const n = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
-    if (!n) return;
-    const t = this.componentData.get(n);
-    t && (t.dependencies.add(e), e.addDependent(n));
-  }
-  /**
-   * Re-register all reactive dependencies that `fromId` tracks into the
-   * currently-active (outer) component context.
-   *
-   * Used by `computed()` to forward its dep-set to the consuming component
-   * without re-executing the getter function a second time.
-   */
-  propagateDependencies(e) {
-    if (this.trackingDisabled) return;
-    const n = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
-    if (!n || n === e) return;
-    const t = this.componentData.get(e);
-    if (!t) return;
-    const r = this.componentData.get(n);
-    if (r)
-      for (const i of t.dependencies)
-        r.dependencies.add(i), i.addDependent(n);
-  }
-  /**
-   * Trigger updates for all components that depend on a state
-   */
-  triggerUpdate(e) {
-    const n = e.getDependents();
-    for (const t of n) {
-      const r = this.componentData.get(t);
-      r && x(r.renderFn, t);
-    }
-  }
-  /**
-   * Clean up component dependencies when component is destroyed
-   */
-  cleanup(e) {
-    const n = this.componentData.get(e);
-    if (n) {
-      for (const r of n.dependencies)
-        r.removeDependent(e);
-      this.componentData.delete(e);
-    }
-    const t = e + ":";
-    for (const r of this.stateStorage.keys())
-      r.startsWith(t) && this.stateStorage.delete(r);
-  }
-}
-const c = new W();
-class _ {
-  _value;
-  /** The unwrapped value last assigned — used for Object.is equality checks. */
-  _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 c.trackDependency(this), this._value;
-  }
-  set value(e) {
-    Object.is(e, this._rawValue) || (c.isRenderingComponent() && c.shouldEmitRenderWarning() && d(
-      `🚨 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), c.triggerUpdate(this));
-  }
-  /**
-   * Read the current value without registering a reactive dependency.
-   * Useful for internal infrastructure (e.g. stable hook slots) that must
-   * inspect the stored value without re-triggering the containing component.
-   * @internal
-   */
-  peek() {
-    return this._value;
-  }
-  /**
-   * Set the initial value without triggering any reactive updates or warnings.
-   * Only intended for internal/infrastructure use (e.g. storing a stable hook
-   * handle in a reactive slot without causing a spurious re-render).
-   * The value is stored as-is without reactive proxy wrapping so that opaque
-   * objects (e.g. TeleportHandle) are not accidentally instrumented.
-   * @internal
-   */
-  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" || e instanceof Node || e instanceof Element || e instanceof HTMLElement ? e : A.createReactiveProxy(
-      e,
-      () => c.triggerUpdate(this),
-      (n) => this.makeReactive(n)
-    );
-  }
-}
-function Z(s) {
-  return c.getOrCreateState(
-    s === void 0 ? null : s
-  );
-}
-function E(s) {
-  if (!s || typeof s != "object") return !1;
-  try {
-    const e = /* @__PURE__ */ Symbol.for("@cer/ReactiveState");
-    return Object.prototype.hasOwnProperty.call(s, e);
-  } catch {
-    return !1;
-  }
-}
-function B(s) {
-  let e, n = !0;
-  const t = S("computed"), r = () => {
-    n = !0;
-  };
-  try {
-    const i = c.getCurrentComponentId();
-    i && c.registerWatcher(i, t);
-  } catch {
-  }
-  return c.setCurrentComponent(t, r), e = s(), c.clearCurrentComponent(), n = !1, {
-    get value() {
-      return n && (c.setCurrentComponent(t, r), e = s(), c.clearCurrentComponent(), n = !1), c.propagateDependencies(t), e;
-    }
-  };
-}
-function K(s) {
-  if (R()) return () => {
-  };
-  const e = S("effect");
-  try {
-    const t = c.getCurrentComponentId();
-    t && c.registerWatcher(t, e);
-  } catch {
-  }
-  const n = () => {
-    c.setCurrentComponent(e, n);
-    try {
-      s();
-    } finally {
-      c.clearCurrentComponent();
-    }
-  };
-  return n(), () => {
-    c.cleanup(e);
-  };
-}
-const b = 50;
-function k(s, e = /* @__PURE__ */ new WeakMap(), n = 0) {
-  if (s === null || typeof s != "object") return s;
-  const t = s;
-  if (e.has(t)) return e.get(t);
-  if (n > b)
-    return d(
-      `[watch] Deep clone exceeded ${b} nesting levels. Returning a reference at this depth instead of cloning further. Consider restructuring your state or switching to a shallow watch.`
-    ), s;
-  if (typeof Node < "u" && t instanceof Node) return s;
-  if (t instanceof Date) return new Date(t.getTime());
-  if (Array.isArray(t)) {
-    const i = [];
-    e.set(t, i);
-    for (let a = 0; a < t.length; a++)
-      i.push(k(t[a], e, n + 1));
-    return i;
-  }
-  const r = {};
-  e.set(t, r);
-  for (const i of Object.keys(t))
-    try {
-      r[i] = k(
-        t[i],
-        e,
-        n + 1
-      );
-    } catch {
-    }
-  return r;
-}
-function J(s, e, n) {
-  if (R()) return () => {
-  };
-  let t;
-  const r = E(s) ? () => s.value : s, i = S("watch");
-  try {
-    const o = c.getCurrentComponentId();
-    o && c.registerWatcher(o, i);
-  } catch {
-  }
-  const a = () => {
-    c.setCurrentComponent(i, a);
-    const o = r();
-    if (c.clearCurrentComponent(), n?.deep) {
-      const l = c.withoutTracking(
-        () => k(o)
-      );
-      e(l, t), t = l;
-    } else o !== t && (e(o, t), t = o);
-  };
-  return c.setCurrentComponent(i, a), t = r(), c.clearCurrentComponent(), n?.deep && (t = c.withoutTracking(() => k(t))), n && n.immediate && e(t, void 0), () => {
-    c.cleanup(i);
-  };
-}
-const Q = (s) => {
-  try {
-    s();
-  } catch {
-  }
-}, g = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), M = 500;
-let f, U, v = !1, D = !1, I;
-const O = !!globalThis.process?.versions?.node;
-function Y(s) {
-  if (g.has(s))
-    return g.get(s);
-  const e = s.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-  return g.size < M && g.set(s, e), e;
-}
-function ee(s) {
-  if (m.has(s))
-    return m.get(s);
-  const e = s.replace(/-([a-z])/g, (n, t) => t.toUpperCase());
-  return m.size < M && m.set(s, e), e;
-}
-function te(s) {
-  if (typeof s == "string") {
-    if (y.has(s))
-      return y.get(s);
-    const e = s.replace(
-      /[&<>"']/g,
-      (n) => ({
-        "&": "&amp;",
-        "<": "&lt;",
-        ">": "&gt;",
-        '"': "&quot;",
-        "'": "&#39;"
-      })[n]
-    );
-    return e !== s && y.size < M && y.set(s, e), e;
-  }
-  return s;
-}
-function u(s) {
-  if (!s) return "";
-  const e = String(s);
-  if (typeof document < "u" && typeof document.createElement == "function") {
-    const o = e.replace(/</g, "").replace(/>/g, ""), l = I || (I = document.createElement("div"));
-    try {
-      u._el = l;
-    } catch {
-    }
-    return l.innerHTML = o, (l.textContent || "").replace(new RegExp("", "g"), "<").replace(new RegExp("", "g"), ">");
-  }
-  const n = {
-    lt: "<",
-    gt: ">",
-    amp: "&",
-    quot: '"',
-    apos: "'",
-    nbsp: " "
-  }, t = f ?? u._namedMap;
-  let r = t;
-  if (!r && O)
-    try {
-      const i = globalThis.require;
-      if (typeof i == "function") {
-        const a = [
-          "@jasonshimmy/custom-elements-runtime/entities.json",
-          // installed package export
-          "../../entities.json",
-          // dist/runtime -> ../../entities.json
-          "../../../entities.json",
-          // src/lib/runtime -> ../../../entities.json
-          "../entities.json",
-          "./entities.json"
-        ];
-        for (const o of a)
-          try {
-            const l = i(o);
-            if (l && typeof l == "object") {
-              r = l;
-              break;
-            }
-          } catch {
-          }
-      }
-    } catch {
-    }
-  if (!r) {
-    r = n, v = !0;
-    try {
-      u._usedFallback = !0;
-    } catch {
-    }
-    const i = u._namedMapLoader ?? U;
-    i && i().then((a) => {
-      f = a;
-      try {
-        u._namedMap = a;
-      } catch {
-      }
-    }).catch(() => {
-    });
-  }
-  if ((v || u._usedFallback) && !(D || u._warnedFallback)) {
-    D = !0;
-    try {
-      u._warnedFallback = !0;
-    } catch {
-    }
-    try {
-      d(
-        "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 e.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (i, a) => {
-    if (a.charCodeAt(0) === 35) {
-      const h = (a.charAt(1) || "").toLowerCase() === "x" ? parseInt(a.slice(2), 16) : parseInt(a.slice(1), 10);
-      return Number.isNaN(h) ? `&${a};` : String.fromCodePoint(h);
-    }
-    const o = r[a] ?? (t && t[a]);
-    return o !== void 0 ? o : `&${a};`;
-  });
-}
-async function H() {
-  const s = [
-    "@jasonshimmy",
-    "custom-elements-runtime",
-    "entities.json"
-  ].join("/");
-  try {
-    const e = await import(
-      /* @vite-ignore */
-      s
-    );
-    return e && (e.default || e);
-  } catch {
-    try {
-      const e = [
-        s,
-        // try package export via dynamic import too (best for installed packages)
-        "./entities.json",
-        "../../entities.json",
-        "../../../entities.json"
-      ];
-      for (const n of e)
-        try {
-          const t = await import(
-            /* @vite-ignore */
-            n
-          );
-          if (t)
-            return t && (t.default || t);
-        } catch {
-        }
-      return {
-        lt: "<",
-        gt: ">",
-        amp: "&",
-        quot: '"',
-        apos: "'",
-        nbsp: " "
-      };
-    } catch {
-      return {
-        lt: "<",
-        gt: ">",
-        amp: "&",
-        quot: '"',
-        apos: "'",
-        nbsp: " "
-      };
-    }
-  }
-}
-U = H;
-u._namedMapLoader = H;
-function ne(s, e) {
-  !s || typeof s != "object" || f && !e?.overwrite || (f = s);
-}
-function se() {
-  f = void 0;
-}
-function re(s) {
-  const e = String(s);
-  return { __unsafeHTML: e, __rawHTML: e };
-}
-function ie(s) {
-  return !!s && (typeof s.__unsafeHTML == "string" || typeof s.__rawHTML == "string");
-}
-function ae(s, e) {
-  if (typeof e == "string") {
-    if (e === "") return;
-    const n = e.split(".");
-    let t = s;
-    for (const r of n) {
-      if (t == null || typeof t != "object") {
-        t = void 0;
-        break;
-      }
-      t = t[r];
-    }
-    return E(t) ? t.value : t;
-  }
-  return e;
-}
-function ce(s, e, n) {
-  const t = String(e).split("."), r = t.pop();
-  if (!r) return;
-  const i = t.reduce(
-    (a, o) => (a[o] == null && (a[o] = {}), a[o]),
-    s
-  );
-  E(i[r]) ? i[r].value = n : i[r] = n;
-}
-function j(s) {
-  try {
-    if (s && typeof s == "object") {
-      if (E(s)) return s.value;
-      if ("value" in s) {
-        const e = s.value;
-        return e == null || typeof e == "string" || typeof e == "number" || typeof e == "boolean" ? e : s;
-      }
-    }
-  } catch {
-  }
-  return s;
-}
-function oe(s) {
-  const e = j(s);
-  if (e == null) return null;
-  const n = typeof e;
-  return n === "string" || n === "number" || n === "boolean" ? String(e) : null;
-}
-function le(s) {
-  if (!s || typeof s != "string") return !1;
-  if (s === "class" || s.endsWith("Class")) return !0;
-  if (s.includes("-"))
-    try {
-      if (s.split("-").some((n) => n === "class")) return !0;
-    } catch {
-    }
-  return !1;
-}
-export {
-  R as A,
-  _ as R,
-  c as a,
-  K as b,
-  B as c,
-  u as d,
-  te as e,
-  q as f,
-  se as g,
-  ne as h,
-  E as i,
-  ae as j,
-  ce as k,
-  H as l,
-  Q as m,
-  $ as n,
-  oe as o,
-  ee as p,
-  le as q,
-  Z as r,
-  V as s,
-  Y as t,
-  re as u,
-  x as v,
-  J as w,
-  X as x,
-  G as y,
-  ie as z
-};
-//# sourceMappingURL=helpers-CweFZFWU.js.map