traceur-rb 0.0.1

data/vendor/node_modules/traceur/node_modules/q-io/node_modules/collections/listen/array-changes.js

@@ -0,0 +1,247 @@
+/*
+    Based in part on observable arrays from Motorola Mobility’s Montage
+    Copyright (c) 2012, Motorola Mobility LLC. All Rights Reserved.
+    3-Clause BSD License
+    https://github.com/motorola-mobility/montage/blob/master/LICENSE.md
+*/
+
+/*
+    This module is responsible for observing changes to owned properties of
+    objects and changes to the content of arrays caused by method calls.
+    The interface for observing array content changes establishes the methods
+    necessary for any collection with observable content.
+*/
+
+require("../shim");
+var List = require("../list");
+var WeakMap = require("weak-map");
+var PropertyChanges = require("./property-changes");
+var RangeChanges = require("./range-changes");
+var MapChanges = require("./map-changes");
+
+var array_splice = Array.prototype.splice;
+var array_slice = Array.prototype.slice;
+var array_reverse = Array.prototype.reverse;
+var array_sort = Array.prototype.sort;
+
+// use different strategies for making arrays observable between Internet
+// Explorer and other browsers.
+var protoIsSupported = {}.__proto__ === Object.prototype;
+var array_makeObservable;
+if (protoIsSupported) {
+    array_makeObservable = function () {
+        this.__proto__ = ChangeDispatchArray;
+    };
+} else {
+    array_makeObservable = function () {
+        Object.defineProperties(this, observableArrayProperties);
+    };
+}
+
+Object.defineProperty(Array.prototype, "makeObservable", {
+    value: array_makeObservable,
+    writable: true,
+    configurable: true,
+    enumerable: false
+});
+
+function defineEach(prototype) {
+    for (var name in prototype) {
+        Object.defineProperty(Array.prototype, name, {
+            value: prototype[name],
+            writable: true,
+            configurable: true,
+            enumerable: false
+        });
+    }
+}
+
+defineEach(PropertyChanges.prototype);
+defineEach(RangeChanges.prototype);
+defineEach(MapChanges.prototype);
+
+var observableArrayProperties = {
+
+    isObservable: {
+        value: true,
+        writable: true,
+        configurable: true
+    },
+
+    makeObservable: {
+        value: Function.noop, // idempotent
+        writable: true,
+        configurable: true
+    },
+
+    reverse: {
+        value: function reverse() {
+
+            var reversed = this.constructClone(this);
+            reversed.reverse();
+            this.swap(0, this.length, reversed);
+
+            return this;
+        },
+        writable: true,
+        configurable: true
+    },
+
+    sort: {
+        value: function sort() {
+
+            // dispatch before change events
+            this.dispatchBeforeRangeChange(this, this, 0);
+            for (var i = 0; i < this.length; i++) {
+                PropertyChanges.dispatchBeforeOwnPropertyChange(this, i, this[i]);
+                this.dispatchBeforeMapChange(i, this[i]);
+            }
+
+            // actual work
+            array_sort.apply(this, arguments);
+
+            // dispatch after change events
+            for (var i = 0; i < this.length; i++) {
+                PropertyChanges.dispatchOwnPropertyChange(this, i, this[i]);
+                this.dispatchMapChange(i, this[i]);
+            }
+            this.dispatchRangeChange(this, this, 0);
+
+            return this;
+        },
+        writable: true,
+        configurable: true
+    },
+
+    splice: {
+        value: function splice(start, length) {
+            var minus = array_slice.call(this, start, start + length);
+            var plus = array_slice.call(arguments, 2);
+            if (!minus.length && !plus.length)
+                return plus; // [], but spare us an instantiation
+            var diff = plus.length - minus.length;
+            var oldLength = this.length;
+            var newLength = Math.max(this.length + diff, start + plus.length);
+            var longest = Math.max(oldLength, newLength);
+
+            // dispatch before change events
+            if (diff) {
+                PropertyChanges.dispatchBeforeOwnPropertyChange(this, "length", this.length);
+            }
+            this.dispatchBeforeRangeChange(plus, minus, start);
+            if (diff === 0) { // substring replacement
+                for (var i = start; i < start + plus.length; i++) {
+                    PropertyChanges.dispatchBeforeOwnPropertyChange(this, i, this[i]);
+                    this.dispatchBeforeMapChange(i, this[i]);
+                }
+            } else if (PropertyChanges.hasOwnPropertyChangeDescriptor(this)) {
+                // all subsequent values changed or shifted.
+                // avoid (longest - start) long walks if there are no
+                // registered descriptors.
+                for (var i = start; i < longest; i++) {
+                    PropertyChanges.dispatchBeforeOwnPropertyChange(this, i, this[i]);
+                    this.dispatchBeforeMapChange(i, this[i]);
+                }
+            }
+
+            // actual work
+            if (start > oldLength) {
+                this.length = start;
+            }
+            var result = array_splice.apply(this, arguments);
+
+            // dispatch after change events
+            if (diff === 0) { // substring replacement
+                for (var i = start; i < start + plus.length; i++) {
+                    PropertyChanges.dispatchOwnPropertyChange(this, i, this[i]);
+                    this.dispatchMapChange(i, this[i]);
+                }
+            } else if (PropertyChanges.hasOwnPropertyChangeDescriptor(this)) {
+                // all subsequent values changed or shifted.
+                // avoid (longest - start) long walks if there are no
+                // registered descriptors.
+                for (var i = start; i < longest; i++) {
+                    PropertyChanges.dispatchOwnPropertyChange(this, i, this[i]);
+                    this.dispatchMapChange(i, this[i]);
+                }
+            }
+            this.dispatchRangeChange(plus, minus, start);
+            if (diff) {
+                PropertyChanges.dispatchOwnPropertyChange(this, "length", this.length);
+            }
+
+            return result;
+        },
+        writable: true,
+        configurable: true
+    },
+
+    // splice is the array content change utility belt.  forward all other
+    // content changes to splice so we only have to write observer code in one
+    // place
+
+    set: {
+        value: function set(index, value) {
+            this.splice(index, 1, value);
+            return this;
+        },
+        writable: true,
+        configurable: true
+    },
+
+    shift: {
+        value: function shift() {
+            return this.splice(0, 1)[0];
+        },
+        writable: true,
+        configurable: true
+    },
+
+    pop: {
+        value: function pop() {
+            if (this.length) {
+                return this.splice(this.length - 1, 1)[0];
+            }
+        },
+        writable: true,
+        configurable: true
+    },
+
+    push: {
+        value: function push(arg) {
+            if (arguments.length === 1) {
+                return this.splice(this.length, 0, arg);
+            } else {
+                var args = array_slice.call(arguments);
+                return this.swap(this.length, 0, args);
+            }
+        },
+        writable: true,
+        configurable: true
+    },
+
+    unshift: {
+        value: function unshift(arg) {
+            if (arguments.length === 1) {
+                return this.splice(0, 0, arg);
+            } else {
+                var args = array_slice.call(arguments);
+                return this.swap(0, 0, args);
+            }
+        },
+        writable: true,
+        configurable: true
+    },
+
+    clear: {
+        value: function clear() {
+            return this.splice(0, this.length);
+        },
+        writable: true,
+        configurable: true
+    }
+
+};
+
+var ChangeDispatchArray = Object.create(Array.prototype, observableArrayProperties);
+

data/vendor/node_modules/traceur/node_modules/q-io/node_modules/collections/listen/map-changes.js

@@ -0,0 +1,147 @@
+"use strict";
+
+var WeakMap = require("weak-map");
+var List = require("../list");
+
+module.exports = MapChanges;
+function MapChanges() {
+    throw new Error("Can't construct. MapChanges is a mixin.");
+}
+
+var object_owns = Object.prototype.hasOwnProperty;
+
+/*
+    Object map change descriptors carry information necessary for adding,
+    removing, dispatching, and shorting events to listeners for map changes
+    for a particular key on a particular object.  These descriptors are used
+    here for shallow map changes.
+
+    {
+        willChangeListeners:Array(Function)
+        changeListeners:Array(Function)
+    }
+*/
+
+var mapChangeDescriptors = new WeakMap();
+
+MapChanges.prototype.getAllMapChangeDescriptors = function () {
+    var Dict = require("../dict");
+    if (!mapChangeDescriptors.has(this)) {
+        mapChangeDescriptors.set(this, Dict());
+    }
+    return mapChangeDescriptors.get(this);
+};
+
+MapChanges.prototype.getMapChangeDescriptor = function (token) {
+    var tokenChangeDescriptors = this.getAllMapChangeDescriptors();
+    token = token || "";
+    if (!tokenChangeDescriptors.has(token)) {
+        tokenChangeDescriptors.set(token, {
+            willChangeListeners: new List(),
+            changeListeners: new List()
+        });
+    }
+    return tokenChangeDescriptors.get(token);
+};
+
+MapChanges.prototype.addMapChangeListener = function (listener, token, beforeChange) {
+    if (!this.isObservable && this.makeObservable) {
+        // for Array
+        this.makeObservable();
+    }
+    var descriptor = this.getMapChangeDescriptor(token);
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+    listeners.push(listener);
+    Object.defineProperty(this, "dispatchesMapChanges", {
+        value: true,
+        writable: true,
+        configurable: true,
+        enumerable: false
+    });
+
+    var self = this;
+    return function cancelMapChangeListener() {
+        if (!self) {
+            // TODO throw new Error("Can't remove map change listener again");
+            return;
+        }
+        self.removeMapChangeListener(listener, token, beforeChange);
+        self = null;
+    };
+};
+
+MapChanges.prototype.removeMapChangeListener = function (listener, token, beforeChange) {
+    var descriptor = this.getMapChangeDescriptor(token);
+
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+
+    var node = listeners.findLast(listener);
+    if (!node) {
+        throw new Error("Can't remove listener: does not exist.");
+    }
+    node["delete"]();
+};
+
+MapChanges.prototype.dispatchMapChange = function (key, value, beforeChange) {
+    var descriptors = this.getAllMapChangeDescriptors();
+    var changeName = "Map" + (beforeChange ? "WillChange" : "Change");
+    descriptors.forEach(function (descriptor, token) {
+
+        if (descriptor.isActive) {
+            return;
+        } else {
+            descriptor.isActive = true;
+        }
+
+        var listeners;
+        if (beforeChange) {
+            listeners = descriptor.willChangeListeners;
+        } else {
+            listeners = descriptor.changeListeners;
+        }
+
+        var tokenName = "handle" + (
+            token.slice(0, 1).toUpperCase() +
+            token.slice(1)
+        ) + changeName;
+
+        try {
+            // dispatch to each listener
+            listeners.forEach(function (listener) {
+                if (listener[tokenName]) {
+                    listener[tokenName](value, key, this);
+                } else if (listener.call) {
+                    listener.call(listener, value, key, this);
+                } else {
+                    throw new Error("Handler " + listener + " has no method " + tokenName + " and is not callable");
+                }
+            }, this);
+        } finally {
+            descriptor.isActive = false;
+        }
+
+    }, this);
+};
+
+MapChanges.prototype.addBeforeMapChangeListener = function (listener, token) {
+    return this.addMapChangeListener(listener, token, true);
+};
+
+MapChanges.prototype.removeBeforeMapChangeListener = function (listener, token) {
+    return this.removeMapChangeListener(listener, token, true);
+};
+
+MapChanges.prototype.dispatchBeforeMapChange = function (key, value) {
+    return this.dispatchMapChange(key, value, true);
+};
+

data/vendor/node_modules/traceur/node_modules/q-io/node_modules/collections/listen/property-changes.js

@@ -0,0 +1,448 @@
+/*
+    Based in part on observable arrays from Motorola Mobility’s Montage
+    Copyright (c) 2012, Motorola Mobility LLC. All Rights Reserved.
+    3-Clause BSD License
+    https://github.com/motorola-mobility/montage/blob/master/LICENSE.md
+*/
+
+/*
+    This module is responsible for observing changes to owned properties of
+    objects and changes to the content of arrays caused by method calls.
+    The interface for observing array content changes establishes the methods
+    necessary for any collection with observable content.
+*/
+
+require("../shim");
+var WeakMap = require("weak-map");
+
+var object_owns = Object.prototype.hasOwnProperty;
+
+/*
+    Object property descriptors carry information necessary for adding,
+    removing, dispatching, and shorting events to listeners for property changes
+    for a particular key on a particular object.  These descriptors are used
+    here for shallow property changes.
+
+    {
+        willChangeListeners:Array(Function)
+        changeListeners:Array(Function)
+    }
+*/
+var propertyChangeDescriptors = new WeakMap();
+
+// Maybe remove entries from this table if the corresponding object no longer
+// has any property change listeners for any key.  However, the cost of
+// book-keeping is probably not warranted since it would be rare for an
+// observed object to no longer be observed unless it was about to be disposed
+// of or reused as an observable.  The only benefit would be in avoiding bulk
+// calls to dispatchOwnPropertyChange events on objects that have no listeners.
+
+/*
+    To observe shallow property changes for a particular key of a particular
+    object, we install a property descriptor on the object that overrides the previous
+    descriptor.  The overridden descriptors are stored in this weak map.  The
+    weak map associates an object with another object that maps property names
+    to property descriptors.
+
+    overriddenObjectDescriptors.get(object)[key]
+
+    We retain the old descriptor for various purposes.  For one, if the property
+    is no longer being observed by anyone, we revert the property descriptor to
+    the original.  For "value" descriptors, we store the actual value of the
+    descriptor on the overridden descriptor, so when the property is reverted, it
+    retains the most recently set value.  For "get" and "set" descriptors,
+    we observe then forward "get" and "set" operations to the original descriptor.
+*/
+var overriddenObjectDescriptors = new WeakMap();
+
+module.exports = PropertyChanges;
+
+function PropertyChanges() {
+    throw new Error("This is an abstract interface. Mix it. Don't construct it");
+}
+
+PropertyChanges.debug = true;
+
+PropertyChanges.prototype.getOwnPropertyChangeDescriptor = function (key) {
+    if (!propertyChangeDescriptors.has(this)) {
+        propertyChangeDescriptors.set(this, {});
+    }
+    var objectPropertyChangeDescriptors = propertyChangeDescriptors.get(this);
+    if (!object_owns.call(objectPropertyChangeDescriptors, key)) {
+        objectPropertyChangeDescriptors[key] = {
+            willChangeListeners: [],
+            changeListeners: []
+        };
+    }
+    return objectPropertyChangeDescriptors[key];
+};
+
+PropertyChanges.prototype.hasOwnPropertyChangeDescriptor = function (key) {
+    if (!propertyChangeDescriptors.has(this)) {
+        return false;
+    }
+    if (!key) {
+        return true;
+    }
+    var objectPropertyChangeDescriptors = propertyChangeDescriptors.get(this);
+    if (!object_owns.call(objectPropertyChangeDescriptors, key)) {
+        return false;
+    }
+    return true;
+};
+
+PropertyChanges.prototype.addOwnPropertyChangeListener = function (key, listener, beforeChange) {
+    if (this.makeObservable && !this.isObservable) {
+        this.makeObservable(); // particularly for observable arrays, for
+        // their length property
+    }
+    var descriptor = PropertyChanges.getOwnPropertyChangeDescriptor(this, key);
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+    PropertyChanges.makePropertyObservable(this, key);
+    listeners.push(listener);
+
+    var self = this;
+    return function cancelOwnPropertyChangeListener() {
+        PropertyChanges.removeOwnPropertyChangeListener(self, key, listeners, beforeChange);
+        self = null;
+    };
+};
+
+PropertyChanges.prototype.addBeforeOwnPropertyChangeListener = function (key, listener) {
+    return PropertyChanges.addOwnPropertyChangeListener(this, key, listener, true);
+};
+
+PropertyChanges.prototype.removeOwnPropertyChangeListener = function (key, listener, beforeChange) {
+    var descriptor = PropertyChanges.getOwnPropertyChangeDescriptor(this, key);
+
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+
+    var index = listeners.lastIndexOf(listener);
+    if (index === -1) {
+        throw new Error("Can't remove listener: does not exist.");
+    }
+    listeners.splice(index, 1);
+
+    if (descriptor.changeListeners.length + descriptor.willChangeListeners.length === 0) {
+        PropertyChanges.makePropertyUnobservable(this, key);
+    }
+};
+
+PropertyChanges.prototype.removeBeforeOwnPropertyChangeListener = function (key, listener) {
+    return PropertyChanges.removeOwnPropertyChangeListener(this, key, listener, true);
+};
+
+PropertyChanges.prototype.dispatchOwnPropertyChange = function (key, value, beforeChange) {
+    var descriptor = PropertyChanges.getOwnPropertyChangeDescriptor(this, key);
+
+    if (descriptor.isActive) {
+        return;
+    }
+    descriptor.isActive = true;
+
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+
+    var changeName = (beforeChange ? "Will" : "") + "Change";
+    var genericHandlerName = "handleProperty" + changeName;
+    var propertyName = String(key);
+    propertyName = propertyName && propertyName[0].toUpperCase() + propertyName.slice(1);
+    var specificHandlerName = "handle" + propertyName + changeName;
+
+    try {
+        // dispatch to each listener
+        listeners.forEach(function (listener) {
+            var thisp = listener;
+            listener = (
+                listener[specificHandlerName] ||
+                listener[genericHandlerName] ||
+                listener
+            );
+            if (!listener.call) {
+                throw new Error("No event listener for " + specificHandlerName + " or " + genericHandlerName + " or call on " + listener);
+            }
+            listener.call(thisp, value, key, this);
+        }, this);
+    } finally {
+        descriptor.isActive = false;
+    }
+};
+
+PropertyChanges.prototype.dispatchBeforeOwnPropertyChange = function (key, listener) {
+    return PropertyChanges.dispatchOwnPropertyChange(this, key, listener, true);
+};
+
+PropertyChanges.prototype.makePropertyObservable = function (key) {
+    // arrays are special.  we do not support direct setting of properties
+    // on an array.  instead, call .set(index, value).  this is observable.
+    // 'length' property is observable for all mutating methods because
+    // our overrides explicitly dispatch that change.
+    if (Array.isArray(this)) {
+        return;
+    }
+
+    if (!Object.isExtensible(this, key)) {
+        throw new Error("Can't make property " + JSON.stringify(key) + " observable on " + this + " because object is not extensible");
+    }
+
+    var state;
+    if (typeof this.__state__ === "object") {
+        state = this.__state__;
+    } else {
+        state = {};
+        if (Object.isExtensible(this, "__state__")) {
+            Object.defineProperty(this, "__state__", {
+                value: state,
+                writable: true,
+                enumerable: false
+            });
+        }
+    }
+    state[key] = this[key];
+
+    // memoize overridden property descriptor table
+    if (!overriddenObjectDescriptors.has(this)) {
+        overriddenPropertyDescriptors = {};
+        overriddenObjectDescriptors.set(this, overriddenPropertyDescriptors);
+    }
+    var overriddenPropertyDescriptors = overriddenObjectDescriptors.get(this);
+
+    if (object_owns.call(overriddenPropertyDescriptors, key)) {
+        // if we have already recorded an overridden property descriptor,
+        // we have already installed the observer, so short-here
+        return;
+    }
+
+    // walk up the prototype chain to find a property descriptor for
+    // the property name
+    var overriddenDescriptor;
+    var attached = this;
+    var formerDescriptor = Object.getOwnPropertyDescriptor(attached, key);
+    do {
+        overriddenDescriptor = Object.getOwnPropertyDescriptor(attached, key);
+        if (overriddenDescriptor) {
+            break;
+        }
+        attached = Object.getPrototypeOf(attached);
+    } while (attached);
+    // or default to an undefined value
+    overriddenDescriptor = overriddenDescriptor || {
+        value: undefined,
+        enumerable: true,
+        writable: true,
+        configurable: true
+    };
+
+    if (!overriddenDescriptor.configurable) {
+        throw new Error("Can't observe non-configurable properties");
+    }
+
+    // memoize the descriptor so we know not to install another layer,
+    // and so we can reuse the overridden descriptor when uninstalling
+    overriddenPropertyDescriptors[key] = overriddenDescriptor;
+
+    // give up *after* storing the overridden property descriptor so it
+    // can be restored by uninstall.  Unwritable properties are
+    // silently not overriden.  Since success is indistinguishable from
+    // failure, we let it pass but don't waste time on intercepting
+    // get/set.
+    if (!overriddenDescriptor.writable && !overriddenDescriptor.set) {
+        return;
+    }
+
+    // TODO reflect current value on a displayed property
+
+    var propertyListener;
+    // in both of these new descriptor variants, we reuse the overridden
+    // descriptor to either store the current value or apply getters
+    // and setters.  this is handy since we can reuse the overridden
+    // descriptor if we uninstall the observer.  We even preserve the
+    // assignment semantics, where we get the value from up the
+    // prototype chain, and set as an owned property.
+    if ('value' in overriddenDescriptor) {
+        propertyListener = {
+            get: function () {
+                return overriddenDescriptor.value
+            },
+            set: function (value) {
+                if (value === overriddenDescriptor.value) {
+                    return value;
+                }
+                PropertyChanges.dispatchBeforeOwnPropertyChange(this, key, overriddenDescriptor.value);
+                overriddenDescriptor.value = value;
+                state[key] = value;
+                PropertyChanges.dispatchOwnPropertyChange(this, key, value);
+                return value;
+            },
+            enumerable: overriddenDescriptor.enumerable,
+            configurable: true
+        };
+    } else { // 'get' or 'set', but not necessarily both
+        propertyListener = {
+            get: function () {
+                if (overriddenDescriptor.get) {
+                    return overriddenDescriptor.get.apply(this, arguments);
+                }
+            },
+            set: function (value) {
+                var formerValue;
+
+                // get the actual former value if possible
+                if (overriddenDescriptor.get) {
+                    formerValue = overriddenDescriptor.get.apply(this, arguments);
+                }
+                // call through to actual setter
+                if (overriddenDescriptor.set) {
+                    overriddenDescriptor.set.apply(this, arguments)
+                }
+                // use getter, if possible, to discover whether the set
+                // was successful
+                if (overriddenDescriptor.get) {
+                    value = overriddenDescriptor.get.apply(this, arguments);
+                    state[key] = value;
+                }
+                // if it has not changed, suppress a notification
+                if (value === formerValue) {
+                    return value;
+                }
+                PropertyChanges.dispatchBeforeOwnPropertyChange(this, key, formerValue);
+
+                // dispatch the new value: the given value if there is
+                // no getter, or the actual value if there is one
+                PropertyChanges.dispatchOwnPropertyChange(this, key, value);
+                return value;
+            },
+            enumerable: overriddenDescriptor.enumerable,
+            configurable: true
+        };
+    }
+
+    Object.defineProperty(this, key, propertyListener);
+};
+
+PropertyChanges.prototype.makePropertyUnobservable = function (key) {
+    // arrays are special.  we do not support direct setting of properties
+    // on an array.  instead, call .set(index, value).  this is observable.
+    // 'length' property is observable for all mutating methods because
+    // our overrides explicitly dispatch that change.
+    if (Array.isArray(this)) {
+        return;
+    }
+
+    if (!overriddenObjectDescriptors.has(this)) {
+        throw new Error("Can't uninstall observer on property");
+    }
+    var overriddenPropertyDescriptors = overriddenObjectDescriptors.get(this);
+
+    if (!overriddenPropertyDescriptors[key]) {
+        throw new Error("Can't uninstall observer on property");
+    }
+
+    var overriddenDescriptor = overriddenPropertyDescriptors[key];
+    delete overriddenPropertyDescriptors[key];
+
+    var state;
+    if (typeof this.__state__ === "object") {
+        state = this.__state__;
+    } else {
+        state = {};
+        if (Object.isExtensible(this, "__state__")) {
+            Object.defineProperty(this, "__state__", {
+                value: state,
+                writable: true,
+                enumerable: false
+            });
+        }
+    }
+    delete state[key];
+
+    Object.defineProperty(this, key, overriddenDescriptor);
+};
+
+// constructor functions
+
+PropertyChanges.getOwnPropertyChangeDescriptor = function (object, key) {
+    if (object.getOwnPropertyChangeDescriptor) {
+        return object.getOwnPropertyChangeDescriptor(key);
+    } else {
+        return PropertyChanges.prototype.getOwnPropertyChangeDescriptor.call(object, key);
+    }
+};
+
+PropertyChanges.hasOwnPropertyChangeDescriptor = function (object, key) {
+    if (object.hasOwnPropertyChangeDescriptor) {
+        return object.hasOwnPropertyChangeDescriptor(key);
+    } else {
+        return PropertyChanges.prototype.hasOwnPropertyChangeDescriptor.call(object, key);
+    }
+};
+
+PropertyChanges.addOwnPropertyChangeListener = function (object, key, listener, beforeChange) {
+    if (!Object.isObject(object)) {
+    } else if (object.addOwnPropertyChangeListener) {
+        return object.addOwnPropertyChangeListener(key, listener, beforeChange);
+    } else {
+        return PropertyChanges.prototype.addOwnPropertyChangeListener.call(object, key, listener, beforeChange);
+    }
+};
+
+PropertyChanges.removeOwnPropertyChangeListener = function (object, key, listener, beforeChange) {
+    if (!Object.isObject(object)) {
+    } else if (object.removeOwnPropertyChangeListener) {
+        return object.removeOwnPropertyChangeListener(key, listener, beforeChange);
+    } else {
+        return PropertyChanges.prototype.removeOwnPropertyChangeListener.call(object, key, listener, beforeChange);
+    }
+};
+
+PropertyChanges.dispatchOwnPropertyChange = function (object, key, value, beforeChange) {
+    if (!Object.isObject(object)) {
+    } else if (object.dispatchOwnPropertyChange) {
+        return object.dispatchOwnPropertyChange(key, value, beforeChange);
+    } else {
+        return PropertyChanges.prototype.dispatchOwnPropertyChange.call(object, key, value, beforeChange);
+    }
+};
+
+PropertyChanges.addBeforeOwnPropertyChangeListener = function (object, key, listener) {
+    return PropertyChanges.addOwnPropertyChangeListener(object, key, listener, true);
+};
+
+PropertyChanges.removeBeforeOwnPropertyChangeListener = function (object, key, listener) {
+    return PropertyChanges.removeOwnPropertyChangeListener(object, key, listener, true);
+};
+
+PropertyChanges.dispatchBeforeOwnPropertyChange = function (object, key, value) {
+    return PropertyChanges.dispatchOwnPropertyChange(object, key, value, true);
+};
+
+PropertyChanges.makePropertyObservable = function (object, key) {
+    if (object.makePropertyObservable) {
+        return object.makePropertyObservable(key);
+    } else {
+        return PropertyChanges.prototype.makePropertyObservable.call(object, key);
+    }
+};
+
+PropertyChanges.makePropertyUnobservable = function (object, key) {
+    if (object.makePropertyUnobservable) {
+        return object.makePropertyUnobservable(key);
+    } else {
+        return PropertyChanges.prototype.makePropertyUnobservable.call(object, key);
+    }
+};
+