@ixfx/components 0.15.5 → 0.16.0

package/dist/pending-BGidHppL.js

@@ -0,0 +1,91 @@
+//#region src/common/view-state/pending.ts
+/**
+* Pure helpers for *pending* view state: keyed intent that is waiting for a
+* matching item to appear in the data.
+*
+* Pending sets / maps are insertion-ordered (oldest first) and capped so a
+* long-running app with churning data can't grow them without bound.
+*/
+/** Default cap on pending keys per facet. Oldest entries are dropped first. */
+const MAX_PENDING_KEYS = 2e3;
+const EMPTY_KEYS = /* @__PURE__ */ new Set();
+const EMPTY_FLAGS = /* @__PURE__ */ new Map();
+/**
+* Split `keys` into those `has` reports present (to apply now) and those
+* still missing (to keep pending). Returns the input set untouched as
+* `missing` when nothing matched, so callers can cheaply detect "no change".
+*/
+function partitionKeys(keys, has) {
+	if (keys.size === 0) return {
+		present: [],
+		missing: keys
+	};
+	const present = [];
+	const missing = /* @__PURE__ */ new Set();
+	for (const key of keys) if (has(key)) present.push(key);
+	else missing.add(key);
+	return {
+		present,
+		missing: present.length === 0 ? keys : missing
+	};
+}
+/** As {@link partitionKeys}, for keyed boolean flags (e.g. expanded / collapsed). */
+function partitionFlags(flags, has) {
+	if (flags.size === 0) return {
+		present: [],
+		missing: flags
+	};
+	const present = [];
+	const missing = /* @__PURE__ */ new Map();
+	for (const [key, value] of flags) if (has(key)) present.push([key, value]);
+	else missing.set(key, value);
+	return {
+		present,
+		missing: present.length === 0 ? flags : missing
+	};
+}
+/** Keep at most `max` keys, dropping the oldest. */
+function capKeys(keys, max = MAX_PENDING_KEYS) {
+	if (keys.size <= max) return keys;
+	return new Set([...keys].slice(keys.size - max));
+}
+/** Keep at most `max` flags, dropping the oldest. */
+function capFlags(flags, max = MAX_PENDING_KEYS) {
+	if (flags.size <= max) return flags;
+	return new Map([...flags].slice(flags.size - max));
+}
+/** `flags` without `key` (same instance when absent). */
+function withoutFlag(flags, key) {
+	if (!flags.has(key)) return flags;
+	const next = new Map(flags);
+	next.delete(key);
+	return next;
+}
+/** JSON record → flags map. Non-boolean values are ignored. */
+function flagsFromRecord(record) {
+	if (!record) return EMPTY_FLAGS;
+	const out = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(record)) if (typeof value === `boolean`) out.set(key, value);
+	return out;
+}
+/**
+* Combine pending and live flags into one JSON record. Live entries win when
+* a key is in both (it shouldn't be — matched keys leave pending).
+*/
+function flagsToRecord(...sources) {
+	const out = {};
+	for (const source of sources) for (const [key, value] of source) out[key] = value;
+	return out;
+}
+/** Pending keys followed by live keys, de-duplicated, as a JSON array. */
+function keysToArray(...sources) {
+	const out = /* @__PURE__ */ new Set();
+	for (const source of sources) for (const key of source) out.add(key);
+	return [...out];
+}
+/** Map `keys` to `true` flags — for components that record a plain key set. */
+function keysAsFlags(keys, value = true) {
+	return [...keys].map((k) => [k, value]);
+}
+//#endregion
+export { capKeys as a, keysAsFlags as c, partitionKeys as d, withoutFlag as f, capFlags as i, keysToArray as l, EMPTY_KEYS as n, flagsFromRecord as o, MAX_PENDING_KEYS as r, flagsToRecord as s, EMPTY_FLAGS as t, partitionFlags as u };

package/dist/scroll-hover-guard-Cjw6179Q.js

@@ -0,0 +1,35 @@
+//#region src/interaction/scroll-hover-guard.ts
+const SCROLL_HOVER_SUPPRESS_ATTR = `data-scroll-hover-suppress`;
+function createScrollHoverGuard(config) {
+	const { host, enabled, onResume } = config;
+	let suppressed = false;
+	let lastX = NaN;
+	let lastY = NaN;
+	const end = () => {
+		if (!suppressed) return;
+		suppressed = false;
+		host.toggleAttribute(SCROLL_HOVER_SUPPRESS_ATTR, false);
+	};
+	const onScroll = () => {
+		if (suppressed || !enabled()) return;
+		suppressed = true;
+		host.toggleAttribute(SCROLL_HOVER_SUPPRESS_ATTR, true);
+	};
+	const onPointerMove = (e) => {
+		const moved = !Number.isNaN(lastX) && (e.clientX !== lastX || e.clientY !== lastY);
+		lastX = e.clientX;
+		lastY = e.clientY;
+		if (!moved || !suppressed) return;
+		end();
+		onResume?.(e.clientX, e.clientY);
+	};
+	return {
+		suppressed: () => suppressed,
+		onScroll,
+		onPointerMove,
+		onPointerLeave: end,
+		end
+	};
+}
+//#endregion
+export { createScrollHoverGuard as n, SCROLL_HOVER_SUPPRESS_ATTR as t };

package/dist/{split-layout-JK3xWVX2.d.ts → split-layout-CophkNeU.d.ts}

@@ -1,3 +1,5 @@
+import { a as ViewStateBase, t as GetViewStateOptions } from "./types-LU1u0CB8.js";
+import "./index-9ttcdwlL.js";
 import { LitElement, nothing } from "lit";
 //#region src/split-layout/types.d.ts
 type Axis = `row` | `column`;
@@ -35,6 +37,24 @@ interface LayoutSnapshot {
   version: 1;
   root: SnapshotNode;
 }
+/**
+ * Saved size of one direct child of an `ixfx-split-layout`, keyed by the
+ * child's `id` in {@link SplitLayoutViewState.layout}.
+ */
+interface SplitPanelViewState {
+  /**
+   * Share (0..1) of the weighted flow. For a collapsed panel, the share it
+   * returns to when expanded.
+   */
+  readonly weight: number;
+  /** Collapsed to the gutter. Absent ⇒ expanded. */
+  readonly collapsed?: boolean;
+}
+/** `ixfx-split-layout` view state (`kind: 'split-layout'`). */
+type SplitLayoutViewState = ViewStateBase & {
+  /** Direct children with an author-given `id`, keyed by that id. */
+  readonly layout?: Readonly<Record<string, SplitPanelViewState>>;
+};
 interface PanelInfo {
   id: string;
   el: HTMLElement;
@@ -100,10 +120,17 @@ declare global {
 //#endregion
 //#region src/split-layout/split-layout.d.ts
 declare class SplitLayoutElement extends LitElement {
+  #private;
   direction: Axis;
   sizes: string;
   gutterSize: string;
   snap: string;
+  /**
+   * Forget the saved size of a child that leaves instead of re-applying it
+   * when a child with that id returns. For hosts that drive child sizes
+   * themselves (e.g. `ixfx-dock-host`, whose leaf ids are positional).
+   */
+  forgetAbsent: boolean;
   private _model;
   private _resizing;
   private _groupEl?;
@@ -116,9 +143,20 @@ declare class SplitLayoutElement extends LitElement {
   firstUpdated(): void;
   private _setupObserver;
   private _rebuildModel;
+  private _writeCollapsedAttributes;
   get panels(): PanelInfo[];
-  getLayout(): LayoutSnapshot | null;
-  setLayout(s: LayoutSnapshot): void;
+  /**
+   * Snapshot the size and collapse of every direct child with an `id`.
+   * Includes saved entries for children not currently slotted.
+   */
+  getViewState(options?: GetViewStateOptions<SplitLayoutViewState>): SplitLayoutViewState;
+  /**
+   * Apply saved sizes. Entries for children that aren't slotted yet are kept
+   * and applied when a child with that id appears. Present children without
+   * an entry keep their relative size.
+   */
+  setViewState(state: Partial<SplitLayoutViewState>): void;
+  clearPendingViewState(): void;
   getSizes(_groupId?: string): Record<string, number>;
   setSizes(weights: number[] | Record<string, number>, _groupId?: string): void;
   collapse(idOrEl: string | HTMLElement): void;
@@ -175,4 +213,4 @@ declare global {
   }
 }
 //#endregion
-export { SplitExpandEvent as _, LayoutNode as a, SplitResizeEvent as b, PanelNode as c, SplitChangeEvent as d, SplitCloseDetail as f, SplitExpandDetail as g, SplitCollapseEvent as h, GroupNode as i, SnapshotNode as l, SplitCollapseDetail as m, SplitPanelElement as n, LayoutSnapshot as o, SplitCloseEvent as p, Axis as r, PanelInfo as s, SplitLayoutElement as t, SplitChangeDetail as u, SplitLayoutElementEventMap as v, WhenSmall as x, SplitResizeDetail as y };
+export { WhenSmall as C, SplitResizeEvent as S, SplitExpandEvent as _, LayoutNode as a, SplitPanelViewState as b, PanelNode as c, SplitChangeEvent as d, SplitCloseDetail as f, SplitExpandDetail as g, SplitCollapseEvent as h, GroupNode as i, SnapshotNode as l, SplitCollapseDetail as m, SplitPanelElement as n, LayoutSnapshot as o, SplitCloseEvent as p, Axis as r, PanelInfo as s, SplitLayoutElement as t, SplitChangeDetail as u, SplitLayoutElementEventMap as v, SplitResizeDetail as x, SplitLayoutViewState as y };

package/dist/{split-layout-Deoxy47d.js → split-layout-DTY4PJRp.js}

@@ -1,6 +1,8 @@
 import { t as themeFallbacks } from "./fallbacks-DQ_5OsmR.js";
 import { n as safeCustomElement, t as __decorate } from "./decorate-VRK8rslU.js";
 import { t as handleStyles } from "./handle-DAXs7kbJ.js";
+import { r as MAX_PENDING_KEYS } from "./pending-BGidHppL.js";
+import { t as ViewStateController } from "./view-state-controller-BdyXWUUM.js";
 import { LitElement, css, html, nothing } from "lit";
 import { property, query, state } from "lit/decorators.js";
 //#region src/split-layout/split-drag.ts
@@ -389,6 +391,163 @@ function walkInner(node, path, visitor) {
 	if (node.kind === `group`) for (let i = 0; i < node.children.length; i++) walkInner(node.children[i], [...path, i], visitor);
 }
 //#endregion
+//#region src/split-layout/split-view-state.ts
+const EMPTY_ENTRIES = /* @__PURE__ */ new Map();
+/** Whether `node` has an author-given id (and can therefore carry view state). */
+function isKeyed(node) {
+	return node.id !== `` && node.el?.id === node.id;
+}
+/** Saved form of one child. Collapsed panels record the share they expand back to. */
+function entryOf(node) {
+	if (node.kind === `panel` && node.collapsed) return {
+		weight: node.restoreWeight,
+		collapsed: true
+	};
+	return { weight: node.weight };
+}
+/** Entries for every keyed direct child of `group`. */
+function captureLayout(group) {
+	const out = /* @__PURE__ */ new Map();
+	for (const child of group.children) if (isKeyed(child)) out.set(child.id, entryOf(child));
+	return out;
+}
+/** Combine entry sources into one JSON record (later sources win). */
+function layoutToRecord(...sources) {
+	const out = {};
+	for (const source of sources) for (const [id, entry] of source) out[id] = entry;
+	return out;
+}
+/** JSON record → entries. Entries without a finite, non-negative `weight` are dropped. */
+function layoutFromRecord(record) {
+	if (!record || typeof record !== `object`) return EMPTY_ENTRIES;
+	const out = /* @__PURE__ */ new Map();
+	for (const [id, entry] of Object.entries(record)) {
+		const weight = entry?.weight;
+		if (typeof weight !== `number` || !Number.isFinite(weight) || weight < 0) continue;
+		out.set(id, entry.collapsed === true ? {
+			weight,
+			collapsed: true
+		} : { weight });
+	}
+	return capEntries(out);
+}
+/** Keep at most `max` entries, dropping the oldest. */
+function capEntries(entries, max = MAX_PENDING_KEYS) {
+	if (entries.size <= max) return entries;
+	return new Map([...entries].slice(entries.size - max));
+}
+/**
+* Reconcile a freshly built (normalised) `next` model with the previous one
+* and pending entries:
+*
+* - keyed children of `prev` that are gone → pending (when `retainAbsent`)
+* - pending entries whose child is now present → applied (weight + collapse)
+*   and removed from pending
+* - with `carry`, children that were already there keep their live weight;
+*   children that are new keep the share the DOM gives them
+*
+* Applied and new children are *pinned* to their share; carried children
+* scale to fill what is left, so restoring three of five saved panels and
+* later slotting the other two lands on the saved proportions.
+*/
+function reconcileLayout(prev, next, pending, options) {
+	const nextIds = new Set(next.children.map((c) => c.id));
+	const nextPending = new Map(pending);
+	const demoted = [];
+	if (prev && options.retainAbsent) {
+		for (const child of prev.children) if (isKeyed(child) && !nextIds.has(child.id)) {
+			nextPending.set(child.id, entryOf(child));
+			demoted.push(child.id);
+		}
+	}
+	const prevById = options.carry && prev ? new Map(prev.children.map((c) => [c.id, c])) : void 0;
+	const applied = [];
+	const collapse = [];
+	const shares = [];
+	const children = next.children.map((child, i) => {
+		const entry = isKeyed(child) ? nextPending.get(child.id) : void 0;
+		if (entry) {
+			nextPending.delete(child.id);
+			applied.push(child.id);
+			shares[i] = {
+				value: entry.weight,
+				pinned: true
+			};
+			if (child.kind === `group`) return {
+				...child,
+				weight: entry.weight
+			};
+			const collapsed = entry.collapsed === true;
+			if (collapsed !== child.collapsed) collapse.push([child.el, collapsed]);
+			return {
+				...child,
+				collapsed,
+				weight: entry.weight,
+				restoreWeight: entry.weight
+			};
+		}
+		const before = prevById?.get(child.id);
+		if (before && sameShape(before, child)) {
+			shares[i] = {
+				value: before.weight,
+				pinned: false
+			};
+			return {
+				...child,
+				weight: before.weight
+			};
+		}
+		shares[i] = {
+			value: child.weight,
+			pinned: prevById !== void 0
+		};
+		return child;
+	});
+	return {
+		model: {
+			...next,
+			children: mergeShares(children, shares)
+		},
+		pending: demoted.length === 0 && applied.length === 0 ? pending : capEntries(nextPending),
+		applied,
+		demoted,
+		collapse
+	};
+}
+function sameShape(a, b) {
+	if (a.kind !== b.kind) return false;
+	return a.kind === `group` || b.kind === `panel` && a.collapsed === b.collapsed;
+}
+function isFlexible(node) {
+	return node.kind === `group` || node.fixedPx === null && !node.collapsed;
+}
+/**
+* Pinned flexible children keep their share; floating ones scale to fill the
+* rest. With nothing floating (or pins over-full) every flexible share is
+* simply normalised.
+*/
+function mergeShares(children, shares) {
+	let pinnedTotal = 0;
+	let floatingTotal = 0;
+	children.forEach((child, i) => {
+		if (!isFlexible(child)) return;
+		if (shares[i].pinned) pinnedTotal += shares[i].value;
+		else floatingTotal += shares[i].value;
+	});
+	const scaleFloating = floatingTotal > 0 && pinnedTotal < 1;
+	const total = scaleFloating ? 1 : pinnedTotal + floatingTotal || 1;
+	const floatScale = scaleFloating ? (1 - pinnedTotal) / floatingTotal : 1 / total;
+	const pinScale = scaleFloating ? 1 : 1 / total;
+	return children.map((child, i) => {
+		if (!isFlexible(child)) return child;
+		const weight = shares[i].value * (shares[i].pinned ? pinScale : floatScale);
+		return weight === child.weight ? child : {
+			...child,
+			weight
+		};
+	});
+}
+//#endregion
 //#region src/split-layout/split-panel.ts
 let SplitPanelElement = class SplitPanelElement extends LitElement {
 	constructor(..._args) {
@@ -449,11 +608,17 @@ let SplitLayoutElement = class SplitLayoutElement extends LitElement {
 		this.sizes = ``;
 		this.gutterSize = ``;
 		this.snap = ``;
+		this.forgetAbsent = false;
 		this._model = null;
 		this._resizing = false;
 		this._observer = null;
 		this._applyingOwnMutation = false;
 		this._dragStructurallyChanged = false;
+		this.#viewState = new ViewStateController(this, {
+			kind: `split-layout`,
+			capture: () => this.getViewState()
+		});
+		this.#pendingLayout = EMPTY_ENTRIES;
 		this._dragMachine = createDragMachine({
 			onDragStart: (state) => this._handleDragStart(state),
 			onDragMove: (state, deltaX, deltaY) => this._handleDragMove(state, deltaX, deltaY),
@@ -479,6 +644,9 @@ let SplitLayoutElement = class SplitLayoutElement extends LitElement {
 			window.removeEventListener(`pointerup`, this._onPointerUp);
 		};
 	}
+	#viewState;
+	/** Saved entries for children not currently present. */
+	#pendingLayout;
 	connectedCallback() {
 		super.connectedCallback();
 		this._setupObserver();
@@ -491,8 +659,11 @@ let SplitLayoutElement = class SplitLayoutElement extends LitElement {
 		this._rebuildModel();
 	}
 	_setupObserver() {
-		this._observer = new MutationObserver(() => {
-			if (!this._applyingOwnMutation) Promise.resolve().then(() => this._rebuildModel());
+		this._observer = new MutationObserver((records) => {
+			if (!this._applyingOwnMutation) {
+				const carry = !records.some((r) => isOwnAttributeChange(this, r));
+				Promise.resolve().then(() => this._rebuildModel(carry));
+			}
 		});
 		this._observer.observe(this, {
 			childList: true,
@@ -507,15 +678,33 @@ let SplitLayoutElement = class SplitLayoutElement extends LitElement {
 				`direction`,
 				`collapsed`,
 				`sizes`
-			]
+			],
+			attributeOldValue: true
 		});
 	}
-	_rebuildModel() {
+	_rebuildModel(carry = true) {
 		this._reindexSlots();
-		const normalized = normalise(buildModel(this));
-		this._model = preserveRestoreWeights(this._model, normalized);
+		const model = buildModel(this);
+		const normalized = preserveRestoreWeights(this._model, normalise(model));
+		const result = reconcileLayout(this._model, normalized, this.#pendingLayout, {
+			carry,
+			retainAbsent: !this.forgetAbsent
+		});
+		this._model = result.model;
+		this.#pendingLayout = result.pending;
+		this._writeCollapsedAttributes(result.collapse);
+		if (result.applied.length > 0) this.#viewState.restoring(() => this.#viewState.notify());
+		else if (result.demoted.length > 0) this.#viewState.notify(`data`);
 		this.requestUpdate();
 	}
+	_writeCollapsedAttributes(writes) {
+		if (writes.length === 0) return;
+		for (const [el, collapsed] of writes) {
+			el.toggleAttribute(`collapsed`, collapsed);
+			el.toggleAttribute(`data-collapsed`, collapsed);
+		}
+		this._observer?.takeRecords();
+	}
 	get panels() {
 		if (!this._model) return [];
 		const panels = [];
@@ -534,17 +723,38 @@ let SplitLayoutElement = class SplitLayoutElement extends LitElement {
 		});
 		return panels;
 	}
-	getLayout() {
-		if (!this._model) return null;
-		return toSnapshot(this._model);
+	/**
+	* Snapshot the size and collapse of every direct child with an `id`.
+	* Includes saved entries for children not currently slotted.
+	*/
+	getViewState(options) {
+		const withPending = options?.includePending ?? true;
+		const live = this._model ? captureLayout(this._model) : [];
+		return this.#viewState.shape({ layout: layoutToRecord(withPending ? this.#pendingLayout : [], live) }, options);
 	}
-	setLayout(s) {
-		if (!this._model) return;
-		this._applyingOwnMutation = true;
-		this._model = applySnapshot(this._model, s);
-		this.requestUpdate();
-		this._applyingOwnMutation = false;
-		this._emitChange();
+	/**
+	* Apply saved sizes. Entries for children that aren't slotted yet are kept
+	* and applied when a child with that id appears. Present children without
+	* an entry keep their relative size.
+	*/
+	setViewState(state) {
+		if (!this.#viewState.accepts(state) || state.layout === void 0) return;
+		this.#viewState.restoring(() => {
+			this.#pendingLayout = layoutFromRecord(state.layout);
+			if (!this._model) {
+				this.#viewState.notify();
+				return;
+			}
+			this._applyingOwnMutation = true;
+			this._rebuildModel();
+			this._observer?.takeRecords();
+			this._applyingOwnMutation = false;
+			this._emitResize();
+			this._emitChange();
+		});
+	}
+	clearPendingViewState() {
+		this.#pendingLayout = EMPTY_ENTRIES;
 	}
 	getSizes(_groupId) {
 		if (!this._model) return {};
@@ -818,9 +1028,9 @@ let SplitLayoutElement = class SplitLayoutElement extends LitElement {
 		}));
 	}
 	_emitChange() {
-		const layout = this.getLayout();
-		if (!layout) return;
-		const detail = { layout };
+		if (!this._model) return;
+		this.#viewState.notify();
+		const detail = { layout: toSnapshot(this._model) };
 		this.dispatchEvent(new CustomEvent(`ixfx-split-change`, {
 			detail,
 			bubbles: true,
@@ -1018,9 +1228,31 @@ __decorate([property({
 	attribute: `gutter-size`
 })], SplitLayoutElement.prototype, "gutterSize", void 0);
 __decorate([property({ type: String })], SplitLayoutElement.prototype, "snap", void 0);
+__decorate([property({
+	type: Boolean,
+	attribute: `forget-absent`
+})], SplitLayoutElement.prototype, "forgetAbsent", void 0);
 __decorate([state()], SplitLayoutElement.prototype, "_model", void 0);
 __decorate([state()], SplitLayoutElement.prototype, "_resizing", void 0);
 __decorate([query(`.grid`)], SplitLayoutElement.prototype, "_groupEl", void 0);
 SplitLayoutElement = __decorate([safeCustomElement(`ixfx-split-layout`)], SplitLayoutElement);
+/** Attributes that set a child's share (or take it out of the weighted flow). */
+const WEIGHT_ATTRIBUTES = /* @__PURE__ */ new Set([
+	`size`,
+	`weight`,
+	`sizes`,
+	`fixed`,
+	`collapsed`
+]);
+/**
+* A weight attribute on `host` or one of its direct children whose value
+* really changed (not e.g. `direction` reflecting on first render).
+*/
+function isOwnAttributeChange(host, record) {
+	if (record.type !== `attributes` || record.attributeName === null || !WEIGHT_ATTRIBUTES.has(record.attributeName)) return false;
+	const target = record.target;
+	if (target !== host && target.parentElement !== host) return false;
+	return target.getAttribute(record.attributeName) !== record.oldValue;
+}
 //#endregion
 export { distribute as a, preserveRestoreWeights as c, toSnapshot as d, walk as f, buildModel as i, resolveTracks as l, SplitPanelElement as n, findPanelNode as o, applySnapshot as r, normalise as s, SplitLayoutElement as t, setPanelRestoreWeight as u };

package/dist/split-layout.d.ts

@@ -1,2 +1,2 @@
-import { t as SplitLayoutElement } from "./split-layout-JK3xWVX2.js";
+import { t as SplitLayoutElement } from "./split-layout-CophkNeU.js";
 export { SplitLayoutElement };

package/dist/split-layout.js

@@ -1,2 +1,2 @@
-import { t as SplitLayoutElement } from "./split-layout-Deoxy47d.js";
+import { t as SplitLayoutElement } from "./split-layout-DTY4PJRp.js";
 export { SplitLayoutElement };

package/dist/sunburst-tree.d.ts

@@ -1,2 +1,2 @@
-import { i as SunburstZoomEvent, n as SunburstTreeListElementEventMap, r as SunburstZoomDetail, t as SunburstTreeListElement } from "./sunbursttree-list--Z0uyh8O.js";
-export { SunburstTreeListElement, SunburstTreeListElementEventMap, SunburstZoomDetail, SunburstZoomEvent };
+import { a as SunburstViewState, i as SunburstZoomEvent, n as SunburstTreeListElementEventMap, r as SunburstZoomDetail, t as SunburstTreeListElement } from "./sunbursttree-list-D6j5BxVQ.js";
+export { SunburstTreeListElement, SunburstTreeListElementEventMap, type SunburstViewState, SunburstZoomDetail, SunburstZoomEvent };

package/dist/sunburst-tree.js

@@ -1,2 +1,2 @@
-import { t as SunburstTreeListElement } from "./sunbursttree-list-yXwS-uEI.js";
+import { t as SunburstTreeListElement } from "./sunbursttree-list-B_VxOHlo.js";
 export { SunburstTreeListElement };