cx 23.4.3 → 23.4.4

package/dist/data.js

@@ -0,0 +1,2109 @@
+import {
+	isString,
+	isObject,
+	isFunction,
+	Format,
+	isDigit,
+	quoteStr,
+	Component,
+	isArray,
+	isDefined,
+	SubscriberList,
+	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) {
+			if (typeof name !== "string") return proxy;
+			switch (name) {
+				case "isAccessorChain":
+					return true;
+				case "toString":
+				case "valueOf":
+				case "nameOf":
+					lastOp = name;
+					return proxy;
+			}
+			var newChain = chain;
+			if (newChain.length > 0) newChain += ".";
+			newChain += name;
+			return createAccessorModelProxy(newChain);
+		},
+		apply: function apply() {
+			switch (lastOp) {
+				case "nameOf":
+					var lastDotIndex = chain.lastIndexOf(".");
+					return lastDotIndex > 0 ? chain.substring(lastDotIndex + 1) : chain;
+				default:
+					return chain;
+			}
+		},
+	});
+	return proxy;
+}
+function isAccessorChain(value) {
+	return value != null && !!value.isAccessorChain;
+}
+
+var bindingCache = {};
+var Binding = /*#__PURE__*/ (function () {
+	function Binding(path) {
+		this.path = path;
+		this.parts = path.split(".");
+		var body = "return (x";
+		var selector = "x";
+		for (var i = 0; i < this.parts.length; i++) {
+			if (this.parts[i][0] >= "0" && this.parts[i][0] <= "9") selector += "[" + this.parts[i] + "]";
+			else selector += "." + this.parts[i];
+			if (i + 1 < this.parts.length) body += " && " + selector;
+			else body += " ? " + selector + " : undefined";
+		}
+		body += ")";
+		this.value = new Function("x", body);
+	}
+	var _proto = Binding.prototype;
+	_proto.set = function set(state, value) {
+		var 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]);
+			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++) {
+			part = this.parts[i];
+			var no = Object.assign({}, o[part]);
+			o[part] = no;
+			o = no;
+		}
+		part = this.parts[this.parts.length - 1];
+		if (!o.hasOwnProperty(part)) return state;
+		delete o[part];
+		return ns;
+	};
+	Binding.get = function get(path) {
+		if (isString(path)) {
+			var 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 (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;
+	return value instanceof Binding;
+}
+
+function ownKeys(object, enumerableOnly) {
+	var keys = Object.keys(object);
+	if (Object.getOwnPropertySymbols) {
+		var symbols = Object.getOwnPropertySymbols(object);
+		enumerableOnly &&
+			(symbols = symbols.filter(function (sym) {
+				return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+			})),
+			keys.push.apply(keys, symbols);
+	}
+	return keys;
+}
+function _objectSpread2(target) {
+	for (var i = 1; i < arguments.length; i++) {
+		var source = null != arguments[i] ? arguments[i] : {};
+		i % 2
+			? ownKeys(Object(source), !0).forEach(function (key) {
+					_defineProperty(target, key, source[key]);
+			  })
+			: Object.getOwnPropertyDescriptors
+			? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source))
+			: ownKeys(Object(source)).forEach(function (key) {
+					Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+			  });
+	}
+	return target;
+}
+function _defineProperty(obj, key, value) {
+	key = _toPropertyKey(key);
+	if (key in obj) {
+		Object.defineProperty(obj, key, {
+			value: value,
+			enumerable: true,
+			configurable: true,
+			writable: true,
+		});
+	} else {
+		obj[key] = value;
+	}
+	return obj;
+}
+function _inheritsLoose(subClass, superClass) {
+	subClass.prototype = Object.create(superClass.prototype);
+	subClass.prototype.constructor = subClass;
+	_setPrototypeOf(subClass, superClass);
+}
+function _setPrototypeOf(o, p) {
+	_setPrototypeOf = Object.setPrototypeOf
+		? Object.setPrototypeOf.bind()
+		: function _setPrototypeOf(o, p) {
+				o.__proto__ = p;
+				return o;
+		  };
+	return _setPrototypeOf(o, p);
+}
+function _isNativeReflectConstruct() {
+	if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+	if (Reflect.construct.sham) return false;
+	if (typeof Proxy === "function") return true;
+	try {
+		Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+function _construct(Parent, args, Class) {
+	if (_isNativeReflectConstruct()) {
+		_construct = Reflect.construct.bind();
+	} else {
+		_construct = function _construct(Parent, args, Class) {
+			var a = [null];
+			a.push.apply(a, args);
+			var Constructor = Function.bind.apply(Parent, a);
+			var instance = new Constructor();
+			if (Class) _setPrototypeOf(instance, Class.prototype);
+			return instance;
+		};
+	}
+	return _construct.apply(null, arguments);
+}
+function _assertThisInitialized(self) {
+	if (self === void 0) {
+		throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+	}
+	return self;
+}
+function _toPrimitive(input, hint) {
+	if (typeof input !== "object" || input === null) return input;
+	var prim = input[Symbol.toPrimitive];
+	if (prim !== undefined) {
+		var res = prim.call(input, hint || "default");
+		if (typeof res !== "object") return res;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+	var key = _toPrimitive(arg, "string");
+	return typeof key === "symbol" ? key : String(key);
+}
+
+function computable() {
+	var _ref;
+	if (arguments.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]);
+	if (typeof compute != "function") throw new Error("Last argument to the computable function should be a function.");
+	var inputs = [],
+		a;
+	for (var i = 0; i + 1 < arguments.length; i++) {
+		a = i < 0 || arguments.length <= i ? undefined : arguments[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.");
+	}
+	function memoize(warmupData) {
+		var lastValue,
+			lastArgs =
+				warmupData &&
+				inputs.map(function (s) {
+					return s(warmupData);
+				});
+		return function (data) {
+			var 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;
+				dirty = true;
+			}
+			if (dirty) lastValue = compute.apply(null, lastArgs);
+			return lastValue;
+		};
+	}
+	var selector = function selector(data) {
+		return compute.apply(
+			null,
+			inputs.map(function (s) {
+				return s(data);
+			})
+		);
+	};
+	selector.memoize = memoize;
+	return selector;
+}
+
+/*
+   Helper usage example
+
+   Expression.registerHelper('_', _);
+   let e = Expression.compile('_.min({data})');
+ */
+
+var expCache = {},
+	helpers = {},
+	helperNames = [],
+	helperValues = [],
+	expFatArrows = null;
+function getExpr(expr) {
+	if (expr.memoize) return expr;
+	function memoize() {
+		var lastValue,
+			lastRunBindings = {},
+			lastRunResults = {},
+			getters = {},
+			currentData,
+			len = -1;
+		var get = function get(bindingWithFormat) {
+			var getter = getters[bindingWithFormat];
+			if (!getter) {
+				var binding = bindingWithFormat,
+					format;
+				var colonIndex = bindingWithFormat.indexOf(":");
+				if (colonIndex != -1) {
+					format = Format.parse(bindingWithFormat.substring(colonIndex + 1));
+					binding = bindingWithFormat.substring(0, colonIndex);
+				} else {
+					var 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);
+					lastRunBindings[len] = b.value;
+					lastRunResults[len] = value;
+					len++;
+					return value;
+				};
+				if (format) {
+					var valueGetter = getter;
+					getter = function getter(data) {
+						return format(valueGetter(data));
+					};
+				}
+				getters[bindingWithFormat] = getter;
+			}
+			return getter(currentData);
+		};
+		return function (data) {
+			var i = 0;
+			for (; i < len; i++) if (lastRunBindings[i](data) !== lastRunResults[i]) break;
+			if (i !== len) {
+				len = 0;
+				currentData = data;
+				lastValue = expr(get);
+			}
+			return lastValue;
+		};
+	}
+	var result = memoize();
+	result.memoize = memoize;
+	return result;
+}
+function expression(str) {
+	if (isFunction(str)) return getExpr(str);
+	var r = expCache[str];
+	if (r) return r;
+	var quote = false;
+	var termStart = -1,
+		curlyBrackets = 0,
+		percentExpression;
+	var fb = ["return ("];
+	var args = {};
+	var formats = [];
+	var subExpr = 0;
+	for (var i = 0; i < str.length; i++) {
+		var c = str[i];
+		switch (c) {
+			case "{":
+				if (curlyBrackets > 0) curlyBrackets++;
+				else {
+					if (!quote && termStart < 0 && (str[i + 1] != "{" || str[i - 1] == "%")) {
+						termStart = i + 1;
+						curlyBrackets = 1;
+						percentExpression = str[i - 1] == "%";
+						if (percentExpression) fb.pop(); //%
+					} else if (str[i - 1] != "{") fb.push(c);
+				}
+				break;
+			case "}":
+				if (termStart >= 0) {
+					if (--curlyBrackets == 0) {
+						var term = str.substring(termStart, i);
+						var 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);
+						if (colon == -1) {
+							var nullSepIndex = binding.indexOf("|", formatStart);
+							if (nullSepIndex != -1) {
+								format = binding.substring(nullSepIndex);
+								binding = binding.substring(0, nullSepIndex);
+							}
+						}
+						var argName = binding.replace(/\./g, "_");
+						if (isDigit(argName[0])) argName = "$" + argName;
+						if (percentExpression || (binding[0] == "[" && binding[binding.length - 1] == "]")) {
+							argName = "expr" + ++subExpr;
+							args[argName] = expression(percentExpression ? binding : binding.substring(1, binding.length - 1));
+						} else args[argName] = binding;
+						if (format) {
+							var formatter = "fmt" + formats.length;
+							fb.push(formatter, "(", argName, ", ", quoteStr(format), ")");
+							formats.push(Format.parse(format));
+						} else fb.push(argName);
+						termStart = -1;
+					}
+				} else fb.push(c);
+				break;
+			case '"':
+			case "'":
+				if (curlyBrackets == 0) {
+					if (!quote) quote = c;
+					else if (str[i - 1] != "\\" && quote == c) quote = false;
+					fb.push(c);
+				}
+				break;
+			default:
+				if (termStart < 0) fb.push(c);
+				break;
+		}
+	}
+	fb.push(")");
+	var body = fb.join("");
+	if (expFatArrows) body = expFatArrows(body);
+
+	//console.log(body);
+	var keys = Object.keys(args);
+	try {
+		var _Function;
+		var compute = (_Function = _construct(
+			Function,
+			formats
+				.map(function (f, i) {
+					return "fmt" + i;
+				})
+				.concat(keys, helperNames, [body])
+		)).bind.apply(_Function, [Format].concat(formats, helperValues));
+		var selector = computable.apply(
+			void 0,
+			keys
+				.map(function (k) {
+					return args[k];
+				})
+				.concat([compute])
+		);
+		expCache[str] = selector;
+		return selector;
+	} catch (err) {
+		throw new Error("Failed to parse expression: '" + str + "'. Error: " + err.message);
+	}
+}
+var Expression = {
+	get: function get(str) {
+		return expression(str);
+	},
+	compile: function compile(str) {
+		return this.get(str).memoize();
+	},
+	registerHelper: function registerHelper(name, helper) {
+		helpers[name] = helper;
+		helperNames = Object.keys(helpers);
+		helperValues = helperNames.map(function (n) {
+			return helpers[n];
+		});
+	},
+};
+function plugFatArrowExpansion(impl) {
+	expFatArrows = impl;
+}
+function invalidateExpressionCache() {
+	expCache = {};
+}
+
+function plus(str) {
+	return str.length ? str + " + " : str;
+}
+var tplCache = {};
+function stringTemplate(str) {
+	var expr = tplCache[str];
+	if (expr) return expr;
+	expr = "";
+	var termStart = -1,
+		quoteStart = 0,
+		term,
+		bracketsOpen = 0,
+		percentSign;
+	for (var i = 0; i < str.length; i++) {
+		var c = str[i];
+		switch (c) {
+			case "{":
+				if (termStart < 0) {
+					if (str[i + 1] == "{" && str[i - 1] != "%") {
+						expr = plus(expr) + quoteStr(str.substring(quoteStart, i) + "{");
+						i++;
+						quoteStart = i + 1;
+					} else {
+						termStart = i + 1;
+						percentSign = str[i - 1] == "%";
+						if (i > quoteStart) expr = plus(expr) + quoteStr(str.substring(quoteStart, percentSign ? i - 1 : i));
+						bracketsOpen = 1;
+					}
+				} else bracketsOpen++;
+				break;
+			case "}":
+				if (termStart >= 0) {
+					if (--bracketsOpen == 0) {
+						term = str.substring(termStart, i);
+						if (term.indexOf(":") == -1) {
+							var nullSepIndex = term.indexOf("|");
+							if (nullSepIndex == -1) term += ":s";
+							else term = term.substring(0, nullSepIndex) + ":s" + term.substring(nullSepIndex);
+						}
+						expr = plus(expr) + (percentSign ? "%{" : "{") + term + "}";
+						termStart = -1;
+						quoteStart = i + 1;
+						bracketsOpen = 0;
+					}
+				} else if (str[i + 1] == "}") {
+					expr = plus(expr) + quoteStr(str.substring(quoteStart, i) + "}");
+					i++;
+					quoteStart = i + 1;
+				}
+				break;
+		}
+	}
+	if (quoteStart < str.length) expr = plus(expr) + quoteStr(str.substring(quoteStart));
+	return (tplCache[str] = expression(expr));
+}
+var StringTemplate = {
+	get: function get(str) {
+		return stringTemplate(str);
+	},
+	compile: function compile(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);
+	},
+};
+function invalidateStringTemplateCache() {
+	tplCache = {};
+}
+
+var Ref = /*#__PURE__*/ (function (_Component) {
+	_inheritsLoose(Ref, _Component);
+	function Ref(config) {
+		var _this;
+		_this = _Component.call(this, config) || this;
+		_this.get = _this.get.bind(_assertThisInitialized(_this));
+		if (_this.set) _this.set = _this.set.bind(_assertThisInitialized(_this));
+		return _this;
+	}
+	var _proto = Ref.prototype;
+	_proto.get = function 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) {
+		return Ref.create(config, {
+			get: this.get,
+			set: this.set,
+		});
+	};
+	_proto.ref = function ref(path) {
+		var _this2 = this;
+		var 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);
+				if (data === newData) return false;
+				return _this2.set(newData);
+			},
+		});
+	};
+
+	//allows the function to be passed as a selector, e.g. to computable or addTrigger
+	_proto.memoize = function memoize() {
+		return this.get;
+	};
+	return Ref;
+})(Component);
+Ref.prototype.isRef = true;
+Ref.factory = function (alias, config, more) {
+	if (isFunction(alias)) {
+		var cfg = _objectSpread2(_objectSpread2({}, config), more);
+		if (cfg.store) Object.assign(cfg, cfg.store.getMethods());
+		var result = alias(cfg);
+		if (result instanceof Ref) return result;
+		return this.create(_objectSpread2(_objectSpread2(_objectSpread2({}, config), more), result));
+	}
+	return this.create(_objectSpread2(_objectSpread2({}, config), more));
+};
+
+var StoreRef = /*#__PURE__*/ (function (_Ref) {
+	_inheritsLoose(StoreRef, _Ref);
+	function StoreRef(config) {
+		var _this;
+		_this = _Ref.call(this, config) || this;
+		if (isAccessorChain(_this.path)) _this.path = _this.path.toString();
+		return _this;
+	}
+	var _proto = StoreRef.prototype;
+	_proto.get = function get() {
+		return this.store.get(this.path);
+	};
+	_proto.set = function set(value) {
+		return this.store.set(this.path, value);
+	};
+	_proto.init = function init(value) {
+		return this.store.init(this.path, value);
+	};
+	_proto.toggle = function 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));
+	};
+
+	//allows the function to be passed as a selector, e.g. to computable or addTrigger
+	_proto.memoize = function memoize() {
+		return this.get;
+	};
+	_proto.ref = function ref(path) {
+		return new StoreRef({
+			path: this.path + "." + path,
+			store: this.store,
+		});
+	};
+	_proto.as = function 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) {
+		Object.assign(this, config);
+		this.cache = {
+			version: -1,
+		};
+		if (this.store) this.setStore(this.store);
+	}
+	var _proto = View.prototype;
+	_proto.getData = function getData() {
+		throw new Error("abstract method");
+	};
+	_proto.init = function init(path, value) {
+		if (typeof path == "object" && path != null) {
+			var changed = false;
+			for (var 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);
+		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;
+			return changed;
+		}
+		var 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);
+		});
+	};
+
+	//protected
+	_proto.setItem = function 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;
+		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);
+		return this.deleteItem(binding.path);
+	};
+
+	//protected
+	_proto.deleteItem = function deleteItem(path) {
+		if (this.store) return this.store.deleteItem(path);
+		throw new Error("abstract method");
+	};
+	_proto.clear = function clear() {
+		if (this.store) return this.store.clear();
+		throw new Error("abstract method");
+	};
+	_proto.get = function get(path) {
+		var 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);
+			});
+		return Binding.get(path).value(storeData);
+	};
+	_proto.toggle = function 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];
+		}
+		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);
+		if (dirty) this.notify();
+		return dirty;
+	};
+	_proto.silently = function silently(callback) {
+		if (this.store) return this.store.silently(callback);
+		throw new Error("abstract method");
+	};
+	_proto.notify = function notify(path) {
+		if (this.notificationsSuspended) this.dirty = true;
+		else this.doNotify(path);
+	};
+	_proto.doNotify = function doNotify(path) {
+		if (this.store) return this.store.notify(path);
+		throw new Error("abstract method");
+	};
+	_proto.subscribe = function 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) {
+		if (this.store) return this.store.dispatch(action);
+		throw new Error("The underlying store doesn't support dispatch.");
+	};
+	_proto.getMeta = function getMeta() {
+		return this.meta;
+	};
+	_proto.setStore = function setStore(store) {
+		this.store = store;
+		this.meta = store.getMeta();
+	};
+	_proto.ref = function ref(path, defaultValue) {
+		if (isDefined(defaultValue)) this.init(path, defaultValue);
+		return StoreRef.create({
+			store: this,
+			path: path,
+		});
+	};
+	_proto.getMethods = function 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),
+			toggle: this.toggle.bind(this),
+			init: this.init.bind(this),
+			ref: this.ref.bind(this),
+			mutate: this.ref.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) {
+	_inheritsLoose(SubscribableView, _View);
+	function SubscribableView(config) {
+		var _this;
+		_this = _View.call(this, config) || this;
+		_this.subscribers = new SubscriberList();
+		_this.changes = [];
+		return _this;
+	}
+	var _proto = SubscribableView.prototype;
+	_proto.subscribe = function subscribe(callback) {
+		return this.subscribers.subscribe(callback);
+	};
+	_proto.unsubscribeAll = function unsubscribeAll() {
+		this.subscribers.clear();
+	};
+	_proto.doNotify = function doNotify(path) {
+		var _this2 = this;
+		if (this.notificationsSuspended) return;
+		if (!this.async) {
+			this.subscribers.notify([path]);
+		} else {
+			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);
+				}, 0);
+			}
+		}
+	};
+	_proto.silently = function silently(callback) {
+		this.notificationsSuspended = (this.notificationsSuspended || 0) + 1;
+		var wasDirty = this.dirty,
+			dirty;
+		this.dirty = false;
+		try {
+			callback(this);
+		} finally {
+			this.notificationsSuspended--;
+			dirty = this.dirty;
+			this.dirty = wasDirty;
+		}
+		return dirty;
+	};
+	return SubscribableView;
+})(View);
+SubscribableView.prototype.async = false;
+
+var Store = /*#__PURE__*/ (function (_SubscribableView) {
+	_inheritsLoose(Store, _SubscribableView);
+	function Store(config) {
+		var _this;
+		if (config === void 0) {
+			config = {};
+		}
+		_this = _SubscribableView.call(this, config) || this;
+		_this.data = config.data || {};
+		_this.meta = {
+			version: 0,
+		};
+		return _this;
+	}
+	var _proto = Store.prototype;
+	_proto.getData = function getData() {
+		return this.data;
+	};
+	_proto.setItem = function setItem(path, value) {
+		var next = Binding.get(path).set(this.data, value);
+		if (next != this.data) {
+			this.data = next;
+			this.meta.version++;
+			this.notify(path);
+			return true;
+		}
+		return false;
+	};
+	_proto.deleteItem = function deleteItem(path) {
+		var next = Binding.get(path)["delete"](this.data);
+		if (next != this.data) {
+			this.data = next;
+			this.meta.version++;
+			this.notify(path);
+			return true;
+		}
+		return false;
+	};
+	_proto.clear = function clear() {
+		this.data = {};
+		this.meta.version++;
+		this.notify();
+	};
+	return Store;
+})(SubscribableView);
+Store.prototype.async = false;
+
+var ExposedRecordView = /*#__PURE__*/ (function (_View) {
+	_inheritsLoose(ExposedRecordView, _View);
+	function ExposedRecordView() {
+		return _View.apply(this, arguments) || this;
+	}
+	var _proto = ExposedRecordView.prototype;
+	_proto.getData = function getData() {
+		if (this.sealed && this.meta.version === this.cache.version && this.cache.itemIndex === this.itemIndex)
+			return this.cache.result;
+		this.cache.result = this.embed(this.store.getData());
+		this.cache.version = this.meta.version;
+		this.cache.itemIndex = this.itemIndex;
+		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 ? _objectSpread2({}, data) : data;
+		copy[this.recordName] = record;
+		if (this.indexName) copy[this.indexName] = this.itemIndex;
+		return copy;
+	};
+	_proto.setIndex = function setIndex(index) {
+		this.itemIndex = index;
+	};
+	_proto.setItem = function 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);
+			if (d === data) return false;
+			var record = d[this.recordName];
+			var newCollection = [].concat(
+				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;
+		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));
+			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);
+			if (d === data) return false;
+			var record = d[this.recordName];
+			newCollection = [].concat(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) {
+	_inheritsLoose(ExposedValueView, _View);
+	function ExposedValueView() {
+		return _View.apply(this, arguments) || this;
+	}
+	var _proto = ExposedValueView.prototype;
+	_proto.getData = function getData() {
+		if (this.sealed && this.meta.version === this.cache.version && this.cache.key === this.key)
+			return this.cache.result;
+		var data = this.store.getData();
+		var container = this.containerBinding.value(data) || {};
+		var 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 ? _objectSpread2({}, data) : data;
+		this.cache.result[this.recordName] = record;
+		return this.cache.result;
+	};
+	_proto.setKey = function setKey(key) {
+		this.key = key;
+	};
+	_proto.getKey = function getKey() {
+		return this.key;
+	};
+	_proto.setItem = function setItem(path, value) {
+		if (path == this.recordName || path.indexOf(this.recordName + ".") == 0) {
+			var data = this.getData();
+			var d = Binding.get(path).set(data, value);
+			if (d === data) return false;
+			var container = this.containerBinding.value(d);
+			var record = d[this.recordName];
+			var newContainer = Object.assign({}, container);
+			newContainer[this.key] = record;
+			return this.store.setItem(this.containerBinding.path, newContainer);
+		}
+		return this.store.setItem(path, value);
+	};
+	_proto.deleteItem = function deleteItem(path) {
+		var data, container, newContainer;
+		if (path == this.recordName) {
+			data = this.getData();
+			container = this.containerBinding.value(data);
+			if (!container || !container.hasOwnProperty(path)) return false;
+			newContainer = Object.assign({}, container);
+			delete newContainer[this.key];
+			this.store.set(this.containerBinding.path, newContainer);
+		} else if (path.indexOf(this.recordName + ".") == 0) {
+			data = this.getData();
+			var d = Binding.get(path)["delete"](data);
+			if (d === data) return false;
+			container = this.containerBinding.value(d);
+			var record = d[this.recordName];
+			newContainer = Object.assign({}, container);
+			newContainer[this.key] = record;
+			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) {
+	_inheritsLoose(ReadOnlyDataView, _View);
+	function ReadOnlyDataView() {
+		return _View.apply(this, arguments) || this;
+	}
+	var _proto = ReadOnlyDataView.prototype;
+	_proto.getData = function getData() {
+		if (this.sealed && this.meta.version === this.cache.version && this.cache.data === this.data)
+			return this.cache.result;
+		var data = this.store.getData();
+		this.cache.result =
+			this.sealed || this.immutable || this.store.sealed
+				? Object.assign({}, data, this.getAdditionalData(data))
+				: Object.assign(data, this.getAdditionalData(data));
+		this.cache.version = this.meta.version;
+		this.cache.data = this.data;
+		return this.cache.result;
+	};
+	_proto.getAdditionalData = function getAdditionalData() {
+		return this.data;
+	};
+	_proto.setData = function setData(data) {
+		this.data = data;
+	};
+	return ReadOnlyDataView;
+})(View);
+ReadOnlyDataView.prototype.immutable = false;
+
+var AugmentedViewBase = /*#__PURE__*/ (function (_View) {
+	_inheritsLoose(AugmentedViewBase, _View);
+	function AugmentedViewBase() {
+		return _View.apply(this, arguments) || this;
+	}
+	var _proto = AugmentedViewBase.prototype;
+	_proto.getData = function getData() {
+		if (this.meta.version === this.cache.version && this.sealed) return this.cache.result;
+		var parentStoreData = this.store.getData();
+		var result = this.getBaseData(parentStoreData);
+		this.embedAugmentData(result, parentStoreData);
+		this.cache.result = result;
+		this.cache.parentStoreData = parentStoreData;
+		this.cache.version = this.meta.version;
+		return this.cache.result;
+	};
+	_proto.getBaseData = function getBaseData(parentStoreData) {
+		if (this.sealed || this.immutable || this.store.sealed) return _objectSpread2({}, parentStoreData);
+		return parentStoreData;
+	};
+	_proto.embedAugmentData = function embedAugmentData(result, parentStoreData) {
+		throw new Error("abstract");
+	};
+	_proto.isExtraKey = function isExtraKey(key) {
+		throw new Error("abstract");
+	};
+	_proto.setExtraKeyValue = function setExtraKeyValue(key, value) {
+		throw new Error("abstract");
+	};
+	_proto.deleteExtraKeyValue = function deleteExtraKeyValue(key) {
+		throw new Error("abstract");
+	};
+	_proto.setItem = function setItem(path, value) {
+		var binding = Binding.get(path);
+		if (this.isExtraKey(binding.parts[0])) {
+			var bindingRoot = binding.parts[0];
+			var newValue = value;
+			if (binding.parts.length > 1) {
+				var data = {};
+				this.embedAugmentData(data, this.store.getData());
+				newValue = binding.set(data, value)[bindingRoot];
+			}
+			return this.setExtraKeyValue(bindingRoot, newValue);
+		}
+		return _View.prototype.setItem.call(this, path, value);
+	};
+	_proto.deleteItem = function deleteItem(path) {
+		var binding = Binding.get(path);
+		if (this.isExtraKey(binding.parts[0])) {
+			var bindingRoot = binding.parts[0];
+			if (binding.parts.length == 1) return this.deleteExtraKeyValue(bindingRoot);
+			var data = {};
+			this.embedAugmentData(data, this.store.getData());
+			var newValue = binding["delete"](data)[bindingRoot];
+			return this.setExtraKeyValue(bindingRoot, newValue);
+		}
+		return _View.prototype.deleteItem.call(this, path);
+	};
+	return AugmentedViewBase;
+})(View);
+AugmentedViewBase.prototype.immutable = false;
+
+var NestedDataView = /*#__PURE__*/ (function (_AugmentedViewBase) {
+	_inheritsLoose(NestedDataView, _AugmentedViewBase);
+	function NestedDataView() {
+		return _AugmentedViewBase.apply(this, arguments) || this;
+	}
+	var _proto = NestedDataView.prototype;
+	_proto.embedAugmentData = function embedAugmentData(result, parentStoreData) {
+		if (this.nestedData) {
+			var nested = this.nestedData.getSelector()(parentStoreData);
+			for (var 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);
+
+var ZoomIntoPropertyView = /*#__PURE__*/ (function (_NestedDataView) {
+	_inheritsLoose(ZoomIntoPropertyView, _NestedDataView);
+	function ZoomIntoPropertyView() {
+		return _NestedDataView.apply(this, arguments) || this;
+	}
+	var _proto = ZoomIntoPropertyView.prototype;
+	_proto.getBaseData = function getBaseData(parentStoreData) {
+		var x = this.binding.value(parentStoreData);
+		if (x != null && typeof x != "object") throw new Error("Zoomed value must be an object.");
+		return _objectSpread2({}, x);
+	};
+	_proto.embedAugmentData = function 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);
+ZoomIntoPropertyView.prototype.rootName = "$root";
+
+function createStructuredSelector(selector, constants) {
+	var keys = Object.keys(selector);
+	if (keys.length == 0)
+		return function () {
+			return constants;
+		};
+	function memoize() {
+		var lastResult = Object.assign({}, constants);
+		var memoizedSelectors = {};
+		keys.forEach(function (key) {
+			memoizedSelectors[key] = selector[key].memoize ? selector[key].memoize() : selector[key];
+			lastResult[key] = undefined;
+		});
+		return function (data) {
+			var result = lastResult,
+				k,
+				v,
+				i;
+			for (i = 0; i < keys.length; i++) {
+				k = keys[i];
+				v = memoizedSelectors[k](data);
+				if (result === lastResult) {
+					if (v === lastResult[k]) continue;
+					result = Object.assign({}, lastResult);
+				}
+				result[k] = v;
+			}
+			return (lastResult = result);
+		};
+	}
+	function evaluate(data) {
+		var result = Object.assign({}, constants);
+		for (var i = 0; i < keys.length; i++) {
+			result[keys[i]] = selector[keys[i]](data);
+		}
+		return result;
+	}
+	evaluate.memoize = memoize;
+	return evaluate;
+}
+
+function isSelector(config) {
+	if (config == null) return true;
+	switch (typeof config) {
+		case "object":
+			if (config.type || config.$type) return false;
+			return !!(config.bind || config.tpl || config.expr || config.get);
+		case "function":
+			return true;
+		case "string":
+			return true;
+		case "number":
+			return true;
+		case "boolean":
+			return true;
+	}
+	return false;
+}
+
+var undefinedF = function undefinedF() {
+	return undefined;
+};
+var nullF = function nullF() {
+	return 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);
+					});
+				};
+			}
+
+			//toString converts accessor chains to binding paths
+			if (config.bind) return Binding.get(config.bind.toString()).value;
+			if (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];
+			}
+			return createStructuredSelector(selectors, constants);
+		case "function":
+			if (isAccessorChain(config)) return Binding.get(config.toString()).value;
+			return config;
+		default:
+			return function () {
+				return config;
+			};
+	}
+}
+
+function defaultValue(pv) {
+	if (typeof pv == "object" && pv && pv.structured) return pv.defaultValue;
+	return pv;
+}
+function getSelectorConfig(props, values, nameMap) {
+	var functions = {},
+		structures = {},
+		defaultValues = {},
+		constants,
+		p,
+		v,
+		pv,
+		constant = true;
+	for (p in props) {
+		v = values[p];
+		pv = props[p];
+		if (isUndefined(v) && pv && (pv.bind || pv.tpl || pv.expr)) v = pv;
+		if (v === null) {
+			if (!constants) constants = {};
+			constants[p] = null;
+		} else if (typeof v == "object") {
+			if (v.bind) {
+				if (isUndefined(v.defaultValue) && v != pv) v.defaultValue = defaultValue(pv);
+				if (isDefined(v.defaultValue)) defaultValues[v.bind] = v.defaultValue;
+				nameMap[p] = v.bind;
+				functions[p] = Binding.get(v.bind).value;
+				constant = false;
+			} else if (v.expr) {
+				functions[p] = Expression.get(v.expr);
+				constant = false;
+			} else if (v.get) {
+				functions[p] = v.get;
+				constant = false;
+			} else if (v.tpl) {
+				functions[p] = StringTemplate.get(v.tpl);
+				constant = false;
+			} else if (pv && typeof pv == "object" && pv.structured) {
+				if (isArray(v)) functions[p] = getSelector(v);
+				else {
+					var s = getSelectorConfig(v, v, {});
+					structures[p] = s;
+					Object.assign(defaultValues, s.defaultValues);
+				}
+				constant = false;
+			} else {
+				if (!constants) constants = {};
+				constants[p] = v;
+			}
+		} else if (isFunction(v)) {
+			if (isAccessorChain(v)) {
+				var path = v.toString();
+				nameMap[p] = path;
+				functions[p] = Binding.get(path).value;
+			} else functions[p] = v;
+			constant = false;
+		} else {
+			if (isUndefined(v)) {
+				if (isUndefined(pv)) continue;
+				v = defaultValue(pv);
+			}
+			if (isUndefined(v)) continue;
+			if (!constants) constants = {};
+			constants[p] = v;
+		}
+	}
+	return {
+		functions: functions,
+		structures: structures,
+		defaultValues: defaultValues,
+		constants: constants,
+		constant: constant,
+	};
+}
+function createSelector(_ref) {
+	var functions = _ref.functions,
+		structures = _ref.structures,
+		constants = _ref.constants;
+	_ref.defaultValues;
+	var selector = {};
+	for (var n in functions) {
+		selector[n] = functions[n];
+	}
+	for (var _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;
+		this.nameMap = {};
+		this.config = getSelectorConfig(props, values, this.nameMap);
+	}
+	var _proto = StructuredSelector.prototype;
+	_proto.init = function init(store) {
+		store.init(this.config.defaultValues);
+	};
+	_proto.create = function create(memoize) {
+		if (memoize === void 0) {
+			memoize = true;
+		}
+		var selector = createSelector(this.config);
+		if (memoize && selector.memoize) return selector.memoize();
+		return selector;
+	};
+	_proto.createStoreSelector = function createStoreSelector() {
+		if (this.config.constant) {
+			var result = _objectSpread2({}, this.config.constants);
+			return function () {
+				return result;
+			};
+		}
+		var selector = this.create();
+		return function (store) {
+			return selector(store.getData());
+		};
+	};
+	return StructuredSelector;
+})();
+
+var AggregateFunction = /*#__PURE__*/ (function () {
+	function AggregateFunction() {}
+	AggregateFunction.sum = function sum() {
+		return new Sum();
+	};
+	AggregateFunction.avg = function avg() {
+		return new Avg();
+	};
+	AggregateFunction.count = function count() {
+		return new Count();
+	};
+	AggregateFunction.distinct = function distinct() {
+		return new Distinct();
+	};
+	AggregateFunction.min = function min() {
+		return new Min();
+	};
+	AggregateFunction.max = function max() {
+		return new Max();
+	};
+	return AggregateFunction;
+})();
+var Sum = /*#__PURE__*/ (function () {
+	function Sum() {}
+	var _proto = Sum.prototype;
+	_proto.process = function process(value) {
+		this.empty = false;
+		if (!isNaN(value)) this.result += value;
+		else this.invalid = true;
+	};
+	_proto.getResult = function 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;
+		}
+		this.empty = false;
+		if (!isNaN(value) && !isNaN(count)) {
+			this.result += value * count;
+			this.count += count;
+		} else this.invalid = true;
+	};
+	_proto2.getResult = function 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) {
+		if (value != null) this.result++;
+	};
+	_proto3.getResult = function getResult() {
+		return this.result;
+	};
+	return Count;
+})();
+Count.prototype.result = 0;
+var Distinct = /*#__PURE__*/ (function () {
+	function Distinct() {
+		this.values = {};
+	}
+	var _proto4 = Distinct.prototype;
+	_proto4.process = function process(value) {
+		if (value == null || this.values[value]) return;
+		this.values[value] = true;
+		this.empty = false;
+		this.result++;
+	};
+	_proto4.getResult = function 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) {
+		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() {
+		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) {
+		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() {
+		if (this.empty || this.invalid) return null;
+		return this.result;
+	};
+	return Min;
+})();
+Min.prototype.result = 0;
+Min.prototype.empty = true;
+
+/*
+ 'column': {
+   index: 0,
+   sort: 'asc',
+   group: true
+   aggregate: 'count'
+ }
+ */
+
+function transform(o, f) {
+	var res = {};
+	for (var k in o) res[k] = f(o[k], k);
+	return res;
+}
+var Grouper = /*#__PURE__*/ (function () {
+	function Grouper(key, aggregates, dataGetter, nameGetter) {
+		this.keys = Object.keys(key).map(function (k) {
+			return {
+				name: k,
+				value: getSelector(key[k]),
+			};
+		});
+		if (nameGetter) this.nameGetter = getSelector(nameGetter);
+		this.dataGetter =
+			dataGetter ||
+			function (x) {
+				return x;
+			};
+		this.aggregates =
+			aggregates &&
+			transform(aggregates, function (prop) {
+				if (!AggregateFunction[prop.type]) throw new Error("Unknown aggregate function '" + prop.type + "'.");
+				return {
+					value: getSelector(prop.value),
+					weight: getSelector(prop.weight || 1),
+					type: prop.type,
+				};
+			});
+		this.reset();
+	}
+	var _proto = Grouper.prototype;
+	_proto.reset = function reset() {
+		this.groups = this.initGroup(this.keys.length == 0);
+	};
+	_proto.initGroup = function initGroup(leaf) {
+		if (!leaf) return {};
+		return {
+			records: [],
+			indexes: [],
+			aggregates:
+				this.aggregates &&
+				transform(this.aggregates, function (prop) {
+					var f = AggregateFunction[prop.type];
+					return {
+						processor: f(),
+						value: prop.value,
+						weight: prop.weight,
+					};
+				}),
+		};
+	};
+	_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]];
+			if (!sg) {
+				sg = g[key[i]] = this.initGroup(i + 1 == key.length);
+				if (this.nameGetter) sg.name = this.nameGetter(data);
+			}
+			g = sg;
+		}
+		g.records.push(record);
+		g.indexes.push(index);
+		if (g.aggregates) {
+			for (var 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;
+		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;
+		if (level == this.keys.length) {
+			var key = {};
+			this.keys.forEach(function (k, i) {
+				return (key[k.name] = path[i]);
+			});
+			results.push({
+				key: key,
+				name: g.name,
+				records: g.records,
+				indexes: g.indexes,
+				aggregates: transform(g.aggregates, function (p) {
+					return p.processor.getResult();
+				}),
+			});
+		} else {
+			Object.keys(g).forEach(function (k) {
+				return _this2.report(g[k], [].concat(path, [k]), level + 1, results);
+			});
+		}
+	};
+	_proto.getResults = function getResults() {
+		var g = this.groups;
+		var results = [];
+		this.report(g, [], 0, results);
+		return results;
+	};
+	return Grouper;
+})();
+
+function defaultCompare(av, bv) {
+	if (av == null) {
+		if (bv == null) return 0;
+		return -1;
+	}
+	if (bv == null || av > bv) return 1;
+	if (av < bv) return -1;
+	return 0;
+}
+
+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;
+			  };
+		return {
+			getter: dataAccessor
+				? function (x) {
+						return 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++) {
+			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);
+			if (r == 0) continue;
+			return d.factor * r;
+		}
+		return 0;
+	};
+}
+function indexSorter(sorters, dataAccessor, compare) {
+	var cmp = getComparer(sorters, dataAccessor, compare);
+	return function (data) {
+		var result = Array.from(
+			{
+				length: data.length,
+			},
+			function (v, k) {
+				return k;
+			}
+		);
+		result.sort(function (ia, ib) {
+			return cmp(data[ia], data[ib]);
+		});
+		return result;
+	};
+}
+function sorter(sorters, dataAccessor, compare) {
+	var cmp = getComparer(sorters, dataAccessor, compare);
+	return function (data) {
+		var result = [].concat(data);
+		result.sort(cmp);
+		return result;
+	};
+}
+
+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;
+	if (!array) return items;
+	return [].concat(array, items);
+}
+
+function merge(item, data) {
+	var result = item;
+	if (data) for (var 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;
+	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];
+		if (removeFilter && removeFilter(item, index)) {
+			dirty = true;
+			continue;
+		}
+		if (!itemFilter || itemFilter(item, index)) {
+			var newItem = updateCallback(item, index);
+			newArray.push(newItem);
+			if (newItem !== item) dirty = true;
+		} else newArray.push(item);
+	}
+	return dirty ? newArray : array;
+}
+
+function updateTree(array, updateCallback, itemFilter, childrenField, removeFilter) {
+	return updateArray(
+		array,
+		function (item) {
+			var _objectSpread2$1;
+			if (!itemFilter || itemFilter(item)) item = updateCallback(item);
+			var children = item[childrenField];
+			if (!Array.isArray(children)) return item;
+			var updatedChildren = updateTree(children, updateCallback, itemFilter, childrenField, removeFilter);
+			if (updatedChildren != children)
+				return _objectSpread2(
+					_objectSpread2({}, item),
+					{},
+					((_objectSpread2$1 = {}), (_objectSpread2$1[childrenField] = updatedChildren), _objectSpread2$1)
+				);
+			return item;
+		},
+		null,
+		removeFilter
+	);
+}
+
+function removeTreeNodes(array, criteria, childrenField) {
+	if (childrenField === void 0) {
+		childrenField = "$children";
+	}
+	return updateTree(
+		array,
+		null,
+		function () {
+			return false;
+		},
+		childrenField,
+		criteria
+	);
+}
+
+function findTreeNode(array, criteria, childrenField) {
+	if (childrenField === void 0) {
+		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;
+	}
+	return false;
+}
+
+function moveElement(array, sourceIndex, targetIndex) {
+	if (targetIndex == sourceIndex) return array;
+	var el = array[sourceIndex];
+	var res = [].concat(array);
+	if (sourceIndex < targetIndex) {
+		for (var i = sourceIndex; i + 1 < targetIndex; i++) res[i] = res[i + 1];
+		targetIndex--;
+	} else {
+		for (var _i = sourceIndex; _i > targetIndex; _i--) res[_i] = res[_i - 1];
+	}
+	res[targetIndex] = el;
+	return res;
+}
+
+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 findTreePath(array, criteria, childrenField, currentPath) {
+	if (childrenField === void 0) {
+		childrenField = "$children";
+	}
+	if (currentPath === void 0) {
+		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);
+		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
+				changed.push({
+					before: old,
+					after: el,
+				});
+		}
+	}
+	var removed = Array.from(map.values());
+	return {
+		added: added,
+		changed: changed,
+		unchanged: unchanged,
+		removed: removed,
+	};
+}
+
+var ArrayRef = /*#__PURE__*/ (function (_Ref) {
+	_inheritsLoose(ArrayRef, _Ref);
+	function ArrayRef() {
+		return _Ref.apply(this, arguments) || this;
+	}
+	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) {
+		this.update(moveElement, fromIndex, toIndex);
+	};
+	_proto.clear = function clear() {
+		this.set([]);
+	};
+	_proto.sort = function sort(compare) {
+		var data = this.get();
+		if (!data) return;
+		var x = [].concat(data);
+		x.sort(compare);
+		this.set(x);
+	};
+	return ArrayRef;
+})(Ref);
+
+var StoreProxy = /*#__PURE__*/ (function (_View) {
+	_inheritsLoose(StoreProxy, _View);
+	function StoreProxy(getStore) {
+		var _this;
+		_this =
+			_View.call(this, {
+				store: getStore(),
+			}) || this;
+		Object.defineProperty(_assertThisInitialized(_this), "store", {
+			get: getStore,
+		});
+		return _this;
+	}
+	var _proto = StoreProxy.prototype;
+	_proto.getData = function getData() {
+		return this.store.getData();
+	};
+	return StoreProxy;
+})(View);
+
+var ArrayElementView = /*#__PURE__*/ (function (_AugmentedViewBase) {
+	_inheritsLoose(ArrayElementView, _AugmentedViewBase);
+	function ArrayElementView() {
+		return _AugmentedViewBase.apply(this, arguments) || this;
+	}
+	var _proto = ArrayElementView.prototype;
+	_proto.isExtraKey = function isExtraKey(key) {
+		return key == this.recordAlias || key == this.indexAlias || key == this.lengthAlias;
+	};
+	_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());
+		if (!array) return false;
+		var newArray = [].concat(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());
+		if (!array || value === array[this.itemIndex]) return false;
+		var newArray = [].concat(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);
+		if (!isArray(array)) return;
+		result[this.recordAlias] = array[this.itemIndex];
+		result[this.indexAlias] = this.itemIndex;
+		result[this.lengthAlias] = array.length;
+	};
+	_proto.setIndex = function 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;
+	if (isObject(accessor)) {
+		if (accessor.isAccessor || accessor.isRef) return accessor;
+		if (isBinding(accessor)) {
+			var binding = Binding.get(accessor);
+			return {
+				get: binding.value,
+				set: function set(v, store) {
+					return store.set(binding.path, v);
+				},
+				isAccessor: true,
+			};
+		}
+	}
+	if (isAccessorChain(accessor)) {
+		var _binding = Binding.get(accessor);
+		return {
+			get: _binding.value,
+			set: function set(v, store) {
+				return store.set(_binding.path, v);
+			},
+			isAccessor: true,
+		};
+	}
+	if (isSelector(accessor)) {
+		var selector = getSelector(accessor);
+		if (accessor && accessor.set)
+			return {
+				get: selector,
+				isAccessor: true,
+				bindInstance: function bindInstance(instance) {
+					return {
+						get: selector,
+						set: function set(value) {
+							return accessor.set(value, instance);
+						},
+						isAccessor: true,
+					};
+				},
+			};
+		return {
+			get: selector,
+			isAccessor: true,
+		};
+	}
+	return {
+		get: function get() {
+			return accessor;
+		},
+	};
+}
+
+export {
+	ArrayElementView,
+	ArrayRef,
+	AugmentedViewBase,
+	Binding,
+	ExposedRecordView,
+	ExposedValueView,
+	Expression,
+	Grouper,
+	NestedDataView,
+	ReadOnlyDataView,
+	Ref,
+	Store,
+	StoreProxy,
+	StringTemplate,
+	StructuredSelector,
+	SubscribableView,
+	View,
+	ZoomIntoPropertyView,
+	append,
+	computable,
+	createAccessorModelProxy,
+	defaultCompare,
+	diffArrays,
+	enableFatArrowExpansion,
+	expression,
+	filter,
+	findTreeNode,
+	findTreePath,
+	getAccessor,
+	getComparer,
+	getSelector,
+	indexSorter,
+	insertElement,
+	invalidateExpressionCache,
+	invalidateStringTemplateCache,
+	isAccessorChain,
+	isBinding,
+	isSelector,
+	merge,
+	moveElement,
+	plugFatArrowExpansion,
+	removeTreeNodes,
+	sorter,
+	stringTemplate,
+	updateArray,
+	updateTree,
+};