cx 25.11.1 → 26.0.1

package/dist/data.js

@@ -1,6 +1,8 @@
 import {
 	isString,
 	isObject,
+	hasStringAtKey,
+	hasValueAtKey,
 	isFunction,
 	Format,
 	isValidIdentifierName,
@@ -9,18 +11,17 @@ import {
 	isArray,
 	isDefined,
 	SubscriberList,
+	hasKey,
+	hasFunctionAtKey,
 	isUndefined,
 	expandFatArrows,
 } from "cx/util";
 
-var emptyFn = function emptyFn() {};
-function createAccessorModelProxy(chain) {
-	if (chain === void 0) {
-		chain = "";
-	}
-	var lastOp = null;
-	var proxy = new Proxy(emptyFn, {
-		get: function get(_, name) {
+const emptyFn = () => {};
+function createAccessorModelProxy(chain = "") {
+	let lastOp = null;
+	const proxy = new Proxy(emptyFn, {
+		get: (_, name) => {
 			if (typeof name !== "string") return proxy;
 			switch (name) {
 				case "isAccessorChain":
@@ -31,15 +32,15 @@ function createAccessorModelProxy(chain) {
 					lastOp = name;
 					return proxy;
 			}
-			var newChain = chain;
+			let newChain = chain;
 			if (newChain.length > 0) newChain += ".";
 			newChain += name;
 			return createAccessorModelProxy(newChain);
 		},
-		apply: function apply() {
+		apply() {
 			switch (lastOp) {
 				case "nameOf":
-					var lastDotIndex = chain.lastIndexOf(".");
+					const lastDotIndex = chain.lastIndexOf(".");
 					return lastDotIndex > 0 ? chain.substring(lastDotIndex + 1) : chain;
 				default:
 					return chain;
@@ -52,36 +53,38 @@ function isAccessorChain(value) {
 	return value != null && !!value.isAccessorChain;
 }
 
-var bindingCache = {};
-var Binding = /*#__PURE__*/ (function () {
-	function Binding(path) {
+let bindingCache = {};
+class Binding {
+	path;
+	parts;
+	value;
+	constructor(path) {
 		this.path = path;
 		this.parts = path.split(".");
-		var body = "return x";
-		for (var i = 0; i < this.parts.length; i++) body += '?.["' + this.parts[i] + '"]';
+		let body = "return x";
+		for (let i = 0; i < this.parts.length; i++) body += '?.["' + this.parts[i] + '"]';
 		this.value = new Function("x", body);
 	}
-	var _proto = Binding.prototype;
-	_proto.set = function set(state, value) {
-		var cv = this.value(state);
+	set(state, value) {
+		const cv = this.value(state);
 		if (cv === value) return state;
-		var ns = Object.assign({}, state);
-		var o = ns;
-		for (var i = 0; i < this.parts.length; i++) {
-			var part = this.parts[i];
-			var no = i == this.parts.length - 1 ? value : Object.assign({}, o[part]);
+		const ns = Object.assign({}, state);
+		let o = ns;
+		for (let i = 0; i < this.parts.length; i++) {
+			const part = this.parts[i];
+			const no = i === this.parts.length - 1 ? value : Object.assign({}, o[part]);
 			o[part] = no;
 			o = no;
 		}
 		return ns;
-	};
-	_proto["delete"] = function _delete(state) {
-		var ns = Object.assign({}, state);
-		var o = ns;
-		var part;
-		for (var i = 0; i < this.parts.length - 1; i++) {
+	}
+	delete(state) {
+		const ns = Object.assign({}, state);
+		let o = ns;
+		let part;
+		for (let i = 0; i < this.parts.length - 1; i++) {
 			part = this.parts[i];
-			var no = Object.assign({}, o[part]);
+			const no = Object.assign({}, o[part]);
 			o[part] = no;
 			o = no;
 		}
@@ -89,119 +92,72 @@ var Binding = /*#__PURE__*/ (function () {
 		if (!o.hasOwnProperty(part)) return state;
 		delete o[part];
 		return ns;
-	};
-	Binding.get = function get(path) {
+	}
+	static get(path) {
 		if (isString(path)) {
-			var b = bindingCache[path];
+			let b = bindingCache[path];
 			if (b) return b;
 			b = new Binding(path);
 			bindingCache[path] = b;
 			return b;
 		}
-		if (isObject(path) && isString(path.bind)) return this.get(path.bind);
+		if (isBindingObject(path)) return this.get(path.bind);
 		if (path instanceof Binding) return path;
 		if (isAccessorChain(path)) return this.get(path.toString());
 		throw new Error("Invalid binding definition provided.");
-	};
-	return Binding;
-})();
+	}
+}
 function isBinding(value) {
-	if (isObject(value) && isString(value.bind)) return true;
-	if (value && value.isAccessorChain) return true;
+	if (isObject(value)) {
+		if (hasStringAtKey(value, "bind")) return true;
+		if (hasValueAtKey(value, "isAccessorChain", true)) return true;
+	}
 	return value instanceof Binding;
 }
-
-function _construct(t, e, r) {
-	if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
-	var o = [null];
-	o.push.apply(o, e);
-	var p = new (t.bind.apply(t, o))();
-	return p;
-}
-function _extends() {
-	return (
-		(_extends = Object.assign
-			? Object.assign.bind()
-			: function (n) {
-					for (var e = 1; e < arguments.length; e++) {
-						var t = arguments[e];
-						for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
-					}
-					return n;
-				}),
-		_extends.apply(null, arguments)
-	);
-}
-function _inheritsLoose(t, o) {
-	(t.prototype = Object.create(o.prototype)), (t.prototype.constructor = t), _setPrototypeOf(t, o);
-}
-function _isNativeReflectConstruct() {
-	try {
-		var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-	} catch (t) {}
-	return (_isNativeReflectConstruct = function () {
-		return !!t;
-	})();
-}
-function _setPrototypeOf(t, e) {
-	return (
-		(_setPrototypeOf = Object.setPrototypeOf
-			? Object.setPrototypeOf.bind()
-			: function (t, e) {
-					return (t.__proto__ = e), t;
-				}),
-		_setPrototypeOf(t, e)
-	);
+function isBindingObject(value) {
+	return isObject(value) && hasStringAtKey(value, "bind");
 }
 
-function computable() {
-	var _ref;
-	if (arguments.length == 0)
+function computable(...selectorsAndCompute) {
+	if (selectorsAndCompute.length == 0)
 		throw new Error("computable requires at least a compute function to be passed in arguments.");
-	var compute = ((_ref = arguments.length - 1), _ref < 0 || arguments.length <= _ref ? undefined : arguments[_ref]);
+	let compute = selectorsAndCompute[selectorsAndCompute.length - 1];
 	if (typeof compute != "function") throw new Error("Last argument to the computable function should be a function.");
-	var inputs = [],
+	let inputs = [],
 		a;
-	for (var i = 0; i + 1 < arguments.length; i++) {
-		a = i < 0 || arguments.length <= i ? undefined : arguments[i];
+	for (let i = 0; i + 1 < selectorsAndCompute.length; i++) {
+		a = selectorsAndCompute[i];
 		if (isString(a) || isAccessorChain(a)) inputs.push(Binding.get(a.toString()).value);
 		else if (a.memoize) inputs.push(a.memoize());
 		else if (isFunction(a)) inputs.push(a);
-		else throw new Error("Invalid selector type '" + typeof a + "' received.");
+		else throw new Error(`Invalid selector type '${typeof a}' received.`);
 	}
 	function memoize(warmupData) {
-		var lastValue,
-			lastArgs =
-				warmupData &&
-				inputs.map(function (s) {
-					return s(warmupData);
-				});
+		let lastValue,
+			lastArgs = warmupData && inputs.map((s) => s(warmupData));
 		return function (data) {
-			var dirty = false;
+			let dirty = false;
 			if (!lastArgs) {
 				lastArgs = Array.from({
 					length: inputs.length,
 				});
 				dirty = true;
 			}
-			for (var _i = 0; _i < inputs.length; _i++) {
-				var v = inputs[_i](data);
-				if (v === lastArgs[_i]) continue;
-				lastArgs[_i] = v;
+			for (let i = 0; i < inputs.length; i++) {
+				let v = inputs[i](data);
+				if (v === lastArgs[i]) continue;
+				lastArgs[i] = v;
 				dirty = true;
 			}
 			if (dirty) lastValue = compute.apply(null, lastArgs);
 			return lastValue;
 		};
 	}
-	var selector = function selector(data) {
-		return compute.apply(
+	let selector = (data) =>
+		compute.apply(
 			null,
-			inputs.map(function (s) {
-				return s(data);
-			}),
+			inputs.map((s) => s(data)),
 		);
-	};
 	selector.memoize = memoize;
 	return selector;
 }
@@ -212,56 +168,53 @@ function computable() {
    Expression.registerHelper('_', _);
    let e = Expression.compile('_.min({data})');
  */
-
-var helpers = {},
+let helpers = {},
 	helperNames = [],
 	helperValues = [],
 	expFatArrows = null;
 function getExpr(expr) {
 	if (expr.memoize) return expr;
 	function memoize() {
-		var lastValue,
+		let lastValue,
 			lastRunBindings = {},
 			lastRunResults = {},
 			getters = {},
 			currentData,
 			len = -1;
-		var get = function get(bindingWithFormat) {
-			var getter = getters[bindingWithFormat];
+		let get = function (bindingWithFormat) {
+			let getter = getters[bindingWithFormat];
 			if (!getter) {
-				var binding = bindingWithFormat,
+				let binding = bindingWithFormat,
 					format;
-				var colonIndex = bindingWithFormat.indexOf(":");
+				let colonIndex = bindingWithFormat.indexOf(":");
 				if (colonIndex != -1) {
 					format = Format.parse(bindingWithFormat.substring(colonIndex + 1));
 					binding = bindingWithFormat.substring(0, colonIndex);
 				} else {
-					var nullSeparatorIndex = bindingWithFormat.indexOf(":");
+					let nullSeparatorIndex = bindingWithFormat.indexOf(":");
 					if (nullSeparatorIndex != -1) {
 						format = Format.parse(bindingWithFormat.substring(nullSeparatorIndex));
 						binding = bindingWithFormat.substring(0, nullSeparatorIndex - 1);
 					}
 				}
-				var b = Binding.get(binding);
-				getter = function getter(data) {
-					var value = b.value(data);
+				let b = Binding.get(binding);
+				getter = (data) => {
+					let value = b.value(data);
 					lastRunBindings[len] = b.value;
 					lastRunResults[len] = value;
 					len++;
 					return value;
 				};
 				if (format) {
-					var valueGetter = getter;
-					getter = function getter(data) {
-						return format(valueGetter(data));
-					};
+					let valueGetter = getter;
+					getter = (data) => format(valueGetter(data));
 				}
 				getters[bindingWithFormat] = getter;
 			}
 			return getter(currentData);
 		};
 		return function (data) {
-			var i = 0;
+			let i = 0;
 			for (; i < len; i++) if (lastRunBindings[i](data) !== lastRunResults[i]) break;
 			if (i !== len) {
 				len = 0;
@@ -271,26 +224,26 @@ function getExpr(expr) {
 			return lastValue;
 		};
 	}
-	var result = memoize();
+	let result = memoize();
 	result.memoize = memoize;
 	return result;
 }
 function expression(str) {
 	if (isFunction(str)) return getExpr(str);
-	var cache = getExpressionCache();
-	var r = cache[str];
+	let cache = getExpressionCache();
+	let r = cache[str];
 	if (r) return r;
-	var quote = false;
-	var termStart = -1,
+	let quote = false;
+	let termStart = -1,
 		curlyBrackets = 0,
 		percentExpression;
-	var fb = ["return ("];
-	var args = {};
-	var formats = [];
-	var subExprCount = 0;
-	var invalidNameCount = 0;
-	for (var i = 0; i < str.length; i++) {
-		var c = str[i];
+	let fb = ["return ("];
+	let args = {};
+	let formats = [];
+	let subExprCount = 0;
+	let invalidNameCount = 0;
+	for (let i = 0; i < str.length; i++) {
+		let c = str[i];
 		switch (c) {
 			case "{":
 				if (curlyBrackets > 0 && !quote) curlyBrackets++;
@@ -305,27 +258,27 @@ function expression(str) {
 				if (termStart >= 0) {
 					if (quote) continue;
 					if (--curlyBrackets == 0) {
-						var term = str.substring(termStart, i);
-						var formatStart = 0;
+						let term = str.substring(termStart, i);
+						let formatStart = 0;
 						if (term[0] == "[") formatStart = term.indexOf("]");
-						var colon = term.indexOf(":", formatStart > 0 ? formatStart : 0);
-						var binding = colon == -1 ? term : term.substring(0, colon);
-						var format = colon == -1 ? null : term.substring(colon + 1);
+						let colon = term.indexOf(":", formatStart > 0 ? formatStart : 0);
+						let binding = colon == -1 ? term : term.substring(0, colon);
+						let format = colon == -1 ? null : term.substring(colon + 1);
 						if (colon == -1) {
-							var nullSepIndex = binding.indexOf("|", formatStart);
+							let nullSepIndex = binding.indexOf("|", formatStart);
 							if (nullSepIndex != -1) {
 								format = binding.substring(nullSepIndex);
 								binding = binding.substring(0, nullSepIndex);
 							}
 						}
-						var argName = binding.replace(/\./g, "_");
+						let argName = binding.replace(/\./g, "_");
 						if (!isValidIdentifierName(argName)) argName = "inv" + ++invalidNameCount;
 						if (percentExpression || (binding[0] == "[" && binding[binding.length - 1] == "]")) {
-							argName = "expr" + ++subExprCount;
+							argName = `expr${++subExprCount}`;
 							args[argName] = expression(percentExpression ? binding : binding.substring(1, binding.length - 1));
 						} else args[argName] = binding;
 						if (format) {
-							var formatter = "fmt" + formats.length;
+							let formatter = "fmt" + formats.length;
 							fb.push(formatter, "(", argName, ", ", quoteStr(format), ")");
 							formats.push(Format.parse(format));
 						} else fb.push(argName);
@@ -337,8 +290,8 @@ function expression(str) {
 			case "'":
 				if (!quote) quote = c;
 				else if (quote == c) {
-					var at = i - 1;
-					var slashCount = 0;
+					let at = i - 1;
+					let slashCount = 0;
 					while (at >= 0 && str[at] === "\\") {
 						slashCount++;
 						at--;
@@ -353,51 +306,35 @@ function expression(str) {
 		}
 	}
 	fb.push(")");
-	var body = fb.join("");
+	let body = fb.join("");
 	if (expFatArrows) body = expFatArrows(body);
-
 	//console.log(body);
-	var keys = Object.keys(args);
+	let keys = Object.keys(args);
 	try {
-		var _Function;
-		var compute = (_Function = _construct(
-			Function,
-			["fmt"].concat(
-				formats.map(function (f, i) {
-					return "fmt" + i;
-				}),
-				helperNames,
-				keys,
-				[body],
-			),
-		)).bind.apply(_Function, [Format, Format.value].concat(formats, helperValues));
-		var selector = computable.apply(
-			void 0,
-			keys
-				.map(function (k) {
-					return args[k];
-				})
-				.concat([compute]),
+		let compute = new Function("fmt", ...formats.map((f, i) => "fmt" + i), ...helperNames, ...keys, body).bind(
+			Format,
+			Format.value,
+			...formats,
+			...helperValues,
 		);
+		let selector = computable(...keys.map((k) => args[k]), compute);
 		cache[str] = selector;
 		return selector;
 	} catch (err) {
-		throw new Error("Failed to parse expression: '" + str + "'. Error: " + err.message);
+		throw new Error(`Failed to parse expression: '${str}'. ${err}`);
 	}
 }
-var Expression = {
-	get: function get(str) {
+const Expression = {
+	get: function (str) {
 		return expression(str);
 	},
-	compile: function compile(str) {
+	compile: function (str) {
 		return this.get(str).memoize();
 	},
-	registerHelper: function registerHelper(name, helper) {
+	registerHelper: function (name, helper) {
 		helpers[name] = helper;
 		helperNames = Object.keys(helpers);
-		helperValues = helperNames.map(function (n) {
-			return helpers[n];
-		});
+		helperValues = helperNames.map((n) => helpers[n]);
 	},
 };
 function plugFatArrowExpansion(impl) {
@@ -406,10 +343,8 @@ function plugFatArrowExpansion(impl) {
 function invalidateExpressionCache() {
 	expCache = {};
 }
-var expCache = {};
-var getExpressionCache = function getExpressionCache() {
-	return expCache;
-};
+let expCache = {};
+let getExpressionCache = () => expCache;
 function setGetExpressionCacheCallback(callback) {
 	getExpressionCache = callback;
 }
@@ -418,16 +353,16 @@ function plus(str) {
 	return str.length ? str + " + " : str;
 }
 function stringTemplate(str) {
-	var tplCache = getTplCache();
-	var expr = tplCache[str];
-	if (expr) return expr;
-	expr = "";
-	var termStart = -1,
+	let tplCache = getTplCache();
+	let cached = tplCache[str];
+	if (cached) return cached;
+	let expr = "";
+	let termStart = -1,
 		quoteStart = 0,
 		term,
 		bracketsOpen = 0,
-		percentSign;
-	for (var i = 0; i < str.length; i++) {
+		percentSign = false;
+	for (let i = 0; i < str.length; i++) {
 		switch (str[i]) {
 			case "{":
 				if (termStart < 0) {
@@ -449,7 +384,7 @@ function stringTemplate(str) {
 					if (--bracketsOpen == 0) {
 						term = str.substring(termStart, i);
 						if (term.indexOf(":") == -1) {
-							var nullSepIndex = term.indexOf("|");
+							let nullSepIndex = term.indexOf("|");
 							if (nullSepIndex == -1) term += ":s";
 							else term = term.substring(0, nullSepIndex) + ":s" + term.substring(nullSepIndex);
 						}
@@ -469,24 +404,19 @@ function stringTemplate(str) {
 	if (quoteStart < str.length || expr.length == 0) expr = plus(expr) + quoteStr(str.substring(quoteStart));
 	return (tplCache[str] = expression(expr));
 }
-var StringTemplate = {
-	get: function get(str) {
+const StringTemplate = {
+	get: function (str) {
 		return stringTemplate(str);
 	},
-	compile: function compile(str) {
+	compile: function (str) {
 		return stringTemplate(str).memoize();
 	},
-	format: function format(_format) {
-		for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-			args[_key - 1] = arguments[_key];
-		}
-		return stringTemplate(_format)(args);
+	format: function (format, ...args) {
+		return stringTemplate(format)(args);
 	},
 };
-var tplCache = {};
-var getTplCache = function getTplCache() {
-	return tplCache;
-};
+let tplCache = {};
+let getTplCache = () => tplCache;
 function invalidateStringTemplateCache() {
 	tplCache = {};
 }
@@ -494,301 +424,278 @@ function setGetStringTemplateCacheCallback(callback) {
 	getTplCache = callback;
 }
 
-var Ref = /*#__PURE__*/ (function (_Component) {
-	function Ref(config) {
-		var _this;
-		_this = _Component.call(this, config) || this;
-		_this.get = _this.get.bind(_this);
-		if (_this.set) _this.set = _this.set.bind(_this);
-		return _this;
-	}
-	_inheritsLoose(Ref, _Component);
-	var _proto = Ref.prototype;
-	_proto.get = function get() {
+class Ref extends Component {
+	constructor(config) {
+		super(config);
+		this.get = this.get.bind(this);
+		if (this.set) this.set = this.set.bind(this);
+	}
+	get() {
 		throw new Error("Ref's get method is not implemented.");
-	};
-	_proto.init = function init(value) {
-		if (this.get() === undefined) this.set(value);
-	};
-	_proto.toggle = function toggle() {
-		this.set(!this.get());
-	};
-	_proto.update = function update(cb) {
-		for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-			args[_key - 1] = arguments[_key];
-		}
-		this.set(cb.apply(void 0, [this.get()].concat(args)));
-	};
-	_proto.as = function as(config) {
+	}
+	set(value) {
+		throw new Error("Ref's set method is not implemented.");
+	}
+	delete() {
+		throw new Error("Ref's delete method is not implemented.");
+	}
+	init(value) {
+		if (value === undefined) return; // Component.init() compatibility
+		if (this.get() === undefined) return this.set(value);
+		return false;
+	}
+	toggle() {
+		return this.set(!this.get());
+	}
+	update(cb, ...args) {
+		return this.set(cb(this.get(), ...args));
+	}
+	as(config) {
 		return Ref.create(config, {
 			get: this.get,
 			set: this.set,
 		});
-	};
-	_proto.ref = function ref(path) {
-		var _this2 = this;
-		var binding = Binding.get(path);
+	}
+	ref(path) {
+		let binding = Binding.get(path);
 		return Ref.create({
-			get: function get() {
-				return binding.value(_this2.get());
-			},
-			set: function set(value) {
-				var data = _this2.get();
-				var newData = binding.set(data, value);
+			get: () => binding.value(this.get()),
+			set: (value) => {
+				let data = this.get();
+				let newData = binding.set(data, value);
 				if (data === newData) return false;
-				return _this2.set(newData);
+				return this.set(newData);
 			},
 		});
-	};
-
+	}
 	//allows the function to be passed as a selector, e.g. to computable or addTrigger
-	_proto.memoize = function memoize() {
+	memoize() {
 		return this.get;
-	};
-	return Ref;
-})(Component);
+	}
+}
 Ref.prototype.isRef = true;
 Ref.factory = function (alias, config, more) {
 	if (isFunction(alias)) {
-		var cfg = _extends({}, config, more);
+		let cfg = {
+			...config,
+			...more,
+		};
 		if (cfg.store) Object.assign(cfg, cfg.store.getMethods());
-		var result = alias(cfg);
+		let result = alias(cfg);
 		if (result instanceof Ref) return result;
-		return this.create(_extends({}, config, more, result));
+		return this.create({
+			...config,
+			...more,
+			...result,
+		});
 	}
-	return this.create(_extends({}, config, more));
+	return this.create({
+		...config,
+		...more,
+	});
 };
 
-var StoreRef = /*#__PURE__*/ (function (_Ref) {
-	function StoreRef(config) {
-		var _this;
-		_this = _Ref.call(this, config) || this;
-		if (isAccessorChain(_this.path)) _this.path = _this.path.toString();
-		return _this;
-	}
-	_inheritsLoose(StoreRef, _Ref);
-	var _proto = StoreRef.prototype;
-	_proto.get = function get() {
+class StoreRef extends Ref {
+	constructor(config) {
+		super(config);
+		if (isAccessorChain(this.path)) this.path = this.path.toString();
+	}
+	get() {
 		return this.store.get(this.path);
-	};
-	_proto.set = function set(value) {
+	}
+	set(value) {
 		return this.store.set(this.path, value);
-	};
-	_proto.init = function init(value) {
+	}
+	init(value) {
+		if (value === undefined) return;
 		return this.store.init(this.path, value);
-	};
-	_proto.toggle = function toggle() {
+	}
+	toggle() {
 		return this.store.toggle(this.path);
-	};
-	_proto["delete"] = function _delete() {
-		return this.store["delete"](this.path);
-	};
-	_proto.update = function update() {
-		var _this$store;
-		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-			args[_key] = arguments[_key];
-		}
-		return (_this$store = this.store).update.apply(_this$store, [this.path].concat(args));
-	};
-
+	}
+	delete() {
+		return this.store.delete(this.path);
+	}
+	update(cb, ...args) {
+		return this.store.update(this.path, cb, ...args);
+	}
 	//allows the function to be passed as a selector, e.g. to computable or addTrigger
-	_proto.memoize = function memoize() {
+	memoize() {
 		return this.get;
-	};
-	_proto.ref = function ref(path) {
+	}
+	ref(path) {
 		return new StoreRef({
-			path: this.path + "." + path,
+			path: `${this.path}.${path}`,
 			store: this.store,
 		});
-	};
-	_proto.as = function as(config) {
+	}
+	as(config) {
 		return StoreRef.create(config, {
 			path: this.path,
 			store: this.store,
 			get: this.get,
 			set: this.set,
 		});
-	};
-	return StoreRef;
-})(Ref);
+	}
+}
 
-var View = /*#__PURE__*/ (function () {
-	function View(config) {
+class View {
+	cache;
+	notificationsSuspended = 0;
+	dirty = false;
+	constructor(config) {
 		Object.assign(this, config);
 		this.cache = {
 			version: -1,
 		};
 		if (this.store) this.setStore(this.store);
 	}
-	var _proto = View.prototype;
-	_proto.getData = function getData() {
+	getData() {
 		throw new Error("abstract method");
-	};
-	_proto.init = function init(path, value) {
+	}
+	init(path, value) {
 		if (typeof path == "object" && path != null) {
-			var changed = false;
-			for (var key in path)
+			let changed = false;
+			for (let key in path)
 				if (path.hasOwnProperty(key) && this.get(key) === undefined && this.setItem(key, path[key])) changed = true;
 			return changed;
 		}
-		var binding = Binding.get(path);
+		let binding = Binding.get(path);
 		if (this.get(binding.path) === undefined) return this.setItem(binding.path, value);
 		return false;
-	};
-	_proto.set = function set(path, value) {
-		if (isObject(path)) {
-			var changed = false;
-			for (var key in path) if (path.hasOwnProperty(key) && this.setItem(key, path[key])) changed = true;
+	}
+	set(path, value) {
+		if (typeof path == "object" && path != null) {
+			let changed = false;
+			for (let key in path) if (path.hasOwnProperty(key) && this.setItem(key, path[key])) changed = true;
 			return changed;
 		}
-		var binding = Binding.get(path);
+		let binding = Binding.get(path);
 		return this.setItem(binding.path, value);
-	};
-	_proto.copy = function copy(from, to) {
-		var value = this.get(from);
-		this.set(to, value);
-	};
-	_proto.move = function move(from, to) {
-		var _this = this;
-		this.batch(function () {
-			_this.copy(from, to);
-			_this["delete"](from);
+	}
+	copy(from, to) {
+		let value = this.get(from);
+		return this.set(to, value);
+	}
+	move(from, to) {
+		return this.batch(() => {
+			this.copy(from, to);
+			this.delete(from);
 		});
-	};
-
+	}
 	//protected
-	_proto.setItem = function setItem(path, value) {
+	setItem(path, value) {
 		if (this.store) return this.store.setItem(path, value);
 		throw new Error("abstract method");
-	};
-	_proto["delete"] = function _delete(path) {
-		var _this2 = this;
+	}
+	delete(path) {
 		if (arguments.length > 1) path = Array.from(arguments);
-		if (isArray(path))
-			return path
-				.map(function (arg) {
-					return _this2["delete"](arg);
-				})
-				.some(Boolean);
-		var binding = Binding.get(path);
+		if (isArray(path)) return path.map((arg) => this.delete(arg)).some(Boolean);
+		let binding = Binding.get(path);
 		return this.deleteItem(binding.path);
-	};
-
+	}
 	//protected
-	_proto.deleteItem = function deleteItem(path) {
+	deleteItem(path) {
 		if (this.store) return this.store.deleteItem(path);
 		throw new Error("abstract method");
-	};
-	_proto.clear = function clear() {
+	}
+	clear() {
 		if (this.store) return this.store.clear();
 		throw new Error("abstract method");
-	};
-	_proto.get = function get(path) {
-		var storeData = this.getData();
+	}
+	get(path, ...args) {
+		let storeData = this.getData();
 		if (arguments.length > 1) path = Array.from(arguments);
-		if (isArray(path))
-			return path.map(function (arg) {
-				return Binding.get(arg).value(storeData);
-			});
+		if (isArray(path)) return path.map((arg) => Binding.get(arg).value(storeData));
 		return Binding.get(path).value(storeData);
-	};
-	_proto.toggle = function toggle(path) {
+	}
+	toggle(path) {
 		return this.set(path, !this.get(path));
-	};
-	_proto.update = function update(path, updateFn) {
-		for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-			args[_key - 2] = arguments[_key];
-		}
+	}
+	update(path, updateFn, ...args) {
 		if (arguments.length == 1 && isFunction(path))
-			return this.load(path.apply(null, [this.getData(), updateFn].concat(args)));
-		return this.set(path, updateFn.apply(null, [this.get(path)].concat(args)));
-	};
-	_proto.batch = function batch(callback) {
-		var dirty = this.silently(callback);
+			return this.load(path.apply(null, [this.getData(), updateFn, ...args]));
+		return this.set(path, updateFn.apply(null, [this.get(path), ...args]));
+	}
+	mutate(path, updateFn, ...args) {
+		throw new Error(
+			"Mutate requires Immer. Please install 'immer' and 'cx-immer' packages and enable store mutation by calling enableImmerMutate().",
+		);
+	}
+	batch(callback) {
+		let dirty = this.silently(callback);
 		if (dirty) this.notify();
 		return dirty;
-	};
-	_proto.silently = function silently(callback) {
+	}
+	silently(callback) {
 		if (this.store) return this.store.silently(callback);
 		throw new Error("abstract method");
-	};
-	_proto.notify = function notify(path) {
+	}
+	notify(path) {
 		if (this.notificationsSuspended) this.dirty = true;
 		else this.doNotify(path);
-	};
-	_proto.doNotify = function doNotify(path) {
+	}
+	doNotify(path) {
 		if (this.store) return this.store.notify(path);
 		throw new Error("abstract method");
-	};
-	_proto.subscribe = function subscribe(callback) {
+	}
+	subscribe(callback) {
 		if (this.store) return this.store.subscribe(callback);
 		throw new Error("abstract method");
-	};
-	_proto.load = function load(data) {
-		return this.batch(function (store) {
-			for (var key in data) store.set(key, data[key]);
-		});
-	};
-	_proto.dispatch = function dispatch(action) {
+	}
+	load(data) {
+		return this.set(data);
+	}
+	dispatch(action) {
 		if (this.store) return this.store.dispatch(action);
 		throw new Error("The underlying store doesn't support dispatch.");
-	};
-	_proto.getMeta = function getMeta() {
+	}
+	getMeta() {
 		return this.meta;
-	};
-	_proto.setStore = function setStore(store) {
+	}
+	setStore(store) {
 		this.store = store;
 		this.meta = store.getMeta();
-	};
-	_proto.ref = function ref(path, defaultValue) {
+	}
+	ref(path, defaultValue) {
 		if (isDefined(defaultValue)) this.init(path, defaultValue);
 		return StoreRef.create({
 			store: this,
-			path: path,
+			path,
 		});
-	};
-	_proto.getMethods = function getMethods() {
+	}
+	getMethods() {
 		return {
 			getData: this.getData.bind(this),
 			set: this.set.bind(this),
 			get: this.get.bind(this),
 			update: this.update.bind(this),
-			delete: this["delete"].bind(this),
+			delete: this.delete.bind(this),
 			toggle: this.toggle.bind(this),
 			init: this.init.bind(this),
 			ref: this.ref.bind(this),
-			mutate: this.ref.bind(this),
+			mutate: this.mutate.bind(this),
 		};
-	};
-	return View;
-})();
+	}
+}
 View.prototype.sealed = false; //indicate that data should be copied before virtual items are added
 
-//Immer integration point
-View.prototype.mutate = function () {
-	throw new Error(
-		"Mutate requires Immer. Please install 'immer' and 'cx-immer' packages and enable store mutation by calling enableImmerMutate().",
-	);
-};
-
-var SubscribableView = /*#__PURE__*/ (function (_View) {
-	function SubscribableView(config) {
-		var _this;
-		_this = _View.call(this, config) || this;
-		_this.subscribers = new SubscriberList();
-		_this.changes = [];
-		return _this;
-	}
-	_inheritsLoose(SubscribableView, _View);
-	var _proto = SubscribableView.prototype;
-	_proto.subscribe = function subscribe(callback) {
+class SubscribableView extends View {
+	subscribers;
+	changes;
+	scheduled;
+	constructor(config) {
+		super(config);
+		this.subscribers = new SubscriberList();
+		this.changes = [];
+	}
+	subscribe(callback) {
 		return this.subscribers.subscribe(callback);
-	};
-	_proto.unsubscribeAll = function unsubscribeAll() {
+	}
+	unsubscribeAll() {
 		this.subscribers.clear();
-	};
-	_proto.doNotify = function doNotify(path) {
-		var _this2 = this;
+	}
+	doNotify(path) {
 		if (this.notificationsSuspended) return;
 		if (!this.async) {
 			this.subscribers.notify([path]);
@@ -796,18 +703,18 @@ var SubscribableView = /*#__PURE__*/ (function (_View) {
 			this.changes.push(path || "");
 			if (!this.scheduled) {
 				this.scheduled = true;
-				setTimeout(function () {
-					_this2.scheduled = false;
-					var changes = _this2.changes;
-					_this2.changes = [];
-					_this2.subscribers.notify(changes);
+				setTimeout(() => {
+					this.scheduled = false;
+					let changes = this.changes;
+					this.changes = [];
+					this.subscribers.notify(changes);
 				}, 0);
 			}
 		}
-	};
-	_proto.silently = function silently(callback) {
+	}
+	silently(callback) {
 		this.notificationsSuspended = (this.notificationsSuspended || 0) + 1;
-		var wasDirty = this.dirty,
+		let wasDirty = this.dirty,
 			dirty;
 		this.dirty = false;
 		try {
@@ -818,31 +725,24 @@ var SubscribableView = /*#__PURE__*/ (function (_View) {
 			this.dirty = wasDirty;
 		}
 		return dirty;
-	};
-	return SubscribableView;
-})(View);
+	}
+}
 SubscribableView.prototype.async = false;
 
-var Store = /*#__PURE__*/ (function (_SubscribableView) {
-	function Store(config) {
-		var _this;
-		if (config === void 0) {
-			config = {};
-		}
-		_this = _SubscribableView.call(this, config) || this;
-		_this.data = config.data || {};
-		_this.meta = {
+class Store extends SubscribableView {
+	data;
+	constructor(config = {}) {
+		super(config);
+		this.data = config.data ?? {};
+		this.meta = {
 			version: 0,
 		};
-		return _this;
 	}
-	_inheritsLoose(Store, _SubscribableView);
-	var _proto = Store.prototype;
-	_proto.getData = function getData() {
+	getData() {
 		return this.data;
-	};
-	_proto.setItem = function setItem(path, value) {
-		var next = Binding.get(path).set(this.data, value);
+	}
+	setItem(path, value) {
+		let next = Binding.get(path).set(this.data, value);
 		if (next != this.data) {
 			this.data = next;
 			this.meta.version++;
@@ -850,9 +750,9 @@ var Store = /*#__PURE__*/ (function (_SubscribableView) {
 			return true;
 		}
 		return false;
-	};
-	_proto.deleteItem = function deleteItem(path) {
-		var next = Binding.get(path)["delete"](this.data);
+	}
+	deleteItem(path) {
+		let next = Binding.get(path).delete(this.data);
 		if (next != this.data) {
 			this.data = next;
 			this.meta.version++;
@@ -860,23 +760,25 @@ var Store = /*#__PURE__*/ (function (_SubscribableView) {
 			return true;
 		}
 		return false;
-	};
-	_proto.clear = function clear() {
+	}
+	clear() {
 		this.data = {};
 		this.meta.version++;
 		this.notify();
-	};
-	return Store;
-})(SubscribableView);
+	}
+}
 Store.prototype.async = false;
 
-var ExposedRecordView = /*#__PURE__*/ (function (_View) {
-	function ExposedRecordView() {
-		return _View.apply(this, arguments) || this;
+class ExposedRecordView extends View {
+	itemIndex;
+	immutable;
+	collectionBinding;
+	recordName;
+	indexName;
+	constructor(config) {
+		super(config);
 	}
-	_inheritsLoose(ExposedRecordView, _View);
-	var _proto = ExposedRecordView.prototype;
-	_proto.getData = function getData() {
+	getData() {
 		if (
 			this.sealed &&
 			this.meta.version === this.cache.version &&
@@ -889,65 +791,63 @@ var ExposedRecordView = /*#__PURE__*/ (function (_View) {
 		this.cache.itemIndex = this.itemIndex;
 		this.meta = this.store.meta;
 		return this.cache.result;
-	};
-	_proto.embed = function embed(data) {
-		var collection = this.collectionBinding.value(data);
-		var record = collection[this.itemIndex];
-		var copy = this.sealed || this.immutable || this.store.sealed ? _extends({}, data) : data;
+	}
+	embed(data) {
+		const collection = this.collectionBinding.value(data);
+		const record = collection[this.itemIndex];
+		const copy =
+			this.sealed || this.immutable || this.store.sealed
+				? {
+						...data,
+					}
+				: data;
 		copy[this.recordName] = record;
 		if (this.indexName) copy[this.indexName] = this.itemIndex;
 		return copy;
-	};
-	_proto.setIndex = function setIndex(index) {
+	}
+	setIndex(index) {
 		this.itemIndex = index;
-	};
-	_proto.setItem = function setItem(path, value) {
+	}
+	setItem(path, value) {
 		if (path == this.recordName || path.indexOf(this.recordName + ".") == 0) {
-			var storeData = this.store.getData();
-			var collection = this.collectionBinding.value(storeData);
-			var data = this.embed(storeData);
-			var d = Binding.get(path).set(data, value);
+			const storeData = this.store.getData();
+			const collection = this.collectionBinding.value(storeData);
+			const data = this.embed(storeData);
+			const d = Binding.get(path).set(data, value);
 			if (d === data) return false;
-			var record = d[this.recordName];
-			var newCollection = [].concat(
-				collection.slice(0, this.itemIndex),
-				[record],
-				collection.slice(this.itemIndex + 1),
-			);
+			const record = d[this.recordName];
+			const newCollection = [...collection.slice(0, this.itemIndex), record, ...collection.slice(this.itemIndex + 1)];
 			return this.store.setItem(this.collectionBinding.path, newCollection);
 		}
 		return this.store.setItem(path, value);
-	};
-	_proto.deleteItem = function deleteItem(path) {
-		var storeData, collection, newCollection;
+	}
+	deleteItem(path) {
+		let storeData, collection, newCollection;
 		if (path == this.recordName) {
 			storeData = this.store.getData();
 			collection = this.collectionBinding.value(storeData);
-			newCollection = [].concat(collection.slice(0, this.itemIndex), collection.slice(this.itemIndex + 1));
+			newCollection = [...collection.slice(0, this.itemIndex), ...collection.slice(this.itemIndex + 1)];
 			return this.store.setItem(this.collectionBinding.path, newCollection);
 		} else if (path.indexOf(this.recordName + ".") == 0) {
 			storeData = this.store.getData();
 			collection = this.collectionBinding.value(storeData);
-			var data = this.embed(storeData);
-			var d = Binding.get(path)["delete"](data);
+			const data = this.embed(storeData);
+			const d = Binding.get(path).delete(data);
 			if (d === data) return false;
-			var record = d[this.recordName];
-			newCollection = [].concat(collection.slice(0, this.itemIndex), [record], collection.slice(this.itemIndex + 1));
+			const record = d[this.recordName];
+			newCollection = [...collection.slice(0, this.itemIndex), record, ...collection.slice(this.itemIndex + 1)];
 			return this.store.setItem(this.collectionBinding.path, newCollection);
 		}
 		return this.store.deleteItem(path);
-	};
-	return ExposedRecordView;
-})(View);
+	}
+}
 ExposedRecordView.prototype.immutable = false;
 
-var ExposedValueView = /*#__PURE__*/ (function (_View) {
-	function ExposedValueView() {
-		return _View.apply(this, arguments) || this;
+class ExposedValueView extends View {
+	constructor(config) {
+		super(config);
 	}
-	_inheritsLoose(ExposedValueView, _View);
-	var _proto = ExposedValueView.prototype;
-	_proto.getData = function getData() {
+	getData() {
 		if (
 			this.sealed &&
 			this.meta.version === this.cache.version &&
@@ -955,23 +855,28 @@ var ExposedValueView = /*#__PURE__*/ (function (_View) {
 			this.meta == this.store.meta
 		)
 			return this.cache.result;
-		var data = this.store.getData();
-		var container = this.containerBinding.value(data) || {};
-		var record = container[this.key];
+		let data = this.store.getData();
+		let container = this.containerBinding.value(data) || {};
+		let record = container[this.key];
 		this.cache.version = this.meta.version;
 		this.cache.key = this.key;
-		this.cache.result = this.sealed || this.immutable || this.store.sealed ? _extends({}, data) : data;
+		this.cache.result =
+			this.sealed || this.immutable || this.store.sealed
+				? {
+						...data,
+					}
+				: data;
 		this.cache.result[this.recordName] = record;
 		this.meta = this.store.meta;
 		return this.cache.result;
-	};
-	_proto.setKey = function setKey(key) {
+	}
+	setKey(key) {
 		this.key = key;
-	};
-	_proto.getKey = function getKey() {
+	}
+	getKey() {
 		return this.key;
-	};
-	_proto.setItem = function setItem(path, value) {
+	}
+	setItem(path, value) {
 		if (path == this.recordName || path.indexOf(this.recordName + ".") == 0) {
 			var data = this.getData();
 			var d = Binding.get(path).set(data, value);
@@ -983,8 +888,8 @@ var ExposedValueView = /*#__PURE__*/ (function (_View) {
 			return this.store.setItem(this.containerBinding.path, newContainer);
 		}
 		return this.store.setItem(path, value);
-	};
-	_proto.deleteItem = function deleteItem(path) {
+	}
+	deleteItem(path) {
 		var data, container, newContainer;
 		if (path == this.recordName) {
 			data = this.getData();
@@ -995,7 +900,7 @@ var ExposedValueView = /*#__PURE__*/ (function (_View) {
 			this.store.set(this.containerBinding.path, newContainer);
 		} else if (path.indexOf(this.recordName + ".") == 0) {
 			data = this.getData();
-			var d = Binding.get(path)["delete"](data);
+			var d = Binding.get(path).delete(data);
 			if (d === data) return false;
 			container = this.containerBinding.value(d);
 			var record = d[this.recordName];
@@ -1004,21 +909,18 @@ var ExposedValueView = /*#__PURE__*/ (function (_View) {
 			return this.store.setItem(this.containerBinding.path, newContainer);
 		}
 		return this.store.deleteItem(path);
-	};
-	return ExposedValueView;
-})(View);
+	}
+}
 ExposedValueView.prototype.immutable = false;
 
-var ReadOnlyDataView = /*#__PURE__*/ (function (_View) {
-	function ReadOnlyDataView() {
-		return _View.apply(this, arguments) || this;
+class ReadOnlyDataView extends View {
+	constructor(config) {
+		super(config);
 	}
-	_inheritsLoose(ReadOnlyDataView, _View);
-	var _proto = ReadOnlyDataView.prototype;
-	_proto.getData = function getData() {
+	getData() {
 		if (this.sealed && this.meta.version === this.cache.version && this.cache.data === this.data)
 			return this.cache.result;
-		var data = this.store.getData();
+		let data = this.store.getData();
 		this.cache.result =
 			this.sealed || this.immutable || this.store.sealed
 				? Object.assign({}, data, this.getAdditionalData(data))
@@ -1026,158 +928,156 @@ var ReadOnlyDataView = /*#__PURE__*/ (function (_View) {
 		this.cache.version = this.meta.version;
 		this.cache.data = this.data;
 		return this.cache.result;
-	};
-	_proto.getAdditionalData = function getAdditionalData() {
+	}
+	getAdditionalData(data) {
 		return this.data;
-	};
-	_proto.setData = function setData(data) {
+	}
+	setData(data) {
 		this.data = data;
-	};
-	return ReadOnlyDataView;
-})(View);
+	}
+}
 ReadOnlyDataView.prototype.immutable = false;
 
-var AugmentedViewBase = /*#__PURE__*/ (function (_View) {
-	function AugmentedViewBase() {
-		return _View.apply(this, arguments) || this;
+class AugmentedViewBase extends View {
+	constructor(config) {
+		super(config);
 	}
-	_inheritsLoose(AugmentedViewBase, _View);
-	var _proto = AugmentedViewBase.prototype;
-	_proto.getData = function getData() {
+	getData() {
 		if (this.sealed && this.meta.version === this.cache.version && this.meta === this.store.meta)
 			return this.cache.result;
-		var parentStoreData = this.store.getData();
-		var result = this.getBaseData(parentStoreData);
+		let parentStoreData = this.store.getData();
+		let result = this.getBaseData(parentStoreData);
 		this.embedAugmentData(result, parentStoreData);
 		this.cache.result = result;
 		this.cache.parentStoreData = parentStoreData;
 		this.cache.version = this.meta.version;
 		this.meta = this.store.meta;
 		return this.cache.result;
-	};
-	_proto.getBaseData = function getBaseData(parentStoreData) {
-		if (this.sealed || this.immutable || this.store.sealed) return _extends({}, parentStoreData);
+	}
+	getBaseData(parentStoreData) {
+		if (this.sealed || this.immutable || this.store.sealed)
+			return {
+				...parentStoreData,
+			};
 		return parentStoreData;
-	};
-	_proto.embedAugmentData = function embedAugmentData(result, parentStoreData) {
+	}
+	embedAugmentData(result, parentStoreData) {
 		throw new Error("abstract");
-	};
-	_proto.isExtraKey = function isExtraKey(key) {
+	}
+	isExtraKey(key) {
 		throw new Error("abstract");
-	};
-
+	}
 	// Stores which need to support nested aliases should override this method
-	_proto.getExtraKeyBinding = function getExtraKeyBinding(key) {
-		var binding = Binding.get(key);
+	getExtraKeyBinding(key) {
+		let binding = Binding.get(key);
 		return this.isExtraKey(binding.parts[0]) ? Binding.get(binding.parts[0]) : null;
-	};
-	_proto.setExtraKeyValue = function setExtraKeyValue(key, value) {
+	}
+	setExtraKeyValue(key, value) {
 		throw new Error("abstract");
-	};
-	_proto.deleteExtraKeyValue = function deleteExtraKeyValue(key) {
+	}
+	deleteExtraKeyValue(key) {
 		throw new Error("abstract");
-	};
-	_proto.setItem = function setItem(path, value) {
-		var extraKeyBinding = this.getExtraKeyBinding(path);
+	}
+	setItem(path, value) {
+		let extraKeyBinding = this.getExtraKeyBinding(path);
 		if (extraKeyBinding) {
-			var binding = Binding.get(path);
-			var newValue = value;
+			let binding = Binding.get(path);
+			let newValue = value;
 			if (binding.parts.length > extraKeyBinding.parts.length) {
-				var data = {};
+				let data = {};
 				this.embedAugmentData(data, this.store.getData());
-				var _binding = Binding.get(path);
-				data = _binding.set(data, value);
+				let binding = Binding.get(path);
+				data = binding.set(data, value);
 				newValue = extraKeyBinding.value(data);
 			}
 			return this.setExtraKeyValue(extraKeyBinding.path, newValue);
 		}
-		return _View.prototype.setItem.call(this, path, value);
-	};
-	_proto.deleteItem = function deleteItem(path) {
-		var extraKeyBinding = this.getExtraKeyBinding(path);
+		return super.setItem(path, value);
+	}
+	deleteItem(path) {
+		let extraKeyBinding = this.getExtraKeyBinding(path);
 		if (extraKeyBinding) {
 			if (path == extraKeyBinding.path) return this.deleteExtraKeyValue(extraKeyBinding.path);
-			var data = {};
+			let data = {};
 			this.embedAugmentData(data, this.store.getData());
-			var binding = Binding.get(path);
-			data = binding["delete"](data);
-			var newValue = extraKeyBinding.value(data);
+			let binding = Binding.get(path);
+			data = binding.delete(data);
+			let newValue = extraKeyBinding.value(data);
 			return this.setExtraKeyValue(extraKeyBinding.path, newValue);
 		}
-		return _View.prototype.deleteItem.call(this, path);
-	};
-	return AugmentedViewBase;
-})(View);
+		return super.deleteItem(path);
+	}
+}
 AugmentedViewBase.prototype.immutable = false;
 
-var NestedDataView = /*#__PURE__*/ (function (_AugmentedViewBase) {
-	function NestedDataView() {
-		return _AugmentedViewBase.apply(this, arguments) || this;
+class NestedDataView extends AugmentedViewBase {
+	constructor(config) {
+		super(config);
 	}
-	_inheritsLoose(NestedDataView, _AugmentedViewBase);
-	var _proto = NestedDataView.prototype;
-	_proto.embedAugmentData = function embedAugmentData(result, parentStoreData) {
+	embedAugmentData(result, parentStoreData) {
 		if (this.nestedData) {
-			var nested = this.nestedData.getSelector()(parentStoreData);
-			for (var key in nested) result[key] = nested[key];
+			let nested = this.nestedData.getSelector()(parentStoreData);
+			for (let key in nested) result[key] = nested[key];
 		}
-	};
-	_proto.isExtraKey = function isExtraKey(key) {
-		return this.nestedData && this.nestedData.containsKey(key);
-	};
-	_proto.setExtraKeyValue = function setExtraKeyValue(key, value) {
-		this.nestedData.setItem(key, value);
-	};
-	_proto.deleteExtraKeyValue = function deleteExtraKeyValue(key) {
-		this.setExtraKeyValue(key, undefined);
-	};
-	return NestedDataView;
-})(AugmentedViewBase);
+	}
+	isExtraKey(key) {
+		return !!this.nestedData && this.nestedData.containsKey(key);
+	}
+	setExtraKeyValue(key, value) {
+		if (!this.nestedData) throw new Error("Internal error. This should not happen.");
+		return this.nestedData.setItem(key, value);
+	}
+	deleteExtraKeyValue(key) {
+		return this.setExtraKeyValue(key, undefined);
+	}
+}
 
-var ZoomIntoPropertyView = /*#__PURE__*/ (function (_NestedDataView) {
-	function ZoomIntoPropertyView() {
-		return _NestedDataView.apply(this, arguments) || this;
-	}
-	_inheritsLoose(ZoomIntoPropertyView, _NestedDataView);
-	var _proto = ZoomIntoPropertyView.prototype;
-	_proto.getBaseData = function getBaseData(parentStoreData) {
-		var x = this.binding.value(parentStoreData);
+class ZoomIntoPropertyView extends NestedDataView {
+	constructor(config) {
+		super(config);
+	}
+	getBaseData(parentStoreData) {
+		let x = this.binding.value(parentStoreData);
 		if (x != null && typeof x != "object") throw new Error("Zoomed value must be an object.");
-		return _extends({}, x);
-	};
-	_proto.embedAugmentData = function embedAugmentData(result, parentStoreData) {
+		return {
+			...x,
+		};
+	}
+	embedAugmentData(result, parentStoreData) {
 		result[this.rootName] = parentStoreData;
-		_NestedDataView.prototype.embedAugmentData.call(this, result, parentStoreData);
-	};
-	_proto.setItem = function setItem(path, value) {
-		if (path.indexOf(this.rootName + ".") == 0) this.store.setItem(path.substring(this.rootName.length + 1), value);
-		else if (this.isExtraKey(Binding.get(path).parts[0])) _NestedDataView.prototype.setItem.call(this, path, value);
-		else _NestedDataView.prototype.setItem.call(this, this.binding.path + "." + path, value);
-	};
-	_proto.deleteItem = function deleteItem(path) {
-		if (path.indexOf(this.rootName + ".") == 0) this.store.deleteItem(path.substring(this.rootName.length + 1));
-		else if (this.isExtraKey(Binding.get(path).parts[0])) _NestedDataView.prototype.deleteItem.call(this, path);
-		else _NestedDataView.prototype.deleteItem.call(this, this.binding.path + "." + path);
-	};
-	return ZoomIntoPropertyView;
-})(NestedDataView);
+		super.embedAugmentData(result, parentStoreData);
+	}
+	setItem(path, value) {
+		if (path.indexOf(this.rootName + ".") == 0)
+			return this.store.setItem(path.substring(this.rootName.length + 1), value);
+		if (this.isExtraKey(Binding.get(path).parts[0])) return super.setItem(path, value);
+		return super.setItem(this.binding.path + "." + path, value);
+	}
+	deleteItem(path) {
+		if (path.indexOf(this.rootName + ".") == 0) return this.store.deleteItem(path.substring(this.rootName.length + 1));
+		if (this.isExtraKey(Binding.get(path).parts[0])) return super.deleteItem(path);
+		return super.deleteItem(this.binding.path + "." + path);
+	}
+}
 ZoomIntoPropertyView.prototype.rootName = "$root";
 
 function createStructuredSelector(selector, constants) {
-	var keys = Object.keys(selector);
-	if (keys.length == 0)
-		return function () {
-			return constants;
-		};
+	let keys = Object.keys(selector);
+	constants = constants ?? {};
+	if (keys.length == 0) {
+		let result = () => constants;
+		result.memoize = () => result;
+		return result;
+	}
 	function memoize() {
-		var lastResult = Object.assign({}, constants);
-		var memoizedSelectors = {};
-		keys.forEach(function (key) {
+		let lastResult = Object.assign({}, constants);
+		let memoizedSelectors = {};
+		keys.forEach((key) => {
 			memoizedSelectors[key] = selector[key].memoize ? selector[key].memoize() : selector[key];
 			lastResult[key] = undefined;
 		});
 		return function (data) {
-			var result = lastResult,
+			let result = lastResult,
 				k,
 				v,
 				i;
@@ -1193,15 +1093,15 @@ function createStructuredSelector(selector, constants) {
 			return (lastResult = result);
 		};
 	}
-	function evaluate(data) {
-		var result = Object.assign({}, constants);
-		for (var i = 0; i < keys.length; i++) {
+	let result = function evaluate(data) {
+		let result = Object.assign({}, constants);
+		for (let i = 0; i < keys.length; i++) {
 			result[keys[i]] = selector[keys[i]](data);
 		}
 		return result;
-	}
-	evaluate.memoize = memoize;
-	return evaluate;
+	};
+	result.memoize = memoize;
+	return result;
 }
 
 function isSelector(config) {
@@ -1222,47 +1122,46 @@ function isSelector(config) {
 	return false;
 }
 
-var undefinedF = function undefinedF() {
-	return undefined;
-};
-var nullF = function nullF() {
-	return null;
-};
+var undefinedF = () => undefined;
+var nullF = () => null;
 function getSelector(config) {
 	if (config === undefined) return undefinedF;
 	if (config === null) return nullF;
 	switch (typeof config) {
 		case "object":
 			if (isArray(config)) {
-				var _selectors = config.map(function (x) {
-					return getSelector(x);
-				});
-				return function (data) {
-					return _selectors.map(function (elementSelector) {
-						return elementSelector(data);
-					});
-				};
+				let selectors = config.map((x) => getSelector(x));
+				return (data) => selectors.map((elementSelector) => elementSelector(data));
 			}
-
 			//toString converts accessor chains to binding paths
-			if (config.bind) return Binding.get(config.bind.toString()).value;
-			if (isString(config.tpl)) return StringTemplate.get(config.tpl);
-			if (config.expr) return Expression.get(config.expr);
-			if (config.get) return config.get;
-			var selectors = {};
-			var constants = {};
-			for (var key in config) {
-				if (isSelector(config[key])) selectors[key] = getSelector(config[key]);
-				else constants[key] = config[key];
+			if (hasKey(config, "bind") && config.bind != null) return Binding.get(config.bind.toString()).value;
+			if (hasStringAtKey(config, "tpl")) return StringTemplate.get(config.tpl);
+			if (hasKey(config, "expr") && (isString(config.expr) || isFunction(config.expr)))
+				return Expression.get(config.expr);
+			if (hasFunctionAtKey(config, "get")) return config.get;
+			let selectors = {};
+			let constants = {};
+			let obj = config;
+			for (let key in obj) {
+				switch (typeof obj[key]) {
+					case "bigint":
+					case "boolean":
+					case "number":
+					case "string":
+						constants[key] = obj[key];
+						break;
+					default:
+						if (isSelector(obj[key])) selectors[key] = getSelector(obj[key]);
+						else constants[key] = obj[key];
+						break;
+				}
 			}
 			return createStructuredSelector(selectors, constants);
 		case "function":
 			if (isAccessorChain(config)) return Binding.get(config.toString()).value;
 			return config;
 		default:
-			return function () {
-				return config;
-			};
+			return () => config;
 	}
 }
 
@@ -1271,7 +1170,7 @@ function defaultValue(pv) {
 	return pv;
 }
 function getSelectorConfig(props, values, nameMap) {
-	var functions = {},
+	let functions = {},
 		structures = {},
 		defaultValues = {},
 		constants,
@@ -1305,7 +1204,7 @@ function getSelectorConfig(props, values, nameMap) {
 			} else if (pv && typeof pv == "object" && pv.structured) {
 				if (isArray(v)) functions[p] = getSelector(v);
 				else {
-					var s = getSelectorConfig(v, v, {});
+					let s = getSelectorConfig(v, v, {});
 					structures[p] = s;
 					Object.assign(defaultValues, s.defaultValues);
 				}
@@ -1316,7 +1215,7 @@ function getSelectorConfig(props, values, nameMap) {
 			}
 		} else if (isFunction(v)) {
 			if (isAccessorChain(v)) {
-				var path = v.toString();
+				let path = v.toString();
 				nameMap[p] = path;
 				functions[p] = Binding.get(path).value;
 			} else functions[p] = v;
@@ -1332,216 +1231,195 @@ function getSelectorConfig(props, values, nameMap) {
 		}
 	}
 	return {
-		functions: functions,
-		structures: structures,
-		defaultValues: defaultValues,
-		constants: constants,
-		constant: constant,
+		functions,
+		structures,
+		defaultValues,
+		constants,
+		constant,
 	};
 }
-function createSelector(_ref) {
-	var functions = _ref.functions,
-		structures = _ref.structures,
-		constants = _ref.constants;
-	_ref.defaultValues;
-	var selector = {};
-	for (var n in functions) {
+function createSelector({ functions, structures, constants, defaultValues }) {
+	let selector = {};
+	for (let n in functions) {
 		selector[n] = functions[n];
 	}
-	for (var _n in structures) selector[_n] = createSelector(structures[_n]);
+	for (let n in structures) selector[n] = createSelector(structures[n]);
 	return createStructuredSelector(selector, constants);
 }
-var StructuredSelector = /*#__PURE__*/ (function () {
-	function StructuredSelector(_ref2) {
-		var props = _ref2.props,
-			values = _ref2.values;
+class StructuredSelector {
+	nameMap;
+	config;
+	constructor({ props, values }) {
 		this.nameMap = {};
 		this.config = getSelectorConfig(props, values, this.nameMap);
 	}
-	var _proto = StructuredSelector.prototype;
-	_proto.init = function init(store) {
+	init(store) {
 		store.init(this.config.defaultValues);
-	};
-	_proto.create = function create(memoize) {
-		if (memoize === void 0) {
-			memoize = true;
-		}
-		var selector = createSelector(this.config);
+	}
+	create(memoize = true) {
+		let selector = createSelector(this.config);
 		if (memoize && selector.memoize) return selector.memoize();
 		return selector;
-	};
-	_proto.createStoreSelector = function createStoreSelector() {
+	}
+	createStoreSelector() {
 		if (this.config.constant) {
-			var result = _extends({}, this.config.constants);
-			return function () {
-				return result;
+			let result = {
+				...this.config.constants,
 			};
+			return () => result;
 		}
-		var selector = this.create();
-		return function (store) {
-			return selector(store.getData());
-		};
-	};
-	return StructuredSelector;
-})();
+		let selector = this.create();
+		return (store) => selector(store.getData());
+	}
+}
 
-var AggregateFunction = /*#__PURE__*/ (function () {
-	function AggregateFunction() {}
-	AggregateFunction.sum = function sum() {
+class AggregateFunction {
+	static sum() {
 		return new Sum();
-	};
-	AggregateFunction.avg = function avg() {
+	}
+	static avg() {
 		return new Avg();
-	};
-	AggregateFunction.count = function count() {
+	}
+	static count() {
 		return new Count();
-	};
-	AggregateFunction.distinct = function distinct() {
+	}
+	static distinct() {
 		return new Distinct();
-	};
-	AggregateFunction.min = function min() {
+	}
+	static min() {
 		return new Min();
-	};
-	AggregateFunction.max = function max() {
+	}
+	static max() {
 		return new Max();
-	};
-	AggregateFunction.last = function last() {
+	}
+	static last() {
 		return new LastValue();
-	};
-	return AggregateFunction;
-})();
-var Sum = /*#__PURE__*/ (function () {
-	function Sum() {}
-	var _proto = Sum.prototype;
-	_proto.process = function process(value) {
+	}
+}
+class Sum {
+	result = 0;
+	empty = true;
+	invalid;
+	process(value) {
 		this.empty = false;
 		if (!isNaN(value)) this.result += value;
 		else this.invalid = true;
-	};
-	_proto.getResult = function getResult() {
+	}
+	getResult() {
 		if (this.invalid) return null;
 		return this.result;
-	};
-	return Sum;
-})();
+	}
+}
 Sum.prototype.result = 0;
 Sum.prototype.empty = true;
-var Avg = /*#__PURE__*/ (function () {
-	function Avg() {}
-	var _proto2 = Avg.prototype;
-	_proto2.process = function process(value, count) {
-		if (count === void 0) {
-			count = 1;
-		}
+class Avg {
+	result = 0;
+	count = 0;
+	empty = true;
+	invalid;
+	process(value, count = 1) {
 		this.empty = false;
 		if (!isNaN(value) && !isNaN(count)) {
 			this.result += value * count;
 			this.count += count;
 		} else this.invalid = true;
-	};
-	_proto2.getResult = function getResult() {
+	}
+	getResult() {
 		if (this.empty || this.invalid || this.count == 0) return null;
 		return this.result / this.count;
-	};
-	return Avg;
-})();
+	}
+}
 Avg.prototype.result = 0;
 Avg.prototype.count = 0;
 Avg.prototype.empty = true;
-var Count = /*#__PURE__*/ (function () {
-	function Count() {}
-	var _proto3 = Count.prototype;
-	_proto3.process = function process(value) {
+class Count {
+	result = 0;
+	process(value) {
 		if (value != null) this.result++;
-	};
-	_proto3.getResult = function getResult() {
+	}
+	getResult() {
 		return this.result;
-	};
-	return Count;
-})();
+	}
+}
 Count.prototype.result = 0;
-var Distinct = /*#__PURE__*/ (function () {
-	function Distinct() {
+class Distinct {
+	values = {};
+	empty = true;
+	result = 0;
+	invalid;
+	constructor() {
 		this.values = {};
 	}
-	var _proto4 = Distinct.prototype;
-	_proto4.process = function process(value) {
+	process(value) {
 		if (value == null || this.values[value]) return;
 		this.values[value] = true;
 		this.empty = false;
 		this.result++;
-	};
-	_proto4.getResult = function getResult() {
+	}
+	getResult() {
 		if (this.empty || this.invalid) return null;
 		return this.result;
-	};
-	return Distinct;
-})();
+	}
+}
 Distinct.prototype.result = 0;
 Distinct.prototype.empty = true;
-var Max = /*#__PURE__*/ (function () {
-	function Max() {}
-	var _proto5 = Max.prototype;
-	_proto5.process = function process(value) {
+class Max {
+	result = 0;
+	empty = true;
+	invalid;
+	process(value) {
 		if (!isNaN(value)) {
 			if (this.empty) this.result = value;
 			else if (value > this.result) this.result = value;
 			this.empty = false;
 		} else if (value != null) this.invalid = true;
-	};
-	_proto5.getResult = function getResult() {
+	}
+	getResult() {
 		if (this.empty || this.invalid) return null;
 		return this.result;
-	};
-	return Max;
-})();
+	}
+}
 Max.prototype.result = 0;
 Max.prototype.empty = true;
-var Min = /*#__PURE__*/ (function () {
-	function Min() {}
-	var _proto6 = Min.prototype;
-	_proto6.process = function process(value) {
+class Min {
+	result = 0;
+	empty = true;
+	invalid;
+	process(value) {
 		if (!isNaN(value)) {
 			if (this.empty) this.result = value;
 			else if (value < this.result) this.result = value;
 			this.empty = false;
 		} else if (value != null) this.invalid = true;
-	};
-	_proto6.getResult = function getResult() {
+	}
+	getResult() {
 		if (this.empty || this.invalid) return null;
 		return this.result;
-	};
-	return Min;
-})();
+	}
+}
 Min.prototype.result = 0;
 Min.prototype.empty = true;
-var LastValue = /*#__PURE__*/ (function () {
-	function LastValue() {}
-	var _proto7 = LastValue.prototype;
-	_proto7.process = function process(value) {
+class LastValue {
+	result = null;
+	process(value) {
 		this.result = value;
-	};
-	_proto7.getResult = function getResult() {
+	}
+	getResult() {
 		return this.result;
-	};
-	return LastValue;
-})();
+	}
+}
 LastValue.prototype.result = null;
 
-/*
- 'column': {
-   index: 0,
-   sort: 'asc',
-   group: true
-   aggregate: 'count'
- }
- */
-
-var Grouper = /*#__PURE__*/ (function () {
-	function Grouper(key, aggregates, dataGetter, nameGetter) {
-		this.keys = Object.keys(key).map(function (keyField) {
-			var isSimpleField = keyField.indexOf(".") === -1;
-			var keySetter;
+class Grouper {
+	keys;
+	nameGetter;
+	dataGetter;
+	aggregates;
+	groups;
+	constructor(key, aggregates, dataGetter, nameGetter) {
+		this.keys = Object.keys(key).map((keyField) => {
+			let isSimpleField = keyField.indexOf(".") === -1;
+			let keySetter;
 			if (isSimpleField) {
 				// use simple field setter wherever possible
 				keySetter = function set(result, value) {
@@ -1550,49 +1428,41 @@ var Grouper = /*#__PURE__*/ (function () {
 				};
 			} else {
 				// for complex paths, use deep setter
-				var binding = Binding.get(keyField);
-				keySetter = function keySetter(result, value) {
-					return binding.set(result, value);
-				};
+				let binding = Binding.get(keyField);
+				keySetter = (result, value) => binding.set(result, value);
 			}
 			return {
 				name: keyField,
-				keySetter: keySetter,
+				keySetter,
 				value: getSelector(key[keyField]),
 			};
 		});
 		if (nameGetter) this.nameGetter = getSelector(nameGetter);
-		this.dataGetter =
-			dataGetter ||
-			function (x) {
-				return x;
-			};
+		this.dataGetter = dataGetter || ((x) => x);
 		this.aggregates =
 			aggregates &&
-			transformValues(aggregates, function (prop) {
-				var _prop$weight;
-				if (!AggregateFunction[prop.type]) throw new Error("Unknown aggregate function '" + prop.type + "'.");
+			transformValues(aggregates, (prop) => {
+				if (!(prop.type in AggregateFunction)) throw new Error(`Unknown aggregate function '${prop.type}'.`);
 				return {
 					value: getSelector(prop.value),
-					weight: getSelector((_prop$weight = prop.weight) != null ? _prop$weight : 1),
+					weight: getSelector(prop.weight ?? 1),
 					type: prop.type,
 				};
 			});
 		this.reset();
 	}
-	var _proto = Grouper.prototype;
-	_proto.reset = function reset() {
+	reset() {
 		this.groups = this.initGroup(this.keys.length == 0);
-	};
-	_proto.initGroup = function initGroup(leaf) {
+	}
+	initGroup(leaf) {
 		if (!leaf) return {};
 		return {
 			records: [],
 			indexes: [],
 			aggregates:
 				this.aggregates &&
-				transformValues(this.aggregates, function (prop) {
-					var f = AggregateFunction[prop.type];
+				transformValues(this.aggregates, (prop) => {
+					let f = AggregateFunction[prop.type];
 					return {
 						processor: f(),
 						value: prop.value,
@@ -1600,15 +1470,13 @@ var Grouper = /*#__PURE__*/ (function () {
 					};
 				}),
 		};
-	};
-	_proto.process = function process(record, index) {
-		var data = this.dataGetter(record);
-		var key = this.keys.map(function (k) {
-			return k.value(data);
-		});
-		var g = this.groups;
-		for (var i = 0; i < key.length; i++) {
-			var sg = g[key[i]];
+	}
+	process(record, index) {
+		let data = this.dataGetter(record);
+		let key = this.keys.map((k) => k.value(data));
+		let g = this.groups;
+		for (let i = 0; i < key.length; i++) {
+			let sg = g[key[i]];
 			if (!sg) {
 				sg = g[key[i]] = this.initGroup(i + 1 == key.length);
 				if (this.nameGetter) sg.name = this.nameGetter(data);
@@ -1618,24 +1486,19 @@ var Grouper = /*#__PURE__*/ (function () {
 		g.records.push(record);
 		g.indexes.push(index);
 		if (g.aggregates) {
-			for (var k in g.aggregates)
+			for (let k in g.aggregates)
 				g.aggregates[k].processor.process(g.aggregates[k].value(data), g.aggregates[k].weight(data));
 		}
-	};
-	_proto.processAll = function processAll(records, indexes) {
-		var _this = this;
+	}
+	processAll(records, indexes) {
 		if (indexes) {
-			for (var i = 0; i < records.length; i++) this.process(records[i], indexes[i]);
-		} else
-			records.forEach(function (r, i) {
-				return _this.process(r, i);
-			});
-	};
-	_proto.report = function report(g, path, level, results) {
-		var _this2 = this;
+			for (let i = 0; i < records.length; i++) this.process(records[i], indexes[i]);
+		} else records.forEach((r, i) => this.process(r, i));
+	}
+	report(g, path, level, results) {
 		if (level == this.keys.length) {
-			var key = {};
-			this.keys.forEach(function (k, i) {
+			let key = {};
+			this.keys.forEach((k, i) => {
 				key = k.keySetter(key, path[i]);
 			});
 			results.push({
@@ -1643,38 +1506,29 @@ var Grouper = /*#__PURE__*/ (function () {
 				name: g.name,
 				records: g.records,
 				indexes: g.indexes,
-				aggregates: resolveKeyPaths(
-					transformValues(g.aggregates, function (p) {
-						return p.processor.getResult();
-					}),
-				),
+				aggregates: resolveKeyPaths(transformValues(g.aggregates, (p) => p.processor.getResult())),
 			});
 		} else {
-			Object.keys(g).forEach(function (k) {
-				return _this2.report(g[k], [].concat(path, [k]), level + 1, results);
-			});
+			Object.keys(g).forEach((k) => this.report(g[k], [...path, k], level + 1, results));
 		}
-	};
-	_proto.getResults = function getResults() {
-		var g = this.groups;
-		var results = [];
+	}
+	getResults() {
+		let g = this.groups;
+		let results = [];
 		this.report(g, [], 0, results);
 		return results;
-	};
-	return Grouper;
-})();
-
+	}
+}
 // transform object values using a function
 function transformValues(o, f) {
-	var res = {};
-	for (var k in o) res[k] = f(o[k], k);
+	let res = {};
+	for (let k in o) res[k] = f(o[k], k);
 	return res;
 }
-
 // transform keys like 'a.b.c' into nested objects
 function resolveKeyPaths(o) {
-	var res = {};
-	for (var k in o) {
+	let res = {};
+	for (let k in o) {
 		if (k.indexOf(".") > 0) res = Binding.get(k).set(res, o[k]);
 		else res[k] = o[k];
 	}
@@ -1692,40 +1546,27 @@ function defaultCompare(av, bv) {
 }
 
 function getComparer(sorters, dataAccessor, comparer) {
-	var resolvedSorters = (sorters || []).map(function (s) {
-		var selector = isDefined(s.value)
-			? getSelector(s.value)
-			: s.field
-				? function (x) {
-						return x[s.field];
-					}
-				: function () {
-						return null;
-					};
+	let resolvedSorters = (sorters || []).map((s) => {
+		let selector = isDefined(s.value) ? getSelector(s.value) : s.field ? (x) => x[s.field] : () => null;
 		return {
-			getter: dataAccessor
-				? function (x) {
-						return selector(dataAccessor(x));
-					}
-				: selector,
+			getter: dataAccessor ? (x) => selector(dataAccessor(x)) : selector,
 			factor: s.direction && s.direction[0].toLowerCase() == "d" ? -1 : 1,
 			compare: s.comparer || s.compare || comparer || defaultCompare,
 		};
 	});
 	return function (a, b) {
-		var d, av, bv;
-		for (var i = 0; i < resolvedSorters.length; i++) {
+		let d, av, bv;
+		for (let i = 0; i < resolvedSorters.length; i++) {
 			d = resolvedSorters[i];
 			av = d.getter(a);
 			bv = d.getter(b);
-
 			// show nulls always on the bottom
 			if (av == null) {
 				if (bv == null) continue;
 				else return 1;
 			}
 			if (bv == null) return -1;
-			var r = d.compare(av, bv);
+			let r = d.compare(av, bv);
 			if (r == 0) continue;
 			return d.factor * r;
 		}
@@ -1733,26 +1574,22 @@ function getComparer(sorters, dataAccessor, comparer) {
 	};
 }
 function indexSorter(sorters, dataAccessor, compare) {
-	var cmp = getComparer(sorters, dataAccessor, compare);
+	let cmp = getComparer(sorters, dataAccessor, compare);
 	return function (data) {
-		var result = Array.from(
+		let result = Array.from(
 			{
 				length: data.length,
 			},
-			function (v, k) {
-				return k;
-			},
+			(v, k) => k,
 		);
-		result.sort(function (ia, ib) {
-			return cmp(data[ia], data[ib]);
-		});
+		result.sort((ia, ib) => cmp(data[ia], data[ib]));
 		return result;
 	};
 }
 function sorter(sorters, dataAccessor, compare) {
-	var cmp = getComparer(sorters, dataAccessor, compare);
+	let cmp = getComparer(sorters, dataAccessor, compare);
 	return function (data) {
-		var result = [].concat(data);
+		let result = [...data];
 		result.sort(cmp);
 		return result;
 	};
@@ -1762,43 +1599,46 @@ function enableFatArrowExpansion() {
 	plugFatArrowExpansion(expandFatArrows);
 }
 
-function append(array) {
-	for (var _len = arguments.length, items = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-		items[_key - 1] = arguments[_key];
-	}
-	if (items.length == 0) return array;
+function append(array, ...items) {
+	if (items.length === 0) return array ?? [];
 	if (!array) return items;
-	return [].concat(array, items);
+	return [...array, ...items];
 }
 
 function merge(item, data) {
-	var result = item;
-	if (data) for (var key in data) result = Binding.get(key).set(result, data[key]);
+	let result = item;
+	if (data) {
+		for (const key in data) {
+			result = Binding.get(key).set(result, data[key]);
+		}
+	}
 	return result;
 }
 
 function filter(array, callback) {
 	if (array == null) return array;
-	var result = array.filter(callback);
-	if (result.length == array.length) return array;
+	const result = array.filter(callback);
+	if (result.length === array.length) return array;
 	return result;
 }
 
 function updateArray(array, updateCallback, itemFilter, removeFilter) {
 	if (!array) return array;
-	var newArray = [];
-	var dirty = false;
-	for (var index = 0; index < array.length; index++) {
-		var item = array[index];
+	const newArray = [];
+	let dirty = false;
+	for (let index = 0; index < array.length; index++) {
+		const item = array[index];
 		if (removeFilter && removeFilter(item, index)) {
 			dirty = true;
 			continue;
 		}
 		if (!itemFilter || itemFilter(item, index)) {
-			var newItem = updateCallback(item, index);
+			const newItem = updateCallback(item, index);
 			newArray.push(newItem);
 			if (newItem !== item) dirty = true;
-		} else newArray.push(item);
+		} else {
+			newArray.push(item);
+		}
 	}
 	return dirty ? newArray : array;
 }
@@ -1806,14 +1646,16 @@ function updateArray(array, updateCallback, itemFilter, removeFilter) {
 function updateTree(array, updateCallback, itemFilter, childrenField, removeFilter) {
 	return updateArray(
 		array,
-		function (item) {
-			var _extends2;
+		(item) => {
 			if (!itemFilter || itemFilter(item)) item = updateCallback(item);
-			var children = item[childrenField];
+			const children = item[childrenField];
 			if (!Array.isArray(children)) return item;
-			var updatedChildren = updateTree(children, updateCallback, itemFilter, childrenField, removeFilter);
+			const updatedChildren = updateTree(children, updateCallback, itemFilter, childrenField, removeFilter);
 			if (updatedChildren != children)
-				return _extends({}, item, ((_extends2 = {}), (_extends2[childrenField] = updatedChildren), _extends2));
+				return {
+					...item,
+					[childrenField]: updatedChildren,
+				};
 			return item;
 		},
 		null,
@@ -1821,271 +1663,223 @@ function updateTree(array, updateCallback, itemFilter, childrenField, removeFilt
 	);
 }
 
-function removeTreeNodes(array, criteria, childrenField) {
-	if (childrenField === void 0) {
-		childrenField = "$children";
-	}
+function removeTreeNodes(array, criteria, childrenField = "$children") {
 	return updateTree(
 		array,
-		null,
-		function () {
-			return false;
-		},
+		(x) => x,
+		() => false,
 		childrenField,
 		criteria,
 	);
 }
 
-function findTreeNode(array, criteria, childrenField) {
-	if (childrenField === void 0) {
-		childrenField = "$children";
-	}
+function findTreeNode(array, criteria, childrenField = "$children") {
 	if (!Array.isArray(array)) return false;
-	for (var i = 0; i < array.length; i++) {
-		if (criteria(array[i])) return array[i];
-		var child = findTreeNode(array[i][childrenField], criteria, childrenField);
-		if (child) return child;
+	for (const node of array) {
+		if (criteria(node)) return node;
+		const children = node[childrenField];
+		const found = findTreeNode(children, criteria, childrenField);
+		if (found) return found;
 	}
 	return false;
 }
 
 function moveElement(array, sourceIndex, targetIndex) {
-	if (targetIndex == sourceIndex) return array;
-	var el = array[sourceIndex];
-	var res = [].concat(array);
+	if (sourceIndex === targetIndex) return array;
+	const result = [...array];
+	const element = result[sourceIndex];
 	if (sourceIndex < targetIndex) {
-		for (var i = sourceIndex; i + 1 < targetIndex; i++) res[i] = res[i + 1];
+		for (let i = sourceIndex; i < targetIndex - 1; i++) {
+			result[i] = result[i + 1];
+		}
+		result[targetIndex - 1] = result[targetIndex];
 		targetIndex--;
 	} else {
-		for (var _i = sourceIndex; _i > targetIndex; _i--) res[_i] = res[_i - 1];
+		for (let i = sourceIndex; i > targetIndex; i--) {
+			result[i] = result[i - 1];
+		}
 	}
-	res[targetIndex] = el;
-	return res;
+	result[targetIndex] = element;
+	return result;
 }
 
-function insertElement(array, index) {
-	for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-		args[_key - 2] = arguments[_key];
-	}
-	return [].concat(array.slice(0, index), args, array.slice(index));
+function insertElement(array, index, ...elements) {
+	return [...array.slice(0, index), ...elements, ...array.slice(index)];
 }
 
-function findTreePath(array, criteria, childrenField, currentPath) {
-	if (childrenField === void 0) {
-		childrenField = "$children";
-	}
-	if (currentPath === void 0) {
-		currentPath = [];
-	}
+function findTreePath(array, criteria, childrenField = "$children", currentPath = []) {
 	if (!Array.isArray(array)) return false;
-	for (var i = 0; i < array.length; i++) {
-		currentPath.push(array[i]);
-		if (criteria(array[i])) return currentPath;
-		var childPath = findTreePath(array[i][childrenField], criteria, childrenField, currentPath);
+	for (const node of array) {
+		currentPath.push(node);
+		if (criteria(node)) return [...currentPath];
+		const children = node[childrenField];
+		const childPath = findTreePath(children, criteria, childrenField, currentPath);
 		if (childPath) return childPath;
 		currentPath.pop();
 	}
 	return false;
 }
 
-function diffArrays(oldArray, newArray, keyFn) {
-	if (!keyFn)
-		keyFn = function keyFn(e) {
-			return e;
-		};
-	var map = new Map();
-	for (var i = 0; i < oldArray.length; i++) map.set(keyFn(oldArray[i]), oldArray[i]);
-	var added = [],
-		changed = [],
-		unchanged = [];
-	for (var _i = 0; _i < newArray.length; _i++) {
-		var el = newArray[_i];
-		var k = keyFn(el);
-		var old = map.get(k);
-		if (isUndefined(old)) added.push(el);
-		else {
-			map["delete"](k);
-			if (el == old) unchanged.push(el);
-			else
+function diffArrays(oldArray, newArray, keyFn = (e) => e) {
+	const map = new Map();
+	oldArray.forEach((item) => {
+		const key = keyFn(item);
+		map.set(key, item);
+	});
+	const added = [];
+	const changed = [];
+	const unchanged = [];
+	newArray.forEach((item) => {
+		const key = keyFn(item);
+		const oldItem = map.get(key);
+		if (isUndefined(oldItem)) {
+			added.push(item);
+		} else {
+			map.delete(key);
+			if (item === oldItem) {
+				unchanged.push(item);
+			} else {
 				changed.push({
-					before: old,
-					after: el,
+					before: oldItem,
+					after: item,
 				});
+			}
 		}
-	}
-	var removed = Array.from(map.values());
+	});
+	const removed = Array.from(map.values());
 	return {
-		added: added,
-		changed: changed,
-		unchanged: unchanged,
-		removed: removed,
+		added,
+		changed,
+		unchanged,
+		removed,
 	};
 }
 
-var ArrayRef = /*#__PURE__*/ (function (_Ref) {
-	function ArrayRef() {
-		return _Ref.apply(this, arguments) || this;
-	}
-	_inheritsLoose(ArrayRef, _Ref);
-	var _proto = ArrayRef.prototype;
-	_proto.append = function append$1() {
-		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-			args[_key] = arguments[_key];
-		}
-		this.update.apply(this, [append].concat(args));
-	};
-	_proto.insert = function insert(index) {
-		for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-			args[_key2 - 1] = arguments[_key2];
-		}
-		this.update.apply(this, [insertElement].concat(args));
-	};
-	_proto.filter = function filter(predicate) {
-		this.update(function (array) {
-			return array.filter(function (a) {
-				return predicate(a);
-			});
-		});
-	};
-	_proto.move = function move(fromIndex, toIndex) {
+class ArrayRef extends Ref {
+	append(...args) {
+		this.update(append, ...args);
+	}
+	insert(index, ...args) {
+		this.update(insertElement, ...args);
+	}
+	filter(predicate) {
+		this.update((array) => array.filter((a) => predicate(a)));
+	}
+	move(fromIndex, toIndex) {
 		this.update(moveElement, fromIndex, toIndex);
-	};
-	_proto.clear = function clear() {
+	}
+	clear() {
 		this.set([]);
-	};
-	_proto.sort = function sort(compare) {
-		var data = this.get();
+	}
+	sort(compare) {
+		let data = this.get();
 		if (!data) return;
-		var x = [].concat(data);
+		let x = [...data];
 		x.sort(compare);
 		this.set(x);
-	};
-	return ArrayRef;
-})(Ref);
+	}
+}
 
-var StoreProxy = /*#__PURE__*/ (function (_View) {
-	function StoreProxy(getStore) {
-		var _this;
-		_this =
-			_View.call(this, {
-				store: getStore(),
-			}) || this;
-		Object.defineProperty(_this, "store", {
+class StoreProxy extends View {
+	constructor(getStore) {
+		super({
+			store: getStore(),
+		});
+		Object.defineProperty(this, "store", {
 			get: getStore,
 		});
-		return _this;
 	}
-	_inheritsLoose(StoreProxy, _View);
-	var _proto = StoreProxy.prototype;
-	_proto.getData = function getData() {
+	getData() {
 		return this.store.getData();
-	};
-	return StoreProxy;
-})(View);
+	}
+}
 
-var ArrayElementView = /*#__PURE__*/ (function (_AugmentedViewBase) {
-	function ArrayElementView(config) {
-		var _this;
-		_this = _AugmentedViewBase.call(this, config) || this;
-		_this.hasNestedAliases =
-			_this.recordAlias.indexOf(".") >= 0 || _this.indexAlias.indexOf(".") >= 0 || _this.lengthAlias.indexOf(".") >= 0;
-		_this.recordBinding = Binding.get(_this.recordAlias);
-		if (_this.hasNestedAliases) {
-			_this.indexBinding = Binding.get(_this.indexAlias);
-			_this.lengthAlias = Binding.get(_this.lengthAlias);
+class ArrayElementView extends AugmentedViewBase {
+	constructor(config) {
+		super(config);
+		this.hasNestedAliases =
+			this.recordAlias.indexOf(".") >= 0 || this.indexAlias.indexOf(".") >= 0 || this.lengthAlias.indexOf(".") >= 0;
+		this.recordBinding = Binding.get(this.recordAlias);
+		if (this.hasNestedAliases) {
+			this.indexBinding = Binding.get(this.indexAlias);
+			this.lengthBinding = Binding.get(this.lengthAlias);
 		}
-		return _this;
 	}
-	_inheritsLoose(ArrayElementView, _AugmentedViewBase);
-	var _proto = ArrayElementView.prototype;
-	_proto.getExtraKeyBinding = function getExtraKeyBinding(key) {
+	getExtraKeyBinding(key) {
 		if (!key.startsWith(this.recordAlias)) return null;
 		if (key.length == this.recordAlias.length || key[this.recordAlias.length] == ".") return this.recordBinding;
 		return null;
-	};
-	_proto.deleteExtraKeyValue = function deleteExtraKeyValue(key) {
-		if (key != this.recordAlias) throw new Error("Field " + key + " cannot be deleted.");
-		var array = this.arrayAccessor.get(this.store.getData());
+	}
+	deleteExtraKeyValue(key) {
+		if (key != this.recordAlias) throw new Error(`Field ${key} cannot be deleted.`);
+		const array = this.arrayAccessor.get(this.store.getData());
 		if (!array) return false;
-		var newArray = [].concat(array.slice(0, this.itemIndex), array.slice(this.itemIndex + 1));
+		const newArray = [...array.slice(0, this.itemIndex), ...array.slice(this.itemIndex + 1)];
 		return this.arrayAccessor.set(newArray, this.store);
-	};
-	_proto.setExtraKeyValue = function setExtraKeyValue(key, value) {
-		if (key != this.recordAlias) throw new Error("Field " + key + " is read-only.");
-		var array = this.arrayAccessor.get(this.store.getData());
+	}
+	setExtraKeyValue(key, value) {
+		if (key != this.recordAlias) throw new Error(`Field ${key} is read-only.`);
+		const array = this.arrayAccessor.get(this.store.getData());
 		if (!array || value === array[this.itemIndex]) return false;
-		var newArray = [].concat(array.slice(0, this.itemIndex), [value], array.slice(this.itemIndex + 1));
+		const newArray = [...array.slice(0, this.itemIndex), value, ...array.slice(this.itemIndex + 1)];
 		return this.arrayAccessor.set(newArray, this.store);
-	};
-	_proto.embedAugmentData = function embedAugmentData(result, parentStoreData) {
-		var array = this.arrayAccessor.get(parentStoreData);
+	}
+	embedAugmentData(result, parentStoreData) {
+		let array = this.arrayAccessor.get(parentStoreData);
 		if (!isArray(array)) return;
 		if (!this.hasNestedAliases) {
 			result[this.recordAlias] = array[this.itemIndex];
 			result[this.indexAlias] = this.itemIndex;
 			result[this.lengthAlias] = array.length;
 		} else {
-			var copy = result;
+			let copy = result;
 			copy = this.recordBinding.set(copy, array[this.itemIndex]);
 			copy = this.indexBinding.set(copy, this.itemIndex);
-			copy = this.lengthAlias.set(copy, array.length);
+			copy = this.lengthBinding.set(copy, array.length);
 			result[this.recordBinding.parts[0]] = copy[this.recordBinding.parts[0]];
 			result[this.indexBinding.parts[0]] = copy[this.indexBinding.parts[0]];
-			result[this.lengthAlias.parts[0]] = copy[this.lengthAlias.parts[0]];
+			result[this.lengthBinding.parts[0]] = copy[this.lengthBinding.parts[0]];
 		}
-	};
-	_proto.setIndex = function setIndex(itemIndex) {
+	}
+	setIndex(itemIndex) {
 		this.itemIndex = itemIndex;
-	};
-	return ArrayElementView;
-})(AugmentedViewBase);
+	}
+}
 ArrayElementView.prototype.recordAlias = "$record";
 ArrayElementView.prototype.indexAlias = "$index";
 ArrayElementView.prototype.lengthAlias = "$length";
 
-/*
-   Accessor provides a common ground between refs and bindings.
-   Refs offer simplicity, bindings have better performance with more arguments.
-   Accessor works as a common interface which works with both patterns.
- */
-
-function getAccessor(accessor, options) {
-	if (accessor == null) return null;
+function getAccessor(accessor) {
+	if (accessor == null) return undefined;
 	if (isObject(accessor)) {
-		if (accessor.isAccessor || accessor.isRef) return accessor;
+		if ("isAccessor" in accessor || "isRef" in accessor) return accessor;
 		if (isBinding(accessor)) {
-			var binding = Binding.get(accessor);
+			let binding = Binding.get(accessor);
 			return {
 				get: binding.value,
-				set: function set(v, store) {
-					return store.set(binding.path, v);
-				},
+				set: (v, store) => store.set(binding.path, v),
 				isAccessor: true,
 			};
 		}
 	}
 	if (isAccessorChain(accessor)) {
-		var _binding = Binding.get(accessor);
+		let binding = Binding.get(accessor);
 		return {
-			get: _binding.value,
-			set: function set(v, store) {
-				return store.set(_binding.path, v);
-			},
+			get: binding.value,
+			set: (v, store) => store.set(binding.path, v),
 			isAccessor: true,
 		};
 	}
 	if (isSelector(accessor)) {
-		var selector = getSelector(accessor);
+		let selector = getSelector(accessor);
 		if (accessor && accessor.set)
 			return {
 				get: selector,
 				isAccessor: true,
-				bindInstance: function bindInstance(instance) {
+				bindInstance(instance) {
 					return {
 						get: selector,
-						set: function set(value) {
-							return accessor.set(value, instance);
-						},
+						set: (value) => accessor.set(value, instance),
 						isAccessor: true,
 					};
 				},
@@ -2096,9 +1890,7 @@ function getAccessor(accessor, options) {
 		};
 	}
 	return {
-		get: function get() {
-			return accessor;
-		},
+		get: () => accessor,
 	};
 }
 
@@ -2122,6 +1914,7 @@ export {
 	View,
 	ZoomIntoPropertyView,
 	append,
+	bindingCache,
 	computable,
 	createAccessorModelProxy,
 	defaultCompare,
@@ -2140,6 +1933,7 @@ export {
 	invalidateStringTemplateCache,
 	isAccessorChain,
 	isBinding,
+	isBindingObject,
 	isSelector,
 	merge,
 	moveElement,