@oslokommune/punkt-elements 19.10.2 → 19.12.0

package/dist/element-with-slot-CVmm0_IE.js

@@ -0,0 +1,703 @@
+import { f as e, g as t, m as n, t as r } from "./element-DBugHPKM.js";
+import { t as i } from "./async-directive-yh8hG41Q.js";
+//#region src/controllers/pkt-slot-utils.ts
+function a(e) {
+	return e.classList && (e.classList.contains("_dialog_overlay") || e.classList.contains("backdrop")) ? !0 : typeof e.hasAttribute == "function" && e.hasAttribute("data-skip");
+}
+function o(e) {
+	return e.nodeName === "OPTION" || e.nodeName === "DATA";
+}
+function s(e) {
+	return e.nodeType === Node.TEXT_NODE && e.nodeValue?.trim() !== "";
+}
+//#endregion
+//#region src/directives/slot-content.ts
+var c = /* @__PURE__ */ new WeakMap(), l = /* @__PURE__ */ new WeakMap(), u = /* @__PURE__ */ new WeakSet();
+function d(e) {
+	let t = c.get(e);
+	return t || (t = new D(e), c.set(e, t)), t;
+}
+var f = Symbol("default");
+function p(e) {
+	return e === void 0 ? f : e;
+}
+function m(e) {
+	if (e.nodeType !== Node.ELEMENT_NODE) return f;
+	let t = e.getAttribute("slot");
+	return t === null ? f : p(t);
+}
+function h(e) {
+	return Array.isArray(e) ? e.map((e) => {
+		let t = e === null ? f : e;
+		return [t, t];
+	}) : Object.entries(e).map(([e, t]) => [e, t === null ? f : t]);
+}
+function g(e, t) {
+	return e.length === t.length && e.every(([e, n], r) => t[r][0] === e && t[r][1] === n);
+}
+function _(e) {
+	if (e.nodeType === Node.TEXT_NODE) return s(e);
+	if (e.nodeType !== Node.ELEMENT_NODE) return !1;
+	let t = e;
+	return !a(t) && !o(t);
+}
+function v(e) {
+	return e.nodeType === Node.TEXT_NODE && !!e.nodeValue && !s(e);
+}
+function y(e, t) {
+	if (!_(e)) return !1;
+	if (e instanceof HTMLTemplateElement) {
+		let n = m(e);
+		for (let r of Array.from(e.content.childNodes)) b(t, n, r);
+	} else b(t, m(e), e);
+	return !0;
+}
+function b(e, t, n) {
+	let r = e.get(t);
+	r || (r = [], e.set(t, r)), r.push(n);
+}
+function x(e, t, n) {
+	Node.prototype.insertBefore.call(e, t, n);
+}
+function S(e) {
+	e.parentNode && Node.prototype.removeChild.call(e.parentNode, e);
+}
+function C(e) {
+	return Object.getOwnPropertyDescriptor(Node.prototype, "nextSibling").get.call(e);
+}
+function w(e, t) {
+	return e.node.compareDocumentPosition(t.node) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
+}
+function T(e) {
+	if (e.nodeType !== Node.TEXT_NODE || Object.prototype.hasOwnProperty.call(e, "data")) return;
+	let t = e, n = {
+		data: Object.getOwnPropertyDescriptor(CharacterData.prototype, "data"),
+		nodeValue: Object.getOwnPropertyDescriptor(Node.prototype, "nodeValue")
+	};
+	for (let [e, r] of Object.entries(n)) !r?.get || !r.set || Object.defineProperty(t, e, {
+		configurable: !0,
+		get: () => r.get.call(t),
+		set: (e) => {
+			r.set.call(t, e), E(t);
+		}
+	});
+}
+function E(e) {
+	let t = l.get(e);
+	if (t) {
+		s(e) || t.releaseText(e);
+		return;
+	}
+	let n = e.parentNode && c.get(e.parentNode);
+	n && (s(e) ? n.adoptText(e) : n.blankTextChanged(e));
+}
+var D = class e {
+	static {
+		this.PLACEHOLDER_PREFIX = "pkt-slot";
+	}
+	constructor(e) {
+		this.nodesBySlot = /* @__PURE__ */ new Map(), this.trackedNodes = /* @__PURE__ */ new Set(), this.placeholderToNode = /* @__PURE__ */ new Map(), this.nodeToPlaceholder = /* @__PURE__ */ new Map(), this.mirrorOf = /* @__PURE__ */ new Map(), this.hasWhitespace = !1, this.contentBounds = null, this.changedWhitespace = /* @__PURE__ */ new Set(), this.directives = /* @__PURE__ */ new Set(), this.sources = /* @__PURE__ */ new Map(), this.subscribers = /* @__PURE__ */ new Set(), this.generation = 0, this.initialCollectionDone = !1, this.inOwnChange = !1, this.rendering = !1, this.contentEnd = null, this.rootMarker = null, this.observer = null, this.observing = !1, this.wantsObserver = !1, this.followsHostRenders = !1, this.host = e, typeof e.addController == "function" && (this.followsHostRenders = !0, e.addController({
+			hostConnected: () => {
+				if (!this.wantsObserver) return;
+				let e = !this.observing;
+				this.startObserving(), e && this.resync();
+			},
+			hostDisconnected: () => this.stopObservingIfUnused(),
+			hostUpdate: () => {
+				e.hasUpdated || this.collectLateChildren(), this.flushMutations(!1), e.hasUpdated || this.insertContentEnd(), this.rendering = !0, queueMicrotask(() => {
+					this.rendering = !1;
+				});
+			},
+			hostUpdated: () => {
+				this.rendering = !1, !this.rootMarker && this.contentEnd?.parentNode === e && (this.rootMarker = C(this.contentEnd)), this.flushMutations(!0);
+			}
+		}));
+	}
+	collectNodes() {
+		if (this.initialCollectionDone) return;
+		this.initialCollectionDone = !0, this.generation++;
+		let e = Array.from(this.host.childNodes);
+		for (let t of e) this.watchHostText(t), y(t, this.nodesBySlot) && this.track(t);
+		this.syncWhitespace();
+	}
+	collectLateChildren() {
+		if (this.initialCollectionDone) {
+			for (let e of Array.from(this.host.childNodes)) this.trackedNodes.has(e) || this.placeholderToNode.has(e) || (this.watchHostText(e), _(e) && (this.addContent(e), this.generation++));
+			this.syncWhitespace();
+		}
+	}
+	addDirective(e) {
+		this.directives.add(e), this.startObserving();
+	}
+	removeDirective(e) {
+		this.directives.delete(e), this.stopObservingIfUnused();
+	}
+	addSource(e, t, n) {
+		let r = this.sources.get(e);
+		r && r.manager === t && g(r.mapping, n) || (r && r.manager !== t && this.detachFrom(r.manager, e), this.sources.set(e, {
+			manager: t,
+			mapping: n
+		}), t.subscribers.add(this), t.startObserving(), this.handleChange());
+	}
+	removeSource(e) {
+		let t = this.sources.get(e);
+		t && (this.sources.delete(e), this.detachFrom(t.manager, e), this.handleChange());
+	}
+	detachFrom(e, t) {
+		[...this.sources.entries()].some(([n, r]) => n !== t && r.manager === e) || (e.subscribers.delete(this), e.stopObservingIfUnused());
+	}
+	reachableParts(e = /* @__PURE__ */ new Set()) {
+		if (e.has(this)) return [];
+		e.add(this);
+		let t = [...this.directives];
+		for (let n of this.subscribers) t.push(...n.reachableParts(e));
+		return t;
+	}
+	getNodes(e) {
+		return this.placementNodes(e).filter((e) => !u.has(e));
+	}
+	placementNodes(e) {
+		return this.nodesFor(p(e));
+	}
+	hasContent(e) {
+		return this.getNodes(e).length > 0;
+	}
+	nodesFor(e) {
+		let t = this.nodesBySlot.get(e) ?? [];
+		if (this.sources.size === 0) return t;
+		let n = [];
+		for (let { manager: t, mapping: r } of this.sources.values()) for (let [i, a] of r) a === e && n.push(...t.nodesFor(i));
+		return n.length ? [...t, ...n] : t;
+	}
+	ensurePlaceholder(e) {
+		if (this.nodeToPlaceholder.has(e)) return;
+		if (e.parentNode !== this.host) {
+			for (let { manager: t } of this.sources.values()) t.ensurePlaceholder(e);
+			return;
+		}
+		let t = this.isInTemplate(e) ? this.getContentEnd() : e;
+		x(this.host, this.createPlaceholder(e), t);
+	}
+	createPlaceholder(t) {
+		let n = document.createComment(e.PLACEHOLDER_PREFIX);
+		if (t.nodeType === Node.TEXT_NODE) {
+			let e = t;
+			Object.defineProperty(n, "data", {
+				configurable: !0,
+				get: () => e.data,
+				set: (t) => {
+					e.data = t;
+				}
+			});
+		}
+		return this.placeholderToNode.set(n, t), this.nodeToPlaceholder.set(t, n), n;
+	}
+	forgetPlaceholder(e) {
+		let t = this.nodeToPlaceholder.get(e);
+		return t && (this.placeholderToNode.delete(t), this.nodeToPlaceholder.delete(e)), t;
+	}
+	placeholderOf(e) {
+		return this.trackedNodes.has(e) ? this.nodeToPlaceholder.get(e) : void 0;
+	}
+	handleNow(e) {
+		if (this.rendering) return e();
+		this.flushMutations(!1);
+		let t = e();
+		return this.flushMutations(!1), t;
+	}
+	positionInHost(e) {
+		if (!e || e.parentNode === this.host) return this.rendering || e && !this.isInTemplate(e) ? e : this.getContentEnd() ?? e;
+		if (this.trackedNodes.has(e)) return this.nodeToPlaceholder.get(e) ?? e;
+		for (let t = e.previousSibling; t; t = t.previousSibling) {
+			let e = this.placeholderOf(t);
+			if (e) return e.nextSibling;
+		}
+		for (let t = e.nextSibling; t; t = t.nextSibling) {
+			let e = this.placeholderOf(t);
+			if (e) return e;
+		}
+		return this.reachableParts().some((t) => t.parentOfPart() === e.parentNode) ? this.getContentEnd() : e;
+	}
+	owns(e) {
+		return this.trackedNodes.has(e);
+	}
+	moveDistributed(e, t) {
+		let n = this.nodeToPlaceholder.get(e);
+		if (this.rendering || !n || !this.trackedNodes.has(e) || !e.parentNode || e.parentNode === this.host) return !1;
+		this.flushMutations(!1);
+		let r = this.positionInHost(t);
+		if (r === n || r === e) return !0;
+		if (r && r.parentNode !== this.host) return !1;
+		let i = m(e), a = this.nodesBySlot.get(i);
+		if (!a || !a.includes(e)) return !1;
+		let o = null;
+		for (let t = r; t && !o; t = t.nextSibling) {
+			let n = this.placeholderToNode.get(t) ?? t;
+			if (!(n === e || !this.trackedNodes.has(n))) {
+				if (n instanceof HTMLTemplateElement) return !1;
+				m(n) === i && (o = n);
+			}
+		}
+		let s = a[a.length - 1] === e ? a[a.length - 2] : a[a.length - 1], c = o ?? s;
+		return c && (!c.parentNode || c.parentNode === this.host) ? !1 : (this.asOwnChange(() => {
+			x(this.host, n, r), a.splice(a.indexOf(e), 1), a.splice(o ? a.indexOf(o) : a.length, 0, e), o ? x(o.parentNode, e, o) : s && x(s.parentNode, e, s.nextSibling), this.handleChange();
+		}), !0);
+	}
+	replaceContent(e) {
+		if (!this.initialCollectionDone) return !1;
+		let t = e.flatMap((e) => e.nodeType === Node.DOCUMENT_FRAGMENT_NODE ? Array.from(e.childNodes) : [e]);
+		if (t.some((e) => e.contains(this.host))) return !1;
+		this.flushMutations(!1);
+		let n = this.getContentEnd();
+		return n ? (this.asOwnChange(() => {
+			let e = new Set(this.trackedNodes);
+			for (let t of this.nodesBySlot.values()) t.forEach((t) => e.add(t));
+			for (let t of e) {
+				let e = this.forgetPlaceholder(t);
+				e && S(e), S(t), this.untrack(t);
+			}
+			for (this.nodesBySlot.clear(), this.mirrorOf.clear(), this.contentBounds = null; n.previousSibling;) S(n.previousSibling);
+			let r = document.createDocumentFragment();
+			r.append(...t), x(this.host, r, n);
+			for (let e of t) this.watchHostText(e), _(e) && this.addContent(e);
+			this.handleChange();
+		}), !0) : !1;
+	}
+	adoptText(e) {
+		!this.initialCollectionDone || this.trackedNodes.has(e) || e.parentNode !== this.host || this.isInTemplate(e) || (this.flushMutations(!1), this.asOwnChange(() => {
+			this.dropMirror(e), this.insertInSlotOrder(e), this.track(e), this.handleChange();
+		}));
+	}
+	blankTextChanged(e) {
+		let t = this.mirrorOf.get(e);
+		t && (t.data = e.data, e.data) || this.initialCollectionDone && (e.parentNode !== this.host || this.isInTemplate(e) || (this.watchHostText(e), this.changedWhitespace.add(e), this.flushMutations(!1), this.asOwnChange(() => this.handleChange())));
+	}
+	releaseText(e) {
+		if (this.flushMutations(!1), !this.trackedNodes.has(e)) return;
+		let t = this.nodeToPlaceholder.get(e);
+		(t ? t.parentNode === this.host : e.parentNode === this.host) && this.asOwnChange(() => {
+			t && (this.forgetPlaceholder(e), Node.prototype.replaceChild.call(this.host, e, t)), this.removeContent(e), this.watchHostText(e), this.handleChange();
+		});
+	}
+	watchHostText(e) {
+		T(e), v(e) && (this.hasWhitespace = !0, this.changedWhitespace.add(e));
+	}
+	syncWhitespace() {
+		if (!this.hasWhitespace) return;
+		let e = this.findContentBounds(), t = this.contentBounds, n = this.changedWhitespace;
+		if (this.contentBounds = e, this.changedWhitespace = /* @__PURE__ */ new Set(), !e) {
+			for (let e of [...this.mirrorOf.keys()]) this.dropMirror(e);
+			return;
+		}
+		if (this.dropMirrorsOutside(), !t) this.collectBlankBetween(e.firstAt, e.lastAt, n);
+		else {
+			if (t.first !== e.first) {
+				let r = this.placeOf(t.first);
+				r && this.precedes(e.firstAt, r) ? this.collectBlankBetween(e.firstAt, r, n) : this.collectBlankBeside(e.firstAt, "nextSibling", n);
+			}
+			if (t.last !== e.last) {
+				let r = this.placeOf(t.last);
+				r && this.precedes(r, e.lastAt) ? this.collectBlankBetween(r, e.lastAt, n) : this.collectBlankBeside(e.lastAt, "previousSibling", n);
+			}
+		}
+		for (let t of n) t.parentNode === this.host && v(t) && this.isBetween(t, e) ? this.addMirror(t) : this.dropMirror(t);
+	}
+	dropMirrorsOutside() {
+		let e = this.nodesBySlot.get(f) ?? [], t = [], n = (e) => {
+			if (u.has(e)) t.push(this.nodeToPlaceholder.get(e));
+			else if (this.placeOf(e)) return !1;
+			return !0;
+		};
+		for (let t = 0; t < e.length && n(e[t]); t++);
+		for (let t = e.length - 1; t >= 0 && n(e[t]); t--);
+		t.forEach((e) => this.dropMirror(e));
+	}
+	precedes(e, t) {
+		return !!(e.compareDocumentPosition(t) & Node.DOCUMENT_POSITION_FOLLOWING);
+	}
+	collectBlankBeside(e, t, n) {
+		for (let r = e[t]; r; r = r[t]) {
+			if (v(r)) {
+				n.add(r);
+				continue;
+			}
+			let e = this.placeholderToNode.get(r) ?? r;
+			if (!u.has(e) && this.trackedNodes.has(e)) return;
+		}
+	}
+	findContentBounds() {
+		let e = this.nodesBySlot.get(f) ?? [], t = (e) => u.has(e) ? null : this.placeOf(e), n, r = null, i, a = null;
+		for (let i = 0; i < e.length && !r; i++) [n, r] = [e[i], t(e[i])];
+		for (let n = e.length - 1; n >= 0 && !a; n--) [i, a] = [e[n], t(e[n])];
+		return n && i && r && a ? {
+			first: n,
+			last: i,
+			firstAt: r,
+			lastAt: a
+		} : null;
+	}
+	placeOf(e) {
+		if (!this.trackedNodes.has(e)) return null;
+		let t = this.nodeToPlaceholder.get(e) ?? e;
+		return t.parentNode === this.host ? t : null;
+	}
+	isBetween(e, { firstAt: t, lastAt: n }) {
+		return this.precedes(t, e) && this.precedes(e, n);
+	}
+	collectBlankBetween(e, t, n) {
+		if (e === t) return;
+		let [r, i] = this.precedes(e, t) ? [e, t] : [t, e];
+		for (let e = r.nextSibling; e && e !== i; e = e.nextSibling) v(e) && n.add(e);
+	}
+	addMirror(e) {
+		if (this.mirrorOf.has(e)) return;
+		let t = document.createTextNode(e.data);
+		u.add(t), this.mirrorOf.set(e, t), this.placeholderToNode.set(e, t), this.nodeToPlaceholder.set(t, e), this.insertInSlotOrder(t);
+	}
+	dropMirror(e) {
+		let t = this.mirrorOf.get(e);
+		t && (this.mirrorOf.delete(e), this.forgetPlaceholder(t), S(t), this.removeFromSlots(t));
+	}
+	insertContentEnd() {
+		this.contentEnd || (this.contentEnd = document.createComment(""), Object.defineProperty(this.contentEnd, "nextSibling", {
+			configurable: !0,
+			get: () => null
+		})), this.contentEnd.parentNode !== this.host && x(this.host, this.contentEnd, null);
+	}
+	getContentEnd() {
+		let e = this.contentEnd;
+		return e ? (e.parentNode !== this.host && this.rootMarker?.parentNode === this.host && x(this.host, e, this.rootMarker), e.parentNode === this.host ? e : null) : null;
+	}
+	isInTemplate(e) {
+		let t = this.getContentEnd();
+		return !t || e.parentNode !== this.host ? !1 : e === t || !!(t.compareDocumentPosition(e) & Node.DOCUMENT_POSITION_FOLLOWING);
+	}
+	startObserving() {
+		if (this.wantsObserver = !0, this.observing) return;
+		this.observing = !0;
+		let e = () => {
+			!this.observing || typeof MutationObserver > "u" || (this.observer = new MutationObserver((e) => {
+				this.handleMutations(e);
+			}), this.observer.observe(this.host, {
+				childList: !0,
+				subtree: !0
+			}));
+		};
+		this.followsHostRenders ? e() : setTimeout(e, 0);
+	}
+	stopObserving() {
+		this.observing && (this.observing = !1, this.observer?.disconnect(), this.observer = null);
+	}
+	stopObservingIfUnused() {
+		let e = this.directives.size === 0 && this.subscribers.size === 0;
+		(!this.host.isConnected || e && !this.followsHostRenders) && this.stopObserving();
+	}
+	flushMutations(e) {
+		if (this.inOwnChange) return;
+		let t = this.observer?.takeRecords();
+		t?.length && this.handleMutations(t, e);
+	}
+	handleMutations(e, t = !1) {
+		this.inOwnChange || this.asOwnChange(() => this.applyMutations(e, t));
+	}
+	applyMutations(e, t) {
+		let n = !1, r = [], i = /* @__PURE__ */ new Map(), a = [];
+		for (let o of e) {
+			for (let e of o.removedNodes) {
+				let a = this.placeholderToNode.get(e);
+				if (a && e.parentNode === this.host) {
+					t || (this.removeFromSlots(a), this.insertInSlotOrder(a), S(a), u.has(a) && this.changedWhitespace.add(e), n = !0);
+					continue;
+				}
+				if (a) {
+					if (this.placeholderToNode.delete(e), this.nodeToPlaceholder.delete(a), u.has(a) && this.mirrorOf.delete(e), t) continue;
+					S(a), this.removeContent(a), n = !0;
+					continue;
+				}
+				if (this.trackedNodes.has(e) && !this.host.contains(e) && !t) {
+					this.removeContent(e);
+					let t = this.forgetPlaceholder(e);
+					if (t && (r.push(t), o.target !== this.host)) {
+						let e = i.get(o.target) ?? [];
+						e.push(t), i.set(o.target, e);
+					}
+					n = !0;
+				}
+			}
+			if (o.target !== this.host) {
+				o.addedNodes.length && a.push(o);
+				continue;
+			}
+			if (!t) {
+				for (let e of o.addedNodes) if (!this.placeholderToNode.has(e)) {
+					if (this.trackedNodes.has(e) && e.parentNode === this.host) {
+						let t = this.forgetPlaceholder(e);
+						t && S(t), this.removeFromSlots(e), this.insertInSlotOrder(e), n = !0;
+						continue;
+					}
+					!this.trackedNodes.has(e) && _(e) ? (this.addContent(e), n = !0) : (this.watchHostText(e), v(e) && (n = !0));
+				}
+			}
+		}
+		i.size && this.adoptNodesInParts(a, i) && (n = !0);
+		for (let e of r) S(e);
+		this.getContentEnd(), n && this.handleChange();
+	}
+	adoptNodesInParts(e, t) {
+		let n = /* @__PURE__ */ new Set();
+		for (let r of e) t.has(r.target) && r.addedNodes.forEach((e) => n.add(e));
+		if (n.size === 0) return !1;
+		let r = this.reachableParts(), i = [];
+		for (let e of n) {
+			if (!e.parentNode || !t.has(e.parentNode) || l.has(e) || u.has(e) || this.placeholderToNode.has(e)) continue;
+			let n = r.find((t) => t.contains(e));
+			if (!n) continue;
+			let a = this.hostPositionFor(e, n, t);
+			a && i.push({
+				node: e,
+				before: a.before
+			});
+		}
+		if (i.length === 0) return !1;
+		let a = !1;
+		for (let { node: e, before: t } of i.sort(w)) _(e) && !(e instanceof HTMLTemplateElement) ? (x(this.host, this.createPlaceholder(e), t), this.insertInSlotOrder(e), this.track(e), a = !0) : x(this.host, e, t);
+		return a;
+	}
+	hostPositionFor(e, t, n) {
+		let { startNode: r, endNode: i } = t.bounds();
+		for (let t = e.nextSibling; t && t !== i; t = t.nextSibling) {
+			let e = this.placeholderOf(t);
+			if (e) return { before: e };
+		}
+		for (let t = e.previousSibling; t && t !== r; t = t.previousSibling) {
+			let e = this.placeholderOf(t);
+			if (e) return { before: e.nextSibling };
+		}
+		let a = e.parentNode ? n.get(e.parentNode) : void 0;
+		return a ? { before: a[0] } : null;
+	}
+	resync() {
+		this.asOwnChange(() => {
+			let e = !1;
+			for (let t of [...this.trackedNodes]) {
+				let n = this.nodeToPlaceholder.get(t), r = this.host.contains(t);
+				r && (!n || n.parentNode === this.host) || (n && S(this.forgetPlaceholder(t)), r && S(t), this.removeContent(t), e = !0);
+			}
+			let t = this.getContentEnd();
+			for (let n = t ? this.host.firstChild : null; n && n !== t; n = n.nextSibling) this.trackedNodes.has(n) || this.placeholderToNode.has(n) || (this.watchHostText(n), _(n) && (this.addContent(n), e = !0));
+			this.syncWhitespace(), this.sortSlots() && (e = !0), e && this.handleChange();
+		});
+	}
+	sortSlots() {
+		let e = !1;
+		for (let t of this.nodesBySlot.values()) {
+			if (!t.every((e) => this.nodeToPlaceholder.has(e))) continue;
+			let n = t.map((e) => ({
+				node: this.nodeToPlaceholder.get(e),
+				real: e
+			})).sort(w).map(({ real: e }) => e);
+			n.every((e, n) => e === t[n]) || (t.splice(0, t.length, ...n), n.forEach(S), e = !0);
+		}
+		return e;
+	}
+	handleChange() {
+		this.syncWhitespace(), this.generation++, this.notifyDirectives();
+		for (let e of this.subscribers) e.handleChange();
+		this.host.requestUpdate();
+	}
+	notifyDirectives() {
+		for (let e of this.directives) e.handleNodesChanged();
+	}
+	asOwnChange(e) {
+		let t = this.inOwnChange;
+		this.inOwnChange = !0;
+		try {
+			e();
+		} finally {
+			t || (this.observer?.takeRecords(), this.inOwnChange = !1);
+		}
+	}
+	addContent(e) {
+		e instanceof HTMLTemplateElement ? y(e, this.nodesBySlot) : this.insertInSlotOrder(e), this.track(e);
+	}
+	removeContent(e) {
+		this.untrack(e), this.removeFromSlots(e);
+	}
+	track(e) {
+		this.trackedNodes.add(e), l.set(e, this), T(e);
+	}
+	untrack(e) {
+		this.trackedNodes.delete(e), l.get(e) === this && l.delete(e);
+	}
+	insertInSlotOrder(e) {
+		let t = m(e), n = this.nodesBySlot.get(t) ?? [];
+		this.nodesBySlot.set(t, n);
+		let r = this.nodeToPlaceholder.get(e) ?? e, i = (e) => {
+			let t = this.nodeToPlaceholder.get(e) ?? e;
+			return !!(r.compareDocumentPosition(t) & Node.DOCUMENT_POSITION_FOLLOWING);
+		}, a = n.length;
+		for (; a > 0 && i(n[a - 1]);) a--;
+		n.splice(a, 0, e);
+	}
+	removeFromSlots(e) {
+		for (let [t, n] of this.nodesBySlot) {
+			let r = n.indexOf(e);
+			if (r !== -1) {
+				n.splice(r, 1), n.length === 0 && this.nodesBySlot.delete(t);
+				return;
+			}
+		}
+	}
+}, O = e(class extends i {
+	constructor(e) {
+		if (super(e), this.manager = null, this.host = null, this.part = null, this.lastGeneration = -1, e.type !== n.CHILD) throw Error("slotContent() can only be used in child expressions");
+	}
+	render(e, n) {
+		return t;
+	}
+	update(e, [n, r]) {
+		return this.part = e, this.host = n, this.slotName = r, this.manager || (this.manager = d(n), this.manager.collectNodes(), this.manager.addDirective(this)), this.placeNodes(), t;
+	}
+	handleNodesChanged() {
+		!this.isConnected || !this.manager || this.placeNodes();
+	}
+	disconnected() {
+		this.manager?.removeDirective(this), this.manager = null, this.lastGeneration = -1;
+	}
+	reconnected() {
+		this.host && (this.manager = d(this.host), this.manager.addDirective(this), this.placeNodes());
+	}
+	contains(e) {
+		let t = this.parentOfPart();
+		return !this.isConnected || !t ? !1 : this.isInsidePart(e, t, this.coversContainer(t));
+	}
+	bounds() {
+		return {
+			startNode: this.part?.startNode ?? null,
+			endNode: this.part?.endNode ?? null
+		};
+	}
+	parentOfPart() {
+		return this.part ? this.part.startNode ? this.part.startNode.parentNode : this.part.parentNode : null;
+	}
+	placeNodes() {
+		if (!this.manager || !this.part) return;
+		let e = this.manager.generation;
+		if (e === this.lastGeneration) return;
+		this.lastGeneration = e;
+		let t = this.parentOfPart();
+		if (!t) return;
+		let n = this.manager.placementNodes(this.slotName), r = this.coversContainer(t), i = this.part.endNode;
+		for (let e = n.length - 1; e >= 0; e--) {
+			let a = n[e];
+			this.isInsidePart(a, t, r) || (this.manager.ensurePlaceholder(a), x(t, a, i)), i = a;
+		}
+	}
+	coversContainer(e) {
+		let { startNode: t, endNode: n } = this.part;
+		return !n && (!t || t === e.firstChild);
+	}
+	isInsidePart(e, t, n) {
+		if (!this.part || e.parentNode !== t) return !1;
+		if (n) return !0;
+		let { startNode: r, endNode: i } = this.part, a = !r || !!(r.compareDocumentPosition(e) & Node.DOCUMENT_POSITION_FOLLOWING), o = !i || !!(e.compareDocumentPosition(i) & Node.DOCUMENT_POSITION_FOLLOWING);
+		return a && o;
+	}
+}), k = e(class extends i {
+	constructor(e) {
+		if (super(e), this.target = null, this.source = null, this.mapping = [], e.type !== n.ELEMENT) throw Error("forwardSlots() can only be used as an element directive");
+	}
+	render(e, n) {
+		return t;
+	}
+	update(e, [n, r]) {
+		let i = d(e.element);
+		return this.target && this.target !== i && this.target.removeSource(this), this.target = i, this.source = d(n), this.source.collectNodes(), this.mapping = h(r), this.target.addSource(this, this.source, this.mapping), t;
+	}
+	disconnected() {
+		this.target?.removeSource(this);
+	}
+	reconnected() {
+		this.target && this.source && this.target.addSource(this, this.source, this.mapping);
+	}
+}), A = /* @__PURE__ */ new Map();
+function j(e) {
+	if (A.has(e)) return A.get(e);
+	let t, n = HTMLElement.prototype;
+	for (; !t && n;) t = Object.getOwnPropertyDescriptor(n, e), n = Object.getPrototypeOf(n);
+	return A.set(e, t), t;
+}
+function M(e, t) {
+	return t.some((t) => typeof t != "string" && t.contains(e));
+}
+var N = class extends r {
+	connectedCallback() {
+		d(this).collectNodes(), super.connectedCallback();
+	}
+	hasSlotContent(e) {
+		return d(this).hasContent(e);
+	}
+	appendChild(e) {
+		let t = d(this);
+		return t.moveDistributed(e, null) ? e : t.handleNow(() => super.insertBefore(e, t.positionInHost(null)));
+	}
+	append(...e) {
+		if (M(this, e)) {
+			super.append(...e);
+			return;
+		}
+		let t = d(this);
+		t.handleNow(() => {
+			let n = document.createDocumentFragment();
+			n.append(...e), super.insertBefore(n, t.positionInHost(null));
+		});
+	}
+	prepend(...e) {
+		d(this).handleNow(() => super.prepend(...e));
+	}
+	insertBefore(e, t) {
+		let n = d(this);
+		return n.moveDistributed(e, t) ? e : n.handleNow(() => super.insertBefore(e, n.positionInHost(t)));
+	}
+	removeChild(e) {
+		let t = d(this);
+		return e.parentNode === this || !t.owns(e) ? super.removeChild(e) : t.handleNow(() => (e.parentNode?.removeChild(e), e));
+	}
+	replaceChild(e, t) {
+		let n = d(this);
+		return t.parentNode === this || !n.owns(t) ? super.replaceChild(e, t) : n.handleNow(() => (super.insertBefore(e, n.positionInHost(t)), t.parentNode?.removeChild(t), t));
+	}
+	replaceChildren(...e) {
+		let t = e.map((e) => typeof e == "string" ? document.createTextNode(e) : e);
+		d(this).replaceContent(t) || super.replaceChildren(...e);
+	}
+	get textContent() {
+		return j("textContent").get.call(this);
+	}
+	set textContent(e) {
+		let t = e == null ? "" : String(e);
+		d(this).replaceContent(t ? [document.createTextNode(t)] : []) || j("textContent").set.call(this, e);
+	}
+	get innerHTML() {
+		return j("innerHTML").get.call(this);
+	}
+	set innerHTML(e) {
+		let t = document.createElement("template");
+		t.innerHTML = e, d(this).replaceContent(Array.from(t.content.childNodes)) || j("innerHTML").set.call(this, e);
+	}
+	get innerText() {
+		let e = j("innerText");
+		return e?.get ? e.get.call(this) : this.textContent;
+	}
+	set innerText(e) {
+		let t = j("innerText");
+		if (!t?.set) {
+			this.textContent = e;
+			return;
+		}
+		let n = document.createElement("div");
+		t.set.call(n, e), d(this).replaceContent(Array.from(n.childNodes)) || t.set.call(this, e);
+	}
+};
+//#endregion
+export { o as a, O as i, k as n, d as r, N as t };