traceur-rb 0.0.1 → 0.0.2

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

@@ -1,247 +0,0 @@
-/*
-    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

@@ -1,147 +0,0 @@
-"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

@@ -1,448 +0,0 @@
-/*
-    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);
-    }
-};
-