From 882df6fdb9fa8037380ee34ae517e6bc87a08fea Mon Sep 17 00:00:00 2001
From: MaxArt2501 <maxart.x@gmail.com>
Date: Wed, 21 Jan 2015 18:20:00 +0100
Subject: [PATCH] Lite version; reconfigure, setPrototype support

Added a "light" version of the polyfill
Support to "reconfigure" and "setPrototype" notifications
Code refactor, bugfixes
---
 changelog.md               |    9 +
 object-observe-lite.js     |  561 +++++++++++++++++
 object-observe-lite.min.js |    8 +
 object-observe.js          | 1199 ++++++++++++++++++++----------------
 object-observe.min.js      |   21 +-
 readme.md                  |   37 +-
 6 files changed, 1280 insertions(+), 555 deletions(-)
 create mode 100644 object-observe-lite.js
 create mode 100644 object-observe-lite.min.js

diff --git a/changelog.md b/changelog.md
index 4bd0afe..cd50e07 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,12 @@
+## v0.1.2
+
+2015-01-21
+
+* Support for `"reconfigure"` and `"setPrototype"` events
+* New "light" version of the polyfill
+* Various bugfixes
+* Fixed links for specs
+
 ## v0.1.1
 
 2015-01-19
diff --git a/object-observe-lite.js b/object-observe-lite.js
new file mode 100644
index 0000000..09800cd
--- /dev/null
+++ b/object-observe-lite.js
@@ -0,0 +1,561 @@
+/*!
+ * 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
+ */
+/**
+ * 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";
+
+        /**
+         * Relates observed objects and their data
+         * @type {Map<Object, ObjectData}
+         */
+    var 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" ];
+
+    // Functions for internal usage
+
+        /**
+         * 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) {
+            // Duck typing
+            return node && typeof node === "object"
+                    && 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}
+         */
+        isAccessor = O.defineProperties ? function(object, prop) {
+            var desc = O.getOwnPropertyDescriptor(object, prop);
+            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) {
+            for (var i = start || 0; i < array.length; i++)
+                if (array[i] === pivot)
+                    return i;
+            return -1;
+        },
+
+        /**
+         * 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 = O.keys || function(object) {
+            var keys = [], prop;
+            for (prop in object)
+                if (object.hasOwnProperty(prop))
+                    keys.push(prop);
+            return keys;
+        },
+
+        /**
+         * 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;
+        },
+
+        /**
+         * Sets up the observation of an object
+         * @function doObserve
+         * @param {Object} object
+         * @param {Handler} handler
+         * @param {String[]} [acceptList]
+         */
+        doObserve = function(object, handler, acceptList) {
+
+            var data = observed.get(object);
+
+            if (data)
+                data.handlers.set(handler,
+                    setHandler(handler, object, acceptList));
+            else {
+                observed.set(object, data = {
+                    handlers: createMap(),
+                    properties: isNode(object) ? [] : getKeys(object)
+                });
+                data.handlers.set(handler,
+                    setHandler(handler, object, acceptList));
+                retrieveNotifier(object, data);
+                updateValues(object, data);
+
+                // Let the observation begin!
+                setTimeout(function worker() {
+                    // If this happens, the object has been unobserved
+                    if (!observed.has(object)) return;
+
+                    performPropertyChecks(object, data);
+                    broadcastChangeRecords(data);
+
+                    setTimeout(worker, 17);
+                }, 17);
+            }
+        },
+
+        /**
+         * 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 = [],
+                i = 0;
+            while (i < props.length)
+                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.size) return;
+
+            var props, proplen, keys,
+                values = data.values,
+                descs = data.descriptors,
+                i = 0, idx,
+                key, value, ovalue,
+                proto, descr;
+
+            props = data.properties.slice();
+            proplen = props.length;
+            keys = getKeys(object);
+
+            // Check for value additions/changes
+            while (i < keys.length) {
+                key = keys[i++];
+                idx = inArray(key, props);
+                value = object[key];
+
+                if (idx === -1) {
+                    addChangeRecord(data, {
+                        name: key,
+                        type: "add",
+                        object: object
+                    }, except);
+                    data.properties.push(key);
+                    values.push(value);
+                } else {
+                    ovalue = values[idx];
+                    props[idx] = null;
+                    proplen--;
+                    if (ovalue === value ? ovalue === 0 && 1/ovalue !== 1/value 
+                            : ovalue === ovalue || value === value) {
+                        addChangeRecord(data, {
+                            name: key,
+                            type: "update",
+                            object: object,
+                            oldValue: ovalue
+                        }, except);
+                        data.values[idx] = value;
+                    }
+                }
+            }
+
+            // Checks if some property has been deleted
+            for (i = props.length; proplen && i--;)
+                if (props[i] !== null) {
+                    addChangeRecord(data, {
+                        name: props[i],
+                        type: "delete",
+                        object: object,
+                        oldValue: values[i]
+                    }, except);
+                    data.properties.splice(i, 1);
+                    data.values.splice(i, 1);
+                    proplen--;
+                }
+        },
+
+        /**
+         * 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 = observed.get(object);
+            var notifier = data && data.notifier;
+
+            if (notifier) return notifier;
+
+            /** @type {Notifier} */
+            notifier = {
+                /**
+                 * @method notify
+                 * @see http://arv.github.io/ecmascript-object-observe/#notifierprototype._notify
+                 * @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 = observed.get(object);
+                    if (data) {
+                        var recordCopy = { object: object }, prop;
+                        for (prop in changeRecord)
+                            if (prop !== "object")
+                                recordCopy[prop] = changeRecord[prop];
+                        addChangeRecord(data, recordCopy);
+                    }
+                },
+
+                /**
+                 * @method performChange
+                 * @see http://arv.github.io/ecmascript-object-observe/#notifierprototype_.performchange
+                 * @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");
+
+                    if (typeof func !== "function")
+                        throw new TypeError("Cannot perform non-function");
+
+                    // If there's no data, the object has been unobserved
+                    var data = observed.get(object),
+                        prop, changeRecord,
+                        result = func.call(arguments[2]);
+
+                    data && performPropertyChecks(object, data, changeType);
+
+                    // If there's no data, the object has been unobserved
+                    if (data && result && typeof result === "object") {
+                        changeRecord = { object: object, type: changeType };
+                        for (prop in result)
+                            if (prop !== "object" && prop !== "type")
+                                changeRecord[prop] = result[prop];
+                        addChangeRecord(data, changeRecord);
+                    }
+                }
+            };
+            if (data) data.notifier = notifier;
+
+            return notifier;
+        },
+
+        /**
+         * 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 = createMap();
+                data.set(object, hdata = {
+                    acceptList: acceptList,
+                    changeRecords: []
+                });
+                handlers.set(handler, data);
+            }
+
+            return hdata;
+        },
+
+        /**
+         * 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);
+            });
+        };
+
+    observed = createMap();
+    handlers = createMap();
+
+    /**
+     * @function Object.observe
+     * @see http://arv.github.io/ecmascript-object-observe/#Object.observe
+     * @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");
+
+        if (typeof handler !== "function")
+            throw new TypeError("Object.observe cannot deliver to non-function");
+
+        if (O.isFrozen && O.isFrozen(handler))
+            throw new TypeError("Object.observe cannot deliver to a frozen function object");
+
+        if (!isArray(acceptList))
+            acceptList = defaultObjectAccepts;
+
+        doObserve(object, handler, acceptList);
+
+        return object;
+    };
+
+    /**
+     * @function Object.unobserve
+     * @see http://arv.github.io/ecmascript-object-observe/#Object.unobserve
+     * @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");
+
+        if (typeof handler !== "function")
+            throw new TypeError("Object.unobserve cannot deliver to non-function");
+
+        var data = observed.get(object), cbdata;
+
+        if (data && data.handlers.has(handler)) {
+            performPropertyChecks(object, data);
+            broadcastChangeRecords(data);
+
+            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;
+    };
+
+    /**
+     * @function Object.getNotifier
+     * @see http://arv.github.io/ecmascript-object-observe/#GetNotifier
+     * @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");
+
+        if (O.isFrozen && O.isFrozen(object)) return null;
+
+        return retrieveNotifier(object);
+    };
+
+    /**
+     * @function Object.deliverChangeRecords
+     * @see http://arv.github.io/ecmascript-object-observe/#Object.deliverChangeRecords
+     * @see http://arv.github.io/ecmascript-object-observe/#DeliverChangeRecords
+     * @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 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-lite.min.js b/object-observe-lite.min.js
new file mode 100644
index 0000000..53cf28b
--- /dev/null
+++ b/object-observe-lite.min.js
@@ -0,0 +1,8 @@
+Object.observe||function(e,v,t){var g,f,A="add update delete reconfigure setPrototype preventExtensions".split(" "),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},C=v.isArray||function(a){return function(c){return"[object Array]"===a.call(c)}}(e.prototype.toString),l=v.prototype.indexOf?function(a,c,b){return c.indexOf(a,b)}:function(a,c,b){for(b=b||0;b<c.length;b++)if(c[b]===a)return b;return-1},
+q="undefined"!==typeof t.Map&&Map.prototype.forEach?function(){return new Map}:function(){var a=[],c=[];return{size:0,has:function(b){return-1<l(b,a)},get:function(b){return c[l(b,a)]},set:function(b,d){var h=l(b,a);-1===h?(a.push(b),c.push(d),this.size++):c[h]=d},"delete":function(b){b=l(b,a);-1<b&&(a.splice(b,1),c.splice(b,1),this.size--)},forEach:function(b,d){for(var h=0;h<a.length;h++)b.call(d,c[h],a[h],this)}}},w=e.keys||function(a){var c=[],b;for(b in a)a.hasOwnProperty(b)&&c.push(b);return c},
+F=function(a,c,b){var d=g.get(a);d?d.handlers.set(c,x(c,a,b)):(g.set(a,d={handlers:q(),properties:B(a)?[]:w(a)}),d.handlers.set(c,x(c,a,b)),y(a,d),D(a,d),setTimeout(function E(){g.has(a)&&(r(a,d),z(d),setTimeout(E,17))},17))},D=function(a,c){for(var b=c.properties,d=c.values=[],h=0;h<b.length;)d[h]=a[b[h++]]},r=function(a,c,b){if(c.handlers.size){var d,h,e,u=c.values,k=0,g,f,m,n;d=c.properties.slice();h=d.length;for(e=w(a);k<e.length;)if(f=e[k++],g=l(f,d),m=a[f],-1===g)p(c,{name:f,type:"add",object:a},
+b),c.properties.push(f),u.push(m);else if(n=u[g],d[g]=null,h--,n===m?0===n&&1/n!==1/m:n===n||m===m)p(c,{name:f,type:"update",object:a,oldValue:n},b),c.values[g]=m;for(k=d.length;h&&k--;)null!==d[k]&&(p(c,{name:d[k],type:"delete",object:a,oldValue:u[k]},b),c.properties.splice(k,1),c.values.splice(k,1),h--)}},z=function(a){a.handlers.forEach(function(a,b){a.changeRecords.length&&(b(a.changeRecords),a.changeRecords=[])})},y=function(a,c){c||(c=g.get(a));var b=c&&c.notifier;if(b)return b;b={notify:function(b){b.type;
+var c=g.get(a);if(c){var e={object:a},f;for(f in b)"object"!==f&&(e[f]=b[f]);p(c,e)}},performChange:function(b,c,f){if("string"!==typeof b)throw new TypeError("Invalid non-string changeType");if("function"!==typeof c)throw new TypeError("Cannot perform non-function");var e=g.get(a),k;c=c.call(f);e&&r(a,e,b);if(e&&c&&"object"===typeof c){b={object:a,type:b};for(k in c)"object"!==k&&"type"!==k&&(b[k]=c[k]);p(e,b)}}};c&&(c.notifier=b);return b},x=function(a,c,b){var d=f.get(a),e;d?(e=d.get(c))?e.acceptList=
+b:d.set(c,e={acceptList:b,changeRecords:[]}):(d=q(),d.set(c,e={acceptList:b,changeRecords:[]}),f.set(a,d));return e},p=function(a,c,b){a.handlers.forEach(function(a){(null==b||-1===l(b,a.acceptList))&&-1<l(c.type,a.acceptList)&&a.changeRecords.push(c)})};g=q();f=q();e.observe=function(a,c,b){if(null===a||"object"!==typeof a)throw new TypeError("Object.observe cannot observe non-object");if("function"!==typeof c)throw new TypeError("Object.observe cannot deliver to non-function");if(e.isFrozen&&e.isFrozen(c))throw new TypeError("Object.observe cannot deliver to a frozen function object");
+C(b)||(b=A);F(a,c,b);return a};e.unobserve=function(a,c){if(null===a||"object"!==typeof a)throw new TypeError("Object.unobserve cannot unobserve non-object");if("function"!==typeof c)throw new TypeError("Object.unobserve cannot deliver to non-function");var b=g.get(a),d;if(b&&b.handlers.has(c)){r(a,b);z(b);d=f.get(c);if(1===d.size&&d.get(a))f["delete"](c);else d["delete"](a);if(1===b.handlers.size)g["delete"](a);else b.handlers["delete"](c)}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:y(a)};e.deliverChangeRecords=function(a){if("function"!==typeof a)throw new TypeError("Object.deliverChangeRecords cannot deliver to non-function");var c=f.get(a);c&&c.forEach(function(b,c){r(c,g.get(c));b.changeRecords.length&&(a(b.changeRecords),b.changeRecords=[])})}}(Object,Array,this);
diff --git a/object-observe.js b/object-observe.js
index a4adc29..69276b2 100644
--- a/object-observe.js
+++ b/object-observe.js
@@ -15,9 +15,11 @@
  * @property {Map<Handler, HandlerData>}  handlers
  * @property {String[]}                   properties
  * @property {*[]}                        values
+ * @property {Descriptor[]}               descriptors
  * @property {Notifier}                   notifier
  * @property {Boolean}                    frozen
  * @property {Boolean}                    extensible
+ * @property {Object}                     proto
  */
 /**
  * Function definition of a handler
@@ -56,542 +58,665 @@
  */
 
 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) {
-			// Duck typing
-			return node && typeof node === "object"
-					&& 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) {
-			var desc = O.getOwnPropertyDescriptor(object, prop);
-			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) {
-			for (var i = start || 0; i < array.length; i++)
-				if (array[i] === pivot)
-					return i;
-			return -1;
-		},
-
-		/**
-		 * 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 object)
-				if (object.hasOwnProperty(prop))
-					keys.push(prop);
-			return keys;
-		},
-
-		/**
-		 * 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;
-		},
-
-		/**
-		 * 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 data = observed.get(object);
-
-			if (!isArray(acceptList))
-				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,
-					properties: isNode(object) ? [] : getKeys(object)
-				});
-				data.handlers.set(handler,
-					setHandler(handler, object, acceptList));
-				retrieveNotifier(object, data);
-				updateValues(object, data);
-
-				// Let the observation begin!
-				setTimeout(function worker() {
-					// If this happens, the object has been unobserved
-					if (!observed.has(object)) return;
-
-					performPropertyChecks(object, data);
-					broadcastChangeRecords(data);
-
-					setTimeout(worker, 17);
-				}, 17);
-			}
-		},
-
-		/**
-		 * 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 = [],
-				i = 0;
-			while (i < props.length)
-				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.size || data.frozen) return;
-
-			var props, proplen, keys,
-				values = data.values,
-				i = 0, idx, key, handler;
-
-			// If the object isn't extensible, we don't need to check for new
-			// or deleted properties
-			if (data.extensible) {
-
-				props = data.properties.slice();
-				proplen = props.length;
-				keys = getKeys(object);
-
-				while (i < keys.length) {
-					key = keys[i++];
-					idx = inArray(key, props);
-					if (idx === -1) {
-						addChangeRecord(data, {
-							name: key,
-							type: "add",
-							object: object
-						}, except);
-						data.properties.push(key);
-						values.push(object[key]);
-					} else {
-						props[idx] = null;
-						proplen--;
-						if (!isAccessor(object, key) && !areSame(object[key], values[idx])) {
-							addChangeRecord(data, {
-								name: key,
-								type: "update",
-								object: object,
-								oldValue: values[idx]
-							}, except);
-							values[idx] = object[key];
-						}
-					}
-				}
-
-				// Checks if some property has been deleted
-				for (i = props.length; proplen && i--;)
-					if (props[i] !== null) {
-						addChangeRecord(data, {
-							name: props[i],
-							type: "delete",
-							object: object,
-							oldValue: values[i]
-						}, except);
-						data.properties.splice(i, 1);
-						values.splice(i, 1);
-						proplen--;
-					}
-
-				if (O.isExtensible && !O.isExtensible(object)) {
-					data.extensible = false;
-					addChangeRecord(data, {
-						type: "preventExtensions",
-						object: object
-					}, except);
-
-					if (!data.frozen)
-						data.frozen = O.isFrozen(object);
-				}
-
-			} else if (!data.frozen) {
-
-				// If the object is not extensible, but not frozen, we just have
-				// to check for value changes
-				while (i < props.length) {
-					key = props[i++];
-					if (!areSame(object[key], values[i])) {
-						addChangeRecord(data, {
-							name: key,
-							type: "update",
-							object: object,
-							oldValue: values[i]
-						});
-						values[i] = object[key];
-					}
-				}
-
-				if (O.isFrozen(object))
-					data.frozen = true;
-			}
-
-		},
-
-		/**
-		 * 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 = observed.get(object);
-			var notifier = data && data.notifier;
-
-			if (notifier) return notifier;
-
-			/** @type {Notifier} */
-			notifier = {
-				/**
-				 * @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 = observed.get(object);
-					if (data) {
-						var recordCopy = { object: object }, prop;
-						for (prop in changeRecord)
-							if (prop !== "object")
-								recordCopy[prop] = changeRecord[prop];
-						addChangeRecord(data, recordCopy);
-					}
-				},
-
-				/**
-				 * @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");
-
-					if (typeof func !== "function")
-						throw new TypeError("Cannot perform non-function");
-
-					// If there's no data, the object has been unobserved
-					var data = observed.get(object),
-						prop, changeRecord,
-						result = func.call(arguments[2]);
-
-					data && performPropertyChecks(object, data, changeType);
-
-					// If there's no data, the object has been unobserved
-					if (data && result && typeof result === "object") {
-						changeRecord = { object: object, type: changeType };
-						for (prop in result)
-							if (prop !== "object" && prop !== "type")
-								changeRecord[prop] = result[prop];
-						addChangeRecord(data, changeRecord);
-					}
-				}
-			};
-			if (data) data.notifier = notifier;
-
-			return notifier;
-		},
-
-		/**
-		 * 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 = createMap();
-				data.set(object, hdata = {
-					acceptList: acceptList,
-					changeRecords: []
-				});
-				handlers.set(handler, data);
-			}
-
-			return hdata;
-		},
-
-		/**
-		 * 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);
-			});
-		};
-
-	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");
-
-		if (typeof handler !== "function")
-			throw new TypeError("Object.observe cannot deliver to non-function");
-
-		if (O.isFrozen && O.isFrozen(handler))
-			throw new TypeError("Object.observe cannot deliver to a frozen function object");
-
-		doObserve(object, handler, acceptList);
-
-		return object;
-	};
-
-	/**
-	 * @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");
-
-		if (typeof handler !== "function")
-			throw new TypeError("Object.unobserve cannot deliver to non-function");
-
-		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;
-	};
-
-	/**
-	 * @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");
-
-		if (O.isFrozen && O.isFrozen(object)) return null;
-
-		return retrieveNotifier(object);
-	};
-
-	/**
-	 * @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 cbdata = handlers.get(handler);
-		cbdata && cbdata.forEach(function(hdata, object) {
-			performPropertyChecks(object, observed.get(object));
-			if (hdata.changeRecords.length) {
-				handler(hdata.changeRecords);
-				hdata.changeRecords = [];
-			}
-		});
-	};
+    "use strict";
+
+        /**
+         * Relates observed objects and their data
+         * @type {Map<Object, ObjectData}
+         */
+    var 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" ];
+
+    // Functions for internal usage
+
+        /**
+         * 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) {
+            // Duck typing
+            return node && typeof node === "object"
+                    && 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}
+         */
+        isAccessor = O.defineProperties ? function(object, prop) {
+            var desc = O.getOwnPropertyDescriptor(object, prop);
+            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) {
+            for (var i = start || 0; i < array.length; i++)
+                if (array[i] === pivot)
+                    return i;
+            return -1;
+        },
+
+        /**
+         * 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 = O.keys || function(object) {
+            var keys = [], prop;
+            for (prop in object)
+                if (object.hasOwnProperty(prop))
+                    keys.push(prop);
+            return keys;
+        },
+
+        /**
+         * Return the prototype of the object... if defined.
+         * @function getPrototype
+         * @param {Object} object
+         * @returns {Object}
+         */
+        getPrototype = O.getPrototypeOf || null,
+
+        /**
+         * Return the descriptor of the object... if defined.
+         * IE8 supports a (useless) Object.getOwnPropertyDescriptor for DOM
+         * nodes only, so defineProperties is checked instead.
+         * @function getDescriptor
+         * @param {Object} object
+         * @param {String} property
+         * @returns {Descriptor}
+         */
+        getDescriptor = O.defineProperties ? O.getOwnPropertyDescriptor : null,
+
+        /**
+         * 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;
+        },
+
+        /**
+         * Sets up the observation of an object
+         * @function doObserve
+         * @param {Object} object
+         * @param {Handler} handler
+         * @param {String[]} [acceptList]
+         */
+        doObserve = function(object, handler, acceptList) {
+
+            var data = observed.get(object);
+
+            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,
+                    proto: getPrototype && getPrototype(object),
+                    properties: isNode(object) ? [] : getKeys(object)
+                });
+                data.handlers.set(handler,
+                    setHandler(handler, object, acceptList));
+                retrieveNotifier(object, data);
+                updateValues(object, data);
+
+                // Let the observation begin!
+                setTimeout(function worker() {
+                    // If this happens, the object has been unobserved
+                    if (!observed.has(object)) return;
+
+                    performPropertyChecks(object, data);
+                    broadcastChangeRecords(data);
+
+                    setTimeout(worker, 17);
+                }, 17);
+            }
+        },
+
+        /**
+         * 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 = [],
+                i = 0, descs;
+            if (getDescriptor) {
+                descs = data.descriptors = [];
+                while (i < props.length) {
+                    descs[i] = getDescriptor(object, props[i]);
+                    values[i] = object[props[i++]];
+                }
+            } else while (i < props.length)
+                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() {
+            var updateCheck = getDescriptor ? function(object, data, idx, except, descr) {
+                var key = data.properties[idx],
+                    value = object[key],
+                    ovalue = data.values[idx],
+                    odesc = data.descriptors[idx];
+
+                if ("value" in descr && (ovalue === value
+                        ? ovalue === 0 && 1/ovalue !== 1/value 
+                        : ovalue === ovalue || value === value)) {
+                    addChangeRecord(data, {
+                        name: key,
+                        type: "update",
+                        object: object,
+                        oldValue: ovalue
+                    }, except);
+                    data.values[idx] = value;
+                }
+                if (odesc.configurable && (!descr.configurable
+                        || descr.writable !== odesc.writable
+                        || descr.enumerable !== odesc.enumerable
+                        || descr.get !== odesc.get
+                        || descr.set !== odesc.set)) {
+                    addChangeRecord(data, {
+                        name: key,
+                        type: "reconfigure",
+                        object: object,
+                        oldValue: ovalue
+                    }, except);
+                    data.descriptors[idx] = descr;
+                }
+            } : function(object, data, idx, except) {
+                var key = data.properties[idx],
+                    value = object[key],
+                    ovalue = data.values[idx];
+
+                if (ovalue === value ? ovalue === 0 && 1/ovalue !== 1/value 
+                        : ovalue === ovalue || value === value) {
+                    addChangeRecord(data, {
+                        name: key,
+                        type: "update",
+                        object: object,
+                        oldValue: ovalue
+                    }, except);
+                    data.values[idx] = value;
+                }
+            };
+
+            // Checks if some property has been deleted
+            var deletionCheck = getDescriptor ? function(object, props, proplen, data, except) {
+                var i = props.length, descr;
+                while (proplen && i--) {
+                    if (props[i] !== null) {
+                        descr = getDescriptor(object, props[i]);
+                        proplen--;
+
+                        // If there's no descriptor, the property has really
+                        // been deleted; otherwise, it's been reconfigured so
+                        // that's not enumerable anymore
+                        if (descr) updateCheck(object, data, i, except, descr);
+                        else {
+                            addChangeRecord(data, {
+                                name: props[i],
+                                type: "delete",
+                                object: object,
+                                oldValue: data.values[i]
+                            }, except);
+                            data.properties.splice(i, 1);
+                            data.values.splice(i, 1);
+                            data.descriptors.splice(i, 1);
+                        }
+                    }
+                }
+            } : function(object, props, proplen, data, except) {
+                var i = props.length;
+                while (proplen && i--)
+                    if (props[i] !== null) {
+                        addChangeRecord(data, {
+                            name: props[i],
+                            type: "delete",
+                            object: object,
+                            oldValue: data.values[i]
+                        }, except);
+                        data.properties.splice(i, 1);
+                        data.values.splice(i, 1);
+                        proplen--;
+                    }
+            };
+
+            return function(object, data, except) {
+                if (!data.handlers.size || data.frozen) return;
+
+                var props, proplen, keys,
+                    values = data.values,
+                    descs = data.descriptors,
+                    i = 0, idx,
+                    key, value,
+                    proto, descr;
+
+                // If the object isn't extensible, we don't need to check for new
+                // or deleted properties
+                if (data.extensible) {
+
+                    props = data.properties.slice();
+                    proplen = props.length;
+                    keys = getKeys(object);
+
+                    if (descs) {
+                        while (i < keys.length) {
+                            key = keys[i++];
+                            idx = inArray(key, props);
+                            descr = getDescriptor(object, key);
+
+                            if (idx === -1) {
+                                addChangeRecord(data, {
+                                    name: key,
+                                    type: "add",
+                                    object: object
+                                }, except);
+                                data.properties.push(key);
+                                values.push(object[key]);
+                                descs.push(descr);
+                            } else {
+                                props[idx] = null;
+                                proplen--;
+                                updateCheck(object, data, idx, except, descr);
+                            }
+                        }
+                        deletionCheck(object, props, proplen, data, except);
+
+                        if (!O.isExtensible(object)) {
+                            data.extensible = false;
+                            addChangeRecord(data, {
+                                type: "preventExtensions",
+                                object: object
+                            }, except);
+
+                            data.frozen = O.isFrozen(object);
+                        }
+                    } else {
+                        while (i < keys.length) {
+                            key = keys[i++];
+                            idx = inArray(key, props);
+                            value = object[key];
+
+                            if (idx === -1) {
+                                addChangeRecord(data, {
+                                    name: key,
+                                    type: "add",
+                                    object: object
+                                }, except);
+                                data.properties.push(key);
+                                values.push(value);
+                            } else {
+                                props[idx] = null;
+                                proplen--;
+                                updateCheck(object, data, idx, except);
+                            }
+                        }
+                        deletionCheck(object, props, proplen, data, except);
+                    }
+
+                } else if (!data.frozen) {
+
+                    // If the object is not extensible, but not frozen, we just have
+                    // to check for value changes
+                    for (; i < props.length; i++) {
+                        key = props[i];
+                        updateCheck(object, data, i, except, getDescriptor(object, key));
+                    }
+
+                    if (O.isFrozen(object))
+                        data.frozen = true;
+                }
+
+                if (getPrototype) {
+                    proto = getPrototype(object);
+                    if (proto !== data.proto) {
+                        addChangeRecord(data, {
+                            type: "setPrototype",
+                            name: "__proto__",
+                            oldValue: data.proto
+                        });
+                        data.proto = proto;
+                    }
+                }
+            };
+        })(),
+
+        /**
+         * 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 = observed.get(object);
+            var notifier = data && data.notifier;
+
+            if (notifier) return notifier;
+
+            /** @type {Notifier} */
+            notifier = {
+                /**
+                 * @method notify
+                 * @see http://arv.github.io/ecmascript-object-observe/#notifierprototype._notify
+                 * @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 = observed.get(object);
+                    if (data) {
+                        var recordCopy = { object: object }, prop;
+                        for (prop in changeRecord)
+                            if (prop !== "object")
+                                recordCopy[prop] = changeRecord[prop];
+                        addChangeRecord(data, recordCopy);
+                    }
+                },
+
+                /**
+                 * @method performChange
+                 * @see http://arv.github.io/ecmascript-object-observe/#notifierprototype_.performchange
+                 * @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");
+
+                    if (typeof func !== "function")
+                        throw new TypeError("Cannot perform non-function");
+
+                    // If there's no data, the object has been unobserved
+                    var data = observed.get(object),
+                        prop, changeRecord,
+                        result = func.call(arguments[2]);
+
+                    data && performPropertyChecks(object, data, changeType);
+
+                    // If there's no data, the object has been unobserved
+                    if (data && result && typeof result === "object") {
+                        changeRecord = { object: object, type: changeType };
+                        for (prop in result)
+                            if (prop !== "object" && prop !== "type")
+                                changeRecord[prop] = result[prop];
+                        addChangeRecord(data, changeRecord);
+                    }
+                }
+            };
+            if (data) data.notifier = notifier;
+
+            return notifier;
+        },
+
+        /**
+         * 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 = createMap();
+                data.set(object, hdata = {
+                    acceptList: acceptList,
+                    changeRecords: []
+                });
+                handlers.set(handler, data);
+            }
+
+            return hdata;
+        },
+
+        /**
+         * 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);
+            });
+        };
+
+    observed = createMap();
+    handlers = createMap();
+
+    /**
+     * @function Object.observe
+     * @see http://arv.github.io/ecmascript-object-observe/#Object.observe
+     * @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");
+
+        if (typeof handler !== "function")
+            throw new TypeError("Object.observe cannot deliver to non-function");
+
+        if (O.isFrozen && O.isFrozen(handler))
+            throw new TypeError("Object.observe cannot deliver to a frozen function object");
+
+        if (!isArray(acceptList))
+            acceptList = defaultObjectAccepts;
+
+        doObserve(object, handler, acceptList);
+
+        return object;
+    };
+
+    /**
+     * @function Object.unobserve
+     * @see http://arv.github.io/ecmascript-object-observe/#Object.unobserve
+     * @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");
+
+        if (typeof handler !== "function")
+            throw new TypeError("Object.unobserve cannot deliver to non-function");
+
+        var data = observed.get(object), cbdata;
+
+        if (data && data.handlers.has(handler)) {
+            performPropertyChecks(object, data);
+            broadcastChangeRecords(data);
+
+            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;
+    };
+
+    /**
+     * @function Object.getNotifier
+     * @see http://arv.github.io/ecmascript-object-observe/#GetNotifier
+     * @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");
+
+        if (O.isFrozen && O.isFrozen(object)) return null;
+
+        return retrieveNotifier(object);
+    };
+
+    /**
+     * @function Object.deliverChangeRecords
+     * @see http://arv.github.io/ecmascript-object-observe/#Object.deliverChangeRecords
+     * @see http://arv.github.io/ecmascript-object-observe/#DeliverChangeRecords
+     * @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 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
index 6ef0ee3..81ccce6 100644
--- a/object-observe.min.js
+++ b/object-observe.min.js
@@ -1,10 +1,11 @@
-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
+Object.observe||function(e,A,z){var k,r,F="add update delete reconfigure setPrototype preventExtensions".split(" "),G=z.Node?function(b){return b&&b instanceof z.Node}:function(b){return b&&"object"===typeof b&&"number"===typeof b.nodeType&&"string"===typeof b.nodeName},H=A.isArray||function(b){return function(c){return"[object Array]"===b.call(c)}}(e.prototype.toString),t=A.prototype.indexOf?function(b,c,a){return c.indexOf(b,a)}:function(b,c,a){for(a=a||0;a<c.length;a++)if(c[a]===b)return a;return-1},
+w="undefined"!==typeof z.Map&&Map.prototype.forEach?function(){return new Map}:function(){var b=[],c=[];return{size:0,has:function(a){return-1<t(a,b)},get:function(a){return c[t(a,b)]},set:function(a,d){var h=t(a,b);-1===h?(b.push(a),c.push(d),this.size++):c[h]=d},"delete":function(a){a=t(a,b);-1<a&&(b.splice(a,1),c.splice(a,1),this.size--)},forEach:function(a,d){for(var h=0;h<b.length;h++)a.call(d,c[h],b[h],this)}}},B=e.keys||function(b){var c=[],a;for(a in b)b.hasOwnProperty(a)&&c.push(a);return c},
+x=e.getPrototypeOf||null,v=e.defineProperties?e.getOwnPropertyDescriptor:null,J=function(b,c,a){var d=k.get(b);d?d.handlers.set(c,C(c,b,a)):(k.set(b,d={handlers:w(),frozen:e.isFrozen?e.isFrozen(b):!1,extensible:e.isExtensible?e.isExtensible(b):!0,proto:x&&x(b),properties:G(b)?[]:B(b)}),d.handlers.set(c,C(c,b,a)),D(b,d),I(b,d),setTimeout(function l(){k.has(b)&&(y(b,d),E(d),setTimeout(l,17))},17))},I=function(b,c){var a=c.properties,d=c.values=[],h=0,l;if(v)for(l=c.descriptors=[];h<a.length;)l[h]=v(b,
+a[h]),d[h]=b[a[h++]];else for(;h<a.length;)d[h]=b[a[h++]]},y=function(){var b=v?function(a,d,b,c,g){var f=d.properties[b],e=a[f],p=d.values[b],m=d.descriptors[b];"value"in g&&(p===e?0===p&&1/p!==1/e:p===p||e===e)&&(q(d,{name:f,type:"update",object:a,oldValue:p},c),d.values[b]=e);!m.configurable||g.configurable&&g.writable===m.writable&&g.enumerable===m.enumerable&&g.get===m.get&&g.set===m.set||(q(d,{name:f,type:"reconfigure",object:a,oldValue:p},c),d.descriptors[b]=g)}:function(a,d,b,c){var g=d.properties[b],
+f=a[g],e=d.values[b];if(e===f?0===e&&1/e!==1/f:e===e||f===f)q(d,{name:g,type:"update",object:a,oldValue:e},c),d.values[b]=f},c=v?function(a,d,c,e,g){for(var f=d.length,k;c&&f--;)null!==d[f]&&(k=v(a,d[f]),c--,k?b(a,e,f,g,k):(q(e,{name:d[f],type:"delete",object:a,oldValue:e.values[f]},g),e.properties.splice(f,1),e.values.splice(f,1),e.descriptors.splice(f,1)))}:function(a,b,c,e,g){for(var f=b.length;c&&f--;)null!==b[f]&&(q(e,{name:b[f],type:"delete",object:a,oldValue:e.values[f]},g),e.properties.splice(f,
+1),e.values.splice(f,1),c--)};return function(a,d,h){if(d.handlers.size&&!d.frozen){var l,g,f,k=d.values,p=d.descriptors,m=0,u,n,r;if(d.extensible)if(l=d.properties.slice(),g=l.length,f=B(a),p){for(;m<f.length;)n=f[m++],u=t(n,l),r=v(a,n),-1===u?(q(d,{name:n,type:"add",object:a},h),d.properties.push(n),k.push(a[n]),p.push(r)):(l[u]=null,g--,b(a,d,u,h,r));c(a,l,g,d,h);e.isExtensible(a)||(d.extensible=!1,q(d,{type:"preventExtensions",object:a},h),d.frozen=e.isFrozen(a))}else{for(;m<f.length;)n=f[m++],
+u=t(n,l),p=a[n],-1===u?(q(d,{name:n,type:"add",object:a},h),d.properties.push(n),k.push(p)):(l[u]=null,g--,b(a,d,u,h));c(a,l,g,d,h)}else if(!d.frozen){for(;m<l.length;m++)n=l[m],b(a,d,m,h,v(a,n));e.isFrozen(a)&&(d.frozen=!0)}x&&(a=x(a),a!==d.proto&&(q(d,{type:"setPrototype",name:"__proto__",oldValue:d.proto}),d.proto=a))}}}(),E=function(b){b.handlers.forEach(function(b,a){b.changeRecords.length&&(a(b.changeRecords),b.changeRecords=[])})},D=function(b,c){c||(c=k.get(b));var a=c&&c.notifier;if(a)return a;
+a={notify:function(a){a.type;var c=k.get(b);if(c){var e={object:b},g;for(g in a)"object"!==g&&(e[g]=a[g]);q(c,e)}},performChange:function(a,c,e){if("string"!==typeof a)throw new TypeError("Invalid non-string changeType");if("function"!==typeof c)throw new TypeError("Cannot perform non-function");var g=k.get(b),f;c=c.call(e);g&&y(b,g,a);if(g&&c&&"object"===typeof c){a={object:b,type:a};for(f in c)"object"!==f&&"type"!==f&&(a[f]=c[f]);q(g,a)}}};c&&(c.notifier=a);return a},C=function(b,c,a){var d=r.get(b),
+e;d?(e=d.get(c))?e.acceptList=a:d.set(c,e={acceptList:a,changeRecords:[]}):(d=w(),d.set(c,e={acceptList:a,changeRecords:[]}),r.set(b,d));return e},q=function(b,c,a){b.handlers.forEach(function(b){(null==a||-1===t(a,b.acceptList))&&-1<t(c.type,b.acceptList)&&b.changeRecords.push(c)})};k=w();r=w();e.observe=function(b,c,a){if(null===b||"object"!==typeof b)throw new TypeError("Object.observe cannot observe non-object");if("function"!==typeof c)throw new TypeError("Object.observe cannot deliver to non-function");
+if(e.isFrozen&&e.isFrozen(c))throw new TypeError("Object.observe cannot deliver to a frozen function object");H(a)||(a=F);J(b,c,a);return b};e.unobserve=function(b,c){if(null===b||"object"!==typeof b)throw new TypeError("Object.unobserve cannot unobserve non-object");if("function"!==typeof c)throw new TypeError("Object.unobserve cannot deliver to non-function");var a=k.get(b),d;if(a&&a.handlers.has(c)){y(b,a);E(a);d=r.get(c);if(1===d.size&&d.get(b))r["delete"](c);else d["delete"](b);if(1===a.handlers.size)k["delete"](b);
+else a.handlers["delete"](c)}return b};e.getNotifier=function(b){if(null===b||"object"!==typeof b)throw new TypeError("Object.getNotifier cannot getNotifier non-object");return e.isFrozen&&e.isFrozen(b)?null:D(b)};e.deliverChangeRecords=function(b){if("function"!==typeof b)throw new TypeError("Object.deliverChangeRecords cannot deliver to non-function");var c=r.get(b);c&&c.forEach(function(a,c){y(c,k.get(c));a.changeRecords.length&&(b(a.changeRecords),a.changeRecords=[])})}}(Object,Array,this);
diff --git a/readme.md b/readme.md
index 00479ef..1ac9c31 100644
--- a/readme.md
+++ b/readme.md
@@ -1,7 +1,7 @@
 Object.observe polyfill
 =======================
 
-`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.
+`Object.observe` is a very nice [EcmaScript 7 feature](http://arv.github.io/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!
 
@@ -9,6 +9,12 @@ The problem is that most browsers still doesn't support `Object.observe`. While
 
 After giving a look at other polyfills, like [jdarling's](https://github.com/jdarling/Object.observe) and [joelgriffith's](https://github.com/joelgriffith/object-observe-es5), and taking inspiration from them, I decided to write one myself trying to be more adherent to the specifications.
 
+## Which version?
+
+The polyfill comes in two flavours: a "full" and a "light" version. The "full" version aims to be 100% spec compliant, and fully supports all the native observable events. The "light" version, instead, only supports `"add"`, `"update"` and `"delete"`, and ditches most of the checks about properties, but it could be used in most cases where data binding is based on plain objects.
+
+If you don't need to check for `"reconfigure"`, `"preventExtensions"` and `"setPrototype"` events, and you are confident that your observed objects don't have to do with accessor properties or changes in their descriptors, then go for the light version, which should perform reasonably better on older and/old slower environments.
+
 ## Installation
 
 This polyfill extends the native `Object` and doesn't have any dependencies, so loading it is pretty straightforward:
@@ -25,6 +31,8 @@ require("object-observe.js");
 
 That's it. If the environment doesn't already support `Object.observe`, the shim is installed and ready to use.
 
+If you only need the "light" version of the polyfill, replace `object-observe.js` with `object-observe-lite.js`. You can also use the minified versions of the same files (replacing `.js` with `.min.js`).
+
 ## Under the hood
 
 Your intuition may have led you to think that this polyfill is based on polling the properties of the observed object. In other words, "dirty checking". If that's the case, well, you're correct: we have no better tools at the moment.
@@ -85,11 +93,12 @@ 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:
+* Property changes may not be reported in the correct order. The polyfill performs the checks - and issues the notifications - in this order:
 
-  1. `"add"` and `"update"`
-  2. `"delete"`
+  1. `"add"` and `"update"`, or `"reconfigure"`
+  2. `"delete"` or `"reconfigure"`
   3. `"preventExtensions"`
+  4. `"setPrototype"`
   
   This means that the `"add"` change is listed *before* the `"delete"` in the following snippet:
   
@@ -102,7 +111,7 @@ On a side note, it's better not using `setImmediate` (supported by node.js and I
   
   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:
+* When a property is created using `Object.defineProperty` and set to not enumerable, it's basically invisible to the polyfill:
 
   ```js
   Object.defineProperty(object, "bar", {
@@ -155,12 +164,24 @@ 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 - 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;
+* Some deeper considerations about whether using `Object.prototype.watch` or not;
 * support for DOM nodes;
 * code tests, documentation, optimization and cleanup.
 
+### `Array.observe`
+
+The [spec](http://arv.github.io/ecmascript-object-observe/#Array.observe) only states that `Array.observe` is just like `Object.observe` with a fixed accept list of `["add", "update", "delete", "splice"]`, and `Array.unobserve` is equivalent to `Object.unobserve`. That's fine, but where does that `"splice"` event come from?
+
+It's actually triggered by any operation on the array that *may* change the length of the array itself, like `push()` or `splice()`. These operations internally call `notifier.performChange("splice", ...)`, so one solution would be wrapping these methods in `Array.prototype` - or maybe better in the observed array itself - in a `performChange` call. Unfortunately, besides the obvious performance hit, a `"splice"` notification is triggered by this operation too:
+
+```js
+var fibonacci = [ 0, 1, 1, 2, 3 ];
+Array.observe(fibonacci, ...);
+fibonacci[5] = 5;
+```
+
+There's no way to trap this, and forcing developers to only use `Array.prototype` methods leaves me unsure. So, still have to figure out what to do.
+
 ## License
 
 The MIT License (MIT)