cx 26.7.4 → 26.7.6

package/dist/widgets.js

@@ -1,81 +1,60 @@
 import {
-	FocusManager,
-	Instance,
-	StyledContainerBase,
-	Url,
-	VDOM,
-	Widget,
-	createFunctionalComponent,
-	flattenProps,
-	preventFocus,
-	getContentArray,
-	GroupAdapter,
-	Selection,
-	getContent,
-	Container,
-	offFocusOut,
-	preventFocusOnTouch,
-	batchUpdates,
-	oneFocusOut,
-	PureContainerBase,
-	ContainerBase,
-	ZIndexManager,
-	startAppLoop,
-	ResizeManager,
-	Localization,
-	RenderingContext,
-	ContentPlaceholder,
-	Text,
-	History,
-	Cx,
-	registerKeyboardShortcut,
-	unfocusElement,
-	Culture,
-	bind,
-	Format,
-	enableCultureSensitiveFormatting,
-	ContentResolver,
-	DataProxy,
-	KeySelection,
-	PureContainer,
-	ArrayAdapter,
-	InstanceCache,
-	StaticText,
-} from "cx/ui";
-export {
-	ArrayAdapter,
-	Content,
-	ContentPlaceholder,
-	ContentPlaceholderScope,
-	ContentResolver,
-	DataAdapter,
-	DataProxy,
-	DetachedScope,
-	GroupAdapter,
-	IsolatedScope,
-	LabelsLeftLayout,
-	LabelsTopLayout,
-	LabelsTopLayoutCell,
-	PrivateStore,
-	PureContainer,
-	Repeater,
-	Rescope,
-	Restate,
-	StaticText,
-	Text,
-	TreeAdapter,
-	Widget,
-} from "cx/ui";
-import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+	computable,
+	StoreProxy,
+	isAccessorChain,
+	StructuredSelector,
+	invalidateExpressionCache,
+	invalidateStringTemplateCache,
+	defaultCompare,
+	getSelector,
+	SubscribableView,
+	Store,
+	Binding,
+	NestedDataView,
+	ZoomIntoPropertyView,
+	getAccessor,
+	ArrayElementView,
+	ReadOnlyDataView,
+	sorter,
+	ExposedValueView,
+	isBinding,
+	isBindingObject,
+	isSelector,
+	StringTemplate,
+	enableFatArrowExpansion,
+} from "cx/data";
 import {
-	isTouchEvent,
+	isArray,
+	parseStyle,
+	SubscriberList,
+	Component,
+	isFunction,
+	isNonEmptyArray,
+	GlobalCacheIdentifier,
+	debug,
+	processDataFlag,
+	renderFlag,
+	destroyFlag,
+	validatedDebounce,
+	throttle,
 	isUndefined,
 	isString,
 	isDefined,
-	isArray,
-	debug,
-	isFunction,
+	isObject,
+	Console,
+	innerTextTrim,
+	TraversalStack,
+	reverseSlice,
+	appDataFlag,
+	onIdleCallback,
+	shallowEquals,
+	now,
+	Timing,
+	vdomRenderFlag,
+	appLoopFlag,
 	isNumber,
+	isPromise,
+	isTouchEvent,
 	isComponentFactory,
 	createComponentFactory,
 	deprecatedFlag,
@@ -83,15 +62,10 @@ import {
 	addEventListenerWithOptions,
 	scrollElementIntoView,
 	KeyCode,
-	parseStyle,
 	getParentFrameBoundingClientRect,
 	getSearchQueryHighlighter,
-	isNonEmptyArray,
 	getTopLevelBoundingClientRect,
-	isObject,
-	Console,
 	getScrollerBoundingClientRect,
-	SubscriberList,
 	isDataRecord,
 	isSelfOrDescendant,
 	getActiveElement,
@@ -102,7 +76,6 @@ import {
 	isFocusable,
 	closestParent,
 	tooltipsFlag,
-	shallowEquals,
 	stopPropagation,
 	routeAppend,
 	menuFlag,
@@ -111,7 +84,6 @@ import {
 	isFocused,
 	isFocusedDeep,
 	getFocusedElement,
-	isPromise,
 	preventDefault,
 	parseDateInvariant,
 	zeroTime,
@@ -132,22 +104,2817 @@ import {
 	debounce,
 	findScrollableParent,
 } from "cx/util";
+import { VDOM as VDOM$1 } from "cx-react";
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { NumberCulture, DateTimeCulture } from "intl-io";
 import {
-	getAccessor,
-	Binding,
-	ExposedValueView,
-	isBinding,
-	isBindingObject,
-	ReadOnlyDataView,
-	isSelector,
-	Store,
-	StringTemplate,
-	isAccessorChain,
-	getSelector,
-	enableFatArrowExpansion,
-} from "cx/data";
+	FocusManager,
+	Instance as Instance$1,
+	StyledContainerBase as StyledContainerBase$1,
+	Url,
+	VDOM as VDOM$2,
+	Widget as Widget$1,
+	createFunctionalComponent,
+	flattenProps,
+	preventFocus,
+	getContentArray as getContentArray$1,
+	GroupAdapter,
+	Selection,
+	getContent as getContent$1,
+	Container as Container$1,
+	offFocusOut,
+	preventFocusOnTouch,
+	batchUpdates as batchUpdates$1,
+	oneFocusOut,
+	PureContainerBase as PureContainerBase$1,
+	ContainerBase as ContainerBase$1,
+	ZIndexManager,
+	startAppLoop,
+	ResizeManager,
+	Localization as Localization$1,
+	RenderingContext as RenderingContext$1,
+	ContentPlaceholder as ContentPlaceholder$1,
+	Text as Text$1,
+	History,
+	Cx as Cx$1,
+	registerKeyboardShortcut,
+	unfocusElement,
+	Culture as Culture$1,
+	bind,
+	Format,
+	enableCultureSensitiveFormatting,
+	ContentResolver as ContentResolver$1,
+	DataProxy as DataProxy$1,
+	KeySelection,
+	PureContainer as PureContainer$1,
+	ArrayAdapter as ArrayAdapter$1,
+	InstanceCache as InstanceCache$1,
+	StaticText as StaticText$1,
+} from "cx/ui";
+export { ArrayAdapter, DataAdapter, GroupAdapter, TreeAdapter } from "cx/ui";
 import { jsx as jsx$1, jsxs as jsxs$1 } from "cx/jsx-runtime";
 
+var cssHelperCache = {};
+class CSSHelper {
+	static get(code) {
+		var helper = cssHelperCache[code];
+		if (!helper) throw new Error(`Unknown CSS helper '${code}'.`);
+		return helper;
+	}
+	static register(code, helper) {
+		cssHelperCache[code] = helper;
+	}
+	static alias(code, helper) {
+		cssHelperCache[code] = helper;
+	}
+}
+
+function push(list, item) {
+	if (!item) return list || [];
+	if (!list) list = [];
+	list.push(item);
+	return list;
+}
+function pushMore(list, itemArray) {
+	if (!itemArray || itemArray.length == 0) return list || [];
+	if (!list) list = [];
+	list.push.apply(list, itemArray);
+	return list;
+}
+function pushMap(list, itemArray, mapF) {
+	return itemArray ? pushMore(list, itemArray.map(mapF)) : list;
+}
+function join(list) {
+	return list ? list.join(" ") : undefined;
+}
+class CSS {
+	static classPrefix;
+	static resolve(...args) {
+		let list = undefined,
+			type,
+			arg,
+			i,
+			key;
+		for (i = 0; i < args.length; i++) {
+			arg = args[i];
+			if (arg) {
+				type = typeof arg;
+				if (type == "string") list = push(list, arg);
+				else if (type == "object") {
+					if (isArray(arg)) list = pushMore(list, this.resolve(...arg));
+					else for (key in arg) if (arg[key]) list = push(list, key);
+				}
+			}
+		}
+		return list || [];
+	}
+	static block(baseClass, styleModifiers, stateModifiers) {
+		let list;
+		if (baseClass) list = push(list, this.classPrefix + "b-" + baseClass);
+		list = pushMap(list, this.resolve(styleModifiers), (m) => this.classPrefix + "m-" + m);
+		list = pushMap(list, this.resolve(stateModifiers), (m) => this.classPrefix + "s-" + m);
+		return join(list);
+	}
+	static element(baseClass, elementClass, stateModifiers) {
+		let list;
+		if (baseClass && elementClass) list = push(list, this.classPrefix + "e-" + baseClass + "-" + elementClass);
+		list = pushMap(list, this.resolve(stateModifiers), (m) => this.classPrefix + "s-" + m);
+		return join(list);
+	}
+	static state(stateModifiers) {
+		return join(pushMap(undefined, this.resolve(stateModifiers), (m) => this.classPrefix + "s-" + m));
+	}
+	static mod(mods) {
+		return join(pushMap(undefined, this.resolve(mods), (m) => this.classPrefix + "m-" + m));
+	}
+	static expand(...args) {
+		return join(this.resolve(...args));
+	}
+	static parseStyle(str) {
+		return parseStyle(str);
+	}
+}
+CSS.classPrefix = "cx";
+CSSHelper.alias("cx", CSS);
+
+let isBatching = 0;
+let updateSequence = 0;
+let promiseSubscribers = new SubscriberList();
+function batchUpdates(callback) {
+	if (VDOM$1.DOM.unstable_batchedUpdates)
+		VDOM$1.DOM.unstable_batchedUpdates(() => {
+			isBatching++;
+			try {
+				callback();
+			} finally {
+				isBatching--;
+			}
+		});
+	else callback();
+}
+function isBatchingUpdates() {
+	return isBatching > 0;
+}
+// Returns a sequence number identifying the update; pass it to notifyBatchedUpdateCompleted once the
+// update is rendered.
+function notifyBatchedUpdateStarting() {
+	let seq = ++updateSequence;
+	promiseSubscribers.execute((x) => {
+		x.pending++;
+	});
+	return seq;
+}
+function notifyBatchedUpdateCompleted(seq) {
+	promiseSubscribers.execute((x) => {
+		let cb = x;
+		// ignore updates that started before this subscriber attached -- counting them would let the notify
+		// callback fire before the updates the subscriber is actually waiting on are rendered
+		if (seq <= cb.watermark) return;
+		cb.finished++;
+		if (cb.finished >= cb.pending) cb.complete(true);
+	});
+}
+
+const computablePrefix = "computable-";
+const triggerPrefix = "trigger-";
+class Controller extends Component {
+	initialized;
+	computables;
+	constructor(config) {
+		super(config);
+	}
+	init(context) {
+		if (!this.initialized) {
+			this.initialized = true;
+			if (this.onInit && context) this.onInit(context);
+		}
+	}
+	explore(context) {
+		let { store } = this.instance;
+		this.store = store; //in rare cases instance may change its store
+		if (!this.initialized) {
+			this.init(context);
+			//forgive if the developer forgets to call super.init()
+			this.initialized = true;
+		}
+		if (this.computables) {
+			for (let key in this.computables) {
+				let x = this.computables[key];
+				let v = x.selector(store.getData());
+				if (x.type == "computable") store.set(x.name, v);
+			}
+		}
+		if (this.onExplore) {
+			this.onExplore(context);
+		}
+	}
+	prepare(context) {
+		if (this.onPrepare) {
+			this.onPrepare(context);
+		}
+	}
+	cleanup(context) {
+		if (this.onCleanup) {
+			this.onCleanup(context);
+		}
+	}
+	addComputable(name, args, callback) {
+		if (!isArray(args)) throw new Error("Second argument to the addComputable method should be an array.");
+		let selector = computable(...args, callback).memoize();
+		if (!this.computables) this.computables = {};
+		let nameStr = String(name);
+		this.computables[computablePrefix + nameStr] = {
+			name: nameStr,
+			selector,
+			type: "computable",
+		};
+	}
+	addTrigger(name, args, callback, autoRun) {
+		if (!isArray(args)) throw new Error("Second argument to the addTrigger method should be an array.");
+		let selector = computable(...args, callback).memoize(!autoRun && this.store.getData());
+		if (!this.computables) this.computables = {};
+		this.computables[triggerPrefix + name] = {
+			name,
+			selector,
+			type: "trigger",
+		};
+	}
+	removeTrigger(name) {
+		if (this.computables) delete this.computables[triggerPrefix + name];
+	}
+	removeComputable(name) {
+		if (this.computables) delete this.computables[computablePrefix + name];
+	}
+	invokeParentMethod(methodName, ...args) {
+		let parent = this.instance.parent;
+		if (!parent) throw new Error("Cannot invoke a parent controller method as the instance does not have a parent.");
+		return parent.invokeControllerMethod(methodName, ...args);
+	}
+	invokeMethod(methodName, ...args) {
+		return this.instance.invokeControllerMethod(methodName, ...args);
+	}
+	getParentControllerByType(type) {
+		return this.instance.getControllerByType(type);
+	}
+}
+Controller.namespace = "ui.controller.";
+Controller.factory = function (alias, config, more) {
+	if (isFunction(alias)) {
+		let cfg = {
+			...config,
+			...more,
+		};
+		if (cfg.instance) {
+			//in rare cases instance.store may change, so we cannot rely on the store passed through configuration
+			cfg.store = new StoreProxy(() => cfg.instance.store);
+			Object.assign(cfg, cfg.store.getMethods());
+		}
+		let result = alias(cfg);
+		if (result instanceof Controller) return result;
+		return Controller.create({
+			...config,
+			...more,
+			...result,
+		});
+	}
+	return Controller.create({
+		...config,
+		...more,
+	});
+};
+
+let instanceId = 1000;
+/**
+ * Base Instance class
+ */
+class Instance {
+	// Selectors
+	dataSelector;
+	// Lifecycle flags
+	initialized;
+	destroySubscriptions;
+	helpers;
+	components;
+	constructor(widget, key, parent, parentStore) {
+		this.widget = widget;
+		this.key = key;
+		this.id = String(++instanceId);
+		this.cached = {};
+		this.parent = parent;
+		this.parentStore = parentStore ?? parent?.store;
+		if (this.parentStore == null) throw new Error("Cannot create instance without a parent store.");
+	}
+	setParentStore(parentStore) {
+		this.parentStore = parentStore;
+		this.widget.applyParentStore(this);
+	}
+	init(context) {
+		// widget is initialized when the first instance is initialized
+		if (!this.widget.initialized) {
+			this.widget.init();
+			this.widget.initialized = true;
+		}
+		if (!this.dataSelector) {
+			this.widget.selector.init(this.parentStore);
+			this.dataSelector = this.widget.selector.createStoreSelector();
+		}
+		// init instance might change the store, so this must go before the controller initialization
+		this.widget.initInstance(context, this);
+		// initInstance can set the store, otherwise use parent store
+		if (!this.store) this.store = this.parentStore;
+		if (this.widget.onInit) this.widget.onInit(context, this);
+		this.widget.initState(context, this);
+		if (this.widget.controller)
+			this.controller = Controller.create(this.widget.controller, {
+				widget: this.widget,
+				instance: this,
+				store: this.store,
+			});
+		if (
+			this.widget.exploreCleanup ||
+			this.widget.outerLayout ||
+			this.widget.isContent ||
+			this.widget.controller ||
+			this.widget.prepareCleanup
+		)
+			this.needsExploreCleanup = true;
+		if (this.widget.prepare || this.widget.controller) this.needsPrepare = true;
+		if (this.widget.cleanup || this.widget.controller) this.needsCleanup = true;
+		this.initialized = true;
+	}
+	checkVisible(context) {
+		if (!this.initialized) this.init(context);
+		const wasVisible = this.visible;
+		this.rawData = this.dataSelector(this.store);
+		this.visible = this.widget.checkVisible(context, this, this.rawData);
+		if (this.visible && !this.detached) this.parent.instanceCache.addChild(this);
+		this.explored = false;
+		this.prepared = false;
+		if (!this.visible && wasVisible) this.destroy();
+		return this.visible;
+	}
+	scheduleExploreIfVisible(context) {
+		if (this.checkVisible(context)) {
+			context.exploreStack.push(this);
+			if (this.needsExploreCleanup) context.exploreStack.push(this);
+			return true;
+		}
+		return false;
+	}
+	cache(key, value) {
+		const oldValue = this.cached[key];
+		if (oldValue === value) return false;
+		if (!this.cacheList) this.cacheList = {};
+		this.cacheList[key] = value;
+		return true;
+	}
+	markShouldUpdate(context) {
+		let ins = this;
+		let renderList = this.renderList;
+		renderList.markReverseIndex();
+		//notify all parents that child state changed to bust up caching
+		while (ins && !ins.shouldUpdate && ins.explored) {
+			if (ins.renderList !== renderList) {
+				renderList.reverse();
+				renderList = ins.renderList;
+				renderList.markReverseIndex();
+			}
+			ins.shouldUpdate = true;
+			renderList.data.push(ins);
+			ins = ins.widget.isContent
+				? ins.contentPlaceholder
+				: ins.parent?.outerLayout === ins
+					? ins.parent?.parent
+					: ins.parent;
+		}
+		renderList.reverse();
+	}
+	explore(context) {
+		if (!this.visible) throw new Error("Explore invisible!");
+		if (this.explored) {
+			if (this.widget.prepareCleanup) context.prepareList.push(this);
+			if (this.widget.exploreCleanup) this.widget.exploreCleanup(context, this);
+			if (this.parent?.outerLayout === this) context.popNamedValue("content", "body");
+			if (this.widget.controller) context.pop("controller");
+			return;
+		}
+		this.explored = true;
+		if (this.needsPrepare) context.prepareList.push(this);
+		else this.prepared = true;
+		if (this.needsCleanup) context.cleanupList.push(this);
+		if (this.instanceCache) this.instanceCache.mark();
+		//controller may reconfigure the widget and need to go before shouldUpdate calculation
+		this.parentOptions = context.parentOptions;
+		if (!this.controller) {
+			if (context.controller) this.controller = context.controller;
+			else if (this.parent?.controller) this.controller = this.parent?.controller;
+		}
+		this.destroyTracked = false;
+		if (this.controller) {
+			if (this.widget.controller) {
+				if (!this.controller.initialized) {
+					this.controller.init(context);
+					this.controller.initialized = true;
+				}
+				context.push("controller", this.controller);
+				this.controller.explore(context);
+				if (this.controller.onDestroy && this.controller.widget == this.widget) this.trackDestroy();
+			}
+		}
+		if (this.widget.onDestroy || isNonEmptyArray(this.destroySubscriptions)) this.trackDestroy();
+		this.renderList = this.assignedRenderList || this.parent?.renderList || context.getRootRenderList();
+		let shouldUpdate =
+			this.rawData !== this.cached.rawData ||
+			this.state !== this.cached.state ||
+			this.widget.version !== this.cached.widgetVersion ||
+			this.cached.globalCacheIdentifier !== GlobalCacheIdentifier.get();
+		if (shouldUpdate) {
+			this.data = {
+				...this.rawData,
+			};
+			this.widget.prepareData(context, this);
+			debug(processDataFlag, this.widget);
+		}
+		//onExplore might set the outer layout
+		if (this.widget.onExplore) this.widget.onExplore(context, this);
+		if (this.parent?.outerLayout === this) {
+			this.renderList = this.renderList.insertRight();
+			context.pushNamedValue("content", "body", this.parent);
+		}
+		if (this.widget.outerLayout) {
+			this.outerLayout = this.getChild(context, this.widget.outerLayout, null, this.store);
+			this.outerLayout.scheduleExploreIfVisible(context);
+			this.renderList = this.renderList.insertLeft();
+		}
+		if (this.widget.isContent) {
+			this.contentPlaceholder = context.contentPlaceholder && context.contentPlaceholder[this.widget.putInto];
+			if (this.contentPlaceholder) context.contentPlaceholder[this.widget.putInto](this);
+			else {
+				this.renderList = this.renderList.insertLeft();
+				context.pushNamedValue("content", this.widget.putInto, this);
+				if (!context.contentList) context.contentList = {};
+				let list = context.contentList[this.widget.putInto];
+				if (!list) list = context.contentList[this.widget.putInto] = [];
+				list.push(this);
+			}
+		}
+		this.shouldUpdate = false;
+		if (shouldUpdate || this.childStateDirty || !this.widget.memoize) this.markShouldUpdate(context);
+		context.exploreStack.hop();
+		if (this.widget.helpers) {
+			this.helpers = {};
+			for (let cmp in this.widget.helpers) {
+				let helper = this.widget.helpers[cmp];
+				if (helper) {
+					let ins = this.getChild(context, helper);
+					if (ins.scheduleExploreIfVisible(context)) this.helpers[cmp] = ins;
+				}
+			}
+		}
+		//TODO: check do we need to pass data here?
+		this.widget.explore(context, this, this.data);
+	}
+	prepare(context) {
+		if (!this.visible) throw new Error("Prepare invisible!");
+		if (this.prepared) {
+			if (this.widget.prepareCleanup) this.widget.prepareCleanup(context, this);
+			return;
+		}
+		this.prepared = true;
+		if (this.widget.prepare) this.widget.prepare(context, this);
+		if (this.widget.controller && this.controller?.prepare) this.controller.prepare(context);
+	}
+	render(context) {
+		if (!this.visible) throw new Error("Render invisible!");
+		if (this.shouldUpdate) {
+			debug(renderFlag, this.widget, this.key);
+			const vdom = renderResultFix(this.widget.render(context, this, this.key));
+			if (this.widget.isContent || this.outerLayout) this.contentVDOM = vdom;
+			else this.vdom = vdom;
+		}
+		if (this.cacheList) {
+			for (const key in this.cacheList) {
+				this.cached[key] = this.cacheList[key];
+			}
+		}
+		this.cacheList = null;
+		this.cached.rawData = this.rawData;
+		this.cached.data = this.data;
+		this.cached.state = this.state;
+		this.cached.widgetVersion = this.widget.version;
+		this.cached.globalCacheIdentifier = GlobalCacheIdentifier.get();
+		this.childStateDirty = false;
+		if (this.instanceCache) this.instanceCache.sweep();
+		if (this.parent?.outerLayout === this) {
+			//if outer layouts are chained we need to find the originating element (last element with OL set)
+			let parent = this.parent;
+			while (parent.parent?.outerLayout == parent) parent = parent.parent;
+			parent.vdom = this.vdom;
+		}
+		return this.vdom;
+	}
+	cleanup(context) {
+		if (this.widget.controller && this.controller?.cleanup) this.controller.cleanup(context);
+		if (this.widget.cleanup) this.widget.cleanup(context, this);
+	}
+	trackDestroy() {
+		if (!this.destroyTracked) {
+			this.destroyTracked = true;
+			if (this.parent && !this.detached) this.parent.trackDestroyableChild(this);
+		}
+	}
+	trackDestroyableChild(child) {
+		this.instanceCache.trackDestroy(child);
+		this.trackDestroy();
+	}
+	subscribeOnDestroy(callback) {
+		if (!this.destroySubscriptions) this.destroySubscriptions = [];
+		this.destroySubscriptions.push(callback);
+		this.trackDestroy();
+		return () => {
+			if (this.destroySubscriptions) {
+				this.destroySubscriptions = this.destroySubscriptions.filter((cb) => cb !== callback);
+			}
+		};
+	}
+	destroy() {
+		if (this.instanceCache) {
+			this.instanceCache.destroy();
+			this.instanceCache = null;
+		}
+		if (this.destroySubscriptions) {
+			this.destroySubscriptions.forEach((cb) => cb());
+			this.destroySubscriptions = null;
+		}
+		if (this.destroyTracked) {
+			debug(destroyFlag, this);
+			if (this.widget.onDestroy) this.widget.onDestroy(this);
+			if (
+				this.widget.controller &&
+				this.controller &&
+				this.controller.onDestroy &&
+				this.controller.widget == this.widget
+			)
+				this.controller.onDestroy();
+			this.destroyTracked = false;
+		}
+	}
+	setState(state) {
+		let skip = !!this.state;
+		if (this.state) {
+			for (const k in state) {
+				if (this.state[k] !== state[k]) {
+					skip = false;
+					break;
+				}
+			}
+		}
+		if (skip) return;
+		this.state = Object.assign({}, this.state, state);
+		let parent = this.parent;
+		//notify all parents that child state change to bust up caching
+		while (parent) {
+			parent.childStateDirty = true;
+			parent = parent.parent;
+		}
+		batchUpdates(() => {
+			this.store.notify();
+		});
+	}
+	set(prop, value, options = {}) {
+		//skip re-rendering (used for reading state from uncontrolled components)
+		if (options.internal && this.rawData) {
+			this.rawData[prop] = value;
+			this.data[prop] = value;
+		}
+		const setter = this.setters && this.setters[prop];
+		if (setter) {
+			if (options.immediate && isFunction(setter.reset)) setter.reset(value);
+			else setter(value);
+			return true;
+		}
+		const p = this.widget[prop];
+		if (p && typeof p == "object") {
+			if (p.debounce) {
+				this.definePropertySetter(
+					prop,
+					validatedDebounce(
+						(value) => this.doSet(prop, value),
+						() => this.dataSelector(this.store)[prop],
+						p.debounce,
+					),
+				);
+				this.set(prop, value, options);
+				return true;
+			}
+			if (p.throttle) {
+				this.definePropertySetter(
+					prop,
+					throttle((value) => this.doSet(prop, value), p.throttle),
+				);
+				this.set(prop, value, options);
+				return true;
+			}
+		}
+		return this.doSet(prop, value);
+	}
+	definePropertySetter(prop, setter) {
+		if (!this.setters) this.setters = {};
+		this.setters[prop] = setter;
+	}
+	doSet(prop, value) {
+		let changed = false;
+		batchUpdates(() => {
+			const p = this.widget[prop];
+			if (isObject(p)) {
+				const pObj = p;
+				if (pObj.set) {
+					if (isFunction(pObj.set)) {
+						pObj.set(value, this);
+						changed = true;
+					} else if (isString(pObj.set)) {
+						this.controller?.[pObj.set](value, this);
+						changed = true;
+					}
+				} else if (pObj.action) {
+					const action = pObj.action(value, this);
+					this.store.dispatch(action);
+					changed = true;
+				} else if (isString(pObj.bind) || isAccessorChain(pObj.bind)) {
+					changed = this.store.set(pObj.bind, value);
+				}
+			} else if (isAccessorChain(p)) {
+				changed = this.store.set(p.toString(), value);
+			}
+		});
+		return changed;
+	}
+	nestedDataSet(key, value, dataConfig, useParentStore) {
+		let config = dataConfig[key];
+		if (!config)
+			throw new Error(`Unknown nested data key ${key}. Known keys are ${Object.keys(dataConfig).join(", ")}.`);
+		if (isAccessorChain(config))
+			config = {
+				bind: config.toString(),
+			};
+		if (config.bind) {
+			let store = this.store;
+			//in case of Rescope or DataProxy, bindings point to the data in the parent store
+			if (useParentStore && store.store) store = store.store;
+			return isUndefined(value) ? store.deleteItem(config.bind) : store.setItem(config.bind, value);
+		}
+		if (!config.set)
+			throw new Error(
+				`Cannot change nested data value for ${key} as it's read-only. Either define it as a binding or define a set function.`,
+			);
+		if (isString(config.set)) this.getControllerMethod(config.set)(value, this);
+		else if (isFunction(config.set)) config.set(value, this);
+		else
+			throw new Error(
+				`Cannot change nested data value for ${key} the defined setter is neither a function nor a controller method.`,
+			);
+		return true;
+	}
+	replaceState(state) {
+		this.cached.state = this.state;
+		this.state = state;
+		this.store.notify();
+	}
+	getInstanceCache() {
+		if (!this.instanceCache)
+			this.instanceCache = new InstanceCache(this, this.widget.isPureContainer ? this.key : null);
+		return this.instanceCache;
+	}
+	clearChildrenCache() {
+		if (this.instanceCache) this.instanceCache.destroy();
+	}
+	getChild(context, widget, key, store) {
+		return this.getInstanceCache().getChild(widget, store ?? this.store, key);
+	}
+	getDetachedChild(widget, key, store) {
+		const child = widget.createInstance(key, this, store ?? this.store);
+		child.detached = true;
+		return child;
+	}
+	prepareRenderCleanupChild(widget, store, keyPrefix, options) {
+		return widget.prepareRenderCleanup(store ?? this.store, options, keyPrefix, this);
+	}
+	getJsxEventProps() {
+		const { widget } = this;
+		if (!isArray(widget.jsxAttributes)) return null;
+		const props = {};
+		widget.jsxAttributes.forEach((attr) => {
+			if (attr.indexOf("on") == 0 && attr.length > 2) {
+				props[attr] = (e) => this.invoke(attr, e, this);
+			}
+		});
+		return props;
+	}
+	getCallback(methodName) {
+		const scope = this.widget;
+		const callback = scope[methodName];
+		if (typeof callback === "string") return this.getControllerMethod(callback);
+		if (typeof callback !== "function")
+			throw new Error(`Cannot invoke callback method ${methodName} as assigned value is not a function.`);
+		return callback.bind(scope);
+	}
+	/**
+	 * Finds the first controller in the instance tree matching the predicate
+	 * @param predicate Function to test each controller
+	 * @returns The matching controller or undefined
+	 */
+	findController(predicate) {
+		let at = this;
+		while (at?.controller != null) {
+			if (predicate(at.controller)) {
+				return at.controller;
+			}
+			at = at.parent;
+		}
+		return undefined;
+	}
+	/**
+	 * Finds a controller of the specified type in the instance tree
+	 * @param type Controller class/constructor to find
+	 * @returns The matching controller cast to the specified type, or undefined
+	 */
+	findControllerByType(type) {
+		return this.findController((c) => c instanceof type);
+	}
+	/**
+	 * Gets the first controller in the instance tree matching the predicate
+	 * @param predicate Function to test each controller
+	 * @returns The matching controller
+	 * @throws Error if no matching controller is found
+	 */
+	getController(predicate) {
+		const controller = this.findController(predicate);
+		if (!controller) throw new Error("Cannot find a controller matching the given predicate in the instance tree.");
+		return controller;
+	}
+	/**
+	 * Gets a controller of the specified type in the instance tree
+	 * @param type Controller class/constructor to find
+	 * @returns The matching controller cast to the specified type
+	 * @throws Error if no controller of the specified type is found
+	 */
+	getControllerByType(type) {
+		const controller = this.findControllerByType(type);
+		if (!controller) throw new Error(`Cannot find a controller of type "${type.name}" in the instance tree.`);
+		return controller;
+	}
+	getControllerMethod(methodName) {
+		if (!this.controller)
+			throw new Error(`Cannot invoke controller method "${methodName}" as controller is not assigned to the widget.`);
+		const controller = this.findController((c) => !!c[methodName]);
+		if (!controller)
+			throw new Error(
+				`Cannot invoke controller method "${methodName}". The method cannot be found in any of the assigned controllers.`,
+			);
+		return controller[methodName].bind(controller);
+	}
+	invoke(methodName, ...args) {
+		return this.getCallback(methodName).apply(null, args);
+	}
+	invokeControllerMethod(methodName, ...args) {
+		return this.getControllerMethod(methodName).apply(null, args);
+	}
+}
+function renderResultFix(res) {
+	return res != null && isDefined(res.content)
+		? res
+		: {
+				content: res,
+			};
+}
+class InstanceCache {
+	constructor(parent, keyPrefix) {
+		this.children = {};
+		this.parent = parent;
+		this.marked = {};
+		this.monitored = null;
+		this.keyPrefix = keyPrefix != null ? keyPrefix + "-" : "";
+	}
+	getChild(widget, parentStore, key) {
+		const k = this.keyPrefix + (key != null ? key : widget.vdomKey || widget.widgetId);
+		let instance = this.children[k];
+		if (
+			!instance ||
+			instance.widget !== widget ||
+			(!instance.visible && (instance.widget.controller || instance.widget.onInit))
+		) {
+			instance = widget.createInstance(k, this.parent, parentStore);
+			this.children[k] = instance;
+		} else if (instance.parentStore !== parentStore) {
+			instance.setParentStore(parentStore);
+		}
+		return instance;
+	}
+	addChild(instance) {
+		this.marked[instance.key] = instance;
+	}
+	mark() {
+		this.marked = {};
+	}
+	trackDestroy(instance) {
+		if (!this.monitored) this.monitored = {};
+		this.monitored[instance.key] = instance;
+	}
+	destroy() {
+		this.children = {};
+		this.marked = {};
+		if (!this.monitored) return;
+		for (const key in this.monitored) {
+			this.monitored[key].destroy();
+		}
+		this.monitored = null;
+	}
+	sweep() {
+		this.children = this.marked;
+		if (!this.monitored) return;
+		let activeCount = 0;
+		for (const key in this.monitored) {
+			const monitoredChild = this.monitored[key];
+			const child = this.children[key];
+			if (child !== monitoredChild || !monitoredChild.visible) {
+				monitoredChild.destroy();
+				delete this.monitored[key];
+				if (child === monitoredChild) delete this.children[key];
+			} else activeCount++;
+		}
+		if (activeCount === 0) this.monitored = null;
+	}
+}
+
+const VDOM = VDOM$1;
+let widgetId = 100;
+class Widget extends Component {
+	// runtime values
+	widgetId;
+	initialized;
+	components;
+	helpers;
+	selector;
+	nameMap;
+	version;
+	static optimizePrepare;
+	constructor(config) {
+		super(config);
+		this.widgetId = widgetId++;
+		if (isArray(this.jsxSpread)) {
+			if (!this.jsxAttributes) this.jsxAttributes = [];
+			this.jsxSpread.forEach((spread) => {
+				for (const key in spread) {
+					this[key] = spread[key];
+					this.jsxAttributes.push(key);
+				}
+			});
+		}
+	}
+	init() {
+		if (this.styles) this.style = this.styles;
+		if (this.styled) this.style = parseStyle(this.style);
+		if (typeof this.if !== "undefined") this.visible = this.if;
+		this.declareData();
+		if (this.outerLayout) {
+			if (isArray(this.outerLayout)) throw new Error("Only single element outer layout is supported.");
+			//TODO: better handle the case when outer layout is an array. How to get around circular dependency to PureContainer
+			this.outerLayout = Widget.create(this.outerLayout, {});
+		}
+		if (this.contentFor) this.putInto = this.contentFor;
+		if (this.putInto) this.isContent = true;
+		if (isString(this.CSS)) this.CSS = CSSHelper.get(this.CSS);
+		this.initHelpers();
+		this.initComponents();
+		this.initialized = true;
+	}
+	initComponents(...args) {
+		if (args.length > 0) {
+			this.components = Object.assign({}, ...args);
+			for (const k in this.components) {
+				if (!this.components[k]) delete this.components[k];
+			}
+		}
+	}
+	initHelpers(...args) {
+		if (args.length > 0) {
+			this.helpers = Object.assign({}, ...args);
+		}
+	}
+	declareData(...args) {
+		const options = {};
+		if (this.styled) {
+			options.class =
+				options.className =
+				options.style =
+					{
+						structured: true,
+					};
+		}
+		const props = {
+			visible: undefined,
+			mod: {
+				structured: true,
+			},
+			...options,
+		};
+		Object.assign(props, ...args);
+		this.selector = new StructuredSelector({
+			props: props,
+			values: this,
+		});
+		this.nameMap = this.selector.nameMap;
+	}
+	prepareCSS(_context, { data }) {
+		data.classNames = this.CSS.expand(
+			this.CSS.block(this.baseClass, data.mod, data.stateMods),
+			data.class,
+			data.className,
+		);
+		data.style = parseStyle(data.style);
+	}
+	prepareData(context, instance) {
+		if (this.styled) this.prepareCSS(context, instance);
+	}
+	createInstance(key, parent, parentStore) {
+		return new Instance(this, key, parent, parentStore);
+	}
+	initInstance(_context, _instance) {}
+	initState(_context, _instance) {}
+	checkVisible(_context, _instance, data) {
+		return data.visible;
+	}
+	explore(context, instance, data) {
+		if (this.components) {
+			instance.components = {};
+			for (const cmp in this.components) {
+				const ins = instance.getChild(context, this.components[cmp], "cmp-" + cmp, instance.store);
+				if (ins.scheduleExploreIfVisible(context)) instance.components[cmp] = ins;
+			}
+		}
+	}
+	render(context, instance, key) {
+		Console.log(this);
+		throw new Error(
+			'Widget\'s render method should be overridden. This error usually happens if with incorrect imports, i.e. import { TextField } from "cx/data". Please check the console for details about the component configuration.',
+		);
+	}
+	update() {
+		this.version = (this.version || 0) + 1;
+	}
+	applyParentStore(instance) {
+		instance.store = instance.parentStore;
+		// check when this is actually needed, perhaps this is needed only for tables and repeated elements
+		// if (instance.cached) delete instance.cached.rawData; // force prepareData to execute again
+	}
+	static resetCounter() {
+		widgetId = 100;
+	}
+}
+Widget.prototype.visible = true;
+Widget.prototype.memoize = true; //cache rendered content and use it if possible
+Widget.prototype.CSS = CSS;
+Widget.prototype.styled = false;
+Widget.namespace = "ui.";
+Widget.optimizePrepare = true;
+Widget.factory = (type, _config, _more) => {
+	throw new Error(`Invalid widget type: ${type}.`);
+};
+function contentAppend(result, w, prependSpace) {
+	if (w == null || w === false) return false;
+	if (isArray(w)) w.forEach((c) => contentAppend(result, c));
+	else if (isDefined(w.content) && !w.atomic) return contentAppend(result, w.content, false);
+	else {
+		if (prependSpace) result.push(" ");
+		result.push(w);
+	}
+	return true;
+}
+function getContentArray(x) {
+	let result = [];
+	contentAppend(result, x, false);
+	return result;
+}
+function getContent(x) {
+	let result = getContentArray(x);
+	if (result.length == 0) return null;
+	if (result.length == 1) return result[0];
+	return result;
+}
+
+class Text extends Widget {
+	constructor(config) {
+		super(config);
+	}
+	init() {
+		if (!this.value && (this.tpl || this.expr || this.bind))
+			this.value = {
+				tpl: this.tpl,
+				expr: this.expr,
+				bind: this.bind,
+			};
+		super.init();
+	}
+	declareData(...args) {
+		super.declareData(
+			{
+				value: undefined,
+			},
+			...args,
+		);
+	}
+	render(context, { data }, key) {
+		return data.value != null ? data.value : "";
+	}
+}
+Widget.alias("text", Text);
+
+class StaticText extends Widget {
+	render() {
+		return this.text;
+	}
+}
+Widget.alias("static-text", StaticText);
+
+function exploreChildren(context, instance, children, previousResult, key, store) {
+	let newChildren = previousResult || [];
+	let oldChildren = previousResult || newChildren;
+	let identical = previousResult ? 0 : -1;
+	for (let c = 0; c < children.length; c++) {
+		let cell = instance.getChild(context, children[c], key, store);
+		if (cell.checkVisible(context)) {
+			if (identical >= 0) {
+				if (cell == oldChildren[identical]) identical++;
+				else {
+					newChildren = newChildren.slice(0, identical);
+					identical = -1;
+					newChildren.push(cell);
+				}
+			} else newChildren.push(cell);
+			context.exploreStack.push(cell);
+			if (cell.needsExploreCleanup) context.exploreStack.push(cell);
+		}
+	}
+	if (identical >= 0 && identical != newChildren.length) newChildren = newChildren.slice(0, identical);
+	return newChildren;
+}
+
+// Base class for extending with custom Config types
+class ContainerBase extends Widget {
+	init(context) {
+		if (typeof this.ws !== "undefined") this.preserveWhitespace = this.ws;
+		if (this.preserveWhitespace) this.trimWhitespace = false;
+		let items = this.items || this.children || [];
+		delete this.children;
+		this.items = [];
+		if (this.layout) {
+			let layout = Container.create(this.layout, {
+				items,
+			});
+			layout.init(context);
+			this.layout = null;
+			if ("noLayout" in layout && layout.noLayout) {
+				this.useParentLayout = true;
+				this.add(items);
+			} else {
+				this.add(layout);
+				this.layout = layout;
+			}
+		} else {
+			this.add(items);
+		}
+		super.init();
+	}
+	exploreItems(context, instance, items) {
+		instance.children = exploreChildren(context, instance, items, instance.cached.children, null, instance.store);
+		if (instance.cache("children", instance.children)) instance.markShouldUpdate(context);
+	}
+	explore(context, instance) {
+		super.explore(context, instance);
+		this.exploreItems(context, instance, this.items);
+	}
+	render(context, instance, key) {
+		return this.renderChildren(context, instance, key);
+	}
+	renderChildren(_context, instance, key) {
+		let preserveComplexContent = this.useParentLayout;
+		function append(result, r) {
+			if (r == null) return;
+			//react element
+			if (!r.hasOwnProperty("content")) {
+				contentAppend(result, r);
+				return;
+			}
+			if (r.useParentLayout) return r.content.forEach((x) => append(result, x));
+			if (r.atomic || preserveComplexContent) {
+				result.push(r);
+			} else {
+				let first = true;
+				for (let k in r) if (contentAppend(result, r[k], !first)) first = false;
+			}
+		}
+		let result = [];
+		for (let i = 0; i < instance.children.length; i++) {
+			append(result, instance.children[i].vdom);
+		}
+		if (this.useParentLayout)
+			return {
+				useParentLayout: true,
+				content: result,
+			};
+		return result;
+	}
+	clear() {
+		if (this.layout) this.layout.clear();
+		else this.items = [];
+	}
+	add(...args) {
+		if (this.layout) return this.layout.add(...args);
+		for (let a of args) {
+			if (!a) continue;
+			if (isArray(a)) {
+				for (let c of a) this.add(c);
+			} else if (isString(a)) {
+				if (this.trimWhitespace) a = innerTextTrim(a);
+				if (a) this.addText(a);
+			} else if (a.isComponent) this.items.push(this.wrapItem(a));
+			else {
+				this.add(Widget.create(a, this.itemDefaults, {}));
+			}
+		}
+	}
+	wrapItem(item) {
+		return item;
+	}
+	addText(text) {
+		if (this.plainText || text.indexOf("{") == -1 || text.indexOf("}") == -1)
+			this.add(
+				Widget.create(
+					StaticText,
+					{
+						text: text,
+					},
+					{},
+				),
+			);
+		else
+			this.add(
+				Widget.create(
+					Text,
+					{
+						text: {
+							tpl: text,
+						},
+					},
+					{},
+				),
+			);
+	}
+	find(filter, options) {
+		if (!options) options = {};
+		if (!filter || !this.items) return [];
+		let alias = filter;
+		if (isString(filter)) filter = (w) => w.componentAlias == alias;
+		if (filter.isComponentType) filter = (w) => w instanceof alias;
+		let results = [];
+		for (let i = 0; i < this.items.length; i++) {
+			let w = this.items[i];
+			if (w && !w.initialized) w.init();
+			if (filter(w)) {
+				results.push(w);
+				if (options.first) break;
+			}
+			if (w && w.find) results.push(...w.find(filter, options));
+		}
+		return results;
+	}
+	findFirst(filter, options) {
+		return this.find(filter, {
+			...options,
+			first: true,
+		})[0];
+	}
+}
+ContainerBase.prototype.trimWhitespace = true;
+ContainerBase.prototype.plainText = true;
+ContainerBase.prototype.styled = false;
+// Closed type for direct usage - preserves ControllerProp ThisType
+class Container extends ContainerBase {}
+// Base class for styled containers with custom Config types
+class StyledContainerBase extends ContainerBase {}
+StyledContainerBase.prototype.styled = true;
+
+// Base class for extending with custom Config types
+class PureContainerBase extends ContainerBase {}
+PureContainerBase.prototype.isPureContainer = true;
+// Closed type for direct usage - preserves ControllerProp ThisType
+class PureContainer extends PureContainerBase {}
+PureContainer.alias("pure-container", PureContainer);
+
+class IsolatedScope extends PureContainerBase {
+	declareData(...args) {
+		return super.declareData(...args, {
+			data: {
+				structured: true,
+			},
+		});
+	}
+	init() {
+		if (typeof this.bind === "string")
+			this.data = {
+				bind: this.bind,
+			};
+		else if (isArray(this.bind)) {
+			let data = {};
+			this.bind.forEach((x, i) => {
+				data[String(i)] = {
+					bind: x,
+				};
+			});
+			this.data = data;
+		}
+		super.init();
+	}
+	explore(context, instance) {
+		if (instance.shouldUpdate) {
+			super.explore(context, instance);
+		} else if (instance.children) {
+			// mark children to prevent sweeping them away
+			for (let i = 0; i < instance.children.length; i++) instance.instanceCache.addChild(instance.children[i]);
+		}
+	}
+}
+
+class RenderingContext {
+	options;
+	exploreStack;
+	prepareList;
+	cleanupList;
+	stacks;
+	renderList;
+	constructor(options) {
+		this.options = options || {};
+		this.exploreStack = new TraversalStack();
+		this.prepareList = [];
+		this.cleanupList = [];
+		this.stacks = {};
+		this.renderList = new LinkedListsNode();
+	}
+	getStack(key) {
+		let stack = this.stacks[key];
+		if (!stack) stack = this.stacks[key] = [];
+		return stack;
+	}
+	push(key, value) {
+		let stack = this.getStack(key);
+		stack.push(this[key]);
+		return (this[key] = value);
+	}
+	pop(key) {
+		let stack = this.getStack(key);
+		return (this[key] = stack.pop());
+	}
+	pushNamedValue(key, name, value) {
+		let stack = this.getStack(`${key}:${name}`);
+		if (!this[key]) this[key] = {};
+		stack.push(this[key][name]);
+		return (this[key][name] = value);
+	}
+	popNamedValue(key, name) {
+		let stack = this.getStack(`${key}:${name}`);
+		return (this[key][name] = stack.pop());
+	}
+	get(key) {
+		return this[key];
+	}
+	getRootRenderList() {
+		let rl = this.renderList;
+		while (rl.left) rl = rl.left;
+		return rl;
+	}
+}
+class LinkedListsNode {
+	left;
+	right;
+	data;
+	reverseIndex;
+	constructor(left, right) {
+		this.left = left;
+		this.right = right;
+		this.data = [];
+	}
+	insertLeft() {
+		let node = new LinkedListsNode(this.left, this);
+		if (this.left) this.left.right = node;
+		this.left = node;
+		return node;
+	}
+	insertRight() {
+		let node = new LinkedListsNode(this, this.right);
+		if (this.right) this.right.left = node;
+		this.right = node;
+		return node;
+	}
+	markReverseIndex() {
+		this.reverseIndex = this.data.length;
+	}
+	reverse() {
+		reverseSlice(this.data, this.reverseIndex);
+	}
+}
+
+let contents = {};
+let localizations = {};
+let overrides = {};
+let defaults = {};
+let trackDefaults = false;
+class Localization {
+	static register(key) {
+		return (type) => {
+			this.registerPrototype(key, type);
+			return type;
+		};
+	}
+	static registerPrototype(key, type) {
+		contents[key] = type.prototype;
+		if (overrides[key]) this.override(key, overrides[key]);
+	}
+	static trackDefaults() {
+		trackDefaults = true;
+	}
+	static restoreDefaults() {
+		for (let type in defaults) {
+			let proto = contents[type];
+			if (!proto) continue;
+			let d = defaults[type];
+			for (let key in d) proto[key] = d[key];
+		}
+		defaults = {};
+	}
+	static override(key, values) {
+		overrides[key] = values;
+		let p = contents[key];
+		if (p) {
+			if (trackDefaults && !defaults[key]) {
+				let d = (defaults[key] = {});
+				for (let key in values) d[key] = p[key];
+			}
+			Object.assign(p, values);
+		}
+	}
+	static localize(culture, key, values) {
+		let l = localizations[culture];
+		if (!l) l = localizations[culture] = {};
+		l[key] = {
+			...l[key],
+			...values,
+		};
+	}
+	static setCulture(culture) {
+		var l = localizations[culture];
+		if (l) {
+			for (var key in l) {
+				var content = contents[key];
+				if (content) Object.assign(content, l[key]);
+			}
+		}
+	}
+}
+
+// @ts-expect-error
+let stack = [
+	{
+		culture: "en",
+		numberCulture: null,
+		dateTimeCulture: null,
+		cache: {},
+		defaultCurrency: "USD",
+		dateEncoding: (date) => date.toISOString(),
+		timezone: null,
+	},
+];
+function getDefaultCulture() {
+	return stack[0];
+}
+function getCurrentCulture() {
+	return stack[stack.length - 1];
+}
+function pushCulture(cultureInfo) {
+	stack.push(cultureInfo);
+}
+function popCulture(cultureSpecs) {
+	if (stack.length == 1) throw new Error("Cannot pop the last culture object.");
+	if (cultureSpecs && stack[stack.length - 1] !== cultureSpecs) {
+		Console.warn("Popped culture object does not match the current one.");
+	}
+	return stack.pop();
+}
+class Culture {
+	static setCulture(cultureCode) {
+		let cultureSpecs = getDefaultCulture();
+		cultureSpecs.culture = cultureCode;
+		cultureSpecs.cache = {};
+		Localization.setCulture(cultureCode);
+		this.invalidateCache();
+	}
+	static setNumberCulture(cultureCode) {
+		let cultureSpecs = getDefaultCulture();
+		cultureSpecs.numberCulture = cultureCode;
+		delete cultureSpecs.cache.numberCulture;
+		this.invalidateCache();
+	}
+	static setDateTimeCulture(cultureCode) {
+		let cultureSpecs = getDefaultCulture();
+		cultureSpecs.dateTimeCulture = cultureCode;
+		delete cultureSpecs.cache.dateTimeCulture;
+		this.invalidateCache();
+	}
+	static setDefaultCurrency(currencyCode) {
+		let cultureSpecs = getDefaultCulture();
+		cultureSpecs.defaultCurrency = currencyCode;
+		this.invalidateCache();
+	}
+	static setDefaultTimezone(timezone) {
+		let cultureSpecs = getDefaultCulture();
+		cultureSpecs.timezone = timezone;
+		this.invalidateCache();
+	}
+	static setDefaultDateEncoding(encoding) {
+		let cultureSpecs = getDefaultCulture();
+		cultureSpecs.dateEncoding = encoding;
+		this.invalidateCache();
+	}
+	static invalidateCache() {
+		GlobalCacheIdentifier.change();
+		invalidateExpressionCache();
+		invalidateStringTemplateCache();
+	}
+	static get defaultCurrency() {
+		return getCurrentCulture().defaultCurrency;
+	}
+	static get culture() {
+		return getCurrentCulture().culture;
+	}
+	static getNumberCulture() {
+		let { cache, numberCulture, culture } = getCurrentCulture();
+		if (!cache.numberCulture) cache.numberCulture = new NumberCulture(numberCulture ?? culture);
+		return cache.numberCulture;
+	}
+	static getDateTimeCulture() {
+		let { cache, dateTimeCulture, culture, timezone } = getCurrentCulture();
+		if (!cache.dateTimeCulture)
+			cache.dateTimeCulture = new DateTimeCulture(dateTimeCulture ?? culture, {
+				defaultTimezone: timezone,
+			});
+		return cache.dateTimeCulture;
+	}
+	static getDefaultDateEncoding() {
+		return getCurrentCulture().dateEncoding;
+	}
+	static getComparer(options) {
+		let { culture } = getCurrentCulture();
+		if (typeof Intl.Collator != "undefined") return new Intl.Collator(culture, options).compare;
+		return defaultCompare;
+	}
+}
+
+// On by default. Once a synchronous update burst grows deep, Cx starts issuing updates from microtasks
+// so React's global nested-update counter resets before continuing -- preventing "Maximum update depth
+// exceeded" on large renders that write to the store while they render (e.g. a several-hundred-page
+// report). For updates that settle in a single render -- virtually all of them -- this is equivalent to
+// rendering synchronously; it only diverges under a deep re-entrant render burst. If you suspect it
+// causes trouble, opt out at app startup with disableSyncUpdateCoalescing() -- and please report the
+// issue so it can be fixed.
+// Synchronous updates allowed within one burst before Cx switches to issuing updates from a microtask.
+// Kept under React's ~50 nested-update limit (which is global to the root, not per component); the
+// default trades a little initial-render time for a safety margin. Override via
+// enableSyncUpdateCoalescing(limit) if needed.
+const defaultSyncBurstLimit = 35;
+let syncBurstLimit = defaultSyncBurstLimit;
+// Microtask-issued updates allowed within one burst before Cx escalates to setTimeout. Deep enough that
+// only a store that never converges reaches it; timeouts let the event loop turn, so the page stays
+// responsive and batchUpdatesAndNotify fallback timers can fire instead of the tab hanging.
+let microtaskBurstLimit = 1000;
+// Module-global because React's nested-update limit is global to the root, not per component. The burst
+// counter resets only when all notifications settle (see completeNotification) -- tying the burst
+// window to unsettled work makes it immune to how React schedules the flushes. Legacy React chains
+// re-entrant updates synchronously within one task, but React 19 may run each round from its own
+// microtask, so no task/microtask boundary is a reliable reset point.
+let syncBurstRounds = 0; // updates issued in the current burst
+let outstandingNotifications = 0; // reported notifications not yet rendered, across all Cx instances
+class Cx extends VDOM.Component {
+	widget;
+	store;
+	parentInstance;
+	instance;
+	flags;
+	renderCount;
+	unsubscribe;
+	forceUpdateCallback;
+	deferCounter;
+	pendingUpdateTimer;
+	unsubscribeIdleRequest;
+	// store notifications reported to batchUpdatesAndNotify subscribers but not yet rendered and completed
+	owedNotifications = new Set();
+	// setState is not allowed before the component mounts; pre-mount notifications set flags.dirty instead
+	// and componentDidMount picks them up (see update())
+	mounted = false;
+	// true once this instance has contributed to syncBurstRounds for the current render round; cleared on
+	// render, so bursts are counted per round rather than per notification (see update())
+	burstRoundCounted = false;
+	constructor(props) {
+		super(props);
+		if (props.instance) {
+			this.widget = props.instance.widget;
+			this.store = props.instance.store;
+		} else {
+			this.widget = PureContainer.create({
+				items: props.widget || props.items,
+			});
+			if (props.parentInstance) {
+				this.parentInstance = props.parentInstance;
+				this.store = props.store || this.parentInstance.store;
+			} else {
+				this.parentInstance = new Instance(this.widget, "0", undefined, props.store);
+				this.store = props.store;
+			}
+			if (!this.store) throw new Error("Cx component requires a store.");
+		}
+		this.state = {
+			deferToken: 0,
+			data: props.subscribe ? this.store.getData() : null,
+		};
+		if (props.subscribe) {
+			this.unsubscribe = this.store.subscribe(this.update.bind(this));
+		}
+		this.flags = {};
+		this.renderCount = 0;
+		this.forceUpdateCallback = this.forceUpdate.bind(this);
+		// deferredUntilIdle content stays hidden until the idle callback scheduled on mount bumps the token
+		this.deferCounter = props.deferredUntilIdle ? 1 : 0;
+	}
+	UNSAFE_componentWillReceiveProps(props) {
+		let newStore = props.instance ? props.instance.store : props.store ? props.store : props.parentInstance.store;
+		if (newStore != this.store) {
+			this.store = newStore;
+			if (this.unsubscribe) this.unsubscribe();
+			if (props.subscribe) this.unsubscribe = this.store.subscribe(this.update.bind(this));
+		}
+		if (props.subscribe) {
+			let data = this.store.getData();
+			if (data !== this.state.data) {
+				this.waitForIdle();
+				this.setState({
+					data,
+				});
+			}
+		}
+	}
+	getInstance() {
+		if (this.props.instance) return this.props.instance;
+		if (this.instance && this.instance.widget === this.widget) {
+			if (this.instance.parentStore != this.store) this.instance.setParentStore(this.store);
+			return this.instance;
+		}
+		if (this.widget && this.parentInstance)
+			return (this.instance = this.parentInstance.getDetachedChild(this.widget, "0", this.store));
+		throw new Error("Could not resolve a widget instance in the Cx component.");
+	}
+	render() {
+		this.burstRoundCounted = false;
+		// an error was captured and is being dispatched to the onError callback (see componentDidCatch);
+		// render nothing until the callback repairs the state
+		if (this.state.error) return null;
+		if (this.props.deferredUntilIdle && this.state.deferToken < this.deferCounter) return null;
+		let cultureInfo = this.props.cultureInfo ?? getCurrentCulture();
+		return jsx(CxContext, {
+			instance: this.getInstance(),
+			flags: this.flags,
+			options: this.props.options,
+			buster: ++this.renderCount,
+			contentFactory: this.props.contentFactory,
+			forceUpdate: this.forceUpdateCallback,
+			cultureInfo: cultureInfo,
+		});
+	}
+	componentDidMount() {
+		this.mounted = true;
+		// schedule the deferredUntilIdle reveal here rather than in the constructor -- the idle callback
+		// could otherwise fire before the component mounts and issue a setState React does not allow yet
+		this.waitForIdle();
+		this.componentDidUpdate();
+		if (this.props.options && this.props.options.onPipeUpdate) this.props.options.onPipeUpdate(this.update.bind(this));
+	}
+	componentDidUpdate() {
+		if (this.flags.dirty) {
+			this.update();
+		}
+	}
+	update() {
+		let data = this.store.getData();
+		debug(appDataFlag, data);
+		if (this.flags.preparing || !this.mounted) this.flags.dirty = true;
+		// Synchronous path: while batching (incl. batchUpdatesAndNotify, which page-breaking relies on) or for
+		// `immediate` instances.
+		else if (this.props.immediate || isBatchingUpdates()) {
+			// Every notification is reported to batchUpdatesAndNotify subscribers up front and completed only
+			// once the setState that renders it commits, so notify callbacks never fire before the DOM reflects
+			// the change. Each notification always gets its own setState; only its timing escalates as the
+			// burst grows: synchronous at first, then from a microtask (lets React's commit finish so its
+			// global nested-update counter resets instead of tripping "Maximum update depth exceeded"), and
+			// finally from a timeout (lets the event loop turn, so a store that never converges degrades to a
+			// responsive page instead of a frozen tab).
+			let seq = notifyBatchedUpdateStarting();
+			this.owedNotifications.add(seq);
+			outstandingNotifications++;
+			// Count render rounds rather than notifications: only the first notification an instance
+			// receives per render round bumps the shared depth (the flag clears on render). This tracks
+			// React's nested-commit count -- the thing the escalation must stay under -- so a round that
+			// writes many values doesn't burn through the budget in one go.
+			if (!this.burstRoundCounted) {
+				this.burstRoundCounted = true;
+				++syncBurstRounds;
+				if (process.env.NODE_ENV !== "production" && syncBurstRounds === microtaskBurstLimit + 1)
+					console.error(
+						"Cx: store updates are not converging after " +
+							microtaskBurstLimit +
+							" render rounds -- possible update loop. Updates are now issued from timeouts to keep the page responsive. Look for code that writes a new value to the store on every render.",
+					);
+			}
+			if (syncBurstRounds <= syncBurstLimit) this.issueStateUpdate(seq);
+			else if (syncBurstRounds <= microtaskBurstLimit) queueMicrotask(() => this.issueStateUpdate(seq));
+			else setTimeout(() => this.issueStateUpdate(seq), 0);
+		} else {
+			// standard mode: coalesce sequential store commands into a single deferred update
+			this.scheduleStateUpdate();
+		}
+	}
+	// Render the latest store data and report the notification completed once the commit is done, so
+	// batchUpdatesAndNotify resolves only when the DOM reflects the store.
+	issueStateUpdate(seq) {
+		// skip notifications no longer owed -- unmount may have already released them
+		if (!this.owedNotifications.has(seq)) return;
+		this.setState(
+			{
+				data: this.store.getData(),
+			},
+			() => this.completeNotification(seq),
+		);
+	}
+	completeNotification(seq) {
+		// skip notifications no longer owed -- unmount may have already released them
+		if (!this.owedNotifications.delete(seq)) return;
+		outstandingNotifications--;
+		notifyBatchedUpdateCompleted(seq);
+		// everything settled -- the next burst starts fresh, and so does React's nested-update counter
+		// (the commit that settled the last notification ends without scheduling further synchronous work)
+		if (outstandingNotifications === 0) syncBurstRounds = 0;
+	}
+	scheduleStateUpdate() {
+		if (!this.pendingUpdateTimer) {
+			let seq = notifyBatchedUpdateStarting();
+			this.owedNotifications.add(seq);
+			outstandingNotifications++;
+			this.pendingUpdateTimer = setTimeout(() => {
+				delete this.pendingUpdateTimer;
+				// read fresh data at fire time so the coalesced update renders the latest store state
+				this.setState(
+					{
+						data: this.store.getData(),
+					},
+					() => this.completeNotification(seq),
+				);
+			}, 0);
+		}
+	}
+	waitForIdle() {
+		if (!this.props.deferredUntilIdle) return;
+		if (this.unsubscribeIdleRequest) this.unsubscribeIdleRequest();
+		let token = ++this.deferCounter;
+		this.unsubscribeIdleRequest = onIdleCallback(
+			() => {
+				this.setState({
+					deferToken: token,
+				});
+			},
+			{
+				timeout: this.props.idleTimeout || 30000,
+			},
+		);
+	}
+	componentWillUnmount() {
+		// Release notifications that will never render so a waiting batchUpdatesAndNotify can settle instead
+		// of waiting out its fallback timeout.
+		for (let seq of this.owedNotifications) this.completeNotification(seq);
+		if (this.pendingUpdateTimer) clearTimeout(this.pendingUpdateTimer);
+		if (this.unsubscribeIdleRequest) this.unsubscribeIdleRequest();
+		if (this.unsubscribe) this.unsubscribe();
+		if (this.props.options && this.props.options.onPipeUpdate) this.props.options.onPipeUpdate(null);
+	}
+	shouldComponentUpdate(props, state) {
+		if (props.deferredUntilIdle && state.deferToken != this.deferCounter) return false;
+		return (
+			state !== this.state ||
+			!props.params ||
+			!shallowEquals(props.params, this.props.params) ||
+			props.instance !== this.props.instance ||
+			props.widget !== this.props.widget ||
+			props.store !== this.props.store ||
+			props.parentInstance !== this.props.parentInstance ||
+			props.cultureInfo !== this.props.cultureInfo
+		);
+	}
+	// Render null for the failed subtree while the error is dispatched to componentDidCatch below --
+	// returning a state update here is what React expects of an error boundary (rendering the broken
+	// children again would just rethrow).
+	static getDerivedStateFromError() {
+		return {
+			error: true,
+		};
+	}
+	componentDidCatch(error, info) {
+		this.flags.preparing = false;
+		// without an onError callback this instance is not an error boundary -- rethrow so the error
+		// reaches the nearest ancestor boundary, matching the behavior before getDerivedStateFromError
+		// was introduced
+		if (!this.props.onError) throw error;
+		this.props.onError(error, this.getInstance(), info);
+		// the callback had a chance to repair the state (e.g. replace the failing content) -- resume rendering
+		this.setState({
+			error: false,
+		});
+	}
+}
+class CxContext extends VDOM.Component {
+	renderCount;
+	timings;
+	content;
+	renderingContext;
+	constructor(props) {
+		super(props);
+		this.renderCount = 0;
+		this.UNSAFE_componentWillReceiveProps(props);
+	}
+	UNSAFE_componentWillReceiveProps(props) {
+		this.timings = {
+			start: now(),
+		};
+		let { instance, options, contentFactory } = props;
+		let count = 0,
+			visible,
+			context,
+			forceContinue;
+		//should not be tracked by parents for destroy
+		if (!instance.detached)
+			throw new Error("The instance passed to a Cx component should be detached from its parent.");
+		if (this.props.instance !== instance && this.props.instance.destroyTracked) this.props.instance.destroy();
+		this.props.flags.preparing = true;
+		if (this.props.cultureInfo) pushCulture(this.props.cultureInfo);
+		try {
+			do {
+				count++;
+				forceContinue = false;
+				context = new RenderingContext(options);
+				context.forceUpdate = this.props.forceUpdate;
+				this.props.flags.dirty = false;
+				instance.assignedRenderList = context.getRootRenderList();
+				visible = instance.scheduleExploreIfVisible(context);
+				if (visible) {
+					while (!context.exploreStack.empty()) {
+						let inst = context.exploreStack.pop();
+						//console.log("EXPLORE", inst.widget.constructor.name, inst.widget.tag, inst.widget.widgetId);
+						inst.explore(context);
+					}
+				} else if (instance.destroyTracked) {
+					instance.destroy();
+				}
+				if (this.props.flags.dirty && count <= 3 && Widget.optimizePrepare && now() - this.timings.start < 8) {
+					forceContinue = true;
+					continue;
+				}
+				if (visible) {
+					this.timings.afterExplore = now();
+					for (let i = 0; i < context.prepareList.length; i++) context.prepareList[i].prepare(context);
+					this.timings.afterPrepare = now();
+				}
+			} while (
+				forceContinue ||
+				(this.props.flags.dirty && count <= 3 && Widget.optimizePrepare && now() - this.timings.start < 8)
+			);
+			if (visible) {
+				//walk in reverse order so children get rendered first
+				let renderList = context.getRootRenderList();
+				while (renderList) {
+					for (let i = renderList.data.length - 1; i >= 0; i--) {
+						renderList.data[i].render(context);
+					}
+					renderList = renderList.right;
+				}
+				this.content = getContent(instance.vdom);
+				if (contentFactory)
+					this.content = contentFactory({
+						children: this.content,
+					});
+				this.timings.afterRender = now();
+				for (let i = 0; i < context.cleanupList.length; i++) context.cleanupList[i].cleanup(context);
+			} else {
+				this.content = null;
+				this.timings.afterExplore = this.timings.afterPrepare = this.timings.afterRender = now();
+			}
+		} finally {
+			if (this.props.cultureInfo) popCulture(this.props.cultureInfo);
+		}
+		this.timings.beforeVDOMRender = now();
+		this.props.flags.preparing = false;
+		this.props.flags.rendering = true;
+		this.renderingContext = context;
+	}
+	render() {
+		return this.content;
+	}
+	componentDidMount() {
+		this.componentDidUpdate();
+	}
+	componentDidUpdate() {
+		this.props.flags.rendering = false;
+		this.timings.afterVDOMRender = now();
+		//let {instance} = this.props;
+		//instance.cleanup(this.renderingContext);
+		this.timings.afterCleanup = now();
+		this.renderCount++;
+		if (process.env.NODE_ENV !== "production") {
+			let { start, beforeVDOMRender, afterVDOMRender, afterPrepare, afterExplore, afterRender, afterCleanup } =
+				this.timings;
+			Timing.log(
+				vdomRenderFlag,
+				this.renderCount,
+				"cx",
+				(beforeVDOMRender - start + afterCleanup - afterVDOMRender).toFixed(2) + "ms",
+				"vdom",
+				(afterVDOMRender - beforeVDOMRender).toFixed(2) + "ms",
+			);
+			Timing.log(
+				appLoopFlag,
+				this.renderCount,
+				this.renderingContext.options.name || "main",
+				"total",
+				(afterCleanup - start).toFixed(1) + "ms",
+				"explore",
+				(afterExplore - start).toFixed(1) + "ms",
+				"prepare",
+				(afterPrepare - afterExplore).toFixed(1),
+				"render",
+				(afterRender - afterPrepare).toFixed(1),
+				"vdom",
+				(afterVDOMRender - beforeVDOMRender).toFixed(1),
+				"cleanup",
+				(afterCleanup - afterVDOMRender).toFixed(1),
+			);
+		}
+	}
+	componentWillUnmount() {
+		let { instance } = this.props;
+		if (instance.destroyTracked) instance.destroy();
+	}
+}
+
+class ContainmentStore extends SubscribableView {
+	constructor(config) {
+		super(config);
+		this.selector = config.selector;
+	}
+	getData() {
+		return this.store.getData();
+	}
+	setItem(path, value) {
+		return this.wrapper(() => {
+			this.store.setItem(path, value);
+		});
+	}
+	deleteItem(path) {
+		return this.wrapper(() => {
+			this.store.deleteItem(path);
+		});
+	}
+	wrapper(callback) {
+		if (this.store.silently(callback)) {
+			let data = this.getData();
+			let containedData = this.selector(data);
+			if (containedData === this.cache.containedData) {
+				this.store.notify();
+			} else {
+				this.cache.containedData = containedData;
+				this.notify(undefined);
+			}
+			return true;
+		}
+		return false;
+	}
+}
+class DetachedScope extends IsolatedScope {
+	declareData(...args) {
+		return super.declareData(...args, {
+			exclusiveData: {
+				structured: true,
+			},
+		});
+	}
+	init() {
+		if (typeof this.exclusive === "string")
+			this.exclusiveData = {
+				bind: this.exclusive,
+			};
+		if (Array.isArray(this.exclusive)) {
+			this.exclusiveData = {};
+			this.exclusive.forEach((x, i) => {
+				this.exclusiveData[String(i)] = {
+					bind: x,
+				};
+			});
+		}
+		this.container = PureContainer.create({
+			type: PureContainer,
+			items: this.children || this.items,
+		});
+		delete this.children;
+		this.items = [];
+		if (this.name)
+			this.options = {
+				...this.options,
+				name: this.name,
+			};
+		super.init();
+	}
+	initInstance(context, instance) {
+		const config = {
+			store: instance.parentStore,
+			selector: getSelector(this.exclusiveData || this.data),
+		};
+		instance.subStore = new ContainmentStore(config);
+	}
+	applyParentStore(instance) {
+		instance.store = instance.parentStore;
+		instance.subStore.setStore(instance.parentStore);
+	}
+	render(context, instance, key) {
+		return jsx(
+			Cx,
+			{
+				widget: this.container,
+				store: instance.subStore,
+				parentInstance: instance,
+				subscribe: true,
+				options: this.options,
+				onError: this.onError,
+			},
+			key,
+		);
+	}
+}
+
+let persistenceCache = {};
+class Restate extends PureContainerBase {
+	declareData(...args) {
+		return super.declareData(...args, {
+			deferredUntilIdle: undefined,
+			idleTimeout: undefined,
+			cacheKey: undefined,
+		});
+	}
+	init() {
+		this.container = PureContainer.create({
+			items: this.children || this.items,
+			layout: this.layout,
+			controller: this.controller,
+			outerLayout: this.outerLayout,
+			useParentLayout: !this.detached,
+			ws: this.ws,
+		});
+		this.privateDataSelector = new StructuredSelector({
+			props: this.data || {},
+			values: this.data,
+		});
+		this.items = [];
+		delete this.children;
+		delete this.controller;
+		delete this.outerLayout;
+		delete this.layout;
+		if (this.useParentLayout == null) this.useParentLayout = !this.detached;
+		super.init();
+	}
+	initSubStore(context, instance) {
+		let { cacheKey } = instance.data;
+		this.privateDataSelector.init(instance.store);
+		instance.subStore = new RestateStore({
+			store: instance.store,
+			detached: this.detached,
+			privateData: this.data || {},
+			data: cacheKey ? persistenceCache[cacheKey] || {} : {},
+			dataSelector: this.privateDataSelector.create(),
+			onSet: (path, value) => instance.nestedDataSet(path, value, this.data),
+		});
+		if (cacheKey) {
+			instance.subscribeOnDestroy(() => {
+				persistenceCache[cacheKey] = instance.subStore.getData();
+			});
+		}
+	}
+	applyParentStore(instance) {
+		if (instance.subStore) instance.subStore.setStore(instance.parentStore);
+	}
+	explore(context, instance) {
+		if (!instance.subStore) this.initSubStore(context, instance);
+		if (instance.subStore.parentDataCheck()) instance.markShouldUpdate();
+		instance.cultureInfo = this.culture ?? getCurrentCulture();
+		if (instance.cache("cultureInfo", instance.culture)) instance.markShouldUpdate();
+		super.explore(context, instance);
+	}
+	exploreItems(context, instance, items) {
+		if (!this.detached) {
+			instance.container = instance.getChild(context, this.container, "container", instance.subStore);
+			instance.container.scheduleExploreIfVisible(context);
+			instance.children = [instance.container];
+		}
+	}
+	render(context, instance, key) {
+		if (!this.detached) return instance.container.render(context);
+		return jsx(
+			Cx,
+			{
+				widget: this.container,
+				parentInstance: instance,
+				store: instance.subStore,
+				subscribe: true,
+				options: this.options,
+				onError: this.onError,
+				deferredUntilIdle: instance.data.deferredUntilIdle,
+				idleTimeout: instance.data.idleTimeout,
+				immediate: this.immediate,
+				cultureInfo: instance.cultureInfo,
+			},
+			key,
+		);
+	}
+}
+Restate.prototype.detached = false;
+Restate.prototype.waitForIdle = false;
+Restate.prototype.immediate = false;
+Restate.prototype.culture = null;
+const PrivateStore = Restate;
+class RestateStore extends Store {
+	constructor(config) {
+		super(config);
+		this.parentDataVersion = -1;
+	}
+	getData() {
+		this.silently(() => {
+			this.parentDataCheck();
+		});
+		return super.getData();
+	}
+	parentDataCheck() {
+		if (this.parentDataVersion == this.store.meta.version) return false;
+		this.parentDataVersion = this.store.meta.version;
+		this.parentData = this.dataSelector(this.store.getData());
+		return this.batch(() => {
+			for (let key in this.parentData) {
+				super.setItem(key, this.parentData[key]);
+			}
+		});
+	}
+	setItem(path, value) {
+		let binding = Binding.get(path);
+		let bindingRoot = binding.parts[0];
+		if (!isObject(this.privateData) || !this.privateData.hasOwnProperty(bindingRoot)) {
+			let changed = isUndefined(value) ? super.deleteItem(path) : super.setItem(path, value);
+			return changed;
+		}
+		let newValue = value;
+		if (binding.parts.length > 1) newValue = binding.set(this.getData(), value)[bindingRoot];
+		this.onSet(bindingRoot, newValue);
+		this.batch(() => {
+			super.setItem(bindingRoot, newValue);
+			this.parentDataCheck();
+		});
+		return true;
+	}
+	deleteItem(path) {
+		return this.setItem(path, undefined);
+	}
+	doNotify() {
+		if (!this.detached) this.store.notify(undefined);
+		super.doNotify(undefined);
+	}
+	// override the default implementation to avoid meta overwrites
+	setStore(store) {
+		this.store = store;
+	}
+}
+
+class StructuredInstanceDataAccessor {
+	instance;
+	dataConfig;
+	useParentStore;
+	dataSelector;
+	constructor(config) {
+		this.instance = config.instance;
+		this.dataConfig = config.data;
+		this.useParentStore = config.useParentStore;
+		this.dataSelector = getSelector(config.data);
+		if (this.dataSelector.memoize) this.dataSelector = this.dataSelector.memoize();
+	}
+	getSelector() {
+		return this.dataSelector;
+	}
+	get() {
+		return this.dataSelector.get(this.instance.store.getData());
+	}
+	setItem(key, value) {
+		return this.instance.nestedDataSet(key, value, this.dataConfig, this.useParentStore);
+	}
+	containsKey(key) {
+		return this.dataConfig.hasOwnProperty(key);
+	}
+	getKeys() {
+		return Object.keys(this.dataConfig);
+	}
+}
+
+class DataProxy extends PureContainerBase {
+	init() {
+		if (!this.data) this.data = {};
+		if (this.alias) this.data[this.alias] = this.value;
+		super.init();
+	}
+	initInstance(context, instance) {
+		instance.store = new NestedDataView({
+			store: instance.parentStore,
+			nestedData: new StructuredInstanceDataAccessor({
+				instance,
+				data: this.data,
+				useParentStore: true,
+			}),
+			immutable: this.immutable,
+			sealed: this.sealed,
+		});
+		super.initInstance(context, instance);
+	}
+	applyParentStore(instance) {
+		instance.store.setStore(instance.parentStore);
+	}
+}
+DataProxy.prototype.immutable = false;
+DataProxy.prototype.sealed = false;
+
+class Content extends PureContainerBase {
+	constructor(config) {
+		super(config);
+	}
+	init() {
+		super.init();
+		if (!this.putInto) this.putInto = this.for || this.name;
+	}
+}
+Content.prototype.name = "body";
+Content.prototype.isContent = true;
+Widget.alias("content", Content);
+
+class ContentPlaceholder extends PureContainerBase {
+	declareData(...args) {
+		super.declareData(...args, {
+			name: undefined,
+		});
+	}
+	explore(context, instance) {
+		instance.content = null;
+		let { data } = instance;
+		if (this.allowMultiple) {
+			const contentList = context.contentList && context.contentList[data.name];
+			if (isNonEmptyArray(contentList) && !this.scoped)
+				for (let i = 0; i < contentList.length; i++) this.setContent(context, instance, contentList[i]);
+			// in multi mode register a callback to allow for more entries to be added
+			context.pushNamedValue("contentPlaceholder", data.name, (content) => {
+				this.setContent(context, instance, content);
+			});
+		} else {
+			const content = context.content && context.content[data.name];
+			if (content && !this.scoped) this.setContent(context, instance, content);
+			else
+				context.pushNamedValue("contentPlaceholder", data.name, (content) => {
+					this.setContent(context, instance, content);
+				});
+		}
+		if (this.scoped)
+			instance.unregisterContentPlaceholder = () => {
+				context.popNamedValue("contentPlaceholder", data.name);
+			};
+		super.explore(context, instance);
+	}
+	prepare(context, instance) {
+		let { content } = instance;
+		if (this.allowMultiple) {
+			let contentId = "";
+			let shouldUpdate = false;
+			if (content) {
+				for (let i = 0; i < content.length; i++) {
+					let c = content[i];
+					contentId += c.id + "+";
+					shouldUpdate = shouldUpdate || c.shouldUpdate;
+				}
+			}
+			if (instance.cache("content", contentId) || shouldUpdate) instance.markShouldUpdate(context);
+		} else if (instance.cache("content", content) || (content && content.shouldUpdate))
+			instance.markShouldUpdate(context);
+	}
+	setContent(context, instance, content) {
+		if (this.allowMultiple) {
+			if (instance.content == null) instance.content = [];
+			instance.content.push(content);
+		} else instance.content = content;
+		content.contentPlaceholder = instance;
+	}
+	render(context, instance, key) {
+		const { content } = instance;
+		if (!content) return super.render(context, instance, key);
+		if (this.allowMultiple) return content.map((x) => x.contentVDOM);
+		return content.contentVDOM;
+	}
+}
+ContentPlaceholder.prototype.name = "body";
+ContentPlaceholder.prototype.scoped = false;
+ContentPlaceholder.prototype.allowMultiple = false;
+Widget.alias("content-placeholder", ContentPlaceholder);
+class ContentPlaceholderScope extends PureContainerBase {
+	init() {
+		super.init();
+		if (isString(this.name)) this.name = [this.name];
+	}
+	explore(context, instance) {
+		this.name.forEach((name) => {
+			context.pushNamedValue("contentPlaceholder", name, null);
+			context.pushNamedValue("content", name, null);
+			context.pushNamedValue("contentList", name, []);
+		});
+		super.explore(context, instance);
+	}
+	exploreCleanup(context, instance) {
+		this.name.forEach((name) => {
+			context.popNamedValue("contentPlaceholder", name);
+			context.popNamedValue("content", name);
+			context.popNamedValue("contentList", name);
+		});
+	}
+}
+
+function validContent$1(r) {
+	let content = [];
+	for (let key in r) if (key != "label") contentAppend(content, r[key]);
+	return content;
+}
+class LabelsTopLayout extends StyledContainerBase {
+	constructor(config) {
+		super(config);
+	}
+	init() {
+		if (this.vertical && isUndefined(this.columns)) this.columns = 1;
+		super.init();
+	}
+	render(context, instance, key) {
+		let { children, data } = instance;
+		let state = {
+			rows: [],
+			currentRow: 0,
+			labelCells: [],
+			fieldCells: [],
+			rowCapacities: [this.columns],
+		};
+		const processContent = (r) => {
+			if (!r) return;
+			if (isArray(r.content) && r.useParentLayout) r.content.forEach((x) => processContent(x));
+			else if (r.atomic && r.type == "layout-cell")
+				this.addItem(state, isArray(r.content) && r.content.length == 1 ? r.content[0] : r.content, r.data);
+			else this.addItem(state, r, {});
+		};
+		children.forEach((item) => processContent(item.vdom));
+		this.addRow(state);
+		return jsx(
+			"table",
+			{
+				className: data.classNames,
+				style: data.style,
+				children: jsx("tbody", {
+					children: state.rows,
+				}),
+			},
+			key,
+		);
+	}
+	addRow(state) {
+		if (state.labelCells.length > 0)
+			state.rows.push(
+				jsx(
+					"tr",
+					{
+						children: state.labelCells,
+					},
+					state.rows.length,
+				),
+			);
+		if (state.fieldCells.length > 0)
+			state.rows.push(
+				jsx(
+					"tr",
+					{
+						children: state.fieldCells,
+					},
+					state.rows.length,
+				),
+			);
+		state.labelCells = [];
+		state.fieldCells = [];
+		state.currentRow++;
+		if (state.currentRow == state.rowCapacities.length) state.rowCapacities.push(this.columns);
+	}
+	addItem(state, item, data) {
+		while (state.labelCells.length == state.rowCapacities[state.currentRow]) this.addRow(state);
+		if (data.rowSpan > 1) {
+			for (let row = state.currentRow + 1; row < state.currentRow + data.rowSpan; row++) {
+				if (row == state.rowCapacities.length) state.rowCapacities.push(this.columns);
+				state.rowCapacities[row] -= data.colSpan || 1;
+			}
+		}
+		if (data.colSpan > 1) state.rowCapacities[state.currentRow] -= data.colSpan - 1;
+		state.labelCells.push(
+			jsx(
+				"td",
+				{
+					className: this.CSS.element(this.baseClass, "label"),
+					colSpan: data.colSpan,
+					children: getContent(item.label),
+				},
+				state.labelCells.length,
+			),
+		);
+		state.fieldCells.push(
+			jsx(
+				"td",
+				{
+					className: this.CSS.element(this.baseClass, "field"),
+					colSpan: data.colSpan,
+					rowSpan: isNumber(data.rowSpan) ? 2 * data.rowSpan - 1 : undefined,
+					style: data.style,
+					children: validContent$1(item),
+				},
+				state.fieldCells.length,
+			),
+		);
+	}
+}
+LabelsTopLayout.prototype.baseClass = "labelstoplayout";
+LabelsTopLayout.prototype.vertical = false;
+LabelsTopLayout.prototype.columns = undefined;
+class LabelsTopLayoutCell extends StyledContainerBase {
+	constructor(config) {
+		super(config);
+	}
+	declareData(...args) {
+		super.declareData(...args, {
+			colSpan: undefined,
+			rowSpan: undefined,
+		});
+	}
+	render(context, instance, key) {
+		let { content } = this.renderChildren(context, instance);
+		return {
+			atomic: true,
+			type: "layout-cell",
+			data: instance.data,
+			content,
+		};
+	}
+}
+LabelsTopLayoutCell.prototype.useParentLayout = true;
+
+function validContent(r) {
+	if (!r.hasOwnProperty("content")) return r;
+	let content = [];
+	for (let key in r) if (key != "label") contentAppend(content, r[key]);
+	return content;
+}
+class LabelsLeftLayout extends StyledContainerBase {
+	constructor(config) {
+		super(config);
+	}
+	init() {
+		this.labelStyle = parseStyle(this.labelStyle);
+		super.init();
+	}
+	declareData(...args) {
+		return super.declareData(...args, {
+			labelStyle: {
+				structured: true,
+			},
+			labelClass: {
+				structured: true,
+			},
+		});
+	}
+	render(context, instance, key) {
+		let result = [];
+		let { children, data } = instance;
+		let { CSS, baseClass } = this;
+		let labelClass = CSS.expand(CSS.element(baseClass, "label"), data.labelClass);
+		const addItem = (r, key) => {
+			if (!r) return;
+			if (r.useParentLayout && isArray(r.content)) r.content.forEach((x, i) => addItem(x, key + "-" + i));
+			else {
+				result.push(
+					jsxs(
+						"tr",
+						{
+							children: [
+								jsx("td", {
+									className: labelClass,
+									style: data.labelStyle,
+									children: getContent(r.label),
+								}),
+								jsx("td", {
+									className: CSS.element(baseClass, "field"),
+									children: validContent(r),
+								}),
+							],
+						},
+						key,
+					),
+				);
+			}
+		};
+		children.forEach((c) => {
+			addItem(c.vdom, c.key);
+		});
+		return jsx(
+			"table",
+			{
+				className: data.classNames,
+				style: data.style,
+				children: jsx("tbody", {
+					children: result,
+				}),
+			},
+			key,
+		);
+	}
+}
+LabelsLeftLayout.prototype.baseClass = "labelsleftlayout";
+
+class ContentResolver extends PureContainerBase {
+	constructor(config) {
+		super(config);
+	}
+	declareData(...args) {
+		super.declareData(...args, {
+			params: {
+				structured: true,
+			},
+			loading: undefined,
+		});
+	}
+	init() {
+		super.init();
+		this.initialItems = this.layout ? this.layout.items : this.items;
+		this.clear();
+	}
+	initInstance(context, instance) {
+		instance.content = this.initialItems;
+		instance.cachedParams = {}; //unique value which will never pass the equality check
+	}
+	prepareData(context, instance) {
+		let { data } = instance;
+		if (data.params !== instance.cachedParams && this.onResolve) {
+			instance.cachedParams = data.params;
+			let content = instance.invoke("onResolve", data.params, instance);
+			if (isPromise(content)) {
+				instance.set("loading", true);
+				this.setContent(instance, null);
+				content.then((cnt) => {
+					this.setContent(instance, cnt);
+					instance.setState({
+						cacheBuster: {},
+					});
+					instance.set("loading", false);
+				});
+			} else this.setContent(instance, content);
+		}
+	}
+	setContent(instance, content) {
+		if (content) {
+			this.clear();
+			switch (this.mode) {
+				case "prepend":
+					this.add(content);
+					this.add(this.initialItems);
+					break;
+				case "append":
+					this.add(this.initialItems);
+					this.add(content);
+					break;
+				case "replace":
+					this.add(content);
+					break;
+			}
+			instance.content = this.layout ? this.layout.items : this.items;
+			this.clear();
+		} else instance.content = this.initialItems;
+	}
+	explore(context, instance) {
+		//a little bit hacky
+		if (this.layout) this.layout.items = instance.content;
+		else this.items = instance.content;
+		super.explore(context, instance);
+	}
+}
+ContentResolver.prototype.mode = "replace";
+
+class Rescope extends PureContainerBase {
+	init() {
+		this.binding = Binding.get(this.bind);
+		if (this.rootAlias) this.rootName = this.rootAlias;
+		super.init();
+	}
+	initInstance(context, instance) {
+		instance.store = new ZoomIntoPropertyView({
+			store: instance.parentStore,
+			binding: this.binding,
+			rootName: this.rootName,
+			nestedData: isObject(this.data)
+				? new StructuredInstanceDataAccessor({
+						instance,
+						data: this.data,
+						useParentStore: true,
+					})
+				: undefined,
+		});
+		super.initInstance(context, instance);
+	}
+	applyParentStore(instance) {
+		instance.store.setStore(instance.parentStore);
+	}
+}
+Rescope.prototype.bind = "$page";
+Rescope.prototype.rootName = "$root";
+Widget.alias("rescope", Rescope);
+
+class DataAdapter extends Component {
+	constructor(config) {
+		super(config);
+	}
+	setFilter(filterFn) {
+		this.filterFn = filterFn;
+	}
+	sort(sorters) {}
+}
+DataAdapter.prototype.recordName = "$record";
+DataAdapter.prototype.indexName = "$index";
+DataAdapter.prototype.immutable = false;
+
+class ArrayAdapter extends DataAdapter {
+	constructor(config) {
+		super(config);
+	}
+	init() {
+		this.recordsAccessor = this.recordsBinding ? getAccessor(this.recordsBinding) : getAccessor(this.recordsAccessor);
+		this.recordName = this.recordName?.toString() || "$record";
+		this.indexName = this.indexName?.toString() || "$index";
+	}
+	initInstance(context, instance) {
+		if (!instance.recordStoreCache) {
+			instance.recordStoreCache = new WeakMap();
+			instance.cacheByKey = {};
+		}
+		if (!instance.recordsAccessor && this.recordsAccessor) {
+			instance.recordsAccessor = this.recordsAccessor.bindInstance
+				? this.recordsAccessor.bindInstance(instance)
+				: this.recordsAccessor;
+		}
+	}
+	getRecords(context, instance, records, parentStore) {
+		if (!instance.recordStoreCache) {
+			this.initInstance(context, instance);
+		}
+		return this.mapRecords(context, instance, records, parentStore, instance.recordsAccessor);
+	}
+	mapRecords(context, instance, records, parentStore, recordsAccessor) {
+		let result = [];
+		if (!instance.recordStoreCache) {
+			this.initInstance(context, instance);
+		}
+		if (isArray(records)) {
+			records.forEach((data, index) => {
+				if (this.filterFn && !this.filterFn(data)) return;
+				const record = this.mapRecord(context, instance, data, parentStore, recordsAccessor, index);
+				result.push(record);
+			});
+		}
+		if (this.sorter && !this.preserveOrder) {
+			result = this.sorter(result);
+		}
+		return result;
+	}
+	mapRecord(context, instance, data, parentStore, recordsAccessor, index) {
+		const key = this.cacheByKeyField && this.keyField && isObject(data) ? data[this.keyField] : null;
+		let recordStore = key != null ? instance.cacheByKey[key] : instance.recordStoreCache.get(data);
+		if (recordsAccessor) {
+			if (!recordStore) {
+				recordStore = new ArrayElementView({
+					store: parentStore,
+					arrayAccessor: recordsAccessor,
+					itemIndex: index,
+					recordAlias: this.recordName,
+					indexAlias: this.indexName,
+					immutable: this.immutable,
+					sealed: this.sealed,
+				});
+			} else {
+				recordStore.setStore(parentStore);
+				recordStore.setIndex(index);
+			}
+		} else {
+			if (!recordStore) {
+				recordStore = new ReadOnlyDataView({
+					store: parentStore,
+					data: {
+						[this.recordName]: data,
+						[this.indexName]: index,
+					},
+					immutable: this.immutable,
+					sealed: this.sealed,
+				});
+			} else {
+				recordStore.setStore(parentStore);
+				recordStore.setData({
+					[this.recordName]: data,
+					[this.indexName]: index,
+				});
+			}
+		}
+		if (key != null) {
+			instance.cacheByKey[key] = recordStore;
+		} else if (isObject(data)) {
+			instance.recordStoreCache.set(data, recordStore);
+		}
+		return {
+			store: recordStore,
+			index: index,
+			data: data,
+			type: "data",
+			key: this.keyField && isObject(data) ? data[this.keyField] : index,
+		};
+	}
+	setFilter(filterFn) {
+		this.filterFn = filterFn;
+	}
+	getComparer(sortOptions) {
+		return sortOptions ? Culture.getComparer(sortOptions) : undefined;
+	}
+	buildSorter(sorters) {
+		if (isArray(sorters) && sorters.length > 0) {
+			let dataAccessor;
+			let fieldValueMapper;
+			if (sorters.every((x) => x.field && x.value == null)) {
+				dataAccessor = (x) => x.data;
+				fieldValueMapper = (x) => ({
+					bind: x.field,
+				});
+			} else {
+				dataAccessor = (x) => x.store.getData();
+				fieldValueMapper = (x) => ({
+					bind: this.recordName + "." + x.field,
+				});
+			}
+			this.sorter = sorter(
+				sorters.map((x) => {
+					const s = Object.assign({}, x);
+					if (s.field && s.value == null) {
+						s.value = fieldValueMapper(s);
+					}
+					if (!s.comparer) {
+						s.comparer = this.getComparer(isDefined(s.sortOptions) ? s.sortOptions : this.sortOptions);
+					}
+					return s;
+				}),
+				dataAccessor,
+			);
+		} else {
+			this.sorter = undefined;
+		}
+	}
+	sort(sorters) {
+		if (sorters) {
+			this.buildSorter(sorters);
+		}
+	}
+}
+ArrayAdapter.prototype.immutable = false;
+ArrayAdapter.prototype.sealed = false;
+ArrayAdapter.prototype.keyField = null;
+ArrayAdapter.prototype.cacheByKeyField = true;
+ArrayAdapter.prototype.isTreeAdapter = false;
+ArrayAdapter.autoInit = true;
+
+class UseParentLayout extends PureContainer {}
+UseParentLayout.prototype.noLayout = true;
+UseParentLayout.prototype.useParentLayout = true;
+
+class Repeater extends ContainerBase {
+	recordsAccessor;
+	item;
+	filter;
+	declareData(...args) {
+		super.declareData(
+			{
+				records: undefined,
+				sorters: undefined,
+				sortField: undefined,
+				sortDirection: undefined,
+				filterParams: {
+					structured: true,
+				},
+			},
+			...args,
+		);
+	}
+	init() {
+		this.recordsAccessor = getAccessor(this.records);
+		if (this.recordAlias) this.recordName = this.recordAlias;
+		if (this.indexAlias) this.indexName = this.indexAlias;
+		this.dataAdapter = ArrayAdapter.create({
+			...this.dataAdapter,
+			recordName: this.recordName,
+			indexName: this.indexName,
+			keyField: this.keyField,
+			immutable: this.immutable,
+			sealed: this.sealed,
+			recordsAccessor: this.recordsAccessor,
+			sortOptions: this.sortOptions,
+		});
+		this.item = PureContainer.create({
+			children: this.items || this.children,
+			layout: UseParentLayout,
+		});
+		delete this.children;
+		this.items = [];
+		super.init();
+	}
+	initInstance(context, instance) {
+		this.dataAdapter.initInstance(context, instance);
+	}
+	applyParentStore(instance) {
+		super.applyParentStore(instance);
+		// force prepareData to execute again and propagate the store change to the records
+		if (instance.cached) delete instance.cached.rawData;
+	}
+	prepareData(context, instance) {
+		let { data } = instance;
+		if (data.sortField)
+			data.sorters = [
+				{
+					field: data.sortField,
+					direction: data.sortDirection || "ASC",
+				},
+			];
+		this.dataAdapter.sort(data.sorters);
+		let filter = null;
+		if (this.onCreateFilter) filter = instance.invoke("onCreateFilter", data.filterParams, instance);
+		else if (this.filter) filter = (item) => this.filter(item, data.filterParams);
+		this.dataAdapter.setFilter(filter);
+		instance.mappedRecords = this.dataAdapter.getRecords(context, instance, data.records, instance.store);
+		if (this.onTrackMappedRecords) {
+			instance.invoke("onTrackMappedRecords", instance.mappedRecords, instance);
+		}
+		super.prepareData(context, instance);
+	}
+	explore(context, instance, data) {
+		let instances = [];
+		instance.mappedRecords.forEach((record) => {
+			let subInstance = instance.getChild(context, this.item, record.key, record.store);
+			let changed = subInstance.cache("recordData", record.data) || subInstance.cache("key", record.key);
+			subInstance.record = record;
+			if (this.cached && !changed && subInstance.visible && !subInstance.childStateDirty) {
+				instances.push(subInstance);
+				subInstance.shouldUpdate = false;
+			} else if (subInstance.scheduleExploreIfVisible(context)) instances.push(subInstance);
+		});
+		instance.children = instances;
+	}
+}
+Repeater.prototype.recordName = "$record";
+Repeater.prototype.indexName = "$index";
+Repeater.prototype.cached = false;
+Repeater.prototype.immutable = false;
+Repeater.prototype.sealed = false;
+Repeater.prototype.isPureContainer = true;
+Widget.alias("repeater", Repeater);
+
 function autoFocus(el, component) {
 	let data = component.props.data || component.props.instance.data;
 	let autoFocusValue = el && data.autoFocus;
@@ -196,10 +2963,10 @@ let urlAttributes = {
 	"img.src": true,
 	"iframe.src": true,
 };
-class HtmlElementInstance extends Instance {
+class HtmlElementInstance extends Instance$1 {
 	events;
 }
-class HtmlElement extends StyledContainerBase {
+class HtmlElement extends StyledContainerBase$1 {
 	constructor(config) {
 		super(config);
 		if (isUndefined(this.jsxAttributes) && config)
@@ -361,11 +3128,11 @@ class HtmlElement extends StyledContainerBase {
 				},
 				key,
 			);
-		return VDOM.createElement(this.tag, props, props.children);
+		return VDOM$2.createElement(this.tag, props, props.children);
 	}
 }
 HtmlElement.prototype.tag = "div";
-class ContainerComponent extends VDOM.Component {
+class ContainerComponent extends VDOM$2.Component {
 	el = null;
 	constructor(props) {
 		super(props);
@@ -393,7 +3160,7 @@ class ContainerComponent extends VDOM.Component {
 				if (onMouseMove) onMouseMove(e);
 			};
 		}
-		return VDOM.createElement(tag, props, children);
+		return VDOM$2.createElement(tag, props, children);
 	}
 	componentWillUnmount() {
 		tooltipParentWillUnmount$1(this.props.instance);
@@ -419,9 +3186,9 @@ class ContainerComponent extends VDOM.Component {
 		autoFocus(this.el, this);
 	}
 }
-const originalWidgetFactory = Widget.factory;
+const originalWidgetFactory = Widget$1.factory;
 //support for React components
-Widget.factory = function (type, config, more) {
+Widget$1.factory = function (type, config, more) {
 	const typeType = typeof type;
 	if (typeType === "undefined") {
 		debug("Creating a widget of unknown type.", config, more);
@@ -435,9 +3202,9 @@ Widget.factory = function (type, config, more) {
 			},
 			config,
 		);
-	return originalWidgetFactory.call(Widget, type, config, more);
+	return originalWidgetFactory.call(Widget$1, type, config, more);
 };
-Widget.alias("html-element", HtmlElement);
+Widget$1.alias("html-element", HtmlElement);
 
 let htmlFactoryCache = {};
 function getHtmlElementFactory(tagName) {
@@ -476,12 +3243,12 @@ function cx(typeName, props, ...children) {
 	};
 }
 function react(config) {
-	if (!config || isString(config) || isNumber(config) || VDOM.isValidElement(config)) return config;
+	if (!config || isString(config) || isNumber(config) || VDOM$2.isValidElement(config)) return config;
 	if (isArray(config)) return config.map(react);
 	let type = config.$type;
 	if (isComponentFactory(type) && type.$meta && type.$meta.tag) type = type.$meta.tag;
-	if (isArray(config.children)) return VDOM.createElement(type, config.$props, ...config.children.map(react));
-	return VDOM.createElement(type, config.$props, react(config.children));
+	if (isArray(config.children)) return VDOM$2.createElement(type, config.$props, ...config.children.map(react));
+	return VDOM$2.createElement(type, config.$props, react(config.children));
 }
 
 function getMessage(options) {
@@ -939,7 +3706,7 @@ registerIcon(
 	true,
 );
 
-class Icon extends Widget {
+class Icon extends Widget$1 {
 	declareData(...args) {
 		super.declareData(...args, {
 			name: undefined,
@@ -974,7 +3741,7 @@ class Icon extends Widget {
 }
 Icon.prototype.baseClass = "icon";
 Icon.prototype.styled = true;
-Widget.alias("icon", Icon);
+Widget$1.alias("icon", Icon);
 
 class Button extends HtmlElement {
 	constructor(config) {
@@ -1052,7 +3819,7 @@ class Button extends HtmlElement {
 				key: "icon",
 				className: this.CSS.element(this.baseClass, "icon"),
 			});
-			const children = getContentArray(props.children);
+			const children = getContentArray$1(props.children);
 			props.children = [icon, ...children];
 			props.className = this.CSS.expand(
 				props.className,
@@ -1079,9 +3846,9 @@ Button.prototype.baseClass = "button";
 Button.prototype.icon = false;
 Button.prototype.focusOnMouseDown = false;
 Button.prototype.submit = false;
-Widget.alias("button", Button);
+Widget$1.alias("button", Button);
 
-class DocumentTitle extends Widget {
+class DocumentTitle extends Widget$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -1133,7 +3900,7 @@ class DocumentTitle extends Widget {
 }
 DocumentTitle.prototype.action = "append";
 DocumentTitle.prototype.separator = "";
-Widget.alias("document-title", DocumentTitle);
+Widget$1.alias("document-title", DocumentTitle);
 
 /*
  - renders list of items
@@ -1141,7 +3908,7 @@ Widget.alias("document-title", DocumentTitle);
  - selection
  - fake focus - list appears focused and receives keyboard inputs redirected from other control (dropdown scenario)
  */
-class List extends StyledContainerBase {
+class List extends StyledContainerBase$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -1257,7 +4024,7 @@ class List extends StyledContainerBase {
 			instance: x,
 			key: x.record.key,
 			type: x.record.type,
-			content: getContent(x.render(context)),
+			content: getContent$1(x.render(context)),
 		}));
 		return jsx(
 			ListComponent,
@@ -1287,8 +4054,8 @@ class List extends StyledContainerBase {
 			// Clone to avoid mutating the original config
 			return {
 				...g,
-				header: g.header ? Widget.create(g.header) : undefined,
-				footer: g.footer ? Widget.create(g.footer) : undefined,
+				header: g.header ? Widget$1.create(g.header) : undefined,
+				footer: g.footer ? Widget$1.create(g.footer) : undefined,
 			};
 		});
 		this.adapter.groupBy(normalized);
@@ -1306,8 +4073,8 @@ List.prototype.styled = true;
 List.prototype.scrollSelectionIntoView = false;
 List.prototype.selectMode = false;
 List.prototype.selectOnTab = false;
-Widget.alias("list", List);
-class ListComponent extends VDOM.Component {
+Widget$1.alias("list", List);
+class ListComponent extends VDOM$2.Component {
 	cursorChildIndex = [];
 	unsubscribeScroll;
 	onKeyDown;
@@ -1495,7 +4262,7 @@ class ListComponent extends VDOM.Component {
 		//ignore mouse enter/leave events (support with a flag if a feature request comes)
 		if (!hover) newState.cursor = index;
 		//batch updates to avoid flickering between selection and cursor changes
-		batchUpdates(() => {
+		batchUpdates$1(() => {
 			if (select || widget.selectMode) {
 				let start =
 					selectRange && this.state.selectionStart !== undefined && this.state.selectionStart >= 0
@@ -1639,7 +4406,7 @@ class ListComponent extends VDOM.Component {
 		}
 	}
 }
-class ListItem extends Container {
+class ListItem extends Container$1 {
 	declareData(...args) {
 		super.declareData(...args, {
 			disabled: undefined,
@@ -1656,7 +4423,7 @@ function isItemDisabled(item) {
 	return item?.instance.data.disabled;
 }
 
-class Sandbox extends PureContainerBase {
+class Sandbox extends PureContainerBase$1 {
 	init() {
 		if (this.recordAlias) this.recordName = this.recordAlias;
 		if (this.accessKey) this.key = this.accessKey;
@@ -1706,7 +4473,7 @@ class Sandbox extends PureContainerBase {
 Sandbox.prototype.recordName = "$page";
 Sandbox.prototype.immutable = false;
 Sandbox.prototype.sealed = false;
-Widget.alias("sandbox", Sandbox);
+Widget$1.alias("sandbox", Sandbox);
 
 class CxCredit extends HtmlElement {
 	constructor(config) {
@@ -1741,7 +4508,7 @@ class CxCredit extends HtmlElement {
 }
 CxCredit.prototype.baseClass = "cxcredit";
 CxCredit.prototype.tag = "div";
-Widget.alias("cx-credit", CxCredit);
+Widget$1.alias("cx-credit", CxCredit);
 
 class Heading extends HtmlElement {
 	init() {
@@ -1768,7 +4535,7 @@ class Heading extends HtmlElement {
 Heading.prototype.level = 3;
 Heading.prototype.baseClass = "heading";
 
-class Section extends ContainerBase {
+class Section extends ContainerBase$1 {
 	init() {
 		if (isString(this.headerStyle)) this.headerStyle = parseStyle(this.headerStyle);
 		if (isString(this.footerStyle)) this.footerStyle = parseStyle(this.footerStyle);
@@ -1819,7 +4586,7 @@ class Section extends ContainerBase {
 	}
 	getHeader() {
 		if (this.title)
-			return Widget.create(Heading, {
+			return Widget$1.create(Heading, {
 				text: this.title,
 				level: this.hLevel,
 			});
@@ -1827,7 +4594,7 @@ class Section extends ContainerBase {
 		return null;
 	}
 	getFooter() {
-		if (this.footer) return Widget.create(this.footer);
+		if (this.footer) return Widget$1.create(this.footer);
 		return null;
 	}
 	prepareData(context, instance) {
@@ -1851,14 +4618,14 @@ class Section extends ContainerBase {
 			header = jsx("header", {
 				className: CSS.expand(CSS.element(baseClass, "header"), data.headerClass),
 				style: data.headerStyle,
-				children: getContent(components.header.render(context)),
+				children: getContent$1(components.header.render(context)),
 			});
 		}
 		if (components?.footer) {
 			footer = jsx("footer", {
 				className: CSS.expand(CSS.element(baseClass, "footer"), data.footerClass),
 				style: data.footerStyle,
-				children: getContent(components.footer.render(context)),
+				children: getContent$1(components.footer.render(context)),
 			});
 		}
 		return jsxs(
@@ -1887,7 +4654,7 @@ Section.prototype.pad = true;
 Section.prototype.baseClass = "section";
 Section.prototype.hLevel = 3;
 
-class FlexBox extends ContainerBase {
+class FlexBox extends ContainerBase$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -1965,7 +4732,7 @@ class FlexRow extends FlexBox {}
 class FlexCol extends FlexBox {}
 FlexCol.prototype.direction = "column";
 
-class ProgressBar extends Widget {
+class ProgressBar extends Widget$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -2059,7 +4826,7 @@ function captureMouse2(e, options) {
 		}
 		//if mouse moves double clicking is off
 		options.onDblClick = undefined;
-		batchUpdates(() => {
+		batchUpdates$1(() => {
 			if (options.onMouseMove) options.onMouseMove(e, options.captureData);
 			e.stopPropagation();
 			e.preventDefault(); //disable text selection
@@ -2067,7 +4834,7 @@ function captureMouse2(e, options) {
 	}
 	function end(e) {
 		active = false;
-		batchUpdates(() => {
+		batchUpdates$1(() => {
 			// if (surface.releaseCapture)
 			//    surface.releaseCapture();
 			if (!options.onDblClick) surface.style.display = "none";
@@ -2091,13 +4858,13 @@ function captureMouseOrTouch2(e, options) {
 	if (e.type.indexOf("touch") == 0) {
 		let el = e.currentTarget;
 		let move = (e) => {
-			batchUpdates(() => {
+			batchUpdates$1(() => {
 				if (options.onMouseMove) options.onMouseMove(e, options.captureData);
 				e.preventDefault();
 			});
 		};
 		let end = (e) => {
-			batchUpdates(() => {
+			batchUpdates$1(() => {
 				el.removeEventListener("touchmove", move);
 				el.removeEventListener("touchend", end);
 				if (options.onMouseUp) options.onMouseUp(e);
@@ -2159,7 +4926,7 @@ function getCursorPos(e) {
 	};
 }
 
-class Resizer extends Widget {
+class Resizer extends Widget$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -2190,7 +4957,7 @@ Resizer.prototype.forNextElement = false;
 Resizer.prototype.defaultSize = null;
 Resizer.prototype.minSize = 0;
 Resizer.prototype.maxSize = 1e6;
-class ResizerCmp extends VDOM.Component {
+class ResizerCmp extends VDOM$2.Component {
 	constructor(props) {
 		super(props);
 		this.state = {
@@ -2303,7 +5070,7 @@ class ResizerCmp extends VDOM.Component {
 	}
 }
 
-class HighlightedSearchText extends Widget {
+class HighlightedSearchText extends Widget$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -2341,7 +5108,7 @@ class HighlightedSearchText extends Widget {
 HighlightedSearchText.prototype.styled = true;
 HighlightedSearchText.prototype.baseClass = "highlightedsearchtext";
 
-class ReactElementWrapper extends ContainerBase {
+class ReactElementWrapper extends ContainerBase$1 {
 	init() {
 		// Collect all props to pass to the React component
 		this.props = {};
@@ -2397,7 +5164,7 @@ class ReactElementWrapper extends ContainerBase {
 			...instance.events,
 			children,
 		};
-		return VDOM.createElement(this.componentType, props);
+		return VDOM$2.createElement(this.componentType, props);
 	}
 }
 
@@ -2701,12 +5468,12 @@ function ddHandle(e) {
 function isDragHandleEvent(e) {
 	return lastDragHandle && (e.target == lastDragHandle || lastDragHandle.contains(e.target));
 }
-const DragDropContext = VDOM.createContext
-	? VDOM.createContext({
+const DragDropContext = VDOM$2.createContext
+	? VDOM$2.createContext({
 			disabled: false,
 		})
 	: ({ children }) => children;
-class ContextWrap extends Container {
+class ContextWrap extends Container$1 {
 	render(context, instance, key) {
 		return jsx(
 			DragDropContext.Provider,
@@ -2719,10 +5486,10 @@ class ContextWrap extends Container {
 	}
 }
 
-class OverlayInstance extends Instance {
+class OverlayInstance extends Instance$1 {
 	onBeforeDismiss;
 }
-class OverlayBase extends ContainerBase {
+class OverlayBase extends ContainerBase$1 {
 	static configureOverlayContainer;
 	init() {
 		if (this.center) this.centerX = this.centerY = this.center;
@@ -2928,9 +5695,9 @@ OverlayBase.prototype.dismissOnPopState = false;
 OverlayBase.prototype.closeOnEscape = false;
 OverlayBase.prototype.needsBeacon = false;
 class Overlay extends OverlayBase {}
-Widget.alias("overlay", Overlay);
+Widget$1.alias("overlay", Overlay);
 //TODO: all el related logic should be moved here
-class OverlayContent extends VDOM.Component {
+class OverlayContent extends VDOM$2.Component {
 	render() {
 		return jsx("div", {
 			ref: this.props.onRef,
@@ -2958,7 +5725,7 @@ class OverlayContent extends VDOM.Component {
 	}
 }
 //TODO: This should be called OverlayPortal
-class OverlayComponent extends VDOM.Component {
+class OverlayComponent extends VDOM$2.Component {
 	onOverlayRef;
 	onPopState;
 	unsubscribeWheelBlock;
@@ -2978,7 +5745,7 @@ class OverlayComponent extends VDOM.Component {
 			this.containerEl = this.ownedEl;
 		}
 		// content is rendered in componentDidUpdate if portals are not supported
-		return VDOM.DOM.createPortal ? VDOM.DOM.createPortal(this.renderOverlay(), this.containerEl) : null;
+		return VDOM$2.DOM.createPortal ? VDOM$2.DOM.createPortal(this.renderOverlay(), this.containerEl) : null;
 	}
 	renderOverlay() {
 		let { widget, data } = this.props.instance;
@@ -3353,14 +6120,14 @@ class OverlayComponent extends VDOM.Component {
 		}
 	}
 	componentDidUpdate() {
-		if (this.containerEl && !VDOM.DOM.createPortal) {
-			this.root = VDOM.DOM.createRoot(this.containerEl);
+		if (this.containerEl && !VDOM$2.DOM.createPortal) {
+			this.root = VDOM$2.DOM.createRoot(this.containerEl);
 			this.root.render(this.renderOverlay());
 		}
 		this.overlayDidUpdate();
 	}
 }
-class OverlayBeacon extends VDOM.Component {
+class OverlayBeacon extends VDOM$2.Component {
 	el;
 	render() {
 		return jsxs(Fragment, {
@@ -3949,8 +6716,8 @@ DropdownBase.prototype.firstChildDefinesHeight = false;
 DropdownBase.prototype.firstChildDefinesWidth = false;
 DropdownBase.prototype.cover = false;
 class Dropdown extends DropdownBase {}
-Widget.alias("dropdown", Dropdown);
-Localization.registerPrototype("cx/widgets/Dropdown", Dropdown);
+Widget$1.alias("dropdown", Dropdown);
+Localization$1.registerPrototype("cx/widgets/Dropdown", Dropdown);
 function getViewportRect(padding = 0) {
 	return {
 		left: padding,
@@ -4097,7 +6864,7 @@ TooltipBase.prototype.arrow = true;
 TooltipBase.prototype.alwaysVisible = false;
 TooltipBase.prototype.globalMouseTracking = false;
 class Tooltip extends TooltipBase {}
-Widget.alias("tooltip", Tooltip);
+Widget$1.alias("tooltip", Tooltip);
 function getTooltipInstance(e, parentInstance, tooltip, options = {}) {
 	let target = options.target || (e instanceof Element ? e : e?.currentTarget) || e;
 	debug(tooltipsFlag, "mouse-move", target, parentInstance);
@@ -4139,7 +6906,7 @@ function getTooltipInstance(e, parentInstance, tooltip, options = {}) {
 		tooltipInstance = parentInstance.tooltips[name] = parentInstance.getDetachedChild(tooltipWidget, name, store);
 		tooltipInstance.config = config;
 		tooltipInstance.tooltipName = name;
-		tooltipInstance.init(new RenderingContext());
+		tooltipInstance.init(new RenderingContext$1());
 		if (config.alwaysVisible || config.trackMouse || config.trackMouseX || config.trackMouseY) {
 			tooltipInstance.data = tooltipInstance.dataSelector(store);
 		}
@@ -4284,16 +7051,16 @@ class Window extends OverlayBase {
 	}
 	initHelpers(...args) {
 		return super.initHelpers(...args, {
-			header: Widget.create(
+			header: Widget$1.create(
 				this.header || {
-					type: ContentPlaceholder,
+					type: ContentPlaceholder$1,
 					name: "header",
 					scoped: true,
 				},
 			),
-			footer: Widget.create(
+			footer: Widget$1.create(
 				this.footer || {
-					type: ContentPlaceholder,
+					type: ContentPlaceholder$1,
 					name: "footer",
 					scoped: true,
 				},
@@ -4323,14 +7090,14 @@ class Window extends OverlayBase {
 		let result = [];
 		if (data.title) result.push(data.title);
 		if (instance.helpers) {
-			let header = getContent(instance.helpers.header && instance.helpers.header.render(context));
+			let header = getContent$1(instance.helpers.header && instance.helpers.header.render(context));
 			if (header) result.push(header);
-			if (data.closable && instance.helpers.close) result.push(getContent(instance.helpers.close.render(context)));
+			if (data.closable && instance.helpers.close) result.push(getContent$1(instance.helpers.close.render(context)));
 		}
 		return result;
 	}
 	renderFooter(context, instance, key) {
-		return getContent(instance.helpers && instance.helpers.footer && instance.helpers.footer.render(context));
+		return getContent$1(instance.helpers && instance.helpers.footer && instance.helpers.footer.render(context));
 	}
 	render(context, instance, key) {
 		var header = this.renderHeader(context, instance, "header");
@@ -4361,8 +7128,8 @@ Window.prototype.autoFocus = true;
 Window.prototype.focusable = true;
 Window.prototype.pad = true;
 Window.prototype.needsBeacon = true;
-Widget.alias("window", Window);
-Localization.registerPrototype("cx/widgets/Window", Window);
+Widget$1.alias("window", Window);
+Localization$1.registerPrototype("cx/widgets/Window", Window);
 class WindowComponent extends OverlayComponent {
 	headerEl;
 	footerEl;
@@ -4571,7 +7338,7 @@ MsgBox.prototype.footerDirection = "row";
 MsgBox.prototype.footerJustify = "center";
 MsgBox.prototype.yesText = "Yes";
 MsgBox.prototype.noText = "No";
-Localization.registerPrototype("cx/widgets/MsgBox", MsgBox);
+Localization$1.registerPrototype("cx/widgets/MsgBox", MsgBox);
 function enableMsgBoxAlerts() {
 	registerAlertImpl({
 		yesNo: MsgBox.yesNo.bind(MsgBox),
@@ -4583,7 +7350,7 @@ class Toast extends OverlayBase {
 	init() {
 		if (this.message)
 			this.items = {
-				type: Text,
+				type: Text$1,
 				value: this.message,
 			};
 		super.init();
@@ -4671,7 +7438,7 @@ ContextMenu.prototype.autoFocus = true;
 ContextMenu.prototype.autoFocusFirstChild = false;
 ContextMenu.prototype.focusable = true;
 ContextMenu.prototype.alignArrow = true;
-Localization.registerPrototype("cx/widgets/ContextMenu", ContextMenu);
+Localization$1.registerPrototype("cx/widgets/ContextMenu", ContextMenu);
 const openContextMenu = (e, content, storeOrInstance, options) => {
 	e.preventDefault();
 	e.stopPropagation();
@@ -4688,8 +7455,8 @@ const openContextMenu = (e, content, storeOrInstance, options) => {
 	return menu.open(storeOrInstance, options);
 };
 
-class FlyweightTooltipTrackerInstance extends Instance {}
-class FlyweightTooltipTracker extends Widget {
+class FlyweightTooltipTrackerInstance extends Instance$1 {}
+class FlyweightTooltipTracker extends Widget$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -5233,7 +8000,7 @@ Route$1.prototype = Object.create(Object.prototype);
 Route$1.prototype.constructor = Route$1;
 
 // Base class for extending with custom Config types
-class RouteBase extends PureContainerBase {
+class RouteBase extends PureContainerBase$1 {
 	init() {
 		if (this.path) this.route = this.path;
 		super.init();
@@ -5315,7 +8082,7 @@ RouteBase.prototype.recordName = "$route";
 RouteBase.prototype.prefix = false;
 // Closed type for direct usage
 class Route extends RouteBase {}
-Widget.alias("route", Route);
+Widget$1.alias("route", Route);
 
 class RedirectRoute extends RouteBase {
 	checkVisible(context, instance, data) {
@@ -5337,7 +8104,7 @@ class RedirectRoute extends RouteBase {
 		else instance.set("url", data.redirect);
 	}
 }
-Widget.alias("redirect-route", RedirectRoute);
+Widget$1.alias("redirect-route", RedirectRoute);
 
 class Tab extends HtmlElement {
 	declareData() {
@@ -5402,7 +8169,7 @@ Tab.prototype.baseClass = "tab";
 Tab.prototype.tag = "a";
 Tab.prototype.focusOnMouseDown = false;
 Tab.prototype.default = false;
-Widget.alias("tab", Tab);
+Widget$1.alias("tab", Tab);
 
 class LinkButton extends Button {
 	constructor(config) {
@@ -5506,11 +8273,11 @@ class LinkButton extends Button {
 }
 LinkButton.prototype.match = "equal";
 LinkButton.prototype.tag = "a";
-Widget.alias("link-button", LinkButton);
+Widget$1.alias("link-button", LinkButton);
 
 class Link extends LinkButton {}
 Link.prototype.baseClass = "link";
-Widget.alias("link", Link);
+Widget$1.alias("link", Link);
 
 class MenuItemInstance extends HtmlElementInstance {}
 class MenuItem extends HtmlElement {
@@ -5591,9 +8358,9 @@ MenuItem.prototype.checkedIcon = "check";
 MenuItem.prototype.uncheckedIcon = "dummy";
 MenuItem.prototype.keyboardShortcut = false;
 MenuItem.prototype.openOnFocus = true;
-Widget.alias("submenu", MenuItem);
-Localization.registerPrototype("cx/widgets/MenuItem", MenuItem);
-let MenuItemComponent$1 = class MenuItemComponent extends VDOM.Component {
+Widget$1.alias("submenu", MenuItem);
+Localization$1.registerPrototype("cx/widgets/MenuItem", MenuItem);
+let MenuItemComponent$1 = class MenuItemComponent extends VDOM$2.Component {
 	validateDropdownPosition;
 	unregisterKeyboardShortcut;
 	offParentPositionChange;
@@ -5611,7 +8378,7 @@ let MenuItemComponent$1 = class MenuItemComponent extends VDOM.Component {
 	getDropdown() {
 		let { horizontal, widget, parentPositionChangeEvent } = this.props.instance;
 		if (!this.dropdown && widget.dropdown) {
-			this.dropdown = Widget.create(Dropdown, {
+			this.dropdown = Widget$1.create(Dropdown, {
 				matchWidth: false,
 				placementOrder: widget.placementOrder || this.getDefaultPlacementOrder(horizontal),
 				trackScroll: true,
@@ -5641,7 +8408,7 @@ let MenuItemComponent$1 = class MenuItemComponent extends VDOM.Component {
 		let { CSS, baseClass } = widget;
 		let dropdown =
 			this.state.dropdownOpen &&
-			jsx(Cx, {
+			jsx(Cx$1, {
 				widget: this.getDropdown(),
 				options: {
 					name: "submenu",
@@ -5892,7 +8659,7 @@ let MenuItemComponent$1 = class MenuItemComponent extends VDOM.Component {
 	}
 };
 
-class MenuSpacer extends Widget {
+class MenuSpacer extends Widget$1 {
 	render(context, instance, key) {
 		return {
 			key: true,
@@ -5988,7 +8755,7 @@ Menu.prototype.overflowIcon = "drop-down";
 Menu.Item = MenuItem;
 Menu.Spacer = MenuSpacer;
 class MenuInstance extends HtmlElementInstance {}
-class MenuComponent extends VDOM.Component {
+class MenuComponent extends VDOM$2.Component {
 	el = null;
 	isMeasureOverflowDisabled = false;
 	unsubscribeFocusOut;
@@ -6189,8 +8956,8 @@ class MenuComponent extends VDOM.Component {
 }
 Menu.prototype.baseClass = "menu";
 Menu.prototype.tag = "ul";
-Widget.alias("menu", Menu);
-class MenuItemComponent extends VDOM.Component {
+Widget$1.alias("menu", Menu);
+class MenuItemComponent extends VDOM$2.Component {
 	el = null;
 	constructor(props) {
 		super(props);
@@ -6270,7 +9037,7 @@ class MenuItemComponent extends VDOM.Component {
 
 class Submenu extends MenuItem {}
 
-class Scroller extends StyledContainerBase {
+class Scroller extends StyledContainerBase$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -6296,7 +9063,7 @@ class Scroller extends StyledContainerBase {
 	}
 }
 Scroller.prototype.baseClass = "scroller";
-class HScrollerComponent extends VDOM.Component {
+class HScrollerComponent extends VDOM$2.Component {
 	unsubscribeResize;
 	stopScrolling;
 	scrollLeft;
@@ -6462,7 +9229,7 @@ HScroller.prototype.horizontal = true;
 class VScroller extends Scroller {}
 VScroller.prototype.vertical = true;
 
-class FieldIcon extends Widget {
+class FieldIcon extends Widget$1 {
 	declareData(...args) {
 		super.declareData(...args, {
 			name: undefined,
@@ -6504,7 +9271,7 @@ class HelpText extends HtmlElement {
 }
 HelpText.prototype.tag = "span";
 HelpText.prototype.baseClass = "helptext";
-Widget.alias("help-text", HelpText);
+Widget$1.alias("help-text", HelpText);
 
 class Label extends HtmlElement {
 	constructor(config) {
@@ -6584,7 +9351,7 @@ Label.prototype.baseClass = "label";
 Label.prototype.tag = "label";
 Label.prototype.asterisk = false;
 
-class ValidationError extends Widget {
+class ValidationError extends Widget$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -6628,10 +9395,10 @@ class ValidationError extends Widget {
 }
 ValidationError.prototype.baseClass = "validationerror";
 ValidationError.prototype.styled = true;
-Widget.alias("validation-error", ValidationError);
+Widget$1.alias("validation-error", ValidationError);
 
-class FieldInstance extends Instance {}
-class Field extends PureContainerBase {
+class FieldInstance extends Instance$1 {}
+class Field extends PureContainerBase$1 {
 	declareData(...args) {
 		super.declareData(
 			{
@@ -6897,16 +9664,16 @@ class Field extends PureContainerBase {
 		}
 	}
 	renderLabel(context, instance, key) {
-		if (instance.components?.label) return getContent(instance.components.label.vdom);
+		if (instance.components?.label) return getContent$1(instance.components.label.vdom);
 	}
 	renderInput(context, instance, key) {
 		throw new Error("Not implemented.");
 	}
 	renderHelp(context, instance, key) {
-		if (instance.components?.help) return getContent(instance.components.help.render(context));
+		if (instance.components?.help) return getContent$1(instance.components.help.render(context));
 	}
 	renderIcon(context, instance, key) {
-		if (instance.components?.icon) return getContent(instance.components.icon.render(context));
+		if (instance.components?.icon) return getContent$1(instance.components.icon.render(context));
 	}
 	formatValue(context, { data }) {
 		return data.text || data.value;
@@ -7004,7 +9771,7 @@ Field.prototype.styled = true;
 //Field.prototype.disabled = null;
 //Field.prototype.readOnly = null;
 //Field.prototype.viewMode = null;
-Localization.registerPrototype("cx/widgets/Field", Field);
+Localization$1.registerPrototype("cx/widgets/Field", Field);
 function getFieldTooltip(instance) {
 	let { widget, data, state } = instance;
 	if (widget.errorTooltip && data.error && (!state || state.visited || !widget.suppressErrorsUntilVisited))
@@ -7049,8 +9816,8 @@ class TextField extends Field {
 			{
 				instance: instance,
 				data: instance.data,
-				label: this.labelPlacement && getContent(this.renderLabel(context, instance, "label")),
-				help: this.helpPlacement && getContent(this.renderHelp(context, instance, "help")),
+				label: this.labelPlacement && getContent$1(this.renderLabel(context, instance, "label")),
+				help: this.helpPlacement && getContent$1(this.renderHelp(context, instance, "help")),
 				icon: this.renderIcon(context, instance, "icon"),
 			},
 			key,
@@ -7081,8 +9848,8 @@ TextField.prototype.showClear = false;
 TextField.prototype.alwaysShowClear = false;
 TextField.prototype.keyboardShortcut = "false";
 TextField.prototype.trim = false;
-Localization.registerPrototype("cx/widgets/TextField", TextField);
-let Input$2 = class Input extends VDOM.Component {
+Localization$1.registerPrototype("cx/widgets/TextField", TextField);
+let Input$2 = class Input extends VDOM$2.Component {
 	input;
 	constructor(props) {
 		super(props);
@@ -7273,7 +10040,7 @@ let Input$2 = class Input extends VDOM.Component {
 		return value;
 	}
 };
-Widget.alias("textfield", TextField);
+Widget$1.alias("textfield", TextField);
 
 var SquareIcon = registerIcon(
 	"square",
@@ -7346,7 +10113,7 @@ class Checkbox extends Field {
 					this.handleClick(e, instance);
 				},
 				style: data.style,
-				children: [content, this.labelPlacement && getContent(this.renderLabel(context, instance, "label"))],
+				children: [content, this.labelPlacement && getContent$1(this.renderLabel(context, instance, "label"))],
 			},
 			key,
 		);
@@ -7444,8 +10211,8 @@ Checkbox.prototype.baseClass = "checkbox";
 Checkbox.prototype.native = false;
 Checkbox.prototype.indeterminate = false;
 Checkbox.prototype.unfocusable = false;
-Widget.alias("checkbox", Checkbox);
-class CheckboxCmp extends VDOM.Component {
+Widget$1.alias("checkbox", Checkbox);
+class CheckboxCmp extends VDOM$2.Component {
 	constructor(props) {
 		super(props);
 		this.state = {
@@ -7567,7 +10334,7 @@ class Radio extends Field {
 					this.handleClick(e, instance);
 				},
 				htmlFor: data.id,
-				children: [content, this.labelPlacement && getContent(this.renderLabel(context, instance, "label"))],
+				children: [content, this.labelPlacement && getContent$1(this.renderLabel(context, instance, "label"))],
 			},
 			key,
 		);
@@ -7645,8 +10412,8 @@ class Radio extends Field {
 Radio.prototype.baseClass = "radio";
 Radio.prototype.native = false;
 Radio.prototype.default = false;
-Widget.alias("radio", Radio);
-class RadioCmp extends VDOM.Component {
+Widget$1.alias("radio", Radio);
+class RadioCmp extends VDOM$2.Component {
 	constructor(props) {
 		super(props);
 		this.state = {
@@ -7724,8 +10491,8 @@ class Select extends Field {
 				instance: instance,
 				multiple: this.multiple,
 				select: (v) => this.select(v, instance),
-				label: this.labelPlacement && getContent(this.renderLabel(context, instance, "label")),
-				help: this.helpPlacement && getContent(this.renderHelp(context, instance, "help")),
+				label: this.labelPlacement && getContent$1(this.renderLabel(context, instance, "label")),
+				help: this.helpPlacement && getContent$1(this.renderHelp(context, instance, "help")),
 				icon: this.renderIcon(context, instance, "icon"),
 				children: this.renderChildren(context, instance),
 			},
@@ -7757,9 +10524,9 @@ Select.prototype.suppressErrorsUntilVisited = true;
 Select.prototype.showClear = true;
 Select.prototype.alwaysShowClear = false;
 Select.prototype.icon = null;
-Widget.alias("select", Select);
-Localization.registerPrototype("cx/widgets/Select", Select);
-class SelectComponent extends VDOM.Component {
+Widget$1.alias("select", Select);
+Localization$1.registerPrototype("cx/widgets/Select", Select);
+class SelectComponent extends VDOM$2.Component {
 	select = null;
 	constructor(props) {
 		super(props);
@@ -7941,7 +10708,7 @@ class Option extends HtmlElement {
 		);
 	}
 }
-Widget.alias("option", Option);
+Widget$1.alias("option", Option);
 
 var ForwardIcon = registerIcon(
 	"forward",
@@ -8068,7 +10835,7 @@ class Calendar extends Field {
 				date = mixed;
 			}
 		}
-		let encode = calendarWidget.encoding || Culture.getDefaultDateEncoding();
+		let encode = calendarWidget.encoding || Culture$1.getDefaultDateEncoding();
 		instance.set("value", encode(date));
 		if (this.onSelect) instance.invoke("onSelect", e, instance, date);
 	}
@@ -8085,7 +10852,7 @@ Calendar.prototype.showTodayButton = false;
 Calendar.prototype.todayButtonText = "Today";
 Calendar.prototype.startWithMonday = false;
 Calendar.prototype.focusable = true;
-Localization.registerPrototype("cx/widgets/Calendar", Calendar);
+Localization$1.registerPrototype("cx/widgets/Calendar", Calendar);
 const validationCheck = (date, data, disabledDaysOfWeek) => {
 	if (data.maxValue && !upperBoundCheck(date, data.maxValue, data.maxExclusive)) return false;
 	if (data.minValue && !lowerBoundCheck(date, data.minValue, data.minExclusive)) return false;
@@ -8096,7 +10863,7 @@ const validationCheck = (date, data, disabledDaysOfWeek) => {
 	}
 	return true;
 };
-class CalendarCmp extends VDOM.Component {
+class CalendarCmp extends VDOM$2.Component {
 	el = null;
 	unsubscribeWheel;
 	constructor(props) {
@@ -8436,7 +11203,7 @@ class CalendarCmp extends VDOM.Component {
 				),
 			);
 		}
-		let culture = Culture.getDateTimeCulture();
+		let culture = Culture$1.getDateTimeCulture();
 		let monthNames = culture.getMonthNames("long");
 		let dayNames = culture.getWeekdayNames("short").map((x) => x.substr(0, 2));
 		if (startWithMonday) dayNames = [...dayNames.slice(1), dayNames[0]];
@@ -8562,7 +11329,7 @@ class CalendarCmp extends VDOM.Component {
 	}
 }
 const readDate = (ds) => new Date(Number(ds.year), Number(ds.month) - 1, Number(ds.date));
-Widget.alias("calendar", Calendar);
+Widget$1.alias("calendar", Calendar);
 
 class LookupField extends Field {
 	declareData(...args) {
@@ -8731,8 +11498,8 @@ class LookupField extends Field {
 				itemConfig: this.itemConfig,
 				bindings: this.bindings,
 				baseClass: this.baseClass,
-				label: this.labelPlacement && getContent(this.renderLabel(context, instance, "label")),
-				help: this.helpPlacement && getContent(this.renderHelp(context, instance, "help")),
+				label: this.labelPlacement && getContent$1(this.renderLabel(context, instance, "label")),
+				help: this.helpPlacement && getContent$1(this.renderHelp(context, instance, "help")),
 				forceUpdate: context.forceUpdate,
 				icon: this.renderIcon(context, instance, "icon"),
 			},
@@ -8809,8 +11576,8 @@ LookupField.prototype.pageSize = 100;
 LookupField.prototype.infinite = false;
 LookupField.prototype.quickSelectAll = false;
 LookupField.prototype.onGetRecordDisplayText = null;
-Localization.registerPrototype("cx/widgets/LookupField", LookupField);
-Widget.alias("lookupfield", LookupField);
+Localization$1.registerPrototype("cx/widgets/LookupField", LookupField);
+Widget$1.alias("lookupfield", LookupField);
 function getOptionKey(bindings, data) {
 	return bindings.filter((a) => a.key).map((b) => Binding.get(b.remote).value(data));
 }
@@ -8842,7 +11609,7 @@ class SelectionDelegate extends Selection {
 		return false;
 	}
 }
-class LookupComponent extends VDOM.Component {
+class LookupComponent extends VDOM$2.Component {
 	dom = {};
 	itemStore;
 	dropdown;
@@ -8891,7 +11658,7 @@ class LookupComponent extends VDOM.Component {
 		if (this.dropdown) return this.dropdown;
 		let { widget } = this.props.instance;
 		let { lastDropdown } = this.props.instance;
-		this.list = Widget.create({
+		this.list = Widget$1.create({
 			type: List,
 			sortField: widget.sort && widget.optionTextField,
 			sortDirection: "ASC",
@@ -8948,7 +11715,7 @@ class LookupComponent extends VDOM.Component {
 				return false;
 			},
 		};
-		return (this.dropdown = Widget.create(dropdown));
+		return (this.dropdown = Widget$1.create(dropdown));
 	}
 	renderDropdownContents() {
 		let content;
@@ -9005,7 +11772,7 @@ class LookupComponent extends VDOM.Component {
 						this.subscribeListOnScroll(el);
 					},
 					className: CSS.element(baseClass, "scroll-container"),
-					children: jsx(Cx, {
+					children: jsx(Cx$1, {
 						widget: this.list,
 						store: this.itemStore,
 						options: {
@@ -9110,7 +11877,7 @@ class LookupComponent extends VDOM.Component {
 				$options: this.state.options,
 				$query: this.lastQuery,
 			});
-			dropdown = jsx(Cx, {
+			dropdown = jsx(Cx$1, {
 				widget: this.getDropdown(),
 				store: this.itemStore,
 				options: {
@@ -9722,7 +12489,7 @@ class NumberField extends Field {
 			let result = instance.invoke("onParseInput", value, instance);
 			if (result !== undefined) return result;
 		}
-		return Culture.getNumberCulture().parse(value);
+		return Culture$1.getNumberCulture().parse(value);
 	}
 	validate(context, instance) {
 		super.validate(context, instance);
@@ -9748,8 +12515,8 @@ class NumberField extends Field {
 			{
 				data: instance.data,
 				instance: instance,
-				label: this.labelPlacement && getContent(this.renderLabel(context, instance, "label")),
-				help: this.helpPlacement && getContent(this.renderHelp(context, instance, "help")),
+				label: this.labelPlacement && getContent$1(this.renderLabel(context, instance, "label")),
+				help: this.helpPlacement && getContent$1(this.renderHelp(context, instance, "help")),
 				icon: this.renderIcon(context, instance, "icon"),
 			},
 			key,
@@ -9776,9 +12543,9 @@ NumberField.prototype.snapToIncrement = true;
 NumberField.prototype.icon = null;
 NumberField.prototype.showClear = false;
 NumberField.prototype.alwaysShowClear = false;
-Widget.alias("numberfield", NumberField);
-Localization.registerPrototype("cx/widgets/NumberField", NumberField);
-let Input$1 = class Input extends VDOM.Component {
+Widget$1.alias("numberfield", NumberField);
+Localization$1.registerPrototype("cx/widgets/NumberField", NumberField);
+let Input$1 = class Input extends VDOM$2.Component {
 	input;
 	unsubscribeOnWheel;
 	constructor(props) {
@@ -10116,8 +12883,8 @@ class TextArea extends TextField {
 			{
 				data: instance.data,
 				instance: instance,
-				label: this.labelPlacement && getContent(this.renderLabel(context, instance, "label")),
-				help: this.helpPlacement && getContent(this.renderHelp(context, instance, "help")),
+				label: this.labelPlacement && getContent$1(this.renderLabel(context, instance, "label")),
+				help: this.helpPlacement && getContent$1(this.renderHelp(context, instance, "help")),
 			},
 			key,
 		);
@@ -10129,7 +12896,7 @@ class TextArea extends TextField {
 TextArea.prototype.baseClass = "textarea";
 TextArea.prototype.reactOn = "blur";
 TextArea.prototype.suppressErrorsUntilVisited = true;
-class Input extends VDOM.Component {
+class Input extends VDOM$2.Component {
 	input;
 	constructor(props) {
 		super(props);
@@ -10255,9 +13022,9 @@ class Input extends VDOM.Component {
 		this.onChange(e.target.value, "blur");
 	}
 }
-Widget.alias("textarea", TextArea);
+Widget$1.alias("textarea", TextArea);
 
-class ValidationGroup extends PureContainerBase {
+class ValidationGroup extends PureContainerBase$1 {
 	declareData(...args) {
 		super.declareData(...args, {
 			errors: undefined,
@@ -10308,10 +13075,10 @@ class ValidationGroup extends PureContainerBase {
 	}
 }
 ValidationGroup.prototype.isolated = false;
-Widget.alias("validation-group", ValidationGroup);
+Widget$1.alias("validation-group", ValidationGroup);
 
 class FieldGroup extends ValidationGroup {}
-Widget.alias("field-group", FieldGroup);
+Widget$1.alias("field-group", FieldGroup);
 
 class LabeledContainer extends FieldGroup {
 	declareData(...args) {
@@ -10331,7 +13098,7 @@ class LabeledContainer extends FieldGroup {
 			if (this.label.isComponentType) labelConfig = this.label;
 			else if (isSelector(this.label)) labelConfig.text = this.label;
 			else Object.assign(labelConfig, this.label);
-			this.label = Widget.create(labelConfig);
+			this.label = Widget$1.create(labelConfig);
 		}
 		super.init();
 	}
@@ -10352,7 +13119,7 @@ class LabeledContainer extends FieldGroup {
 	}
 }
 LabeledContainer.prototype.styled = true;
-Widget.alias("labeled-container", LabeledContainer);
+Widget$1.alias("labeled-container", LabeledContainer);
 
 enableCultureSensitiveFormatting();
 class MonthPickerInstance extends FieldInstance {
@@ -10452,7 +13219,7 @@ class MonthPicker extends Field {
 	}
 	handleSelect(e, instance, date1, date2) {
 		let { data, widget, isMonthDateSelectable } = instance;
-		let encode = widget.encoding || Culture.getDefaultDateEncoding();
+		let encode = widget.encoding || Culture$1.getDefaultDateEncoding();
 		if (data.disabled) return;
 		if (isMonthDateSelectable && !isMonthDateSelectable(date1)) return;
 		if (!dateSelectableCheck(date1, data)) return;
@@ -10478,8 +13245,8 @@ MonthPicker.prototype.maxExclusiveErrorText = "Select a date before {0:d}.";
 MonthPicker.prototype.minValueErrorText = "Select {0:d} or later.";
 MonthPicker.prototype.minExclusiveErrorText = "Select a date after {0:d}.";
 MonthPicker.prototype.inclusiveTo = false;
-Localization.registerPrototype("cx/widgets/MonthPicker", MonthPicker);
-Widget.alias("month-picker", MonthPicker);
+Localization$1.registerPrototype("cx/widgets/MonthPicker", MonthPicker);
+Widget$1.alias("month-picker", MonthPicker);
 const dateSelectableCheck = (date, data) => {
 	if (data.maxValue && !upperBoundCheck(date, data.maxValue, data.maxExclusive)) return false;
 	if (data.minValue && !lowerBoundCheck(date, data.minValue, data.minExclusive)) return false;
@@ -10488,7 +13255,7 @@ const dateSelectableCheck = (date, data) => {
 const monthNumber = (date) => {
 	return date.getFullYear() * 12 + date.getMonth();
 };
-class MonthPickerComponent extends VDOM.Component {
+class MonthPickerComponent extends VDOM$2.Component {
 	dom = {};
 	dragStartDates;
 	constructor(props) {
@@ -10914,7 +13681,7 @@ class MonthPickerComponent extends VDOM.Component {
 				to = Math.max(a, b);
 			}
 		}
-		let monthNames = Culture.getDateTimeCulture().getMonthNames("short");
+		let monthNames = Culture$1.getDateTimeCulture().getMonthNames("short");
 		let showCursor = this.state.focused;
 		for (let y = start; y <= end; y++) {
 			let selectableMonths = 0b111111111111;
@@ -11203,8 +13970,8 @@ class ColorPicker extends Field {
 ColorPicker.prototype.baseClass = "colorpicker";
 ColorPicker.prototype.reportOn = "blur change";
 ColorPicker.prototype.format = "rgba";
-Widget.alias("color-picker", ColorPicker);
-class ColorPickerComponent extends VDOM.Component {
+Widget$1.alias("color-picker", ColorPicker);
+class ColorPickerComponent extends VDOM$2.Component {
 	data;
 	constructor(props) {
 		super(props);
@@ -11696,7 +14463,7 @@ class MonthField extends Field {
 		return this.range ? data.from == null : data.value == null;
 	}
 	init() {
-		if (!this.culture) this.culture = Culture.getDateTimeCulture();
+		if (!this.culture) this.culture = Culture$1.getDateTimeCulture();
 		if (isDefined(this.hideClear)) this.showClear = !this.hideClear;
 		if (this.alwaysShowClear) this.showClear = true;
 		super.init();
@@ -11772,8 +14539,8 @@ class MonthField extends Field {
 					minValueErrorText: this.minValueErrorText,
 					minExclusiveErrorText: this.minExclusiveErrorText,
 				},
-				label: this.labelPlacement && getContent(this.renderLabel(context, instance, "label")),
-				help: this.helpPlacement && getContent(this.renderHelp(context, instance, "help")),
+				label: this.labelPlacement && getContent$1(this.renderLabel(context, instance, "label")),
+				help: this.helpPlacement && getContent$1(this.renderHelp(context, instance, "help")),
 				icon: this.renderIcon(context, instance, "icon"),
 			},
 			key,
@@ -11792,7 +14559,7 @@ class MonthField extends Field {
 	}
 	handleSelect(instance, date1, date2) {
 		let { widget } = instance;
-		let encode = widget.encoding ?? Culture.getDefaultDateEncoding();
+		let encode = widget.encoding ?? Culture$1.getDefaultDateEncoding();
 		instance.setState({
 			inputError: false,
 		});
@@ -11825,9 +14592,9 @@ MonthField.prototype.alwaysShowClear = false;
 MonthField.prototype.range = false;
 MonthField.prototype.reactOn = "enter blur";
 MonthField.prototype.inclusiveTo = false;
-Localization.registerPrototype("cx/widgets/MonthField", MonthField);
-Widget.alias("monthfield", MonthField);
-class MonthInput extends VDOM.Component {
+Localization$1.registerPrototype("cx/widgets/MonthField", MonthField);
+Widget$1.alias("monthfield", MonthField);
+class MonthInput extends VDOM$2.Component {
 	input;
 	dropdown;
 	openDropdownOnFocus = false;
@@ -11872,7 +14639,7 @@ class MonthInput extends VDOM.Component {
 			constrain: true,
 			firstChildDefinesWidth: true,
 		};
-		return (this.dropdown = Widget.create(dropdown));
+		return (this.dropdown = Widget$1.create(dropdown));
 	}
 	render() {
 		const { instance, label, help, data, icon: iconVDOM } = this.props;
@@ -11913,7 +14680,7 @@ class MonthInput extends VDOM.Component {
 		}
 		var dropdown = false;
 		if (this.state.dropdownOpen)
-			dropdown = jsx(Cx, {
+			dropdown = jsx(Cx$1, {
 				widget: this.getDropdown(),
 				parentInstance: instance,
 				options: {
@@ -12158,8 +14925,8 @@ class ColorField extends Field {
 					value: this.value,
 					format: this.format,
 				},
-				label: this.labelPlacement && getContent(this.renderLabel(context, instance, "label")),
-				help: this.helpPlacement && getContent(this.renderHelp(context, instance, "help")),
+				label: this.labelPlacement && getContent$1(this.renderLabel(context, instance, "label")),
+				help: this.helpPlacement && getContent$1(this.renderHelp(context, instance, "help")),
 			},
 			key,
 		);
@@ -12170,9 +14937,9 @@ ColorField.prototype.format = "rgba";
 ColorField.prototype.suppressErrorsUntilVisited = true;
 ColorField.prototype.showClear = true;
 ColorField.prototype.alwaysShowClear = false;
-Widget.alias("color-field", ColorField);
-Localization.registerPrototype("cx/widgets/ColorField", ColorField);
-class ColorInput extends VDOM.Component {
+Widget$1.alias("color-field", ColorField);
+Localization$1.registerPrototype("cx/widgets/ColorField", ColorField);
+class ColorInput extends VDOM$2.Component {
 	data;
 	dropdown;
 	input;
@@ -12226,7 +14993,7 @@ class ColorInput extends VDOM.Component {
 			firstChildDefinesHeight: true,
 			firstChildDefinesWidth: true,
 		};
-		return (this.dropdown = Widget.create(dropdown));
+		return (this.dropdown = Widget$1.create(dropdown));
 	}
 	render() {
 		let { instance, label, help, data } = this.props;
@@ -12266,7 +15033,7 @@ class ColorInput extends VDOM.Component {
 		});
 		let dropdown = false;
 		if (this.state.dropdownOpen)
-			dropdown = jsx(Cx, {
+			dropdown = jsx(Cx$1, {
 				widget: this.getDropdown(),
 				parentInstance: instance,
 				options: {
@@ -12508,8 +15275,8 @@ UploadButton.prototype.multiple = false;
 UploadButton.prototype.method = "POST";
 UploadButton.prototype.abortOnDestroy = false;
 UploadButton.prototype.uploadInProgressText = "Upload is in progress.";
-Localization.registerPrototype("cx/widgets/UploadButton", UploadButton);
-class UploadButtonComponent extends VDOM.Component {
+Localization$1.registerPrototype("cx/widgets/UploadButton", UploadButton);
+class UploadButtonComponent extends VDOM$2.Component {
 	uploads;
 	el;
 	constructor(props) {
@@ -12664,7 +15431,7 @@ class UploadButtonComponent extends VDOM.Component {
 		});
 	}
 }
-Widget.alias("upload-button", UploadButton);
+Widget$1.alias("upload-button", UploadButton);
 
 class Slider extends Field {
 	declareData(...args) {
@@ -12719,7 +15486,7 @@ class Slider extends Field {
 			{
 				instance: instance,
 				data: instance.data,
-				label: this.labelPlacement && getContent(this.renderLabel(context, instance, "label")),
+				label: this.labelPlacement && getContent$1(this.renderLabel(context, instance, "label")),
 			},
 			key,
 		);
@@ -12732,8 +15499,8 @@ Slider.prototype.vertical = false;
 Slider.prototype.incrementPercentage = 0.01;
 Slider.prototype.wheel = false;
 Slider.prototype.invert = false;
-Widget.alias("slider", Slider);
-class SliderComponent extends VDOM.Component {
+Widget$1.alias("slider", Slider);
+class SliderComponent extends VDOM$2.Component {
 	dom;
 	unsubscribeOnWheel;
 	constructor(props) {
@@ -13123,7 +15890,7 @@ class Switch extends Field {
 					}
 				},
 				children: [
-					this.labelPlacement && getContent(this.renderLabel(context, instance, "label")),
+					this.labelPlacement && getContent$1(this.renderLabel(context, instance, "label")),
 					"\u00A0",
 					jsxs("div", {
 						className: CSS.element(baseClass, "axis"),
@@ -13166,9 +15933,9 @@ class Switch extends Field {
 }
 Switch.prototype.baseClass = "switch";
 Switch.prototype.focusOnMouseDown = false;
-Widget.alias("switch", Switch);
+Widget$1.alias("switch", Switch);
 
-class Wheel extends PureContainerBase {
+class Wheel extends PureContainerBase$1 {
 	declareData(...args) {
 		return super.declareData(...args, {
 			value: undefined,
@@ -13214,7 +15981,7 @@ Wheel.prototype.styled = true;
 /** A cyclic wheel renders its option list this many times, leaving scroll
  * headroom on both sides of the centre copy. */
 const WHEEL_BUFFER_COPIES = 3;
-class WheelComponent extends VDOM.Component {
+class WheelComponent extends VDOM$2.Component {
 	index;
 	wheelEl;
 	scrollEl;
@@ -13452,7 +16219,7 @@ class WheelComponent extends VDOM.Component {
 }
 
 enableCultureSensitiveFormatting();
-class DateTimePicker extends Widget {
+class DateTimePicker extends Widget$1 {
 	declareData(...args) {
 		return super.declareData(...args, {
 			value: undefined,
@@ -13495,7 +16262,7 @@ function buildNumberWheel(range, startAt) {
 			),
 	);
 }
-class DateTimePickerComponent extends VDOM.Component {
+class DateTimePickerComponent extends VDOM$2.Component {
 	el;
 	keyDownPipes;
 	constructor(props) {
@@ -13559,7 +16326,7 @@ class DateTimePickerComponent extends VDOM.Component {
 	handleChange() {
 		let { widget } = this.props.instance;
 		let pickerWidget = widget;
-		let encode = pickerWidget.encoding || Culture.getDefaultDateEncoding();
+		let encode = pickerWidget.encoding || Culture$1.getDefaultDateEncoding();
 		this.props.instance.set("value", encode(this.state.date));
 	}
 	render() {
@@ -13567,7 +16334,7 @@ class DateTimePickerComponent extends VDOM.Component {
 		let { widget } = instance;
 		let { CSS, baseClass } = widget;
 		let date = this.state.date;
-		let culture = Culture.getDateTimeCulture();
+		let culture = Culture$1.getDateTimeCulture();
 		let monthNames = culture.getMonthNames("short");
 		// Years: a window spanning the current century, rebuilt when it changes.
 		let currentCentury = (date.getFullYear() / 100) | 0;
@@ -13906,7 +16673,7 @@ class DateTimePickerComponent extends VDOM.Component {
 
 const TimeList = createFunctionalComponent(({ value, step, format, encoding, onSelect, ...props }) =>
 	jsx$1("cx", {
-		children: jsx$1(ContentResolver, {
+		children: jsx$1(ContentResolver$1, {
 			params: {
 				step,
 				format,
@@ -13927,12 +16694,12 @@ const TimeList = createFunctionalComponent(({ value, step, format, encoding, onS
 				}
 				let stepMs = step * 60 * 1000;
 				return jsx$1("cx", {
-					children: jsx$1(DataProxy, {
+					children: jsx$1(DataProxy$1, {
 						data: {
 							$value: value,
 						},
 						immutable: true,
-						children: jsx$1(DataProxy, {
+						children: jsx$1(DataProxy$1, {
 							data: {
 								$selection: {
 									get: ({ $value }) => {
@@ -13951,7 +16718,7 @@ const TimeList = createFunctionalComponent(({ value, step, format, encoding, onS
 										copy.setMinutes(date.getMinutes());
 										copy.setSeconds(date.getSeconds());
 										copy.setMilliseconds(0);
-										let encode = encoding || Culture.getDefaultDateEncoding();
+										let encode = encoding || Culture$1.getDefaultDateEncoding();
 										store.set("$value", encode(copy));
 									},
 								},
@@ -14092,9 +16859,9 @@ class DateTimeField extends Field {
 					minValueErrorText: this.minValueErrorText,
 					minExclusiveErrorText: this.minExclusiveErrorText,
 				},
-				label: this.labelPlacement && getContent(this.renderLabel(context, instance, "label")),
-				help: this.helpPlacement && getContent(this.renderHelp(context, instance, "help")),
-				icon: getContent(this.renderIcon(context, instance, "icon")),
+				label: this.labelPlacement && getContent$1(this.renderLabel(context, instance, "label")),
+				help: this.helpPlacement && getContent$1(this.renderHelp(context, instance, "help")),
+				icon: getContent$1(this.renderIcon(context, instance, "icon")),
 			},
 			key,
 		);
@@ -14109,7 +16876,7 @@ class DateTimeField extends Field {
 			let result = instance.invoke("onParseInput", date, instance);
 			if (result !== undefined) return result;
 		}
-		date = Culture.getDateTimeCulture().parse(date, {
+		date = Culture$1.getDateTimeCulture().parse(date, {
 			useCurrentDateForDefaults: true,
 		});
 		return date;
@@ -14131,9 +16898,9 @@ DateTimeField.prototype.segment = "datetime";
 DateTimeField.prototype.picker = "auto";
 DateTimeField.prototype.disabledDaysOfWeek = null;
 DateTimeField.prototype.focusInputFirst = false;
-Widget.alias("datetimefield", DateTimeField);
-Localization.registerPrototype("cx/widgets/DateTimeField", DateTimeField);
-class DateTimeInput extends VDOM.Component {
+Widget$1.alias("datetimefield", DateTimeField);
+Localization$1.registerPrototype("cx/widgets/DateTimeField", DateTimeField);
+class DateTimeInput extends VDOM$2.Component {
 	input;
 	dropdown;
 	scrollableParents;
@@ -14223,7 +16990,7 @@ class DateTimeInput extends VDOM.Component {
 				},
 			},
 		};
-		return (this.dropdown = Widget.create(dropdown));
+		return (this.dropdown = Widget$1.create(dropdown));
 	}
 	render() {
 		let { instance, label, help, icon: iconVDOM } = this.props;
@@ -14259,7 +17026,7 @@ class DateTimeInput extends VDOM.Component {
 		}
 		let dropdown;
 		if (this.state.dropdownOpen)
-			dropdown = jsx(Cx, {
+			dropdown = jsx(Cx$1, {
 				widget: this.getDropdown(),
 				parentInstance: instance,
 				options: {
@@ -14480,7 +17247,7 @@ class DateTimeInput extends VDOM.Component {
 				}
 				date = mixed;
 			}
-			let encode = dateTimeWidget.encoding || Culture.getDefaultDateEncoding();
+			let encode = dateTimeWidget.encoding || Culture$1.getDefaultDateEncoding();
 			let value = date ? encode(date) : dateTimeWidget.emptyValue;
 			if (!instance.set("value", value)) this.input.value = value ? Format$1.value(date, data.format) : "";
 		}
@@ -14494,13 +17261,13 @@ class DateField extends DateTimeField {
 }
 DateField.prototype.picker = "calendar";
 DateField.prototype.segment = "date";
-Widget.alias("datefield", DateField);
-Localization.registerPrototype("cx/widgets/DateField", DateField);
+Widget$1.alias("datefield", DateField);
+Localization$1.registerPrototype("cx/widgets/DateField", DateField);
 
 class TimeField extends DateTimeField {}
 TimeField.prototype.segment = "time";
-Widget.alias("timefield", TimeField);
-Localization.registerPrototype("cx/widgets/TimeField", TimeField);
+Widget$1.alias("timefield", TimeField);
+Localization$1.registerPrototype("cx/widgets/TimeField", TimeField);
 
 class Validator extends Field {
 	constructor(config) {
@@ -14542,7 +17309,7 @@ var DropDownIcon = registerIcon(
 	true,
 );
 
-class GridCellEditor extends ContainerBase {
+class GridCellEditor extends ContainerBase$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -14560,7 +17327,7 @@ class GridCellEditor extends ContainerBase {
 	}
 }
 GridCellEditor.prototype.styled = true;
-class GridCellEditorCmp extends VDOM.Component {
+class GridCellEditorCmp extends VDOM$2.Component {
 	el = null;
 	render() {
 		let { className, style, children } = this.props;
@@ -14592,7 +17359,7 @@ function createGridCellEditor(className, style, valid, columnEditor) {
 	});
 }
 
-class GridCell extends StyledContainerBase {
+class GridCell extends StyledContainerBase$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -14654,12 +17421,12 @@ GridCell.prototype.pad = true;
 GridCell.prototype.fixed = false;
 GridCell.prototype.merged = false;
 
-class GridRowLine extends Container {
+class GridRowLine extends Container$1 {
 	constructor(config) {
 		super(config);
 	}
 	init() {
-		this.items = Widget.create(GridCell, this.columns || [], {
+		this.items = Widget$1.create(GridCell, this.columns || [], {
 			recordName: this.recordName,
 		});
 		super.init();
@@ -14705,7 +17472,7 @@ class GridRow extends ValidationGroup {
 	}
 }
 GridRow.prototype.styled = true; //styles used on the wrapper component
-class GridRowComponent extends VDOM.Component {
+class GridRowComponent extends VDOM$2.Component {
 	onDoubleClick;
 	onRowContextMenu;
 	unsubscribeHoverSync;
@@ -14746,7 +17513,7 @@ class GridRowComponent extends VDOM.Component {
 			leave = this.onMouseLeave;
 		}
 		if (this.props.grid.widget.onRowClick) keyDown = this.onKeyDown;
-		return VDOM.createElement(
+		return VDOM$2.createElement(
 			useTrTag ? "tr" : "tbody",
 			{
 				className: CSS.expand(data.classNames, className, this.state && this.state.hover && CSS.state("hover")),
@@ -14867,14 +17634,14 @@ class GridRowComponent extends VDOM.Component {
 	}
 }
 
-class GridInstance extends Instance {
+class GridInstance extends Instance$1 {
 	resetColumnWidths() {
 		this.setState({
 			colWidth: {},
 		});
 	}
 }
-class Grid extends ContainerBase {
+class Grid extends ContainerBase$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -14989,7 +17756,7 @@ class Grid extends ContainerBase {
 				lines.push(l);
 			}
 		}
-		row.header = PureContainer.create({
+		row.header = PureContainer$1.create({
 			items: GridColumnHeaderLine.create(lines),
 		});
 		row.header.items.forEach((line) => {
@@ -15057,7 +17824,7 @@ class Grid extends ContainerBase {
 				);
 		}
 		instance.dataAdapter =
-			this.dataAdapter instanceof ArrayAdapter
+			this.dataAdapter instanceof ArrayAdapter$1
 				? this.dataAdapter
 				: GroupAdapter.create(
 						{
@@ -15074,7 +17841,7 @@ class Grid extends ContainerBase {
 						this.dataAdapter,
 					);
 		instance.dataAdapter.initInstance(context, instance);
-		return Widget.create(GridRow, {
+		return Widget$1.create(GridRow, {
 			class: this.CSS.element(this.baseClass, "data"),
 			className: this.rowClass,
 			style: this.rowStyle,
@@ -15109,10 +17876,13 @@ class Grid extends ContainerBase {
 		if (!isArray(data.records)) data.records = [];
 		if (state.sorters && !isDefined(this.sorters)) data.sorters = state.sorters;
 		let sortField = null;
-		if (isDefined(this.sortField) && isDefined(this.sortDirection)) {
+		// rebuild sorters from the sortField/sortDirection bindings only if a sort field
+		// is actually set; sorts identified by a value selector (columns without a field)
+		// live in data.sorters/state.sorters and cannot round-trip through a field name
+		if (isDefined(this.sortField) && isDefined(this.sortDirection) && data.sortField) {
 			let sorter = {
 				field: data.sortField,
-				direction: data.sortDirection,
+				direction: data.sortDirection || "ASC",
 			};
 			sortField = data.sortField;
 			data.sorters = [sorter];
@@ -15127,11 +17897,11 @@ class Grid extends ContainerBase {
 			data.sorters = [sorter];
 		}
 		if (sortField) {
-			for (let l = 1; l < 10; l++) {
+			for (let l = 0; l < 10; l++) {
 				let line = instance.row[`line${l}`];
-				let sortColumn = line && line.columns && line.columns.find((c) => c.field == sortField);
+				let sortColumn = line && line.columns && line.columns.find((c) => (c.sortField || c.field) == sortField);
 				if (sortColumn) {
-					data.sorters[0].value = sortColumn.sortValue || sortColumn.value;
+					data.sorters[0].value = isDefined(sortColumn.sortValue) ? sortColumn.sortValue : sortColumn.value;
 					data.sorters[0].comparer = sortColumn.comparer;
 					data.sorters[0].sortOptions = sortColumn.sortOptions;
 					break;
@@ -15437,8 +18207,18 @@ class Grid extends ContainerBase {
 						else if (hdwidget.align) mods.push("aligned-" + hdwidget.align);
 						if (hdwidget.sortable && header.widget.allowSorting) {
 							mods.push("sortable");
-							if (data.sorters && data.sorters[0].field == (hdwidget.sortField || hdwidget.field)) {
-								mods.push("sorted-" + data.sorters[0].direction.toLowerCase());
+							let sorter = data.sorters && data.sorters[0];
+							let sortColumnField = hdwidget.sortField || hdwidget.field;
+							let sortColumnValue = isDefined(hdwidget.sortValue) ? hdwidget.sortValue : hdwidget.value;
+							// a sort is identified by its (field, value selector) pair, so columns
+							// sorting by the same field through different value selectors don't both match
+							let sorted =
+								sorter &&
+								!!sorter.direction &&
+								(sortColumnField ? sorter.field == sortColumnField : !sorter.field && isDefined(sortColumnValue)) &&
+								sorter.value === sortColumnValue;
+							if (sorted) {
+								mods.push("sorted-" + sorter.direction.toLowerCase());
 								sortIcon = jsx(DropDownIcon, {
 									className: CSS.element(baseClass, "column-sort-icon"),
 								});
@@ -15467,7 +18247,7 @@ class Grid extends ContainerBase {
 						if (header.components && header.components.tool) {
 							tool = jsx("div", {
 								className: CSS.element(baseClass, "col-header-tool"),
-								children: getContent(header.components.tool.render(context)),
+								children: getContent$1(header.components.tool.render(context)),
 							});
 							mods.push("tool");
 						}
@@ -15510,7 +18290,7 @@ class Grid extends ContainerBase {
 								onClick: (e) => this.onHeaderClick(e, hdwidget, instance, l),
 								onContextMenu: onContextMenu,
 								"data-unique-col-id": colSpan > 1 ? null : hdwidget.uniqueColumnId,
-								children: [getContent(content), sortIcon, tool, prevColumnResizer, resizer],
+								children: [getContent$1(content), sortIcon, tool, prevColumnResizer, resizer],
 							},
 							colIndex,
 						),
@@ -15606,16 +18386,15 @@ class Grid extends ContainerBase {
 		let { data } = instance;
 		let header = column.components[`header${headerLine + 1}`];
 		let field = column.sortField || column.field;
-		let value = column.sortValue || column.value;
+		let value = isDefined(column.sortValue) ? column.sortValue : column.value;
 		let comparer = column.comparer;
 		let sortOptions = column.sortOptions;
-		if (header && header.allowSorting && column.sortable && (field || value || data.sortField)) {
+		if (header && header.allowSorting && column.sortable && (field || isDefined(value))) {
 			let direction = column.primarySortDirection ?? "ASC";
-			if (
-				isNonEmptyArray(data.sorters) &&
-				((!!data.sorters[0].field && data.sorters[0].field == (field || data.sortField)) ||
-					(!!value && data.sorters[0].value == value))
-			) {
+			// the column matches the active sorter only if both the field and the value
+			// selector are the same; two columns may sort by the same field through
+			// different value selectors and represent different sorts
+			if (isNonEmptyArray(data.sorters) && data.sorters[0].field == field && data.sorters[0].value === value) {
 				if (data.sorters[0].direction == "ASC" && (!this.clearableSort || direction == "ASC")) direction = "DESC";
 				else if (data.sorters[0].direction == "DESC" && (!this.clearableSort || direction == "DESC")) direction = "ASC";
 				else {
@@ -15682,7 +18461,7 @@ class Grid extends ContainerBase {
 						style = null;
 					if (c.caption) {
 						if (c.caption.children)
-							v = jsx(Cx, {
+							v = jsx(Cx$1, {
 								widget: c.caption.children,
 								store: store,
 								parentInstance: instance,
@@ -16016,9 +18795,9 @@ Grid.prototype.focusable = null; // automatically resolved
 Grid.prototype.allowsFileDrops = false;
 Grid.prototype.preserveGroupOrder = false;
 Grid.prototype.sortGroups = false;
-Widget.alias("grid", Grid);
-Localization.registerPrototype("cx/widgets/Grid", Grid);
-class GridComponent extends VDOM.Component {
+Widget$1.alias("grid", Grid);
+Localization$1.registerPrototype("cx/widgets/Grid", Grid);
+class GridComponent extends VDOM$2.Component {
 	dom;
 	syncBuffering = false;
 	scrollerRef;
@@ -16088,7 +18867,7 @@ class GridComponent extends VDOM.Component {
 			"td",
 			{
 				className: CSS.element(baseClass, "cell-editor"),
-				children: jsx(Cx, {
+				children: jsx(Cx$1, {
 					parentInstance: instance,
 					subscribe: true,
 					widget: editor,
@@ -16201,7 +18980,7 @@ class GridComponent extends VDOM.Component {
 			};
 			if (!standalone) return wrap(record.vdom);
 			return jsx(
-				Cx,
+				Cx$1,
 				{
 					instance: record.row,
 					parentInstance: instance,
@@ -16248,11 +19027,11 @@ class GridComponent extends VDOM.Component {
 			record.row.shouldUpdate = false;
 		};
 		if (widget.buffered) {
-			let context = new RenderingContext();
+			let context = new RenderingContext$1();
 			let dummyDataClass = CSS.element(baseClass, "data", {
 				dummy: true,
 			});
-			if (!instance.recordInstanceCache) instance.recordInstanceCache = new InstanceCache(instance);
+			if (!instance.recordInstanceCache) instance.recordInstanceCache = new InstanceCache$1(instance);
 			instance.recordInstanceCache.mark();
 			this.getRecordsSlice(start, end).forEach((r, i) => {
 				if (r == null) {
@@ -17305,7 +20084,7 @@ class GridComponent extends VDOM.Component {
 			newState.cursor = index;
 			newState.cellEdit = false;
 		}
-		batchUpdates(() => {
+		batchUpdates$1(() => {
 			if (select) {
 				let start =
 					selectRange && this.state.selectionStart != null && this.state.selectionStart >= 0
@@ -17651,7 +20430,7 @@ class GridComponent extends VDOM.Component {
 		if (selected.length == 0) add(record, record.data, record.index, true);
 		let renderRow = this.createRowRenderer(false);
 		let contents = selected.map((record, i) => ({
-			type: StaticText,
+			type: StaticText$1,
 			text: renderRow(record, i, true, false),
 		}));
 		initiateDragDrop(
@@ -17739,14 +20518,14 @@ class GridComponent extends VDOM.Component {
 		}
 	}
 }
-class GridColumnHeaderLine extends PureContainerBase {
+class GridColumnHeaderLine extends PureContainerBase$1 {
 	declareData() {
 		return super.declareData(...arguments, {
 			showHeader: undefined,
 		});
 	}
 	init() {
-		this.items = Widget.create(GridColumnHeader, this.columns || []);
+		this.items = Widget$1.create(GridColumnHeader, this.columns || []);
 		this.visible = this.showHeader;
 		this.style = this.headerStyle;
 		this.className = this.headerClass;
@@ -17770,7 +20549,7 @@ GridColumnHeaderLine.prototype.isPureContainer = false;
 GridColumnHeaderLine.prototype.styled = true;
 GridColumnHeaderLine.prototype.showHeader = true;
 GridColumnHeaderLine.autoInit = true;
-class GridColumnHeader extends Widget {
+class GridColumnHeader extends Widget$1 {
 	declareData() {
 		return super.declareData(...arguments, {
 			format: undefined,
@@ -17827,7 +20606,7 @@ class GridColumnHeader extends Widget {
 			let children = this.caption.children || this.caption.items;
 			if (children) {
 				delete this.caption.items;
-				this.caption.children = Widget.create(children);
+				this.caption.children = Widget$1.create(children);
 			} else {
 				this.caption.value = getSelector(this.caption.value);
 				this.caption.format = getSelector(this.caption.format);
@@ -17849,7 +20628,7 @@ class GridColumnHeader extends Widget {
 	}
 }
 GridColumnHeader.autoInit = true;
-class GridColumnHeaderCell extends PureContainerBase {
+class GridColumnHeaderCell extends PureContainerBase$1 {
 	declareData() {
 		return super.declareData(...arguments, {
 			text: undefined,
@@ -17864,7 +20643,7 @@ class GridColumnHeaderCell extends PureContainerBase {
 	}
 	initComponents() {
 		return super.initComponents(...arguments, {
-			tool: this.tool && Widget.create(this.tool),
+			tool: this.tool && Widget$1.create(this.tool),
 		});
 	}
 	render(context, instance, key) {
@@ -18007,7 +20786,7 @@ function getDragDropEvent(ev, store, type) {
 	};
 }
 
-class TreeNode extends ContainerBase {
+class TreeNode extends ContainerBase$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -18109,9 +20888,9 @@ TreeNode.prototype.openFolderIcon = "folder-open";
 TreeNode.prototype.arrowIcon = "drop-down";
 TreeNode.prototype.styled = true;
 TreeNode.prototype.hideIcon = false;
-Widget.alias("treenode", TreeNode);
+Widget$1.alias("treenode", TreeNode);
 
-class Pagination extends Widget {
+class Pagination extends Widget$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -18202,9 +20981,9 @@ class Pagination extends Widget {
 Pagination.prototype.baseClass = "pagination";
 Pagination.prototype.length = 5;
 Pagination.prototype.styled = true;
-Widget.alias("pagination", Pagination);
+Widget$1.alias("pagination", Pagination);
 
-class DragSource extends StyledContainerBase {
+class DragSource extends StyledContainerBase$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -18255,8 +21034,8 @@ class DragSource extends StyledContainerBase {
 DragSource.prototype.baseClass = "dragsource";
 DragSource.prototype.hideOnDrag = false;
 DragSource.prototype.handled = false;
-Widget.alias("dragsource", DragSource);
-class DragSourceComponent extends VDOM.Component {
+Widget$1.alias("dragsource", DragSource);
+class DragSourceComponent extends VDOM$2.Component {
 	constructor(props) {
 		super(props);
 		this.state = {
@@ -18359,7 +21138,7 @@ class DragSourceComponent extends VDOM.Component {
 	}
 }
 
-class DragHandle extends StyledContainerBase {
+class DragHandle extends StyledContainerBase$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -18388,9 +21167,9 @@ class DragHandle extends StyledContainerBase {
 }
 DragHandle.prototype.styled = true;
 DragHandle.prototype.baseClass = "draghandle";
-Widget.alias("draghandle", DragHandle);
+Widget$1.alias("draghandle", DragHandle);
 
-class DropZone extends StyledContainerBase {
+class DropZone extends StyledContainerBase$1 {
 	constructor(config) {
 		super(config);
 	}
@@ -18444,8 +21223,8 @@ DropZone.prototype.nearDistance = 0;
 DropZone.prototype.hinflate = 0;
 DropZone.prototype.vinflate = 0;
 DropZone.prototype.baseClass = "dropzone";
-Widget.alias("dropzone", DropZone);
-class DropZoneComponent extends VDOM.Component {
+Widget$1.alias("dropzone", DropZone);
+class DropZoneComponent extends VDOM$2.Component {
 	el = null;
 	unregister;
 	constructor(props) {
@@ -18599,11 +21378,17 @@ export {
 	ColorField,
 	ColorFieldInstance,
 	ColorPicker,
+	Content,
+	ContentPlaceholder,
+	ContentPlaceholderScope,
+	ContentResolver,
 	ContextMenu,
 	CxCredit,
+	DataProxy,
 	DateField,
 	DateTimeField,
 	DateTimePicker,
+	DetachedScope,
 	DocumentTitle,
 	DragDropContext,
 	DragHandle,
@@ -18633,8 +21418,12 @@ export {
 	HtmlElement,
 	HtmlElementInstance,
 	Icon,
+	IsolatedScope,
 	Label,
 	LabeledContainer,
+	LabelsLeftLayout,
+	LabelsTopLayout,
+	LabelsTopLayoutCell,
 	Link,
 	LinkButton,
 	List,
@@ -18658,11 +21447,16 @@ export {
 	OverlayComponent,
 	OverlayInstance,
 	Pagination,
+	PrivateStore,
 	ProgressBar,
+	PureContainer,
 	Radio,
 	ReactElementWrapper,
 	RedirectRoute,
+	Repeater,
+	Rescope,
 	Resizer,
+	Restate,
 	Route,
 	RouteBase,
 	Sandbox,
@@ -18670,9 +21464,11 @@ export {
 	Section,
 	Select,
 	Slider,
+	StaticText,
 	Submenu,
 	Switch,
 	Tab,
+	Text,
 	TextArea,
 	TextField,
 	TimeField,
@@ -18689,6 +21485,7 @@ export {
 	WHEEL_BUFFER_COPIES,
 	Wheel,
 	WheelComponent,
+	Widget,
 	Window,
 	WindowInstance,
 	autoFocus,