@mono-lit/helper 0.0.6 → 0.0.8

package/dist/{mono-data-grid-KDpu4d4_.js → mono-data-grid-Bkr-e1-i.js}

@@ -1,8 +1,8 @@
 import { t as createNotifier } from "./notifier-BIrqUzRh.js";
 import { a as parseFieldPath, c as toODataClause, l as toODataSelector, n as isPath, o as projectFields, r as mergePatch, s as setFieldValue, t as getFieldValue } from "./field-path-BabiMrrA.js";
 import { C as resolveSearchEntries, D as compileFilterPredicate, E as andPredicates, O as joinFilters, S as plainSearchColumns, T as andFilters, f as mergeSearchFields, g as customRemoteClause, h as customPredicate, n as describeError, o as isCanceled, u as DEFAULT_SEARCH_FIELDS, v as hasCustomSearch, w as searchEntryFor, y as hasWildcardSearch } from "./normalize-error-BmLbgANw.js";
-import { a as buildGroups, c as isGroupNode, i as searchFilterOf, o as collectGroupPaths, r as readAllRows, s as flattenLeaves } from "./data-source-read-i6CYSUEl.js";
-import { a as resolveDataSourceOptions, c as composeSummaryApply, d as createApplyGate, f as isRolledUp, h as monoArraySource, i as normalizeSortList, l as summaryAliases, m as storeRows, n as extraLoadOptions, o as toList, p as loadApply, s as buildSummaryApply, t as dataSourceOptionsKey, u as summaryFilterOf } from "./data-source-options-Cz9fVLK8.js";
+import { a as buildGroups, c as isGroupNode, i as searchFilterOf, o as collectGroupPaths, r as readAllRows, s as flattenLeaves } from "./data-source-read-HyBCRg1t.js";
+import { a as resolveDataSourceOptions, c as composeSummaryApply, d as createApplyGate, f as isRolledUp, h as monoArraySource, i as normalizeSortList, l as summaryAliases, m as storeRows, n as extraLoadOptions, o as toList, p as loadApply, s as buildSummaryApply, t as dataSourceOptionsKey, u as summaryFilterOf } from "./data-source-options-BM4r4PRw.js";
 import { n as unwrapReactive } from "./reactive-Dtd-esHO.js";
 import { t as arrayToODataString } from "./filter-odata-Bi27XUpQ.js";
 import { t as monoFilterBuilder } from "./filter-builder-B6Y2mmbM.js";
@@ -1004,6 +1004,16 @@ function monoDataGrid(ds = null, opts = {}) {
 	const checkedRows = /* @__PURE__ */ new Map();
 	let checkConfig = {};
 	let checkPending = false;
+	/**
+	* Bumped on every selection notify (a rejected toggle included — its subscribers repaint the
+	* revert), so a listener can tell a selection change from the grid's other notifies without
+	* diffing the store. See `MonoCheckHandle.version`.
+	*/
+	let checkVersion = 0;
+	function checkChanged() {
+		checkVersion += 1;
+		notify();
+	}
 	/** `keyValue` as a list (empty = project nothing, i.e. keep the whole row). */
 	function checkKeys() {
 		const k = checkConfig.keyValue;
@@ -1126,26 +1136,26 @@ function monoDataGrid(ds = null, opts = {}) {
 				if (next) checkedRows.set(key, item);
 				else checkedRows.delete(key);
 			}
-			notify();
+			checkChanged();
 		},
 		selectPage() {
 			addChecked(ctrl.items);
-			notify();
+			checkChanged();
 		},
 		replace(rows) {
 			checkedRows.clear();
 			addChecked(rows, false);
-			notify();
+			checkChanged();
 		},
 		async selectAll() {
 			if (checkPending) return;
 			if (drainIsReusable()) {
 				addChecked(drainedRows);
-				notify();
+				checkChanged();
 				return;
 			}
 			checkPending = true;
-			notify();
+			checkChanged();
 			try {
 				const select = checkSelect();
 				const rows = await readAllRows(bound, {
@@ -1161,7 +1171,7 @@ function monoDataGrid(ds = null, opts = {}) {
 				throw err;
 			} finally {
 				checkPending = false;
-				notify();
+				checkChanged();
 			}
 		},
 		clear() {
@@ -1169,14 +1179,14 @@ function monoDataGrid(ds = null, opts = {}) {
 			const min = checkLimits().min ?? 0;
 			if (min > 0) {
 				if (checkedRows.size <= min) {
-					notify();
+					checkChanged();
 					return;
 				}
 				const keep = [...checkedRows.entries()].slice(0, min);
 				checkedRows.clear();
 				for (const [key, row] of keep) checkedRows.set(key, row);
 			} else checkedRows.clear();
-			notify();
+			checkChanged();
 		},
 		limits: checkLimits,
 		get atMax() {
@@ -1187,6 +1197,9 @@ function monoDataGrid(ds = null, opts = {}) {
 			const min = checkLimits().min;
 			return min !== void 0 && checkedRows.size <= min;
 		},
+		get version() {
+			return checkVersion;
+		},
 		get pending() {
 			return checkPending;
 		},
@@ -1278,8 +1291,53 @@ function monoDataGrid(ds = null, opts = {}) {
 	function columns() {
 		return columnsHandle;
 	}
+	/**
+	* Row → index and row key → index over `ctrl.items`, built lazily per items ARRAY.
+	*
+	* `rowKey()` / `indexOfRowKey()` were linear scans, and they are per-row calls: every
+	* `<mono-table-checkbox>` asks `check.isChecked(row)` on every notify, so a tick on a grid
+	* holding N rows (infinity scroll and page-size "all" hold the whole set) cost O(N²).
+	*
+	* A HIT is always verified against the live array, and a MISS falls back to the scan
+	* (rebuilding when the scan finds the row) — so an in-place mutation of `ctrl.items`, or a
+	* key that moved, costs one rebuild and is never answered wrong.
+	*/
+	let indexFor = null;
+	let indexByRow = /* @__PURE__ */ new Map();
+	let keyIndexFor = null;
+	let indexByKey = /* @__PURE__ */ new Map();
+	function rebuildRowIndex(items) {
+		indexFor = items;
+		indexByRow = /* @__PURE__ */ new Map();
+		items.forEach((row, i) => {
+			if (!indexByRow.has(row)) indexByRow.set(row, i);
+		});
+	}
+	function indexOfRow(raw) {
+		const items = ctrl.items;
+		if (indexFor !== items) rebuildRowIndex(items);
+		const hit = indexByRow.get(raw);
+		if (hit !== void 0 && items[hit] === raw) return hit;
+		const i = items.indexOf(raw);
+		if (i >= 0) rebuildRowIndex(items);
+		return i;
+	}
+	function rebuildKeyIndex(items) {
+		keyIndexFor = items;
+		indexByKey = /* @__PURE__ */ new Map();
+		items.forEach((row, i) => {
+			const k = rowKeyOf(row, i);
+			if (!indexByKey.has(k)) indexByKey.set(k, i);
+		});
+	}
 	function indexOfRowKey(rowKey) {
-		return ctrl.items.findIndex((row, i) => rowKeyOf(row, i) === rowKey);
+		const items = ctrl.items;
+		if (keyIndexFor !== items) rebuildKeyIndex(items);
+		const hit = indexByKey.get(rowKey);
+		if (hit !== void 0 && hit < items.length && rowKeyOf(items[hit], hit) === rowKey) return hit;
+		const i = items.findIndex((row, j) => rowKeyOf(row, j) === rowKey);
+		if (i >= 0) rebuildKeyIndex(items);
+		return i;
 	}
 	function rowByKey(rowKey) {
 		const i = indexOfRowKey(rowKey);
@@ -1394,7 +1452,12 @@ function monoDataGrid(ds = null, opts = {}) {
 		return !!row && row._Type === EDITABLE_MARK;
 	}
 	function isEditingCell(rowKeyStr, field) {
-		if (!registeredColumns().some((c) => c.field === field && !!c.editable)) return false;
+		let editableCol = false;
+		for (const el of columnEls) if (el.field === field && el.editable) {
+			editableCol = true;
+			break;
+		}
+		if (!editableCol) return false;
 		return ctrl.editingKey === rowKeyStr || isEditableRow(rowByKey(rowKeyStr));
 	}
 	function commitCell(rowKey, field, value) {
@@ -2166,7 +2229,7 @@ function monoDataGrid(ds = null, opts = {}) {
 	*/
 	function rowKey(row) {
 		const raw = unwrapReactive(row);
-		const i = ctrl.items.indexOf(raw);
+		const i = indexOfRow(raw);
 		if (i >= 0) return rowKeyOf(raw, i);
 		const direct = rowKeyOf(raw, NaN);
 		if (direct !== "NaN") return direct;
@@ -2213,26 +2276,50 @@ function monoDataGrid(ds = null, opts = {}) {
 		if (cols.length && out && typeof out === "object") for (const c of cols) out[c.field] = c.map(row?.[c.field], row, index);
 		return out;
 	}
-	/** Recompute `ctrl.mapped` from `ctrl.items`. Cheap no-op without a map. */
+	/** What `ctrl.mapped` was last built from — see `syncMapped`. */
+	let mappedFrom = [];
+	/**
+	* Recompute `ctrl.mapped` from `ctrl.items`. Cheap no-op without a map.
+	*
+	* Skipped when nothing it reads has moved: the same `items` array (same length), the same
+	* row set (`rowSetVersion`) and the same map config. It runs on EVERY notifier flush, so a
+	* checkbox tick or a loading flip re-mapped every row — every accumulated row under infinity
+	* scroll or page-size "all" — and handed out new `mapped` identities each time.
+	*
+	* Never skipped while a row can be edited IN PLACE (an inline edit, a `showForm` row, form
+	* ops): those write straight into the row objects, which no identity check can see.
+	*/
 	function syncMapped() {
 		if (!hasMap()) {
 			ctrl.mapped = ctrl.items;
+			mappedFrom = [];
 			return;
 		}
+		const from = [
+			ctrl.items,
+			ctrl.items.length,
+			rowSetVersion,
+			elementProps.th,
+			opts.map
+		];
+		if (!(formHandle != null || formOps.length > 0 || ctrl.editingKey != null) && from.length === mappedFrom.length && from.every((v, i) => Object.is(v, mappedFrom[i]))) return;
 		const cols = mapColumns();
 		ctrl.mapped = ctrl.items.map((row, i) => mapRow(row, i, cols));
+		mappedFrom = from;
 	}
 	/** Flatten `ctrl.items` into the ready-to-render, keyed `displayRows` list. */
 	function buildDisplayRows() {
 		const out = [];
 		const cols = mapColumns();
 		if (!isGrouped()) {
+			syncMapped();
+			const mapped = ctrl.mapped;
 			ctrl.items.forEach((row, i) => out.push({
 				key: `r:${rowKeyOf(row, i)}`,
 				kind: "row",
 				level: 0,
 				row,
-				mapped: mapRow(row, i, cols)
+				mapped: mapped[i]
 			}));
 			return out;
 		}
@@ -2275,9 +2362,29 @@ function monoDataGrid(ds = null, opts = {}) {
 	}
 	/** Build the full group tree from every matched row the source holds. */
 	function fullGroups() {
-		const raw = bound ? [...bound.items?.() ?? []] : [];
-		return buildGroups(flattenLeaves(raw), groupFields, collapsed);
+		const src = bound ? bound.items?.() ?? [] : [];
+		const from = [
+			src,
+			src.length,
+			groupFields.join("\0"),
+			rowSetVersion
+		];
+		if (!(!(formHandle != null || formOps.length > 0 || ctrl.editingKey != null) && from.length === groupTreeFrom.length && from.every((v, i) => Object.is(v, groupTreeFrom[i])))) {
+			groupTree = buildGroups(flattenLeaves([...src]), groupFields, collapsed);
+			groupTreeFrom = from;
+			return groupTree;
+		}
+		const stamp = (nodes) => {
+			for (const node of nodes) {
+				node.collapsed = collapsed.has(node.path);
+				if (node.items.length && isGroupNode(node.items[0])) stamp(node.items);
+			}
+		};
+		stamp(groupTree);
+		return groupTree;
 	}
+	let groupTreeFrom = [];
+	let groupTree = [];
 	/** Index every group node by path (full, unsliced) for `groupPageInfo`. */
 	function indexPaths(nodes) {
 		for (const node of nodes) {
@@ -3869,12 +3976,16 @@ function monoDataGrid(ds = null, opts = {}) {
 	async function getData() {
 		const s = bound;
 		if (!s) return [];
+		const loadOptions = {};
+		if (resolvedOpts.expand !== void 0) loadOptions.expand = resolvedOpts.expand;
+		if (resolvedOpts.customQueryParams !== void 0) loadOptions.customQueryParams = resolvedOpts.customQueryParams;
 		suppressSync = true;
 		try {
 			return await readAllRows(s, {
 				chunkSize,
 				select: opts.select ?? toList(resolvedOpts.select),
-				sort: mergedSort()
+				sort: mergedSort(),
+				...Object.keys(loadOptions).length ? { loadOptions } : {}
 			});
 		} finally {
 			suppressSync = false;
@@ -3908,7 +4019,7 @@ function monoDataGrid(ds = null, opts = {}) {
 		});
 	}
 	async function exportReport(options) {
-		const { exportTable } = await import("./export-DgomqI_3.js");
+		const { exportTable } = await import("./export-ixRdCS2y.js");
 		return exportTable(options);
 	}
 	function subscribe(cb) {

package/dist/{mono-element-Bc9wElPy.js → mono-element-CKcT0rwv.js}

@@ -1,4 +1,4 @@
-import { S as registerPendingProperty, h as monoApplyPhantomOptions, m as isMonoSsrApp, t as applyMonoUIDefaults, v as monoPendingActive, w as watchSkeletonActivation, x as monoSkeletonInternals } from "./mono-ui-KOBJcnXk.js";
+import { S as registerPendingProperty, h as monoApplyPhantomOptions, m as isMonoSsrApp, t as applyMonoUIDefaults, v as monoPendingActive, w as watchSkeletonActivation, x as monoSkeletonInternals } from "./mono-ui-kvLVIf1V.js";
 import { html } from "lit";
 
 //#region src/composables/mono-pending.ts

package/dist/{mono-form-controller-BkMR8g14.js → mono-form-controller-BrA10erm.js}

@@ -179,6 +179,9 @@ function monoForm(options) {
 	const state = {};
 	/** Props pushed at runtime by the `setProp()` METHOD (watchers / outside code). */
 	const dynamicProps = {};
+	const mergedProps = {};
+	/** Keys whose `dynamicProps` moved since their merged props were cached. */
+	const propsDirty = /* @__PURE__ */ new Set();
 	const elements = {};
 	for (const key of keys) {
 		const initial = inputs[key].value;
@@ -212,10 +215,14 @@ function monoForm(options) {
 	* it is merged LAST over whatever the `setProp()` method has accumulated.
 	*/
 	function propsFor(key) {
+		const hit = mergedProps[key];
+		if (hit && !propsDirty.has(key)) return hit;
 		const merged = {
 			...dynamicProps[key] ?? {},
 			...inputs[key]?.props ?? {}
 		};
+		mergedProps[key] = merged;
+		propsDirty.delete(key);
 		state[key] && (state[key].props = merged);
 		return merged;
 	}
@@ -320,7 +327,10 @@ function monoForm(options) {
 			bag[p] = v;
 			changed = true;
 		}
-		if (changed) notify();
+		if (changed) {
+			propsDirty.add(arg.key);
+			notify();
+		}
 	}
 	function setValidation(arg) {
 		const item = state[arg?.key];
@@ -352,6 +362,7 @@ function monoForm(options) {
 			};
 			state[key].touched = false;
 			dynamicProps[key] = {};
+			propsDirty.add(key);
 		}
 		notify();
 	}

package/dist/{mono-ui-KOBJcnXk.js → mono-ui-kvLVIf1V.js}

@@ -479,9 +479,11 @@ function headerWidth(cell, host) {
 * One auto-sized column, owned by its `mono-table-th`. `schedule()` coalesces every trigger (a
 * controller notify, a body mutation, typing in an editor) into one measurement per frame.
 */
-var ColumnAutoSize = class {
+var ColumnAutoSize = class ColumnAutoSize {
 	constructor(host) {
 		this.host = host;
+		this.growOnly = false;
+		this._floor = 0;
 		this._raf = 0;
 		this._onInput = (e) => {
 			const t = e.target;
@@ -492,16 +494,37 @@ var ColumnAutoSize = class {
 			this.schedule();
 		};
 	}
+	static {
+		this._queued = /* @__PURE__ */ new Set();
+	}
+	static {
+		this._frame = 0;
+	}
+	static _flush() {
+		ColumnAutoSize._frame = 0;
+		const batch = [...ColumnAutoSize._queued];
+		ColumnAutoSize._queued.clear();
+		const writes = batch.map((s) => {
+			s._raf = 0;
+			return s._measure();
+		});
+		for (const write of writes) write?.();
+	}
 	schedule() {
 		if (this._raf) return;
-		this._raf = requestAnimationFrame(() => {
-			this._raf = 0;
-			this._run();
-		});
+		this._raf = 1;
+		ColumnAutoSize._queued.add(this);
+		ColumnAutoSize._frame ||= requestAnimationFrame(() => ColumnAutoSize._flush());
+	}
+	/** Forget the grow-only floor (new rows) and re-measure. */
+	resetFloor() {
+		if (!this._floor) return;
+		this._floor = 0;
+		this.schedule();
 	}
 	/** Stop watching, and hand the column back to whatever width it is given next. */
 	stop(clear = false) {
-		if (this._raf) cancelAnimationFrame(this._raf);
+		ColumnAutoSize._queued.delete(this);
 		this._raf = 0;
 		this._unwatch();
 		if (clear && this._wrote) {
@@ -533,10 +556,11 @@ var ColumnAutoSize = class {
 		document.fonts?.removeEventListener?.("loadingdone", this._onFonts);
 		this._table = void 0;
 	}
-	_run() {
+	/** Measure now (reads only); returns the write to apply after every sizer has measured. */
+	_measure() {
 		const cell = this.host.closest("th, td");
 		const table = cell?.closest("table");
-		if (!cell || !table || !this.host.isConnected) return;
+		if (!cell || !table || !this.host.isConnected) return null;
 		this._watch(table);
 		const index = headerColumnIndex(cell);
 		let width = headerWidth(cell, this.host);
@@ -546,13 +570,17 @@ var ColumnAutoSize = class {
 			if (target) width = Math.max(width, contentWidth(target));
 		}
 		width = Math.ceil(clampWidth(width + 1, this.min, this.max));
+		if (this.growOnly) width = this._floor = Math.max(width, this._floor);
+		else this._floor = 0;
 		const value = `${width}px`;
 		const col = colAt(table, index);
-		if (cell.style.width !== value) cell.style.width = value;
-		if (col && col.style.width !== value) col.style.width = value;
-		this._wrote = {
-			col,
-			cell
+		return () => {
+			if (cell.style.width !== value) cell.style.width = value;
+			if (col && col.style.width !== value) col.style.width = value;
+			this._wrote = {
+				col,
+				cell
+			};
 		};
 	}
 };
@@ -621,10 +649,10 @@ function startMonoSizeAttributes() {
 					applyMonoSizeAttributes(r.target);
 					continue;
 				}
-				for (const node of Array.from(r.addedNodes)) if (node.nodeType === 1) scan(node);
+				for (const node of Array.from(r.addedNodes)) if (node.nodeType === 1 && node.isConnected) scan(node);
 				if (r.removedNodes.length) removed = true;
 			}
-			if (removed) sweep();
+			if (removed && sizers.size) sweep();
 		});
 		observer.observe(document.documentElement, {
 			subtree: true,

package/dist/{popup-portal-C8ttHDRX.js → popup-portal-CINuVjNY.js}

@@ -233,6 +233,8 @@ var PopupPortalController = class {
 		this._classObserver = null;
 		this._viewportBound = false;
 		this._viewportFrame = 0;
+		this._wasOpen = false;
+		this._sizeObserver = null;
 		this._onViewport = () => {
 			if (!this.opts.isOpen() || this._viewportFrame) return;
 			this._viewportFrame = requestAnimationFrame(() => {
@@ -254,24 +256,65 @@ var PopupPortalController = class {
 	hostDisconnected() {
 		this._unbindViewport();
 		this._leaveStack();
+		this._unobserveSize();
+		this._wasOpen = false;
 		this._classObserver?.disconnect();
 		this._classObserver = null;
 		if (this._portal?.parentNode) this._portal.parentNode.removeChild(this._portal);
 		this._portal = null;
 		this._adopted = false;
 	}
+	/**
+	* Position SYNCHRONOUSLY only on the open edge; every later update of an open popup is
+	* coalesced into one frame (`scheduleReposition`), and the custom-property carry-over
+	* (`_syncPortalVars`, two `getComputedStyle`) runs on the open edge only.
+	*
+	* `reposition()` is a write-then-read forced layout, and hosts update constantly while open —
+	* every keystroke in a search box, every arrow-key cursor move, every controller notify — so
+	* running it per update cost one synchronous layout each. A frame callback still runs before
+	* that frame paints, so nothing visibly lags; a panel whose content resizes WITHOUT a host
+	* update (a consumer re-rendering its rows) is caught by the ResizeObserver instead.
+	*/
 	hostUpdated() {
 		if (isServer) return;
 		if (this.opts.isOpen()) {
+			const opening = !this._wasOpen;
+			this._wasOpen = true;
 			this._adopt();
 			this._enterStack();
-			this._syncPortalClass();
-			this.reposition();
+			if (opening) {
+				this._syncPortalClass();
+				this.reposition();
+				this._observeSize();
+			} else {
+				this._syncPortalClass(false);
+				this.scheduleReposition();
+			}
 		} else {
+			this._wasOpen = false;
+			this._unobserveSize();
 			this._leaveStack();
-			this._syncPortalClass();
+			this._syncPortalClass(false);
 		}
 	}
+	/** Reposition when the panel or its anchor changes size while open (content, chips wrapping). */
+	_observeSize() {
+		if (this._sizeObserver || typeof ResizeObserver === "undefined") return;
+		const panel = this._panel ?? this.opts.getPanel();
+		const anchor = this.opts.getAnchor();
+		if (!panel && !anchor) return;
+		this._sizeObserver = new ResizeObserver(() => this.scheduleReposition());
+		if (panel) this._sizeObserver.observe(panel);
+		if (anchor) this._sizeObserver.observe(anchor);
+	}
+	_unobserveSize() {
+		this._sizeObserver?.disconnect();
+		this._sizeObserver = null;
+	}
+	/** Reposition on the next frame, coalesced with any viewport movement already pending. */
+	scheduleReposition() {
+		this._onViewport();
+	}
 	/**
 	* Only relocate to `<body>` when the host renders into light DOM
 	* (`renderRoot === host`). Shadow hosts keep the panel in their shadow root.
@@ -307,8 +350,12 @@ var PopupPortalController = class {
 		this._panel = panel;
 		this._adopted = true;
 	}
-	/** Mirror the style-scope element's classes and `mono-*` attributes onto the portal. */
-	_syncPortalClass() {
+	/**
+	* Mirror the style-scope element's classes and `mono-*` attributes onto the portal.
+	* `withVars` also carries the custom properties across — a computed-style read, so only on
+	* the open edge and on a scope attribute change, not on every host update.
+	*/
+	_syncPortalClass(withVars = true) {
 		if (!this._portal) return;
 		const scope = this.opts.getStyleScope();
 		const cls = scope?.getAttribute("class") ?? "";
@@ -320,7 +367,7 @@ var PopupPortalController = class {
 		}
 		for (const a of Array.from(this._portal.attributes)) if (mirrored(a.name) && !wanted.has(a.name)) this._portal.removeAttribute(a.name);
 		for (const [name, value] of wanted) if (this._portal.getAttribute(name) !== value) this._portal.setAttribute(name, value);
-		this._syncPortalVars(scope);
+		if (withVars) this._syncPortalVars(scope);
 	}
 	/**
 	* Carry the component's public custom properties across the portal (see

package/dist/src/components/accordion/mono-accordion.d.ts

@@ -15,7 +15,6 @@ declare const MonoAccordion_base: Constructor<MonoAccordionCoreInterface> & type
  * Both register `mono-accordion`, so a document loads only one.
  */
 export declare class MonoAccordion extends MonoAccordion_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotObserver?;
   private _slotTitle;

package/dist/src/components/alert/mono-alert.d.ts

@@ -18,7 +18,6 @@ declare const MonoAlert_base: Constructor<MonoAlertCoreInterface> & typeof LitEl
  * rendered, and their captured nodes are parked (kept parented, invisible).
  */
 export declare class MonoAlert extends MonoAlert_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _buckets;

package/dist/src/components/breadcrumb/mono-breadcrumb-list.d.ts

@@ -16,7 +16,6 @@ declare const MonoBreadcrumbList_base: Constructor<MonoBreadcrumbListCoreInterfa
  *     (`@mono-lit/helper/ui/shadow/breadcrumb`) supports standalone only.
  */
 export declare class MonoBreadcrumbList extends MonoBreadcrumbList_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _parent;
   connectedCallback(): void;

package/dist/src/components/breadcrumb/mono-breadcrumb.d.ts

@@ -18,7 +18,6 @@ declare const MonoBreadcrumb_base: Constructor<MonoBreadcrumbCoreInterface> & ty
  * so a document loads only one.
  */
 export declare class MonoBreadcrumb extends MonoBreadcrumb_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _hasBodySlot;

package/dist/src/components/button/mono-button-dropdown.d.ts

@@ -17,7 +17,6 @@ declare const MonoButtonDropdown_base: Constructor<MonoButtonDropdownCoreInterfa
  * build shares it and only swaps the embedded button's tag.
  */
 export declare class MonoButtonDropdown extends MonoButtonDropdown_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   /**
    * The panel is a STATIC element here, not something a helper returns.

package/dist/src/components/button/mono-button.d.ts

@@ -22,7 +22,6 @@ declare const MonoButton_base: Constructor<MonoButtonCoreInterface> & typeof Lit
  * document loads only one.
  */
 export declare class MonoButton extends MonoButton_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _buckets;
   private _slotsCaptured;

package/dist/src/components/card/mono-card.d.ts

@@ -24,7 +24,6 @@ declare const MonoCard_base: Constructor<MonoCardCoreInterface> & typeof LitElem
  * same document.
  */
 export declare class MonoCard extends MonoCard_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _buckets;

package/dist/src/components/chart/mono-chart-presets.d.ts

@@ -6,7 +6,6 @@ import { LitElement, TemplateResult } from "lit";
 declare const MonoChartBar_base: Constructor<MonoChartCoreInterface> & typeof LitElement;
 /** `<mono-chart-bar>` — vertical bars. */
 export declare class MonoChartBar extends MonoChartBar_base {
-  static styles: import("lit").CSSResult[];
   protected _presetType: MonoChartType;
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;
@@ -14,7 +13,6 @@ export declare class MonoChartBar extends MonoChartBar_base {
 declare const MonoChartLine_base: Constructor<MonoChartCoreInterface> & typeof LitElement;
 /** `<mono-chart-line>` — a line series. */
 export declare class MonoChartLine extends MonoChartLine_base {
-  static styles: import("lit").CSSResult[];
   protected _presetType: MonoChartType;
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;
@@ -22,7 +20,6 @@ export declare class MonoChartLine extends MonoChartLine_base {
 declare const MonoChartPie_base: Constructor<MonoChartCoreInterface> & typeof LitElement;
 /** `<mono-chart-pie>` — pie slices. */
 export declare class MonoChartPie extends MonoChartPie_base {
-  static styles: import("lit").CSSResult[];
   protected _presetType: MonoChartType;
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;
@@ -30,7 +27,6 @@ export declare class MonoChartPie extends MonoChartPie_base {
 declare const MonoChartDoughnut_base: Constructor<MonoChartCoreInterface> & typeof LitElement;
 /** `<mono-chart-doughnut>` — a pie with a hole. */
 export declare class MonoChartDoughnut extends MonoChartDoughnut_base {
-  static styles: import("lit").CSSResult[];
   protected _presetType: MonoChartType;
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;

package/dist/src/components/chart/mono-chart.d.ts

@@ -21,7 +21,6 @@ declare const MonoChart_base: Constructor<MonoChartCoreInterface> & typeof LitEl
  * ```
  */
 export declare class MonoChart extends MonoChart_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   protected render(): TemplateResult;
 }

package/dist/src/components/checkbox/mono-checkbox.d.ts

@@ -17,7 +17,6 @@ declare const MonoCheckbox_base: Constructor<MonoCheckboxCoreInterface> & typeof
  * document loads only one.
  */
 export declare class MonoCheckbox extends MonoCheckbox_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _slotsCaptured;
   private _slotIcon;

package/dist/src/components/chip/mono-chip.d.ts

@@ -21,7 +21,6 @@ declare const MonoChip_base: Constructor<MonoChipCoreInterface> & typeof LitElem
  * only one.
  */
 export declare class MonoChip extends MonoChip_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
   private _buckets;
   private _slotsCaptured;

package/dist/src/components/date/mono-date.d.ts

@@ -14,7 +14,6 @@ declare const MonoDate_base: Constructor<MonoDateCoreInterface> & typeof LitElem
  * `mono-date`, so a document loads one.
  */
 export declare class MonoDate extends MonoDate_base {
-  static styles: import("lit").CSSResult[];
   protected createRenderRoot(): HTMLElement;
 }
 declare global {