From 141195893c525de0dbf5b31907f8a4ba8b6e8548 Mon Sep 17 00:00:00 2001
From: MaxArt2501 <maxart.x@gmail.com>
Date: Tue, 20 Jan 2015 01:44:47 +0100
Subject: [PATCH] Using Map, bugfixes, code doc

See changelog.md for more details
---
 changelog.md          |  17 ++
 object-observe.js     | 490 ++++++++++++++++++++++++++++++------------
 object-observe.min.js |  10 +
 readme.md             |  28 ++-
 4 files changed, 400 insertions(+), 145 deletions(-)
 create mode 100644 changelog.md
 create mode 100644 object-observe.min.js

diff --git a/changelog.md b/changelog.md
new file mode 100644
index 0000000..4bd0afe
--- /dev/null
+++ b/changelog.md
@@ -0,0 +1,17 @@
+## v0.1.1
+
+2015-01-19
+
+* Fixed bugs in `Object.unobserve`
+* Fixed bugs in `notifier.performChange`
+* Used `Map`s when available - *much* cleaner code!
+* Added some code documentation
+
+## v0.1.0
+
+2015-01-18 - First preliminary version
+
+* `Object.observe`, `Object.unobserve`
+* `Object.getNotifier`, `Object.deliverChangeRecords`
+* No support for `"reconfigure"` and `"setPrototype"` events
+* No `Array.observe`/`unobserve` yet
\ No newline at end of file
diff --git a/object-observe.js b/object-observe.js
index 4e35b79..a4adc29 100644
--- a/object-observe.js
+++ b/object-observe.js
@@ -1,6 +1,70 @@
+/*!
+ * Object.observe polyfill
+ * by Massimo Artizzu (MaxArt2501)
+ * 
+ * https://github.com/MaxArt2501/object-observe
+ * 
+ * Licensed under the MIT License
+ * See LICENSE for details
+ */
+
+// Some type definitions
+/**
+ * This represents the data relative to an observed object
+ * @typedef  {Object}                     ObjectData
+ * @property {Map<Handler, HandlerData>}  handlers
+ * @property {String[]}                   properties
+ * @property {*[]}                        values
+ * @property {Notifier}                   notifier
+ * @property {Boolean}                    frozen
+ * @property {Boolean}                    extensible
+ */
+/**
+ * Function definition of a handler
+ * @callback Handler
+ * @param {ChangeRecord[]} changes
+*/
+/**
+ * This represents the data relative to an observed object and one of its
+ * handlers
+ * @typedef  {Object}                     HandlerData
+ * @property {String[]}                   acceptList
+ * @property {ChangeRecord[]}             changeRecords
+ */
+/**
+ * Type definition for a change. Any other property can be added using
+ * the notify() or performChange() methods of the notifier.
+ * @typedef  {Object}                     ChangeRecord
+ * @property {String}                     type
+ * @property {Object}                     object
+ * @property {String}                     [name]
+ * @property {*}                          [oldValue]
+ * @property {Number}                     [index]
+ */
+/**
+ * Type definition for a notifier (what Object.getNotifier returns)
+ * @typedef  {Object}                     Notifier
+ * @property {Function}                   notify
+ * @property {Function}                   performChange
+ */
+/**
+ * Function called with Notifier.performChange. It may optionally return a
+ * ChangeRecord that gets automatically notified, but `type` and `object`
+ * properties are overridden.
+ * @callback Performer
+ * @returns {ChangeRecord|undefined}
+ */
+
 Object.observe || (function(O, A, root) {
 	"use strict";
 
+		/**
+		 * Checks if the argument is a Node object. Uses duck typing if Node is
+		 * not defined.
+		 * @function isNode
+		 * @param {?*} node
+		 * @returns {Boolean}
+		 */
 	var isNode = root.Node ? function(node) {
 			return node && node instanceof root.Node;
 		} : function(node) {
@@ -9,10 +73,24 @@ Object.observe || (function(O, A, root) {
 					&& typeof node.nodeType === "number"
 					&& typeof node.nodeName === "string";
 		},
+
+		/**
+		 * Checks if the argument is an Array object. Polyfills Array.isArray.
+		 * @function isArray
+		 * @param {?*} object
+		 * @returns {Boolean}
+		 */
 		isArray = A.isArray || (function(toString) {
 			return function (object) { return toString.call(object) === "[object Array]"; };
 		})(O.prototype.toString),
 
+		/**
+		 * Checks is a property of an object is actually an accessor
+		 * @function isAccessor
+		 * @param {Object} object
+		 * @param {String} prop
+		 * @returns {Boolean}
+		 */
 		// The correct method to check would be getOwnPropertyDescriptor, but
 		// it's supported by IE8 but for DOM elements only. Useless.
 		isAccessor = O.freeze ? function(object, prop) {
@@ -20,6 +98,15 @@ Object.observe || (function(O, A, root) {
 			return desc ? "get" in desc || "set" in desc : false;
 		} : function() { return false; },
 
+		/**
+		 * Returns the index of an item in a collection, or -1 if not found.
+		 * Uses Array.prototype.indexOf is available.
+		 * @function inArray
+		 * @param {*} pivot           Item to look for
+		 * @param {Array} array
+		 * @param {Number} [start=0]  Index to start from
+		 * @returns {Number}
+		 */
 		inArray = A.prototype.indexOf ? function(pivot, array, start) {
 			return array.indexOf(pivot, start);
 		} : function(pivot, array, start) {
@@ -29,75 +116,141 @@ Object.observe || (function(O, A, root) {
 			return -1;
 		},
 
-		getKeys = Object.keys || function(obj) {
-			// Misses checks on obj, don't use as a replacement of Object.keys
+		/**
+		 * Returns an instance of Map, or a Map-like object is Map is not
+		 * supported or doesn't support forEach()
+		 * @function createMap
+		 * @returns {Map}
+		 */
+		createMap = typeof root.Map === "undefined" || !Map.prototype.forEach ? function() {
+			// Lightweight shim of Map. Lacks clear(), entries(), keys() and
+			// values() (the last 3 not supported by IE11, so can't use them),
+			// it doesn't handle the constructor's argument (like IE11) and of
+			// course it doesn't support for...of.
+			// Chrome 31-35 and Firefox 13-24 have a basic support of Map, but
+			// they lack forEach(), so their native implementation is bad for
+			// this polyfill. (Chrome 36+ supports Object.observe.)
+			var keys = [], values = [];
+
+			return {
+				size: 0,
+				has: function(key) { return inArray(key, keys) > -1; },
+				get: function(key) { return values[inArray(key, keys)]; },
+				set: function(key, value) {
+					var i = inArray(key, keys);
+					if (i === -1) {
+						keys.push(key);
+						values.push(value);
+						this.size++;
+					} else values[i] = value;
+				},
+				"delete": function(key) {
+					var i = inArray(key, keys);
+					if (i > -1) {
+						keys.splice(i, 1);
+						values.splice(i, 1);
+						this.size--;
+					}
+				},
+				forEach: function(callback/*, thisObj*/) {
+					for (var i = 0; i < keys.length; i++)
+						callback.call(arguments[1], values[i], keys[i], this);
+				}
+			};
+		} : function() { return new Map(); },
+
+		/**
+		 * Simple shim for Object.keys is not available
+		 * Misses checks on object, don't use as a replacement of Object.keys
+		 * @function getKeys
+		 * @param {Object} object
+		 * @returns {String[]}
+		 */
+		getKeys = Object.keys || function(object) {
 			var keys = [], prop;
-			for (prop in obj)
-				if (obj.hasOwnProperty(prop))
+			for (prop in object)
+				if (object.hasOwnProperty(prop))
 					keys.push(prop);
 			return keys;
 		},
 
-		// This can be used as an exact polyfill of Object.is
-		// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+		/**
+		 * Polyfill for Object.is if not available
+		 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+		 * @function areSame
+		 * @param {*} x
+		 * @param {*} y
+		 * @returns {Boolean}
+		 */
 		areSame = O.is || function(x, y) {
 			if (x === y)
 				return x !== 0 || 1/x === 1/y;
 			return x !== x && y !== y;
 		},
 
-		observed = [],
-		objectData = [],
-
-		callbacks = [],
-		callbackData = [],
+		/**
+		 * Relates observed objects and their data
+		 * @type {Map<Object, ObjectData}
+		 */
+		observed,
+		/**
+		 * List of handlers and their data
+		 * @type {Map<Handler, Map<Object, HandlerData>>}
+		 */
+		handlers,
 
 		defaultObjectAccepts = [ "add", "update", "delete", "reconfigure", "setPrototype", "preventExtensions" ],
 		defaultArrayAccepts = [ "add", "update", "delete", "splice" ],
 
+		/**
+		 * Sets up the observation of an object
+		 * @function doObserve
+		 * @param {Object} object
+		 * @param {Handler} handler
+		 * @param {String[]} [acceptList]
+		 */
 		doObserve = function(object, handler, acceptList) {
 
-			var idx = inArray(object, observed),
-				data, cbdata, cbidx;
+			var data = observed.get(object);
 
 			if (!isArray(acceptList))
-				acceptList = isArray(object) ? defaultArrayAccepts : defaultObjectAccepts;
-
-			if (idx === -1) {
-				observed.push(object) - 1;
-				addCallback(handler, acceptList, object);
-				data = {
-					handlers: [ handler ],
+				acceptList = isArray(object)
+						? defaultArrayAccepts : defaultObjectAccepts;
+
+			if (data)
+				data.handlers.set(handler,
+					setHandler(handler, object, acceptList));
+			else {
+				observed.set(object, data = {
+					handlers: createMap(),
 					frozen: O.isFrozen ? O.isFrozen(object) : false,
-					extensible: O.isExtensible ? O.isExtensible(object) : true
-				};
-				objectData.push(data);
+					extensible: O.isExtensible ? O.isExtensible(object) : true,
+					properties: isNode(object) ? [] : getKeys(object)
+				});
+				data.handlers.set(handler,
+					setHandler(handler, object, acceptList));
 				retrieveNotifier(object, data);
+				updateValues(object, data);
 
-				collectProperties(object, data);
+				// Let the observation begin!
 				setTimeout(function worker() {
 					// If this happens, the object has been unobserved
-					if (inArray(object, observed) === -1) return;
+					if (!observed.has(object)) return;
 
 					performPropertyChecks(object, data);
-					broadcastChangeRecords(object, data);
+					broadcastChangeRecords(data);
 
-					if (!data.frozen)
-						setTimeout(worker, 17);
+					setTimeout(worker, 17);
 				}, 17);
-			} else {
-				data = objectData[idx];
-				addCallback(handler, acceptList, object);
-				if (inArray(handler, data.handlers) === -1)
-					data.handlers.push(handler);
 			}
 		},
 
-		collectProperties = function(object, data) {
-			data.properties = isNode(object) ? [] : getKeys(object);
-			updateValues(object, data);
-		},
-
+		/**
+		 * Updates the stored values of the properties of an observed object
+		 * @function updateValues
+		 * @param {Object} object
+		 * @param {ObjectData} data
+		 */
 		updateValues = function(object, data) {
 			var props = data.properties,
 				values = data.values = [],
@@ -106,8 +259,16 @@ Object.observe || (function(O, A, root) {
 				values[i] = object[props[i++]];
 		},
 
+		/**
+		 * Performs basic property value change checks on an observed object
+		 * @function performPropertyChecks
+		 * @param {Object} object
+		 * @param {ObjectData} data
+		 * @param {String} [except]  Doesn't deliver the changes to the
+		 *                           handlers that accept this type
+		 */
 		performPropertyChecks = function(object, data, except) {
-			if (!data.handlers.length) return;
+			if (!data.handlers.size || data.frozen) return;
 
 			var props, proplen, keys,
 				values = data.values,
@@ -125,7 +286,7 @@ Object.observe || (function(O, A, root) {
 					key = keys[i++];
 					idx = inArray(key, props);
 					if (idx === -1) {
-						addChangeRecord(object, data, {
+						addChangeRecord(data, {
 							name: key,
 							type: "add",
 							object: object
@@ -136,7 +297,7 @@ Object.observe || (function(O, A, root) {
 						props[idx] = null;
 						proplen--;
 						if (!isAccessor(object, key) && !areSame(object[key], values[idx])) {
-							addChangeRecord(object, data, {
+							addChangeRecord(data, {
 								name: key,
 								type: "update",
 								object: object,
@@ -150,7 +311,7 @@ Object.observe || (function(O, A, root) {
 				// Checks if some property has been deleted
 				for (i = props.length; proplen && i--;)
 					if (props[i] !== null) {
-						addChangeRecord(object, data, {
+						addChangeRecord(data, {
 							name: props[i],
 							type: "delete",
 							object: object,
@@ -163,7 +324,7 @@ Object.observe || (function(O, A, root) {
 
 				if (O.isExtensible && !O.isExtensible(object)) {
 					data.extensible = false;
-					addChangeRecord(object, data, {
+					addChangeRecord(data, {
 						type: "preventExtensions",
 						object: object
 					}, except);
@@ -179,7 +340,7 @@ Object.observe || (function(O, A, root) {
 				while (i < props.length) {
 					key = props[i++];
 					if (!areSame(object[key], values[i])) {
-						addChangeRecord(object, data, {
+						addChangeRecord(data, {
 							name: key,
 							type: "update",
 							object: object,
@@ -195,47 +356,63 @@ Object.observe || (function(O, A, root) {
 
 		},
 
-		broadcastChangeRecords = function(object, data) {
-			var handlers = data.handlers,
-				i = 0, j, idx,
-				cbdata, changeRecords;
-
-			for (; i < handlers.length; i++) {
-				cbdata = callbackData[inArray(handlers[i], callbacks)];
-				idx = inArray(object, cbdata.objects);
-				changeRecords = cbdata.changeBundles[idx];
-
-				if (changeRecords.length) {
-					handlers[i](changeRecords);
-					cbdata.changeBundles[idx] = [];
+		/**
+		 * Calls the handlers with their relative change records
+		 * @function broadcastChangeRecords
+		 * @param {ObjectData} data
+		 */
+		broadcastChangeRecords = function(data) {
+			data.handlers.forEach(function(hdata, handler) {
+				if (hdata.changeRecords.length) {
+					handler(hdata.changeRecords);
+					hdata.changeRecords = [];
 				}
-			}
+			});
 		},
 
+		/**
+		 * Returns the notifier for an object - whether it's observed or not
+		 * @param {Object} object
+		 * @param {ObjectData} [data]
+		 * @returns {Notifier}
+		 */
 		retrieveNotifier = function(object, data) {
 			if (!data)
-				data = objectData[inArray(object, observed)];
+				data = observed.get(object);
 			var notifier = data && data.notifier;
 
 			if (notifier) return notifier;
 
+			/** @type {Notifier} */
 			notifier = {
-				// https://github.com/arv/ecmascript-object-observe/blob/master/NewInternalsSpecification.md#notifierprototypenotifychangerecord
+				/**
+				 * @method notify
+				 * @see https://github.com/arv/ecmascript-object-observe/blob/master/NewInternalsSpecification.md#notifierprototypenotifychangerecord
+				 * @memberof Notifier
+				 * @param {ChangeRecord} changeRecord
+				 */
 				notify: function(changeRecord) {
 					changeRecord.type; // Just to check the property is there...
 
 					// If there's no data, the object has been unobserved
-					var data = objectData[inArray(object, observed)];
+					var data = observed.get(object);
 					if (data) {
 						var recordCopy = { object: object }, prop;
 						for (prop in changeRecord)
 							if (prop !== "object")
 								recordCopy[prop] = changeRecord[prop];
-						addChangeRecord(object, data, recordCopy);
+						addChangeRecord(data, recordCopy);
 					}
 				},
 
-				// https://github.com/arv/ecmascript-object-observe/blob/master/NewInternalsSpecification.md#notifierprototypeperformchangechangetype-changefn
+				/**
+				 * @method performChange
+				 * @see https://github.com/arv/ecmascript-object-observe/blob/master/NewInternalsSpecification.md#notifierprototypeperformchangechangetype-changefn
+				 * @memberof Notifier
+				 * @param {String} changeType
+				 * @param {Performer} func     The task performer
+				 * @param {*} [thisObj]        Used to set `this` when calling func
+				 */
 				performChange: function(changeType, func/*, thisObj*/) {
 					if (typeof changeType !== "string")
 						throw new TypeError("Invalid non-string changeType");
@@ -243,7 +420,8 @@ Object.observe || (function(O, A, root) {
 					if (typeof func !== "function")
 						throw new TypeError("Cannot perform non-function");
 
-					var data = objectData[inArray(object, observed)],
+					// If there's no data, the object has been unobserved
+					var data = observed.get(object),
 						prop, changeRecord,
 						result = func.call(arguments[2]);
 
@@ -255,7 +433,7 @@ Object.observe || (function(O, A, root) {
 						for (prop in result)
 							if (prop !== "object" && prop !== "type")
 								changeRecord[prop] = result[prop];
-						addChangeRecord(object, data, changeRecord);
+						addChangeRecord(data, changeRecord);
 					}
 				}
 			};
@@ -264,48 +442,67 @@ Object.observe || (function(O, A, root) {
 			return notifier;
 		},
 
-		addCallback = function(callback, acceptList, object) {
-			var idx = inArray(callback, callbacks),
-				oidx, data;
-
-			if (idx === -1) {
-				callbacks.push(callback);
-				callbackData.push({
-					objects: [ object ],
-					acceptLists: [ acceptList ],
-					changeBundles: [ [] ]
+		/**
+		 * Register (or redefines) an handler in the collection for a given
+		 * object and a given type accept list.
+		 * @function setHandler
+		 * @param {Handler} handler
+		 * @param {Object} object
+		 * @param {String[]} acceptList
+		 * @returns {HandlerData}
+		 */
+		setHandler = function(handler, object, acceptList) {
+			var data = handlers.get(handler), hdata;
+
+			if (data) {
+				hdata = data.get(object);
+				if (hdata) hdata.acceptList = acceptList;
+				else data.set(object, hdata = {
+					acceptList: acceptList,
+					changeRecords: []
 				});
 			} else {
-				data = callbackData[idx];
-				oidx = inArray(object, data.objects);
-				if (oidx === -1) {
-					data.objects.push(object);
-					data.acceptLists.push(acceptList);
-					data.changeBundles.push([]);
-				} else data.acceptLists[oidx] = acceptList;
+				data = createMap();
+				data.set(object, hdata = {
+					acceptList: acceptList,
+					changeRecords: []
+				});
+				handlers.set(handler, data);
 			}
-		},
-
-		addChangeRecord = function(object, data, changeRecord, except) {
-			var handlers = data.handlers,
-				i = 0, cbdata, idx;
-
-			while (i < handlers.length)
-				if (cbdata = callbackData[inArray(handlers[i++], callbacks)]) {
-					idx = inArray(object, cbdata.objects);
 
-					// If except is defined, a Notifier.performChange has been
-					// performed, with except as the type.
-					// All the handlers that accepts that type are skipped.
-					if (except != null && inArray(except, cbdata.acceptLists[idx]) > -1)
-						continue;
+			return hdata;
+		},
 
-					if (inArray(changeRecord.type, cbdata.acceptLists[idx]) > -1)
-						cbdata.changeBundles[idx].push(changeRecord);
-				}
+		/**
+		 * Adds a change record in a given ObjectData
+		 * @function addChangeRecord
+		 * @param {ObjectData} data
+		 * @param {ChangeRecord} changeRecord
+		 * @param {String} [except]
+		 */
+		addChangeRecord = function(data, changeRecord, except) {
+			data.handlers.forEach(function(hdata) {
+				// If except is defined, Notifier.performChange has been
+				// called, with except as the type.
+				// All the handlers that accepts that type are skipped.
+				if ((except == null || inArray(except, hdata.acceptList) === -1)
+						&& inArray(changeRecord.type, hdata.acceptList) > -1)
+					hdata.changeRecords.push(changeRecord);
+			});
 		};
 
-	// https://github.com/arv/ecmascript-object-observe/blob/master/PublicApiSpecification.md#objectobserveo-callback-accept--undefined
+	observed = createMap();
+	handlers = createMap();
+
+	/**
+	 * @function Object.observe
+	 * @see https://github.com/arv/ecmascript-object-observe/blob/master/PublicApiSpecification.md#objectobserveo-callback-accept--undefined
+	 * @param {Object} object
+	 * @param {Handler} handler
+	 * @param {String[]} [acceptList]
+	 * @throws {TypeError}
+	 * @returns {Object}               The observed object
+	 */
 	O.observe = function observe(object, handler, acceptList) {
 		if (object === null || typeof object !== "object")
 			throw new TypeError("Object.observe cannot observe non-object");
@@ -317,9 +514,18 @@ Object.observe || (function(O, A, root) {
 			throw new TypeError("Object.observe cannot deliver to a frozen function object");
 
 		doObserve(object, handler, acceptList);
+
+		return object;
 	};
 
-	// https://github.com/arv/ecmascript-object-observe/blob/master/PublicApiSpecification.md#objectunobserveo-callback
+	/**
+	 * @function Object.unobserve
+	 * @see https://github.com/arv/ecmascript-object-observe/blob/master/PublicApiSpecification.md#objectunobserveo-callback
+	 * @param {Object} object
+	 * @param {Handler} handler
+	 * @throws {TypeError}
+	 * @returns {Object}         The given object
+	 */
 	O.unobserve = function unobserve(object, handler) {
 		if (object === null || typeof object !== "object")
 			throw new TypeError("Object.unobserve cannot unobserve non-object");
@@ -327,31 +533,37 @@ Object.observe || (function(O, A, root) {
 		if (typeof handler !== "function")
 			throw new TypeError("Object.unobserve cannot deliver to non-function");
 
-		var oidx = inArray(object, observed), hidx, idx,
-			handlers, i, cbdata;
-
-		if (oidx > -1) {
-			handlers = objectData[oidx].handlers;
-			for (i = 0; i < handlers.length; i++) {
-				hidx = inArray(handlers[i], callbacks);
-				cbdata = callbackData[hidx];
-
-				if (cbdata.objects.length === 1 && cbdata.objects[0] === object) {
-					callbacks.splice(hidx, 1);
-					callbackData.splice(hidx, 1);
-				} else {
-					idx = inArray(object, cbdata.objects);
-					cbdata.object.splice(idx, 1);
-					cbdata.acceptLists.splice(idx, 1);
-					cbdata.changeBundles.splice(idx, 1);
-				}
-			}
-			observed.splice(oidx, 1);
-			objectData.splice(oidx, 1);
+		var data = observed.get(object), cbdata;
+
+		if (data && data.handlers.has(handler)) {
+			performPropertyChecks(object, data);
+			setTimeout(function() {
+				broadcastChangeRecords(data);
+			}, 0);
+
+			cbdata = handlers.get(handler);
+
+			// In Firefox 13-18, size is a function, but createMap should fall
+			// back to the shim for those versions
+			if (cbdata.size === 1 && cbdata.get(object))
+				handlers["delete"](handler);
+			else cbdata["delete"](object);
+
+			if (data.handlers.size === 1)
+				observed["delete"](object);
+			else data.handlers["delete"](handler);
 		}
+
+		return object;
 	};
 
-	// https://github.com/arv/ecmascript-object-observe/blob/master/PublicApiSpecification.md#objectgetnotifier
+	/**
+	 * @function Object.getNotifier
+	 * @see https://github.com/arv/ecmascript-object-observe/blob/master/PublicApiSpecification.md#objectgetnotifier
+	 * @param {Object} object
+	 * @throws {TypeError}
+	 * @returns {Notifier}
+	 */
 	O.getNotifier = function getNotifier(object) {
 		if (object === null || typeof object !== "object")
 			throw new TypeError("Object.getNotifier cannot getNotifier non-object");
@@ -361,27 +573,25 @@ Object.observe || (function(O, A, root) {
 		return retrieveNotifier(object);
 	};
 
-	// https://github.com/arv/ecmascript-object-observe/blob/master/PublicApiSpecification.md#objectdeliverchangerecords
-	// https://github.com/arv/ecmascript-object-observe/blob/master/NewInternalsSpecification.md#deliverchangerecordsc
+	/**
+	 * @function Object.deliverChangeRecords
+	 * @see https://github.com/arv/ecmascript-object-observe/blob/master/PublicApiSpecification.md#objectdeliverchangerecords
+	 * @see https://github.com/arv/ecmascript-object-observe/blob/master/NewInternalsSpecification.md#deliverchangerecordsc
+	 * @param {Handler} handler
+	 * @throws {TypeError}
+	 */
 	O.deliverChangeRecords = function deliveryChangeRecords(handler) {
 		if (typeof handler !== "function")
 			throw new TypeError("Object.deliverChangeRecords cannot deliver to non-function");
-		
-		var idx = inArray(handler, callbacks), oidx,
-			bundles, cbdata, object, i = 0;
-		if (idx > -1) {
-			cbdata = callbackData[idx];
-			bundles = cbdata.changeBundles;
-			for (i = 0; i < bundles.length; i++) {
-				object = cbdata.objects[i];
-				oidx = inArray(object, observed);
-				performPropertyChecks(object, objectData[oidx]);
-				if (bundles[i].length) {
-					handler(bundles[i]);
-					cbdata.changeBundles[i] = [];
-				}
+
+		var cbdata = handlers.get(handler);
+		cbdata && cbdata.forEach(function(hdata, object) {
+			performPropertyChecks(object, observed.get(object));
+			if (hdata.changeRecords.length) {
+				handler(hdata.changeRecords);
+				hdata.changeRecords = [];
 			}
-		}
+		});
 	};
 
 })(Object, Array, this);
\ No newline at end of file
diff --git a/object-observe.min.js b/object-observe.min.js
new file mode 100644
index 0000000..6ef0ee3
--- /dev/null
+++ b/object-observe.min.js
@@ -0,0 +1,10 @@
+Object.observe||function(e,u,t){var B=t.Node?function(a){return a&&a instanceof t.Node}:function(a){return a&&"object"===typeof a&&"number"===typeof a.nodeType&&"string"===typeof a.nodeName},v=u.isArray||function(a){return function(b){return"[object Array]"===a.call(b)}}(e.prototype.toString),C=e.freeze?function(a,b){var c=e.getOwnPropertyDescriptor(a,b);return c?"get"in c||"set"in c:!1}:function(){return!1},n=u.prototype.indexOf?function(a,b,c){return b.indexOf(a,c)}:function(a,b,c){for(c=c||0;c<
+b.length;c++)if(b[c]===a)return c;return-1},q="undefined"!==typeof t.Map&&Map.prototype.forEach?function(){return new Map}:function(){var a=[],b=[];return{size:0,has:function(b){return-1<n(b,a)},get:function(c){return b[n(c,a)]},set:function(c,d){var h=n(c,a);-1===h?(a.push(c),b.push(d),this.size++):b[h]=d},"delete":function(c){c=n(c,a);-1<c&&(a.splice(c,1),b.splice(c,1),this.size--)},forEach:function(c,d){for(var h=0;h<a.length;h++)c.call(d,b[h],a[h],this)}}},w=Object.keys||function(a){var b=[],
+c;for(c in a)a.hasOwnProperty(c)&&b.push(c);return b},x=e.is||function(a,b){return a===b?0!==a||1/a===1/b:a!==a&&b!==b},k,l,D="add update delete reconfigure setPrototype preventExtensions".split(" "),E=["add","update","delete","splice"],H=function(a,b,c){var d=k.get(a);v(c)||(c=v(a)?E:D);d?d.handlers.set(b,y(b,a,c)):(k.set(a,d={handlers:q(),frozen:e.isFrozen?e.isFrozen(a):!1,extensible:e.isExtensible?e.isExtensible(a):!0,properties:B(a)?[]:w(a)}),d.handlers.set(b,y(b,a,c)),z(a,d),F(a,d),setTimeout(function G(){k.has(a)&&
+(r(a,d),A(d),setTimeout(G,17))},17))},F=function(a,b){for(var c=b.properties,d=b.values=[],h=0;h<c.length;)d[h]=a[c[h++]]},r=function(a,b,c){if(b.handlers.size&&!b.frozen){var d,h,k,g=b.values,f=0,l,m;if(b.extensible){d=b.properties.slice();h=d.length;for(k=w(a);f<k.length;)m=k[f++],l=n(m,d),-1===l?(p(b,{name:m,type:"add",object:a},c),b.properties.push(m),g.push(a[m])):(d[l]=null,h--,C(a,m)||x(a[m],g[l])||(p(b,{name:m,type:"update",object:a,oldValue:g[l]},c),g[l]=a[m]));for(f=d.length;h&&f--;)null!==
+d[f]&&(p(b,{name:d[f],type:"delete",object:a,oldValue:g[f]},c),b.properties.splice(f,1),g.splice(f,1),h--);e.isExtensible&&!e.isExtensible(a)&&(b.extensible=!1,p(b,{type:"preventExtensions",object:a},c),b.frozen||(b.frozen=e.isFrozen(a)))}else if(!b.frozen){for(;f<d.length;)m=d[f++],x(a[m],g[f])||(p(b,{name:m,type:"update",object:a,oldValue:g[f]}),g[f]=a[m]);e.isFrozen(a)&&(b.frozen=!0)}}},A=function(a){a.handlers.forEach(function(a,c){a.changeRecords.length&&(c(a.changeRecords),a.changeRecords=[])})},
+z=function(a,b){b||(b=k.get(a));var c=b&&b.notifier;if(c)return c;c={notify:function(b){b.type;var c=k.get(a);if(c){var e={object:a},g;for(g in b)"object"!==g&&(e[g]=b[g]);p(c,e)}},performChange:function(b,c,e){if("string"!==typeof b)throw new TypeError("Invalid non-string changeType");if("function"!==typeof c)throw new TypeError("Cannot perform non-function");var g=k.get(a),f;c=c.call(e);g&&r(a,g,b);if(g&&c&&"object"===typeof c){b={object:a,type:b};for(f in c)"object"!==f&&"type"!==f&&(b[f]=c[f]);
+p(g,b)}}};b&&(b.notifier=c);return c},y=function(a,b,c){var d=l.get(a),e;d?(e=d.get(b))?e.acceptList=c:d.set(b,e={acceptList:c,changeRecords:[]}):(d=q(),d.set(b,e={acceptList:c,changeRecords:[]}),l.set(a,d));return e},p=function(a,b,c){a.handlers.forEach(function(a){(null==c||-1===n(c,a.acceptList))&&-1<n(b.type,a.acceptList)&&a.changeRecords.push(b)})};k=q();l=q();e.observe=function(a,b,c){if(null===a||"object"!==typeof a)throw new TypeError("Object.observe cannot observe non-object");if("function"!==
+typeof b)throw new TypeError("Object.observe cannot deliver to non-function");if(e.isFrozen&&e.isFrozen(b))throw new TypeError("Object.observe cannot deliver to a frozen function object");H(a,b,c);return a};e.unobserve=function(a,b){if(null===a||"object"!==typeof a)throw new TypeError("Object.unobserve cannot unobserve non-object");if("function"!==typeof b)throw new TypeError("Object.unobserve cannot deliver to non-function");var c=k.get(a),d;if(c&&c.handlers.has(b)){r(a,c);setTimeout(function(){A(c)},
+0);d=l.get(b);if(1===d.size&&d.get(a))l["delete"](b);else d["delete"](a);if(1===c.handlers.size)k["delete"](a);else c.handlers["delete"](b)}return a};e.getNotifier=function(a){if(null===a||"object"!==typeof a)throw new TypeError("Object.getNotifier cannot getNotifier non-object");return e.isFrozen&&e.isFrozen(a)?null:z(a)};e.deliverChangeRecords=function(a){if("function"!==typeof a)throw new TypeError("Object.deliverChangeRecords cannot deliver to non-function");var b=l.get(a);b&&b.forEach(function(b,
+d){r(d,k.get(d));b.changeRecords.length&&(a(b.changeRecords),b.changeRecords=[])})}}(Object,Array,this);
\ No newline at end of file
diff --git a/readme.md b/readme.md
index ec9cb68..00479ef 100644
--- a/readme.md
+++ b/readme.md
@@ -1,7 +1,7 @@
 Object.observe polyfill
 =======================
 
-`Object.observe` is one very nice [EcmaScript 7 feature](https://github.com/arv/ecmascript-object-observe) that has landed on Blink-based browsers (Chrome 36+, Opera 23+) in the [first part of 2014](http://www.html5rocks.com/en/tutorials/es7/observe/). Node.js delivers it too in version 0.11.x.
+`Object.observe` is a very nice [EcmaScript 7 feature](https://github.com/arv/ecmascript-object-observe) that has landed on Blink-based browsers (Chrome 36+, Opera 23+) in the [first part of 2014](http://www.html5rocks.com/en/tutorials/es7/observe/). Node.js delivers it too in version 0.11.x.
 
 In short, it's one of the things web developers wish they had 10-15 years ago: it notifies the application of any changes made to an object, like adding, deleting or updating a property, changing its descriptor and so on. It even supports custom events. Sweet!
 
@@ -69,7 +69,7 @@ So, yeah, dirty checking. `setTimeout(..., 17)`. I know, it sounds lame, but now
 
 On a side note, it's better not using `setImmediate` (supported by node.js and IE 10+) because it clogs the CPU with continuous computations. Doing a check at 60 fps at best should be enough for most cases.
 
-## Limitations
+## Limitations and caveats
 
 * Because properties are polled, when more than one change is made synchronously to the same property, it won't get caught. This means that this won't notify any event:
 
@@ -85,6 +85,23 @@ On a side note, it's better not using `setImmediate` (supported by node.js and I
   
   `Object.prototype.watch` could help in this case, but it would be a partial solution.
 
+* Property changes may not be reported in the correct order. The polyfill performs the checks in order:
+
+  1. `"add"` and `"update"`
+  2. `"delete"`
+  3. `"preventExtensions"`
+  
+  This means that the `"add"` change is listed *before* the `"delete"` in the following snippet:
+  
+  ```js
+  var obj = { foo: "bar" };
+  Object.observe(foo, ...);
+  delete obj.foo;
+  obj.bar = "foo";
+  ```
+  
+  Due to the nature of the shim, there's nothing that can be done about it.
+
 * When a property is created used `Object.defineProperty` and set to not enumerable, it's basically invisible to the polyfill:
 
   ```js
@@ -103,7 +120,9 @@ On a side note, it's better not using `setImmediate` (supported by node.js and I
 
 * It doesn't work correctly on DOM nodes or other *host* objects. Nodes have a lot of enumerable properties that `Object.observe` should *not* check.
 
-* Finally, dirty checking can be intensive. Memory occupation can grow to undesirable levels, not to mention CPU load. Pay attention to the number of objects your application needs to observe, and consider whether a polyfill is actually good for you.
+* **Possible memory leaks**: remember to `unobserve` the objects you want to be garbage collected. This can be avoided with native implementations of `Object.observe`, but due to the fact that in this polyfill observed objects are held in internal [maps](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map), they can't be GC'ed until they're unobserved. ([`WeakMap`s](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap) could solve this particular issue, but of course they're not for every environment - a shim for `Map` is used when not supported - and it's also not possible to iterate through their entries.)
+
+* Dirty checking can be intensive. Memory occupation can grow to undesirable levels, not to mention CPU load. Pay attention to the number of objects your application needs to observe, and consider whether a polyfill is actually good for you.
 
 ## What's provided
 
@@ -136,11 +155,10 @@ This polyfill has been tested (and is working) in the following environments:
 
 ## To do
 
-* `Array.observe` and `Array.unobserve` - they're pretty much doable, I just have to figure out the best way to support them;
+* `Array.observe` and `Array.unobserve` - they're pretty much doable, I just have to figure out the best way to support them - it looks like the `"splice"` event must be internally supported too;
 * consider and eventually deliver support for `reconfigure` and `setPrototype` events, maybe creating a "full" and a "light" version of the polyfill;
 * some deeper considerations about whether using `Object.prototype.watch` or not;
 * support for DOM nodes;
-* consider taking advantage of `Map` whenever possible;
 * code tests, documentation, optimization and cleanup.
 
 ## License