@jasonshimmy/custom-elements-runtime 3.4.0 → 3.5.0

package/dist/helpers-tJgb4Qve.js

@@ -0,0 +1,693 @@
+import { r as e, t } from "./logger-DIJ0UH3R.js";
+//#region src/lib/runtime/scheduler.ts
+function n() {
+	let e = (() => {
+		try {
+			return globalThis.process?.env?.NODE_ENV;
+		} catch {
+			return;
+		}
+	})(), t = (() => {
+		try {
+			if (typeof window > "u") return {
+				vitest: !1,
+				cypress: !1
+			};
+			let e = window;
+			return {
+				vitest: !!e.__vitest__,
+				cypress: !!e.Cypress
+			};
+		} catch {
+			return {
+				vitest: !1,
+				cypress: !1
+			};
+		}
+	})();
+	return {
+		isTest: e === "test" || t.vitest || t.cypress,
+		isVitest: t.vitest,
+		isCypress: t.cypress
+	};
+}
+var r = new 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 = n(), this.schedulePeriodicCleanup();
+	}
+	schedule(e, t) {
+		let 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;
+		let e = this.pendingUpdates;
+		this.pendingUpdates = /* @__PURE__ */ new Map(), this.isFlushScheduled = !1;
+		try {
+			for (let n of e.values()) try {
+				n();
+			} catch (e) {
+				t("Error in batched update:", e);
+			}
+		} 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;
+		let e = () => {
+			this.performPeriodicCleanup(), this.testEnv.isTest || setTimeout(e, this.CLEANUP_INTERVAL);
+		};
+		setTimeout(e, this.CLEANUP_INTERVAL);
+	}
+	performPeriodicCleanup() {
+		let t = Date.now();
+		t - this.lastCleanup < this.CLEANUP_INTERVAL || (this.pendingUpdates.size > 100 && e(`Scheduler has ${this.pendingUpdates.size} pending updates. Consider investigating.`), this.lastCleanup = t);
+	}
+	performEmergencyCleanup(t = this.pendingUpdates) {
+		e("Scheduler emergency cleanup: too many pending updates, clearing oldest entries");
+		let n = Array.from(t.entries()), r = Math.floor(n.length / 2);
+		for (let e = 0; e < r; e++) t.delete(n[e][0]);
+	}
+	scheduleWithPriority(e, n = "normal", r) {
+		if (n === "immediate") {
+			try {
+				e();
+			} catch (e) {
+				t("Error in immediate update:", e);
+			}
+			return;
+		}
+		if (n === "idle") {
+			let t = r ?? e;
+			this.pendingIdleUpdates.size >= this.MAX_PENDING_SIZE && this.performEmergencyCleanup(this.pendingIdleUpdates), this.pendingIdleUpdates.set(t, e), this.scheduleIdleFlush();
+			return;
+		}
+		let i = r ?? e;
+		this.pendingUpdates.size >= this.MAX_PENDING_SIZE && this.performEmergencyCleanup(), this.pendingUpdates.set(i, 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;
+				let e = Date.now();
+				this.flushIdleUpdates({
+					timeRemaining: () => Math.max(0, 50 - (Date.now() - e)),
+					didTimeout: !1
+				});
+			}, 5);
+		}
+	}
+	flushIdleUpdates(e) {
+		let n = Array.from(this.pendingIdleUpdates.entries());
+		this.pendingIdleUpdates = /* @__PURE__ */ new Map();
+		for (let r = 0; r < n.length; r++) {
+			if (e && !e.didTimeout && e.timeRemaining() <= 0) {
+				for (let e = r; e < n.length; e++) this.pendingIdleUpdates.set(n[e][0], n[e][1]);
+				this.scheduleIdleFlush();
+				return;
+			}
+			try {
+				n[r][1]();
+			} catch (e) {
+				t("Error in idle update:", e);
+			}
+		}
+	}
+}();
+function i(e, t) {
+	r.schedule(e, t);
+}
+function a(e, t = "normal", n) {
+	r.scheduleWithPriority(e, t, n);
+}
+function o() {
+	r.flushImmediately();
+}
+function s() {
+	return new Promise((t) => {
+		let n = 0;
+		for (; r.hasPendingUpdates && n < 100;) r.flushImmediately(), n++;
+		n >= 100 && e("[nextTick] Maximum flush iterations reached — possible circular update loop. Check for watchers or computed values that unconditionally mutate reactive state."), queueMicrotask(t);
+	});
+}
+//#endregion
+//#region src/lib/runtime/reactive-proxy-cache.ts
+var c = /* @__PURE__ */ new WeakSet(), l = class {
+	static cache = /* @__PURE__ */ new WeakMap();
+	static arrayHandlerCache = /* @__PURE__ */ new WeakMap();
+	static objectHandlerCache = /* @__PURE__ */ new WeakMap();
+	static getOrCreateProxy(e, t, n = !1) {
+		let r = this.cache.get(e);
+		if (r) return r;
+		let i = n ? this.getOrCreateArrayHandler(t) : this.getOrCreateObjectHandler(t), a = new Proxy(e, i);
+		try {
+			u.markAsProxy(a);
+		} catch {}
+		return this.cache.set(e, a), a;
+	}
+	static getOrCreateArrayHandler(e) {
+		return this.arrayHandlerCache.has(e) || this.arrayHandlerCache.set(e, {
+			get: (t, n, r) => {
+				let i = Reflect.get(t, n, r);
+				return typeof i == "function" && typeof n == "string" && [
+					"push",
+					"pop",
+					"shift",
+					"unshift",
+					"splice",
+					"sort",
+					"reverse",
+					"fill",
+					"copyWithin"
+				].includes(n) ? function(...n) {
+					let r = i.apply(t, n);
+					return e.triggerUpdate(), r;
+				} : typeof i == "object" && i && typeof n == "string" ? e.makeReactiveValue(i) : i;
+			},
+			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) => {
+				let i = Reflect.get(t, n, r);
+				return typeof i == "object" && i && typeof n == "string" ? e.makeReactiveValue(i) : i;
+			},
+			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 };
+	}
+}, u = class {
+	static contextCache = /* @__PURE__ */ new WeakMap();
+	static createReactiveProxy(e, t, n) {
+		try {
+			if (c.has(e)) return e;
+		} catch {}
+		let r = Array.isArray(e), 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);
+	}
+	static markAsProxy(e) {
+		if (e) try {
+			c.add(e);
+		} catch {}
+	}
+}, d = !1;
+function f() {
+	return d;
+}
+function p() {
+	d && e("[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."), d = !0;
+}
+function m() {
+	d = !1;
+}
+//#endregion
+//#region src/lib/runtime/reactive.ts
+var h = 0;
+function g(e) {
+	return `${e}-${++h}`;
+}
+var _ = new 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 {
+			let n = this.componentData.get(e);
+			if (n.watchers && n.watchers.size) {
+				for (let e of n.watchers.values()) try {
+					this.cleanup(e);
+				} 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) {
+		let 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() {
+		let e = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+		if (!e) return !0;
+		let t = this.componentData.get(e);
+		if (!t) return !0;
+		let n = Date.now();
+		return n - t.lastWarnTime < 1e3 ? !1 : (t.lastWarnTime = n, !0);
+	}
+	withoutTracking(e) {
+		let t = this.trackingDisabled;
+		this.trackingDisabled = !0;
+		try {
+			return e();
+		} finally {
+			this.trackingDisabled = t;
+		}
+	}
+	getOrCreateState(e) {
+		let t = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+		if (!t) return new v(e);
+		let n = this.componentData.get(t);
+		if (!n) return new v(e);
+		let r = `${t}:${n.stateIndex++}`, i = this.stateStorage.get(r);
+		return i || (i = new v(e), this.stateStorage.set(r, i)), i;
+	}
+	trackDependency(e) {
+		if (this.trackingDisabled) return;
+		let t = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+		if (!t) return;
+		let n = this.componentData.get(t);
+		n && (n.dependencies.add(e), e.addDependent(t));
+	}
+	propagateDependencies(e) {
+		if (this.trackingDisabled) return;
+		let t = this.currentComponentStack.length ? this.currentComponentStack[this.currentComponentStack.length - 1] : null;
+		if (!t || t === e) return;
+		let n = this.componentData.get(e);
+		if (!n) return;
+		let r = this.componentData.get(t);
+		if (r) for (let e of n.dependencies) r.dependencies.add(e), e.addDependent(t);
+	}
+	triggerUpdate(e) {
+		let t = e.getDependents();
+		for (let e of t) {
+			let t = this.componentData.get(e);
+			t && i(t.renderFn, e);
+		}
+	}
+	cleanup(e) {
+		let t = this.componentData.get(e);
+		if (t) {
+			for (let n of t.dependencies) n.removeDependent(e);
+			this.componentData.delete(e);
+		}
+		let n = e + ":";
+		for (let e of this.stateStorage.keys()) e.startsWith(n) && this.stateStorage.delete(e);
+	}
+}(), v = class {
+	_value;
+	_rawValue;
+	dependents = /* @__PURE__ */ new Set();
+	constructor(e) {
+		this._rawValue = e, this._value = this.makeReactive(e);
+		try {
+			Object.defineProperty(this, Symbol.for("@cer/ReactiveState"), {
+				value: !0,
+				enumerable: !1,
+				configurable: !1
+			});
+		} catch {}
+	}
+	get value() {
+		return _.trackDependency(this), this._value;
+	}
+	set value(t) {
+		Object.is(t, this._rawValue) || (_.isRenderingComponent() && _.shouldEmitRenderWarning() && e("🚨 State modification detected during render! This can cause infinite loops.\n  • Move state updates to event handlers\n  • Use watchEffect/watch for side effects\n  • Ensure computed properties don't modify state"), this._rawValue = t, this._value = this.makeReactive(t), _.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 typeof e != "object" || !e || typeof Node < "u" && e instanceof Node || typeof Element < "u" && e instanceof Element || typeof HTMLElement < "u" && e instanceof HTMLElement ? e : u.createReactiveProxy(e, () => _.triggerUpdate(this), (e) => this.makeReactive(e));
+	}
+};
+function y(e) {
+	return _.getOrCreateState(e === void 0 ? null : e);
+}
+function b(e) {
+	if (!e || typeof e != "object") return !1;
+	try {
+		let t = Symbol.for("@cer/ReactiveState");
+		return Object.prototype.hasOwnProperty.call(e, t);
+	} catch {
+		return !1;
+	}
+}
+function x(e) {
+	let t, n = !0, r = g("computed"), i = () => {
+		n = !0;
+	};
+	try {
+		let e = _.getCurrentComponentId();
+		e && _.registerWatcher(e, r);
+	} catch {}
+	return _.setCurrentComponent(r, i), t = e(), _.clearCurrentComponent(), n = !1, { get value() {
+		return n &&= (_.setCurrentComponent(r, i), t = e(), _.clearCurrentComponent(), !1), _.propagateDependencies(r), t;
+	} };
+}
+function S(e) {
+	if (f()) return () => {};
+	let t = g("effect");
+	try {
+		let e = _.getCurrentComponentId();
+		e && _.registerWatcher(e, t);
+	} catch {}
+	let n = () => {
+		_.setCurrentComponent(t, n);
+		try {
+			e();
+		} finally {
+			_.clearCurrentComponent();
+		}
+	};
+	return n(), () => {
+		_.cleanup(t);
+	};
+}
+var C = 50;
+function w(t, n = /* @__PURE__ */ new WeakMap(), r = 0) {
+	if (typeof t != "object" || !t) return t;
+	let i = t;
+	if (n.has(i)) return n.get(i);
+	if (r > C) return e(`[watch] Deep clone exceeded ${C} nesting levels. Returning a reference at this depth instead of cloning further. Consider restructuring your state or switching to a shallow watch.`), t;
+	if (typeof Node < "u" && i instanceof Node) return t;
+	if (i instanceof Date) return new Date(i.getTime());
+	if (Array.isArray(i)) {
+		let e = [];
+		n.set(i, e);
+		for (let t = 0; t < i.length; t++) e.push(w(i[t], n, r + 1));
+		return e;
+	}
+	let a = {};
+	n.set(i, a);
+	for (let e of Object.keys(i)) try {
+		a[e] = w(i[e], n, r + 1);
+	} catch {}
+	return a;
+}
+function T(e, t, n) {
+	if (f()) return () => {};
+	let r, i = b(e) ? () => e.value : e, a = g("watch");
+	try {
+		let e = _.getCurrentComponentId();
+		e && _.registerWatcher(e, a);
+	} catch {}
+	let o = () => {
+		_.setCurrentComponent(a, o);
+		let e = i();
+		if (_.clearCurrentComponent(), n?.deep) {
+			let n = _.withoutTracking(() => w(e));
+			t(n, r), r = n;
+		} else e !== r && (t(e, r), r = e);
+	};
+	return _.setCurrentComponent(a, o), r = i(), _.clearCurrentComponent(), n?.deep && (r = _.withoutTracking(() => w(r))), n && n.immediate && t(r, void 0), () => {
+		_.cleanup(a);
+	};
+}
+//#endregion
+//#region src/lib/runtime/helpers.ts
+var E = (e) => {
+	try {
+		e();
+	} catch {}
+}, D = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Map(), A = 500, j, M, N = !1, P = !1, F, I = !!globalThis.process?.versions?.node;
+function L(e) {
+	if (D.has(e)) return D.get(e);
+	let t = e.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+	return D.size < A && D.set(e, t), t;
+}
+function R(e) {
+	if (O.has(e)) return O.get(e);
+	let t = e.replace(/-([a-z])/g, (e, t) => t.toUpperCase());
+	return O.size < A && O.set(e, t), t;
+}
+function z(e) {
+	if (typeof e == "string") {
+		if (k.has(e)) return k.get(e);
+		let t = e.replace(/[&<>"']/g, (e) => ({
+			"&": "&amp;",
+			"<": "&lt;",
+			">": "&gt;",
+			"\"": "&quot;",
+			"'": "&#39;"
+		})[e]);
+		return t !== e && k.size < A && k.set(e, t), t;
+	}
+	return e;
+}
+function B(t) {
+	if (!t) return "";
+	let n = String(t);
+	if (typeof document < "u" && typeof document.createElement == "function") {
+		let e = n.replace(/</g, "").replace(/>/g, ""), t = F ||= document.createElement("div");
+		try {
+			B._el = t;
+		} catch {}
+		return t.innerHTML = e, (t.textContent || "").replace(RegExp("", "g"), "<").replace(RegExp("", "g"), ">");
+	}
+	let r = {
+		lt: "<",
+		gt: ">",
+		amp: "&",
+		quot: "\"",
+		apos: "'",
+		nbsp: "\xA0"
+	}, i = j ?? B._namedMap, a = i;
+	if (!a && I) try {
+		let e = globalThis.require;
+		if (typeof e == "function") for (let t of [
+			"@jasonshimmy/custom-elements-runtime/entities.json",
+			"../../entities.json",
+			"../../../entities.json",
+			"../entities.json",
+			"./entities.json"
+		]) try {
+			let n = e(t);
+			if (n && typeof n == "object") {
+				a = n;
+				break;
+			}
+		} catch {}
+	} catch {}
+	if (!a) {
+		a = r, N = !0;
+		try {
+			B._usedFallback = !0;
+		} catch {}
+		let e = B._namedMapLoader ?? M;
+		e && e().then((e) => {
+			j = e;
+			try {
+				B._namedMap = e;
+			} catch {}
+		}).catch(() => {});
+	}
+	if ((N || B._usedFallback) && !(P || B._warnedFallback)) {
+		P = !0;
+		try {
+			B._warnedFallback = !0;
+		} catch {}
+		try {
+			e("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 n.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (e, t) => {
+		if (t.charCodeAt(0) === 35) {
+			let e = (t.charAt(1) || "").toLowerCase() === "x" ? parseInt(t.slice(2), 16) : parseInt(t.slice(1), 10);
+			return Number.isNaN(e) ? `&${t};` : String.fromCodePoint(e);
+		}
+		let n = a[t] ?? (i && i[t]);
+		return n === void 0 ? `&${t};` : n;
+	});
+}
+async function V() {
+	let e = [
+		"@jasonshimmy",
+		"custom-elements-runtime",
+		"entities.json"
+	].join("/");
+	try {
+		// @vite-ignore: dynamic import specifier constructed at runtime
+		let t = await import(
+			/* @vite-ignore */
+			e
+);
+		return t && (t.default || t);
+	} catch {
+		try {
+			let t = [
+				e,
+				"./entities.json",
+				"../../entities.json",
+				"../../../entities.json"
+			];
+			for (let e of t) try {
+				// @vite-ignore: intentionally dynamic path candidates for dev/local resolution
+				let t = await import(
+					/* @vite-ignore */
+					e
+);
+				if (t) return t && (t.default || t);
+			} catch {}
+			return {
+				lt: "<",
+				gt: ">",
+				amp: "&",
+				quot: "\"",
+				apos: "'",
+				nbsp: "\xA0"
+			};
+		} catch {
+			return {
+				lt: "<",
+				gt: ">",
+				amp: "&",
+				quot: "\"",
+				apos: "'",
+				nbsp: "\xA0"
+			};
+		}
+	}
+}
+M = V, B._namedMapLoader = V;
+function H(e, t) {
+	!e || typeof e != "object" || j && !t?.overwrite || (j = e);
+}
+function U() {
+	j = void 0;
+}
+function W(e) {
+	let t = String(e);
+	return {
+		__unsafeHTML: t,
+		__rawHTML: t
+	};
+}
+function G(e) {
+	return !!e && (typeof e.__unsafeHTML == "string" || typeof e.__rawHTML == "string");
+}
+function K(e, t) {
+	if (typeof t == "string") {
+		if (t === "") return;
+		let n = t.split("."), r = e;
+		for (let e of n) {
+			if (typeof r != "object" || !r) {
+				r = void 0;
+				break;
+			}
+			r = r[e];
+		}
+		return b(r) ? r.value : r;
+	}
+	return t;
+}
+function q(e, t, n) {
+	let r = String(t).split("."), i = r.pop();
+	if (!i) return;
+	let a = r.reduce((e, t) => (e[t] ?? (e[t] = {}), e[t]), e);
+	b(a[i]) ? a[i].value = n : a[i] = n;
+}
+function J(e) {
+	try {
+		if (e && typeof e == "object") {
+			if (b(e)) return e.value;
+			if ("value" in e) {
+				let t = e.value;
+				return t == null || typeof t == "string" || typeof t == "number" || typeof t == "boolean" ? t : e;
+			}
+		}
+	} catch {}
+	return e;
+}
+function Y(e) {
+	let t = J(e);
+	if (t == null) return null;
+	let n = typeof t;
+	return n === "string" || n === "number" || n === "boolean" ? String(t) : null;
+}
+function X(e) {
+	if (!e || typeof e != "string") return !1;
+	if (e === "class" || e.endsWith("Class")) return !0;
+	if (e.includes("-")) try {
+		if (e.split("-").some((e) => e === "class")) return !0;
+	} catch {}
+	return !1;
+}
+//#endregion
+export { m as C, s as D, o as E, i as O, p as S, n as T, b as _, X as a, T as b, H as c, q as d, R as f, x as g, v as h, K as i, a as k, E as l, W as m, B as n, G as o, L as p, z as r, V as s, U as t, Y as u, _ as v, f as w, S as x, y };
+
+//# sourceMappingURL=helpers-tJgb4Qve.js.map