@jasonshimmy/custom-elements-runtime 2.5.2 → 2.5.5

package/dist/namespace-helpers-DcD_6_K1.js

@@ -0,0 +1,989 @@
+import { d as E, a as y } from "./logger-BvkEbVM4.js";
+function x() {
+  const s = (() => {
+    try {
+      return globalThis.process?.env?.NODE_ENV;
+    } catch {
+      return;
+    }
+  })(), e = (() => {
+    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: s === "test" || e.vitest || e.cypress,
+    isVitest: e.vitest,
+    isCypress: e.cypress
+  };
+}
+class H {
+  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 = x(), 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, t) {
+    const n = t || e;
+    this.pendingUpdates.size >= this.MAX_PENDING_SIZE && this.performEmergencyCleanup(), this.pendingUpdates.set(n, 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
+   * 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 t of e.values())
+        try {
+          t();
+        } catch (n) {
+          E("Error in batched update:", n);
+        }
+    } 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 && y(
+      `Scheduler has ${this.pendingUpdates.size} pending updates. Consider investigating.`
+    ), this.lastCleanup = e);
+  }
+  /**
+   * Emergency cleanup when pending updates exceed safe limits
+   */
+  performEmergencyCleanup() {
+    y(
+      "Scheduler emergency cleanup: too many pending updates, clearing oldest entries"
+    );
+    const e = Array.from(this.pendingUpdates.entries()), t = Math.floor(e.length / 2);
+    for (let n = 0; n < t; n++)
+      this.pendingUpdates.delete(e[n][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, t = "normal", n) {
+    if (t === "immediate") {
+      try {
+        e();
+      } catch (i) {
+        E("Error in immediate update:", i);
+      }
+      return;
+    }
+    if (t === "idle") {
+      const i = n ?? e;
+      this.pendingIdleUpdates.size >= this.MAX_PENDING_SIZE && this.performEmergencyCleanup(), this.pendingIdleUpdates.set(i, 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()));
+  }
+  /**
+   * 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(
+          (t) => {
+            this.idleCallbackHandle = null, this.flushIdleUpdates(t);
+          },
+          { 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 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) {
+        E("Error in idle update:", r);
+      }
+    }
+  }
+}
+const h = new H();
+function R(s, e) {
+  h.schedule(s, e);
+}
+function V(s, e = "normal", t) {
+  h.scheduleWithPriority(s, e, t);
+}
+function q() {
+  h.flushImmediately();
+}
+function $() {
+  return new Promise((s) => {
+    h.hasPendingUpdates && h.flushImmediately(), queueMicrotask(s);
+  });
+}
+const _ = /* @__PURE__ */ new WeakSet();
+class L {
+  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, t, n = !1) {
+    const r = this.cache.get(e);
+    if (r)
+      return r;
+    const i = n ? this.getOrCreateArrayHandler(t) : this.getOrCreateObjectHandler(t), a = new Proxy(e, i);
+    try {
+      v.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 t = {
+        get: (n, r, i) => {
+          const a = Reflect.get(n, r, i);
+          return typeof a == "function" && typeof r == "string" && [
+            "push",
+            "pop",
+            "shift",
+            "unshift",
+            "splice",
+            "sort",
+            "reverse",
+            "fill",
+            "copyWithin"
+          ].includes(r) ? function(...u) {
+            const d = a.apply(n, u);
+            return e.triggerUpdate(), d;
+          } : a !== null && typeof a == "object" && typeof r == "string" ? e.makeReactiveValue(a) : a;
+        },
+        set: (n, r, i) => (n[r] = e.makeReactiveValue(i), e.triggerUpdate(), !0),
+        deleteProperty: (n, r) => (delete n[r], e.triggerUpdate(), !0)
+      };
+      this.arrayHandlerCache.set(e, t);
+    }
+    return this.arrayHandlerCache.get(e);
+  }
+  /**
+   * Get or create a cached object handler
+   */
+  static getOrCreateObjectHandler(e) {
+    if (!this.objectHandlerCache.has(e)) {
+      const t = {
+        get: (n, r, i) => {
+          const a = Reflect.get(n, r, i);
+          return a !== null && typeof a == "object" && typeof r == "string" ? e.makeReactiveValue(a) : a;
+        },
+        set: (n, r, i) => (n[r] = e.makeReactiveValue(i), e.triggerUpdate(), !0),
+        deleteProperty: (n, r) => (delete n[r], e.triggerUpdate(), !0)
+      };
+      this.objectHandlerCache.set(e, t);
+    }
+    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 v {
+  // 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, t, n) {
+    try {
+      if (_.has(e)) return e;
+    } catch {
+    }
+    const r = Array.isArray(e);
+    let i = this.contextCache.get(t);
+    i || (i = /* @__PURE__ */ new WeakMap(), this.contextCache.set(t, i));
+    let a = i.get(n);
+    return a || (a = {
+      triggerUpdate: t,
+      makeReactiveValue: n
+    }, i.set(n, a)), L.getOrCreateProxy(e, a, r);
+  }
+  /**
+   * Mark an object as a proxy (for optimization)
+   */
+  static markAsProxy(e) {
+    if (e)
+      try {
+        _.add(e);
+      } catch {
+      }
+  }
+}
+let b = !1;
+function U() {
+  return b;
+}
+function G() {
+  b = !0;
+}
+function Z() {
+  b = !1;
+}
+class P {
+  // 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, 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;
+    }
+  }
+  /**
+   * 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, t) {
+    const n = this.componentData.get(e);
+    n && n.watchers.set(t, t);
+  }
+  /**
+   * 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 t = this.componentData.get(e);
+    if (!t) return !0;
+    const n = Date.now();
+    return n - t.lastWarnTime < 1e3 ? !1 : (t.lastWarnTime = n, !0);
+  }
+  /**
+   * Execute a function with tracking disabled
+   */
+  withoutTracking(e) {
+    const t = this.trackingDisabled;
+    this.trackingDisabled = !0;
+    try {
+      return e();
+    } finally {
+      this.trackingDisabled = t;
+    }
+  }
+  /**
+   * Get or create a state instance for the current component
+   */
+  getOrCreateState(e) {
+    const t = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+    if (!t)
+      return new k(e);
+    const n = this.componentData.get(t);
+    if (!n)
+      return new k(e);
+    const r = `${t}:${n.stateIndex++}`;
+    let i = this.stateStorage.get(r);
+    return i || (i = new k(e), this.stateStorage.set(r, i)), i;
+  }
+  /**
+   * Track a dependency for the current component
+   */
+  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));
+  }
+  /**
+   * Trigger updates for all components that depend on a state
+   */
+  triggerUpdate(e) {
+    const t = e.getDependents();
+    for (const n of t) {
+      const r = this.componentData.get(n);
+      r && R(r.renderFn, n);
+    }
+  }
+  /**
+   * Clean up component dependencies when component is destroyed
+   */
+  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);
+  }
+}
+const c = new P();
+class k {
+  _value;
+  dependents = /* @__PURE__ */ new Set();
+  constructor(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) {
+    c.isRenderingComponent() && c.shouldEmitRenderWarning() && y(
+      `🚨 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._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._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 : v.createReactiveProxy(
+      e,
+      () => c.triggerUpdate(this),
+      (t) => this.makeReactive(t)
+    );
+  }
+}
+function X(s) {
+  return c.getOrCreateState(
+    s === void 0 ? null : s
+  );
+}
+function w(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, t = !0;
+  const n = `computed-${crypto.randomUUID()}`, r = () => {
+    t = !0;
+  };
+  try {
+    const i = c.getCurrentComponentId();
+    i && c.registerWatcher(i, n);
+  } catch {
+  }
+  return c.setCurrentComponent(n, r), e = s(), c.clearCurrentComponent(), t = !1, {
+    get value() {
+      return t && (c.setCurrentComponent(n, r), e = s(), c.clearCurrentComponent(), t = !1), s(), e;
+    }
+  };
+}
+function K(s) {
+  if (U()) return () => {
+  };
+  const e = `effect-${crypto.randomUUID()}`;
+  try {
+    const n = c.getCurrentComponentId();
+    n && c.registerWatcher(n, e);
+  } catch {
+  }
+  const t = () => {
+    c.setCurrentComponent(e, t);
+    try {
+      s();
+    } finally {
+      c.clearCurrentComponent();
+    }
+  };
+  return t(), () => {
+    c.cleanup(e);
+  };
+}
+function C(s, e = /* @__PURE__ */ new WeakMap()) {
+  if (s === null || typeof s != "object") return s;
+  const t = s;
+  if (e.has(t)) return e.get(t);
+  if (typeof Node < "u" && t instanceof Node) return s;
+  if (t instanceof Date) return new Date(t.getTime());
+  if (Array.isArray(t)) {
+    const r = [];
+    e.set(t, r);
+    for (let i = 0; i < t.length; i++)
+      r.push(C(t[i], e));
+    return r;
+  }
+  const n = {};
+  e.set(t, n);
+  for (const r of Object.keys(t))
+    try {
+      n[r] = C(t[r], e);
+    } catch {
+    }
+  return n;
+}
+function J(s, e, t) {
+  if (U()) return () => {
+  };
+  let n;
+  const r = w(s) ? () => s.value : s, i = `watch-${crypto.randomUUID()}`;
+  try {
+    const o = c.getCurrentComponentId();
+    o && c.registerWatcher(o, i);
+  } catch {
+  }
+  const a = () => {
+    c.setCurrentComponent(i, a);
+    const o = r();
+    if (c.clearCurrentComponent(), t?.deep) {
+      const u = c.withoutTracking(
+        () => C(o)
+      );
+      e(u, n), n = u;
+    } else o !== n && (e(o, n), n = o);
+  };
+  return c.setCurrentComponent(i, a), n = r(), c.clearCurrentComponent(), t?.deep && (n = c.withoutTracking(() => C(n))), t && t.immediate && e(n, void 0), () => {
+    c.cleanup(i);
+  };
+}
+const Q = (s) => {
+  try {
+    s();
+  } catch {
+  }
+}, p = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), M = 500;
+let f, D, S = !1, A = !1, T;
+const W = !!globalThis.process?.versions?.node;
+function Y(s) {
+  if (p.has(s))
+    return p.get(s);
+  const e = s.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  return p.size < M && p.set(s, e), e;
+}
+function ee(s) {
+  if (g.has(s))
+    return g.get(s);
+  const e = s.replace(/-([a-z])/g, (t, n) => n.toUpperCase());
+  return g.size < M && g.set(s, e), e;
+}
+function te(s) {
+  if (typeof s == "string") {
+    if (m.has(s))
+      return m.get(s);
+    const e = s.replace(
+      /[&<>"']/g,
+      (t) => ({
+        "&": "&amp;",
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&quot;",
+        "'": "&#39;"
+      })[t]
+    );
+    return e !== s && m.size < M && m.set(s, e), e;
+  }
+  return s;
+}
+function l(s) {
+  if (!s) return "";
+  const e = String(s);
+  if (typeof document < "u" && typeof document.createElement == "function") {
+    const o = e.replace(/</g, "").replace(/>/g, ""), u = T || (T = document.createElement("div"));
+    try {
+      l._el = u;
+    } catch {
+    }
+    return u.innerHTML = o, (u.textContent || "").replace(new RegExp("", "g"), "<").replace(new RegExp("", "g"), ">");
+  }
+  const t = {
+    lt: "<",
+    gt: ">",
+    amp: "&",
+    quot: '"',
+    apos: "'",
+    nbsp: " "
+  }, n = f ?? l._namedMap;
+  let r = n;
+  if (!r && W)
+    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 u = i(o);
+            if (u && typeof u == "object") {
+              r = u;
+              break;
+            }
+          } catch {
+          }
+      }
+    } catch {
+    }
+  if (!r) {
+    r = t, S = !0;
+    try {
+      l._usedFallback = !0;
+    } catch {
+    }
+    const i = l._namedMapLoader ?? D;
+    i && i().then((a) => {
+      f = a;
+      try {
+        l._namedMap = a;
+      } catch {
+      }
+    }).catch(() => {
+    });
+  }
+  if ((S || l._usedFallback) && !(A || l._warnedFallback)) {
+    A = !0;
+    try {
+      l._warnedFallback = !0;
+    } catch {
+    }
+    try {
+      y(
+        "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 d = (a.charAt(1) || "").toLowerCase() === "x" ? parseInt(a.slice(2), 16) : parseInt(a.slice(1), 10);
+      return Number.isNaN(d) ? `&${a};` : String.fromCodePoint(d);
+    }
+    const o = r[a] ?? (n && n[a]);
+    return o !== void 0 ? o : `&${a};`;
+  });
+}
+async function I() {
+  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 t of e)
+        try {
+          const n = await import(
+            /* @vite-ignore */
+            t
+          );
+          if (n)
+            return n && (n.default || n);
+        } catch {
+        }
+      return {
+        lt: "<",
+        gt: ">",
+        amp: "&",
+        quot: '"',
+        apos: "'",
+        nbsp: " "
+      };
+    } catch {
+      return {
+        lt: "<",
+        gt: ">",
+        amp: "&",
+        quot: '"',
+        apos: "'",
+        nbsp: " "
+      };
+    }
+  }
+}
+D = I;
+l._namedMapLoader = I;
+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 t = e.split(".");
+    let n = s;
+    for (const r of t) {
+      if (n == null || typeof n != "object") {
+        n = void 0;
+        break;
+      }
+      n = n[r];
+    }
+    return w(n) ? n.value : n;
+  }
+  return e;
+}
+function ce(s, e, t) {
+  const n = String(e).split("."), r = n.pop();
+  if (!r) return;
+  const i = n.reduce(
+    (a, o) => (a[o] == null && (a[o] = {}), a[o]),
+    s
+  );
+  w(i[r]) ? i[r].value = t : i[r] = t;
+}
+function F(s) {
+  try {
+    if (s && typeof s == "object") {
+      if (w(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 = F(s);
+  if (e == null) return null;
+  const t = typeof e;
+  return t === "string" || t === "number" || t === "boolean" ? String(e) : null;
+}
+function ue(s) {
+  if (!s || typeof s != "string") return !1;
+  if (s === "class" || s.endsWith("Class")) return !0;
+  if (s.includes("-"))
+    try {
+      if (s.split("-").some((t) => t === "class")) return !0;
+    } catch {
+    }
+  return !1;
+}
+const N = {
+  xlink: "http://www.w3.org/1999/xlink",
+  xml: "http://www.w3.org/XML/1998/namespace"
+};
+function le(s, e, t) {
+  try {
+    if (!e || !e.includes(":")) {
+      s.setAttribute(e, t);
+      return;
+    }
+    const n = e.indexOf(":"), r = e.substring(0, n), i = e.substring(n + 1), a = N[r];
+    a ? s.setAttributeNS(a, i, t) : s.setAttribute(e, t);
+  } catch {
+    try {
+      s.setAttribute(e, t);
+    } catch {
+    }
+  }
+}
+function de(s, e) {
+  try {
+    if (!e || !e.includes(":")) {
+      s.removeAttribute(e);
+      return;
+    }
+    const t = e.indexOf(":"), n = e.substring(0, t), r = e.substring(t + 1), i = N[n];
+    i ? s.removeAttributeNS(i, r) : s.removeAttribute(e);
+  } catch {
+    try {
+      s.removeAttribute(e);
+    } catch {
+    }
+  }
+}
+const j = "http://www.w3.org/2000/svg", O = "http://www.w3.org/1998/Math/MathML", he = {
+  svg: j,
+  math: O
+};
+export {
+  G as A,
+  Z as B,
+  ie as C,
+  k as R,
+  j as S,
+  he as T,
+  c as a,
+  K as b,
+  B as c,
+  l as d,
+  te as e,
+  q as f,
+  se as g,
+  ne as h,
+  w as i,
+  ae as j,
+  ce as k,
+  I as l,
+  Q as m,
+  $ as n,
+  oe as o,
+  le as p,
+  de as q,
+  X as r,
+  V as s,
+  Y as t,
+  re as u,
+  ee as v,
+  J as w,
+  ue as x,
+  R as y,
+  U as z
+};
+//# sourceMappingURL=namespace-helpers-DcD_6_K1.js.map