objectmodel 4.3.0 → 4.4.0

package/dist/object-model.js

@@ -1,48 +1,48 @@
-// ObjectModel v4.3.0 - http://objectmodel.js.org
+// ObjectModel v4.4.0 - http://objectmodel.js.org
 // MIT License - Sylvain Pollet-Villard
-const
-	ObjectProto = Object.prototype,
-	bettertypeof = x => ObjectProto.toString.call(x).match(/\s([a-zA-Z]+)/)[1],
-	getProto = Object.getPrototypeOf,
-	setProto = Object.setPrototypeOf,
-
-	has = (o, prop) => ObjectProto.hasOwnProperty.call(o, prop),
-	is = (Constructor, obj) => obj instanceof Constructor,
-	isFunction = f => typeof f === "function",
-	isObject = o => o && typeof o === "object",
-	isString = s => typeof s === "string",
-	isPlainObject = o => isObject(o) && getProto(o) === ObjectProto,
-	isIterable = x => x && isFunction(x[Symbol.iterator]),
-
-	proxify = (val, traps) => new Proxy(val, traps),
-
-	merge = (target, src = {}) => {
-		for (let key in src) {
-			if (isPlainObject(src[key])) {
-				const o = {};
-				merge(o, target[key]);
-				merge(o, src[key]);
-				target[key] = o;
-			} else {
-				target[key] = src[key];
-			}
-		}
-		return target
-	},
-
-	define = (obj, key, value, enumerable = false) => {
-		Object.defineProperty(obj, key, { value, enumerable, writable: true, configurable: true });
-	},
-
-	extend = (child, parent, props) => {
-		child.prototype = Object.assign(Object.create(parent.prototype, {
-			constructor: {
-				value: child,
-				writable: true,
-				configurable: true
-			}
-		}), props);
-		setProto(child, parent);
+const
+	ObjectProto = Object.prototype,
+	bettertypeof = x => ObjectProto.toString.call(x).match(/\s([a-zA-Z]+)/)[1],
+	getProto = Object.getPrototypeOf,
+	setProto = Object.setPrototypeOf,
+
+	has = (o, prop) => ObjectProto.hasOwnProperty.call(o, prop),
+	is = (Constructor, obj) => obj instanceof Constructor,
+	isFunction = f => typeof f === "function",
+	isObject = o => o && typeof o === "object",
+	isString = s => typeof s === "string",
+	isPlainObject = o => isObject(o) && getProto(o) === ObjectProto,
+	isIterable = x => x && isFunction(x[Symbol.iterator]),
+
+	proxify = (val, traps) => new Proxy(val, traps),
+
+	merge = (target, src = {}) => {
+		for (let key in src) {
+			if (isPlainObject(src[key])) {
+				const o = {};
+				merge(o, target[key]);
+				merge(o, src[key]);
+				target[key] = o;
+			} else {
+				target[key] = src[key];
+			}
+		}
+		return target
+	},
+
+	define = (obj, key, value, enumerable = false) => {
+		Object.defineProperty(obj, key, { value, enumerable, writable: true, configurable: true });
+	},
+
+	extend = (child, parent, props) => {
+		child.prototype = Object.assign(Object.create(parent.prototype, {
+			constructor: {
+				value: child,
+				writable: true,
+				configurable: true
+			}
+		}), props);
+		setProto(child, parent);
 	};
 
 const
@@ -74,7 +74,8 @@ const
 		if (is(model, obj)) return obj
 
 		if (!isObject(obj) && !isFunction(obj) && obj !== undefined) {
-			stackError(model.errors, Object, obj);
+			// short circuit validation if not receiving an object as expected
+			return obj
 		}
 
 		merge(_this, model.default);
@@ -366,8 +367,8 @@ const
 	};
 
 
-function Model(def, params) {
-	return isPlainObject(def) ? new ObjectModel(def, params) : new BasicModel(def)
+function Model(def) {
+	return isPlainObject(def) ? new ObjectModel(def) : new BasicModel(def)
 }
 
 Object.assign(Model.prototype, {
@@ -519,441 +520,434 @@ extend(Any.remaining, Any, {
 });
 Any[Symbol.iterator] = function* () { yield new Any.remaining(this.definition); };
 
-const initListModel = (base, constructor, def, init, clone, mutators, otherTraps) => {
-
-	return initModel(def, constructor, base, init, model => Object.assign({
-		getPrototypeOf: () => model.prototype,
-		get(l, key) {
-			if (key === _original) return l
-
-			const val = l[key];
-			return isFunction(val) ? proxify(val, {
-				apply(fn, ctx, args) {
-					if (has(mutators, key)) {
-						// indexes of arguments to check def + cast
-						const [begin, end = args.length - 1, getArgDef] = mutators[key];
-						for (let i = begin; i <= end; i++) {
-							const argDef = getArgDef ? getArgDef(i) : model.definition;
-							args[i] = checkDefinition(
-								args[i],
-								argDef,
-								`${base.name}.${key} arguments[${i}]`,
-								model.errors,
-								[],
-								true
-							);
-						}
-
-						if (model.assertions.length > 0) {
-							const testingClone = clone(l);
-							fn.apply(testingClone, args);
-							checkAssertions(testingClone, model, `after ${key} mutation`);
-						}
-
-						unstackErrors(model);
-					}
-
-					return fn.apply(l, args)
-				}
-			}) : val
-		}
-	}, otherTraps))
+const initListModel = (base, constructor, def, init, clone, mutators, otherTraps) => {
+
+	return initModel(def, constructor, base, init, model => Object.assign({
+		getPrototypeOf: () => model.prototype,
+		get(l, key) {
+			if (key === _original) return l
+
+			const val = l[key];
+			return isFunction(val) ? proxify(val, {
+				apply(fn, ctx, args) {
+					if (has(mutators, key)) {
+						// indexes of arguments to check def + cast
+						const [begin, end = args.length - 1, getArgDef] = mutators[key];
+						for (let i = begin; i <= end; i++) {
+							const argDef = getArgDef ? getArgDef(i) : model.definition;
+							args[i] = checkDefinition(
+								args[i],
+								argDef,
+								`${base.name}.${key} arguments[${i}]`,
+								model.errors,
+								[],
+								true
+							);
+						}
+
+						if (model.assertions.length > 0) {
+							const testingClone = clone(l);
+							fn.apply(testingClone, args);
+							checkAssertions(testingClone, model, `after ${key} mutation`);
+						}
+
+						unstackErrors(model);
+					}
+
+					return fn.apply(l, args)
+				}
+			}) : val
+		}
+	}, otherTraps))
 };
 
-function ArrayModel(initialDefinition) {
-	const model = initListModel(
-		Array,
-		ArrayModel,
-		initialDefinition,
-		a => Array.isArray(a) ? a.map(arg => cast(arg, model.definition)) : a,
-		a => [...a],
-		{
-			"copyWithin": [],
-			"fill": [0, 0],
-			"pop": [],
-			"push": [0],
-			"reverse": [],
-			"shift": [],
-			"sort": [],
-			"splice": [2],
-			"unshift": [0]
-		},
-		{
-			set(arr, key, val) {
-				return controlMutation(model, arr, key, val, (a, v) => a[key] = v, true)
-			},
-
-			deleteProperty(arr, key) {
-				return controlMutation(model, arr, key, undefined, a => delete a[key])
-			}
-		}
-	);
-
-	return model
-}
-
-extend(ArrayModel, Model, {
-	toString(stack) {
-		return "Array of " + formatDefinition(this.definition, stack)
-	},
-
-	[_check](arr, path, errors, stack) {
-		if (Array.isArray(arr))
-			(arr[_original] || arr).forEach((a, i) => checkDefinition(a, this.definition, `${path || "Array"}[${i}]`, errors, stack));
-		else stackError(errors, this, arr, path);
-
-		checkAssertions(arr, this, path, errors);
-	},
-
-	extend(...newParts) {
-		return extendModel(new ArrayModel(extendDefinition(this.definition, newParts)), this)
-	}
-});
-
-const controlMutation = (model, array, key, value, applyMutation, canBeExtended) => {
-	const path = `Array[${key}]`;
-	const isInDef = (+key >= 0 && (canBeExtended || key in array));
-	if (isInDef) value = checkDefinition(value, model.definition, path, model.errors, [], true);
-
-	const testArray = [...array];
-	applyMutation(testArray);
-	checkAssertions(testArray, model, path);
-	const isSuccess = !unstackErrors(model);
-	if (isSuccess) applyMutation(array, value);
-	return isSuccess
+function ArrayModel(initialDefinition) {
+	const model = initListModel(
+		Array,
+		ArrayModel,
+		initialDefinition,
+		a => Array.isArray(a) ? a.map(arg => cast(arg, model.definition)) : a,
+		a => [...a],
+		{
+			"copyWithin": [],
+			"fill": [0, 0],
+			"pop": [],
+			"push": [0],
+			"reverse": [],
+			"shift": [],
+			"sort": [],
+			"splice": [2],
+			"unshift": [0]
+		},
+		{
+			set(arr, key, val) {
+				return controlMutation(model, arr, key, val, (a, v) => a[key] = v, true)
+			},
+
+			deleteProperty(arr, key) {
+				return controlMutation(model, arr, key, undefined, a => delete a[key])
+			}
+		}
+	);
+
+	return model
+}
+
+extend(ArrayModel, Model, {
+	toString(stack) {
+		return "Array of " + formatDefinition(this.definition, stack)
+	},
+
+	[_check](arr, path, errors, stack) {
+		if (Array.isArray(arr))
+			(arr[_original] || arr).forEach((a, i) => checkDefinition(a, this.definition, `${path || "Array"}[${i}]`, errors, stack));
+		else stackError(errors, this, arr, path);
+
+		checkAssertions(arr, this, path, errors);
+	},
+
+	extend(...newParts) {
+		return extendModel(new ArrayModel(extendDefinition(this.definition, newParts)), this)
+	}
+});
+
+const controlMutation = (model, array, key, value, applyMutation, canBeExtended) => {
+	const path = `Array[${key}]`;
+	const isInDef = (+key >= 0 && (canBeExtended || key in array));
+	if (isInDef) value = checkDefinition(value, model.definition, path, model.errors, [], true);
+
+	const testArray = [...array];
+	applyMutation(testArray);
+	checkAssertions(testArray, model, path);
+	const isSuccess = !unstackErrors(model);
+	if (isSuccess) applyMutation(array, value);
+	return isSuccess
 };
 
-function SetModel(initialDefinition) {
-	const model = initListModel(
-		Set,
-		SetModel,
-		initialDefinition,
-		it => isIterable(it) ? new Set([...it].map(val => cast(val, model.definition))) : it,
-		set => new Set(set),
-		{
-			"add": [0, 0],
-			"delete": [],
-			"clear": []
-		}
-	);
-
-	return model
-}
-
-extend(SetModel, Model, {
-	toString(stack) {
-		return "Set of " + formatDefinition(this.definition, stack)
-	},
-
-	[_check](set, path, errors, stack) {
-		if (is(Set, set)) {
-			for (let item of set.values()) {
-				checkDefinition(item, this.definition, `${path || "Set"} value`, errors, stack);
-			}
-		} else stackError(errors, this, set, path);
-		checkAssertions(set, this, path, errors);
-	},
-
-	extend(...newParts) {
-		return extendModel(new SetModel(extendDefinition(this.definition, newParts)), this)
-	}
+function SetModel(initialDefinition) {
+	const model = initListModel(
+		Set,
+		SetModel,
+		initialDefinition,
+		it => isIterable(it) ? new Set([...it].map(val => cast(val, model.definition))) : it,
+		set => new Set(set),
+		{
+			"add": [0, 0],
+			"delete": [],
+			"clear": []
+		}
+	);
+
+	return model
+}
+
+extend(SetModel, Model, {
+	toString(stack) {
+		return "Set of " + formatDefinition(this.definition, stack)
+	},
+
+	[_check](set, path, errors, stack) {
+		if (is(Set, set)) {
+			for (let item of set.values()) {
+				checkDefinition(item, this.definition, `${path || "Set"} value`, errors, stack);
+			}
+		} else stackError(errors, this, set, path);
+		checkAssertions(set, this, path, errors);
+	},
+
+	extend(...newParts) {
+		return extendModel(new SetModel(extendDefinition(this.definition, newParts)), this)
+	}
 });
 
-function MapModel(initialKeyDefinition, initialValueDefinition) {
-	const getDef = i => i === 0 ? model.definition.key : model.definition.value;
-	const model = initListModel(
-		Map,
-		MapModel,
-		{ key: initialKeyDefinition, value: initialValueDefinition },
-		it => isIterable(it) ? new Map([...it].map(pair => pair.map((x, i) => cast(x, getDef(i))))) : it,
-		map => new Map(map),
-		{
-			"set": [0, 1, getDef],
-			"delete": [],
-			"clear": []
-		}
-	);
-
-	return model
-}
-
-extend(MapModel, Model, {
-	toString(stack) {
-		return `Map of ${formatDefinition(this.definition.key, stack)} : ${formatDefinition(this.definition.value, stack)}`
-	},
-
-	[_check](map, path, errors, stack) {
-		if (is(Map, map)) {
-			path = path || "Map";
-			for (let [key, value] of map) {
-				checkDefinition(key, this.definition.key, `${path} key`, errors, stack);
-				checkDefinition(value, this.definition.value, `${path}[${format$1(key)}]`, errors, stack);
-			}
-		} else stackError(errors, this, map, path);
-
-		checkAssertions(map, this, path, errors);
-	},
-
-	extend(keyParts, valueParts) {
-		return extendModel(new MapModel(
-			extendDefinition(this.definition.key, keyParts),
-			extendDefinition(this.definition.value, valueParts)
-		), this)
-	}
+function MapModel(initialKeyDefinition, initialValueDefinition) {
+	const getDef = i => i === 0 ? model.definition.key : model.definition.value;
+	const model = initListModel(
+		Map,
+		MapModel,
+		{ key: initialKeyDefinition, value: initialValueDefinition },
+		it => isIterable(it) ? new Map([...it].map(pair => pair.map((x, i) => cast(x, getDef(i))))) : it,
+		map => new Map(map),
+		{
+			"set": [0, 1, getDef],
+			"delete": [],
+			"clear": []
+		}
+	);
+
+	return model
+}
+
+extend(MapModel, Model, {
+	toString(stack) {
+		return `Map of ${formatDefinition(this.definition.key, stack)} : ${formatDefinition(this.definition.value, stack)}`
+	},
+
+	[_check](map, path, errors, stack) {
+		if (is(Map, map)) {
+			path = path || "Map";
+			for (let [key, value] of map) {
+				checkDefinition(key, this.definition.key, `${path} key`, errors, stack);
+				checkDefinition(value, this.definition.value, `${path}[${format$1(key)}]`, errors, stack);
+			}
+		} else stackError(errors, this, map, path);
+
+		checkAssertions(map, this, path, errors);
+	},
+
+	extend(keyParts, valueParts) {
+		return extendModel(new MapModel(
+			extendDefinition(this.definition.key, keyParts),
+			extendDefinition(this.definition.value, valueParts)
+		), this)
+	}
 });
 
-function FunctionModel(...argsDef) {
-	return initModel({ arguments: argsDef }, FunctionModel, Function, null, model => ({
-		getPrototypeOf: () => model.prototype,
-
-		get(fn, key) {
-			return key === _original ? fn : fn[key]
-		},
-
-		apply(fn, ctx, args) {
-			const def = model.definition;
-			const remainingArgDef = def.arguments.find(argDef => is(Any.remaining, argDef));
-			const nbArgsToCheck = remainingArgDef ? Math.max(args.length, def.arguments.length - 1) : def.arguments.length;
-
-			for (let i = 0; i < nbArgsToCheck; i++) {
-				const argDef = remainingArgDef && i >= def.arguments.length - 1 ? remainingArgDef.definition : def.arguments[i];
-				args[i] = checkDefinition(args[i], argDef, `arguments[${i}]`, model.errors, [], true);
-			}
-
-			checkAssertions(args, model, "arguments");
-
-			let result;
-			if (!model.errors.length) {
-				result = Reflect.apply(fn, ctx, args);
-				if ("return" in def)
-					result = checkDefinition(result, def.return, "return value", model.errors, [], true);
-			}
-			unstackErrors(model);
-			return result
-		}
-	}))
-}
-
-extend(FunctionModel, Model, {
-	toString(stack = []) {
-		let out = `Function(${this.definition.arguments.map(
-			argDef => formatDefinition(argDef, [...stack])
-		).join(", ")})`;
-
-		if ("return" in this.definition) {
-			out += " => " + formatDefinition(this.definition.return, stack);
-		}
-		return out
-	},
-
-	return(def) {
-		this.definition.return = def;
-		return this
-	},
-
-	extend(newArgs, newReturns) {
-		const args = this.definition.arguments,
-			  mixedArgs = newArgs.map((a, i) => extendDefinition(i in args ? args[i] : [], newArgs[i])),
-			  mixedReturns = extendDefinition(this.definition.return, newReturns);
-		return extendModel(new FunctionModel(...mixedArgs).return(mixedReturns), this)
-	},
-
-	[_check](f, path, errors) {
-		if (!isFunction(f)) stackError(errors, "Function", f, path);
-	}
+function FunctionModel(...argsDef) {
+	return initModel({ arguments: argsDef }, FunctionModel, Function, null, model => ({
+		getPrototypeOf: () => model.prototype,
+
+		get(fn, key) {
+			return key === _original ? fn : fn[key]
+		},
+
+		apply(fn, ctx, args) {
+			const def = model.definition;
+			const remainingArgDef = def.arguments.find(argDef => is(Any.remaining, argDef));
+			const nbArgsToCheck = remainingArgDef ? Math.max(args.length, def.arguments.length - 1) : def.arguments.length;
+
+			for (let i = 0; i < nbArgsToCheck; i++) {
+				const argDef = remainingArgDef && i >= def.arguments.length - 1 ? remainingArgDef.definition : def.arguments[i];
+				args[i] = checkDefinition(args[i], argDef, `arguments[${i}]`, model.errors, [], true);
+			}
+
+			checkAssertions(args, model, "arguments");
+
+			let result;
+			if (!model.errors.length) {
+				result = Reflect.apply(fn, ctx, args);
+				if ("return" in def)
+					result = checkDefinition(result, def.return, "return value", model.errors, [], true);
+			}
+			unstackErrors(model);
+			return result
+		}
+	}))
+}
+
+extend(FunctionModel, Model, {
+	toString(stack = []) {
+		let out = `Function(${this.definition.arguments.map(
+			argDef => formatDefinition(argDef, [...stack])
+		).join(", ")})`;
+
+		if ("return" in this.definition) {
+			out += " => " + formatDefinition(this.definition.return, stack);
+		}
+		return out
+	},
+
+	return(def) {
+		this.definition.return = def;
+		return this
+	},
+
+	[_check](f, path, errors) {
+		if (!isFunction(f)) stackError(errors, "Function", f, path);
+	}
 });
 
-const styles = {
-	list: "list-style-type: none; padding: 0; margin: 0;",
-	listItem: "padding: 0 0 0 1em;",
-	model: "color: #3e999f;",
-	instance: "color: #718c00; font-style: italic",
-	function: "color: #4271AE",
-	string: "color: #C41A16",
-	number: "color: #1C00CF",
-	boolean: "color: #AA0D91",
-	property: "color: #8959a8",
-	private: "color: #C19ED8",
-	constant: "color: #8959a8; font-weight: bold",
-	privateConstant: "color: #C19ED8; font-weight: bold",
-	null: "color: #8e908c",
-	undeclared: "color: #C0C0C0;",
-	proto: "color: #B871BD; font-style: italic"
-};
-
-const getModel = (instance) => {
-	if (instance === undefined || instance === null)
-		return null
-
-	const proto = getProto(instance);
-	if (!proto || !proto.constructor || !is(Model, proto.constructor))
-		return null
-
-	return proto.constructor
-};
-
-const span = (style, ...children) => ["span", { style }, ...children];
-
-const format = (x, config = {}) => {
-	if (x === null || x === undefined)
-		return span(styles.null, "" + x);
-
-	if (typeof x === "boolean")
-		return span(styles.boolean, x);
-
-	if (typeof x === "number")
-		return span(styles.number, x);
-
-	if (typeof x === "string")
-		return span(styles.string, `"${x}"`);
-
-	if (Array.isArray(x) && config.isModelDefinition) {
-		return span("", ...x.flatMap(part => [format(part, config), " or "]).slice(0, -1))
-	}
-
-	if (isPlainObject(x))
-		return formatObject(x, getModel(x), config)
-
-	if (isFunction(x) && !is(Model, x) && config.isModelDefinition)
-		return span(styles.function, x.name || x.toString());
-
-	return ["object", { object: x, config }]
-};
-
-const formatObject = (o, model, config) => span("",
-	"{",
-	["ol", { style: styles.list }, ...Object.keys(o).map(prop =>
-		["li", { style: styles.listItem }, span(styles.property, prop), ": ", format(o[prop], config)])
-	],
-	"}"
-);
-
-const formatModel = model => {
-	const
-		cfg = { isModelDefinition: true },
-		def = model.definition,
-		formatList = (list, map) => list.flatMap(e => [map(e), ", "]).slice(0, -1);
-	let parts = [];
-
-	if (is(BasicModel, model)) parts = [format(def, cfg)];
-	if (is(ArrayModel, model)) parts = ["Array of ", format(def, cfg)];
-	if (is(SetModel, model)) parts = ["Set of ", format(def, cfg)];
-	if (is(MapModel, model)) parts = ["Map of ", format(def.key, cfg), " : ", format(def.value, cfg)];
-	if (is(FunctionModel, model)) {
-		parts = ["Function(", ...formatList(def.arguments, arg => format(arg, cfg)), ")"];
-		if ("return" in def) parts.push(" => ", format(def.return, cfg));
-	}
-
-	if (model.assertions.length > 0) {
-		parts.push("\n(assertions: ", ...formatList(model.assertions, f => ["object", { object: f }]), ")");
-	}
-
-	return span(styles.model, ...parts)
-};
-
-const ModelFormatter = {
-	header(x, config = {}) {
-		if (x === Any)
-			return span(styles.model, "Any")
-
-		if (is(Any.remaining, x))
-			return span(styles.model, "...", format(x.definition, { isModelDefinition: true }))
-
-		if (is(ObjectModel, x))
-			return span(styles.model, x.name)
-
-		if (is(Model, x)) {
-			return formatModel(x)
-		}
-
-		if (config.isModelDefinition && isPlainObject(x))
-			return format(x, config)
-
-		return null;
-	},
-	hasBody(x) {
-		return is(ObjectModel, x)
-	},
-	body(model) {
-		return span("",
-			"{",
-			["ol", { style: styles.list }, ...Object.keys(model.definition).map(prop => {
-				const isPrivate = model.conventionForPrivate(prop);
-				const isConstant = model.conventionForConstant(prop);
-				const hasDefault = model.default && has(model.default, prop);
-				let style = styles.property;
-
-				if (isPrivate) {
-					style = isConstant ? styles.privateConstant : styles.private;
-				} else if (isConstant) {
-					style = styles.constant;
-				}
-
-				return ["li", { style: styles.listItem },
-					span(style, prop), ": ", format(model.definition[prop], { isModelDefinition: true }),
-					hasDefault ? span(styles.proto, " = ", format(model.default[prop])) : ""
-				]
-			})],
-			"}"
-		)
-	}
-};
-
-const ModelInstanceFormatter = {
-	header(x, config = {}) {
-		if (config.isInstanceProperty && isPlainObject(x)) {
-			return format(x, config)
-		}
-
-		const model = getModel(x);
-		if (is(Model, model)) {
-			const parts = is(ObjectModel, model) ? [model.name] : [["object", { object: x[_original] }], ` (${model.name})`];
-			return span(styles.instance, ...parts)
-		}
-
-		return null;
-	},
-	hasBody(x) {
-		return x && is(ObjectModel, getModel(x))
-	},
-	body(x) {
-		const model = getModel(x);
-		const o = x[_original] || x;
-		return span("",
-			"{",
-			[
-				"ol",
-				{ style: styles.list },
-				...Object.keys(o).map(prop => {
-					const isPrivate = model.conventionForPrivate(prop);
-					const isConstant = model.conventionForConstant(prop);
-					const isDeclared = prop in model.definition;
-					let style = styles.property;
-
-					if (!isDeclared) {
-						style = styles.undeclared;
-					} else if (isPrivate) {
-						style = isConstant ? styles.privateConstant : styles.private;
-					} else if (isConstant) {
-						style = styles.constant;
-					}
-
-					return ["li", { style: styles.listItem },
-						span(style, prop), ": ", format(o[prop], { isInstanceProperty: true })
-					]
-				}),
-				["li", { style: styles.listItem },
-					span(styles.proto, "__proto__", ": ", ["object", { object: getProto(x) }])
-				]
-			],
-			"}"
-		)
-	}
-};
-
-if (typeof window !== "undefined") {
-	window.devtoolsFormatters = (window.devtoolsFormatters || [])
-		.concat(ModelFormatter, ModelInstanceFormatter);
+const styles = {
+	list: "list-style-type: none; padding: 0; margin: 0;",
+	listItem: "padding: 0 0 0 1em;",
+	model: "color: #3e999f;",
+	instance: "color: #718c00; font-style: italic",
+	function: "color: #4271AE",
+	string: "color: #C41A16",
+	number: "color: #1C00CF",
+	boolean: "color: #AA0D91",
+	property: "color: #8959a8",
+	private: "color: #C19ED8",
+	constant: "color: #8959a8; font-weight: bold",
+	privateConstant: "color: #C19ED8; font-weight: bold",
+	null: "color: #8e908c",
+	undeclared: "color: #C0C0C0;",
+	proto: "color: #B871BD; font-style: italic"
+};
+
+const getModel = (instance) => {
+	if (instance === undefined || instance === null)
+		return null
+
+	const proto = getProto(instance);
+	if (!proto || !proto.constructor || !is(Model, proto.constructor))
+		return null
+
+	return proto.constructor
+};
+
+const span = (style, ...children) => ["span", { style }, ...children];
+
+const format = (x, config = {}) => {
+	if (x === null || x === undefined)
+		return span(styles.null, "" + x);
+
+	if (typeof x === "boolean")
+		return span(styles.boolean, x);
+
+	if (typeof x === "number")
+		return span(styles.number, x);
+
+	if (typeof x === "string")
+		return span(styles.string, `"${x}"`);
+
+	if (Array.isArray(x) && config.isModelDefinition) {
+		return span("", ...x.flatMap(part => [format(part, config), " or "]).slice(0, -1))
+	}
+
+	if (isPlainObject(x))
+		return formatObject(x, getModel(x), config)
+
+	if (isFunction(x) && !is(Model, x) && config.isModelDefinition)
+		return span(styles.function, x.name || x.toString());
+
+	return ["object", { object: x, config }]
+};
+
+const formatObject = (o, model, config) => span("",
+	"{",
+	["ol", { style: styles.list }, ...Object.keys(o).map(prop =>
+		["li", { style: styles.listItem }, span(styles.property, prop), ": ", format(o[prop], config)])
+	],
+	"}"
+);
+
+const formatModel = model => {
+	const
+		cfg = { isModelDefinition: true },
+		def = model.definition,
+		formatList = (list, map) => list.flatMap(e => [map(e), ", "]).slice(0, -1);
+	let parts = [];
+
+	if (is(BasicModel, model)) parts = [format(def, cfg)];
+	if (is(ArrayModel, model)) parts = ["Array of ", format(def, cfg)];
+	if (is(SetModel, model)) parts = ["Set of ", format(def, cfg)];
+	if (is(MapModel, model)) parts = ["Map of ", format(def.key, cfg), " : ", format(def.value, cfg)];
+	if (is(FunctionModel, model)) {
+		parts = ["Function(", ...formatList(def.arguments, arg => format(arg, cfg)), ")"];
+		if ("return" in def) parts.push(" => ", format(def.return, cfg));
+	}
+
+	if (model.assertions.length > 0) {
+		parts.push("\n(assertions: ", ...formatList(model.assertions, f => ["object", { object: f }]), ")");
+	}
+
+	return span(styles.model, ...parts)
+};
+
+const ModelFormatter = {
+	header(x, config = {}) {
+		if (x === Any)
+			return span(styles.model, "Any")
+
+		if (is(Any.remaining, x))
+			return span(styles.model, "...", format(x.definition, { isModelDefinition: true }))
+
+		if (is(ObjectModel, x))
+			return span(styles.model, x.name)
+
+		if (is(Model, x)) {
+			return formatModel(x)
+		}
+
+		if (config.isModelDefinition && isPlainObject(x))
+			return format(x, config)
+
+		return null;
+	},
+	hasBody(x) {
+		return is(ObjectModel, x)
+	},
+	body(model) {
+		return span("",
+			"{",
+			["ol", { style: styles.list }, ...Object.keys(model.definition).map(prop => {
+				const isPrivate = model.conventionForPrivate(prop);
+				const isConstant = model.conventionForConstant(prop);
+				const hasDefault = model.default && has(model.default, prop);
+				let style = styles.property;
+
+				if (isPrivate) {
+					style = isConstant ? styles.privateConstant : styles.private;
+				} else if (isConstant) {
+					style = styles.constant;
+				}
+
+				return ["li", { style: styles.listItem },
+					span(style, prop), ": ", format(model.definition[prop], { isModelDefinition: true }),
+					hasDefault ? span(styles.proto, " = ", format(model.default[prop])) : ""
+				]
+			})],
+			"}"
+		)
+	}
+};
+
+const ModelInstanceFormatter = {
+	header(x, config = {}) {
+		if (config.isInstanceProperty && isPlainObject(x)) {
+			return format(x, config)
+		}
+
+		const model = getModel(x);
+		if (is(Model, model)) {
+			const parts = is(ObjectModel, model) ? [model.name] : [["object", { object: x[_original] }], ` (${model.name})`];
+			return span(styles.instance, ...parts)
+		}
+
+		return null;
+	},
+	hasBody(x) {
+		return x && is(ObjectModel, getModel(x))
+	},
+	body(x) {
+		const model = getModel(x);
+		const o = x[_original] || x;
+		return span("",
+			"{",
+			[
+				"ol",
+				{ style: styles.list },
+				...Object.keys(o).map(prop => {
+					const isPrivate = model.conventionForPrivate(prop);
+					const isConstant = model.conventionForConstant(prop);
+					const isDeclared = prop in model.definition;
+					let style = styles.property;
+
+					if (!isDeclared) {
+						style = styles.undeclared;
+					} else if (isPrivate) {
+						style = isConstant ? styles.privateConstant : styles.private;
+					} else if (isConstant) {
+						style = styles.constant;
+					}
+
+					return ["li", { style: styles.listItem },
+						span(style, prop), ": ", format(o[prop], { isInstanceProperty: true })
+					]
+				}),
+				["li", { style: styles.listItem },
+					span(styles.proto, "__proto__", ": ", ["object", { object: getProto(x) }])
+				]
+			],
+			"}"
+		)
+	}
+};
+
+if (typeof window !== "undefined") {
+	window.devtoolsFormatters = (window.devtoolsFormatters || [])
+		.concat(ModelFormatter, ModelInstanceFormatter);
 }
 
 export { Any, ArrayModel, BasicModel, FunctionModel, MapModel, Model, ObjectModel, SetModel };