    /** * @class Object * * Creates an object wrapper. * * The Object constructor creates an object wrapper for the given value. If the value is null or * undefined, it will create and return an empty object, otherwise, it will return an object of a type * that corresponds to the given value. * * When called in a non-constructor context, Object behaves identically. * * # Using Object given undefined and null types * * The following examples store an empty Object object in o: *     var o = new Object(); * *     var o = new Object(undefined); * *     var o = new Object(null); * * # Using Object to create Boolean objects * * The following examples store Boolean objects in o: * *     // equivalent to o = new Boolean(true); *     var o = new Object(true); * *     // equivalent to o = new Boolean(false); *     var o = new Object(Boolean()); * * <div class="notice"> * Documentation for this class comes from [MDN](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object) * and is available under [Creative Commons: Attribution-Sharealike license](http://creativecommons.org/licenses/by-sa/2.0/). * </div> */ /** * @method constructor * Creates new Object. * @param {Object} [value] The value to wrap. */ //Properties  /** * @property prototype * Allows the addition of properties to all objects of type Object. */ //Methods  /** * @method hasOwnProperty * Returns a boolean indicating whether an object contains the specified property as a direct property * of that object and not inherited through the prototype chain. * * Every object descended from `Object` inherits the `hasOwnProperty` method. This method can be used * to determine whether an object has the specified property as a direct property of that object; * unlike the `in` operator, this method does not check down the object's prototype chain. * * The following example determines whether the o object contains a property named prop: * *     o = new Object(); *     o.prop = 'exists'; * *     function changeO() { *         o.newprop = o.prop; *         delete o.prop; *     } * *     o.hasOwnProperty('prop');   //returns true *     changeO(); *     o.hasOwnProperty('prop');   //returns false * * The following example differentiates between direct properties and properties inherited through the * prototype chain: * *     o = new Object(); *     o.prop = 'exists'; *     o.hasOwnProperty('prop');             // returns true *     o.hasOwnProperty('toString');         // returns false *     o.hasOwnProperty('hasOwnProperty');   // returns false * * The following example shows how to iterate over the properties of an object without executing on * inherit properties. * *     var buz = { *         fog: 'stack' *     }; * *     for (var name in buz) { *         if (buz.hasOwnProperty(name)) { *             alert("this is fog (" + name + ") for sure. Value: " + buz[name]); *         } *         else { *             alert(name); // toString or something else *         } *     } * * @param {String} prop The name of the property to test. * @return {Boolean} Returns true if object contains specified property; else * returns false. */ /** * @method isPrototypeOf * Returns a boolean indication whether the specified object is in the prototype chain of the object * this method is called upon. * * `isPrototypeOf` allows you to check whether or not an object exists within another object's * prototype chain. * * For example, consider the following prototype chain: * *     function Fee() { *         // . . . *     } * *     function Fi() { *         // . . . *     } *     Fi.prototype = new Fee(); * *     function Fo() { *         // . . . *     } *     Fo.prototype = new Fi(); * *     function Fum() { *         // . . . *     } *     Fum.prototype = new Fo(); * * Later on down the road, if you instantiate `Fum` and need to check if `Fi`'s prototype exists * within the `Fum` prototype chain, you could do this: * *     var fum = new Fum(); *     . . . * *     if (Fi.prototype.isPrototypeOf(fum)) { *     // do something safe *     } * * This, along with the `instanceof` operator particularly comes in handy if you have code that can * only function when dealing with objects descended from a specific prototype chain, e.g., to * guarantee that certain methods or properties will be present on that object. * * @param {Object} prototype an object to be tested against each link in the prototype chain of the * *object* argument * @param {Object} object the object whose prototype chain will be searched * @return {Boolean} Returns true if object is a prototype and false if not. */ /** * @method propertyIsEnumerable * Returns a boolean indicating if the internal ECMAScript DontEnum attribute is set. * * Every object has a `propertyIsEnumerable` method. This method can determine whether the specified * property in an object can be enumerated by a `for...in` loop, with the exception of properties * inherited through the prototype chain. If the object does not have the specified property, this * method returns false. * * The following example shows the use of `propertyIsEnumerable` on objects and arrays: * *     var o = {}; *     var a = []; *     o.prop = 'is enumerable'; *     a[0] = 'is enumerable'; * *     o.propertyIsEnumerable('prop');   // returns true *     a.propertyIsEnumerable(0);        // returns true * * The following example demonstrates the enumerability of user-defined versus built-in properties: * *     var a = ['is enumerable']; * *     a.propertyIsEnumerable(0);          // returns true *     a.propertyIsEnumerable('length');   // returns false * *     Math.propertyIsEnumerable('random');   // returns false *     this.propertyIsEnumerable('Math');     // returns false * * Direct versus inherited properties * *     var a = []; *     a.propertyIsEnumerable('constructor');         // returns false * *     function firstConstructor() *     { *         this.property = 'is not enumerable'; *     } *     firstConstructor.prototype.firstMethod = function () {}; * *     function secondConstructor() *     { *         this.method = function method() { return 'is enumerable'; }; *     } * *     secondConstructor.prototype = new firstConstructor; *     secondConstructor.prototype.constructor = secondConstructor; * *     var o = new secondConstructor(); *     o.arbitraryProperty = 'is enumerable'; * *     o.propertyIsEnumerable('arbitraryProperty');   // returns true *     o.propertyIsEnumerable('method');              // returns true *     o.propertyIsEnumerable('property');            // returns false * *     o.property = 'is enumerable'; * *     o.propertyIsEnumerable('property');            // returns true * *     // These return false as they are on the prototype which *     // propertyIsEnumerable does not consider (even though the last two *     // are iteratable with for-in) *     o.propertyIsEnumerable('prototype'); // returns false (as of JS 1.8.1/FF3.6) *     o.propertyIsEnumerable('constructor'); // returns false *     o.propertyIsEnumerable('firstMethod'); // returns false * * @param {String} prop The name of the property to test. * @return {Boolean} If the object does not have the specified property, this * method returns false. */ /** * @method toLocaleString * Returns a string representing the object. This method is meant to be overridden by derived objects * for locale-specific purposes. * * `Object`'s `toLocaleString` returns the result of calling `toString`. * * This function is provided to give objects a generic `toLocaleString` method, even though not all * may use it. Currently, only `Array`, `Number`, and `Date` override `toLocaleString`. * * @return {String} Object represented as a string. */ /** * @method toString * Returns a string representation of the object. * * Every object has a `toString()` method that is automatically called when the object is to be * represented as a text value or when an object is referred to in a manner in which a string is * expected. By default, the `toString()` method is inherited by every object descended from `Object`. * If this method is not overridden in a custom object, `toString()` returns "[object type]", where * `type` is the object type. The following code illustrates this: * *     var o = new Object(); *     o.toString();           // returns [object Object] * * You can create a function to be called in place of the default `toString()` method. The * `toString()` method takes no arguments and should return a string. The `toString()` method you * create can be any value you want, but it will be most useful if it carries information about the * object. * * The following code defines the `Dog` object type and creates `theDog`, an object of type `Dog`: * *     function Dog(name,breed,color,sex) { *         this.name=name; *         this.breed=breed; *         this.color=color; *         this.sex=sex; *     } * *     theDog = new Dog("Gabby","Lab","chocolate","female"); * * If you call the `toString()` method on this custom object, it returns the default value inherited * from `Object`: * *     theDog.toString(); //returns [object Object] * * The following code creates and assigns `dogToString()` to override the default `toString()` method. * This function generates a string containing the name, breed, color, and sex of the object, in the * form `"property = value;"`. * *     Dog.prototype.toString = function dogToString() { *         var ret = "Dog " + this.name + " is a " + this.sex + " " + this.color + " " + this.breed; *         return ret; *     } * * With the preceding code in place, any time theDog is used in a string context, JavaScript * automatically calls the `dogToString()` function, which returns the following string: * *     Dog Gabby is a female chocolate Lab * * `toString()` can be used with every object and allows you to get its class. To use the * `Object.prototype.toString()` with every object, you need to call `Function.prototype.call()` or * `Function.prototype.apply()` on it, passing the object you want to inspect as the first parameter * called `thisArg`. * *     var toString = Object.prototype.toString; * *     toString.call(new Date); // [object Date] *     toString.call(new String); // [object String] *     toString.call(Math); // [object Math] * * @return {String} Object represented as a string. */ /** * @method valueOf * Returns the primitive value of the specified object. * * JavaScript calls the `valueOf` method to convert an object to a primitive value. You rarely need to * invoke the `valueOf` method yourself; JavaScript automatically invokes it when encountering an * object where a primitive value is expected. * * By default, the `valueOf` method is inherited by every object descended from `Object`. Every built- * in core object overrides this method to return an appropriate value. If an object has no primitive * value, `valueOf` returns the object itself, which is displayed as: * *     [object Object] * * You can use `valueOf` within your own code to convert a built-in object into a primitive value. * When you create a custom object, you can override `Object.valueOf` to call a custom method instead * of the default `Object` method. * * You can create a function to be called in place of the default `valueOf` method. Your function must * take no arguments. * * Suppose you have an object type `myNumberType` and you want to create a `valueOf` method for it. * The following code assigns a user-defined function to the object's valueOf method: * *     myNumberType.prototype.valueOf = new Function(functionText) * * With the preceding code in place, any time an object of type `myNumberType` is used in a context * where it is to be represented as a primitive value, JavaScript automatically calls the function * defined in the preceding code. * * An object's `valueOf` method is usually invoked by JavaScript, but you can invoke it yourself as * follows: * *     myNumber.valueOf() * * Note: Objects in string contexts convert via the `toString` method, which is different from * `String` objects converting to string primitives using `valueOf`. All objects have a string * conversion, if only `"[object type]"`. But many objects do not convert to number, boolean, or * function. * * @return {Object} Returns value of the object or the object itself. */ //Properties  /** * @property constructor * Specifies the function that creates an object's prototype. * * Returns a reference to the Object function that created the instance's prototype. Note that the * value of this property is a reference to the function itself, not a string containing the * function's name, but it isn't read only (except for primitive Boolean, Number or String values: 1, * true, "read-only"). * * All objects inherit a `constructor` property from their `prototype`: * *     o = new Object // or o = {} in JavaScript 1.2 *     o.constructor == Object *     a = new Array // or a = [] in JavaScript 1.2 *     a.constructor == Array *     n = new Number(3) *     n.constructor == Number * * Even though you cannot construct most HTML objects, you can do comparisons. For example, * *     document.constructor == Document *     document.form3.constructor == Form * * The following example creates a prototype, `Tree`, and an object of that type, theTree. The example then displays the `constructor` property for the object `theTree`. * *     function Tree(name) { *         this.name = name; *     } *     theTree = new Tree("Redwood"); *     console.log("theTree.constructor is " + theTree.constructor); * * This example displays the following output: * *     theTree.constructor is function Tree(name) { *         this.name = name; *     } * * The following example shows how to modify constructor value of generic objects. Only true, 1 and * "test" variable constructors will not be changed. This example explains that is not always so safe * to believe in constructor function. * *     function Type(){}; *     var	types = [ * 	    new Array,	[], *	    new Boolean,	true, *	    new Date, *	    new Error, *	    new Function,	function(){}, *	    Math, *	    new Number,	1, *	    new Object,	{}, *	    new RegExp,	/(?:)/, *	    new String,	"test" *     ]; *     for(var i = 0; i < types.length; i++){ *         types[i].constructor = Type; *         types[i] = [types[i].constructor, types[i] instanceof Type, types[i].toString()]; *     }; *     alert(types.join("\n")); */ // ECMAScript 5 methods  /** * @method create * @static * Creates a new object with the specified prototype object and properties. * * ## Classical inheritance with Object.create * * Below is an example of how to use `Object.create` to achieve * classical inheritance, this is for single inheritance, which is all * that Javascript supports. * *     //Shape - superclass *     function Shape() { *       this.x = 0; *       this.y = 0; *     } * *     Shape.prototype.move = function(x, y) { *         this.x += x; *         this.y += y; *         console.info("Shape moved."); *     }; * *     // Rectangle - subclass *     function Rectangle() { *       Shape.call(this); //call super constructor. *     } * *     Rectangle.prototype = Object.create(Shape.prototype); * *     var rect = new Rectangle(); * *     rect instanceof Rectangle //true. *     rect instanceof Shape //true. * *     rect.move(); //Outputs, "Shape moved." * * If you wish to inherit from multiple objects, then mixins are a possibility. * *     function MyClass() { *          SuperClass.call(this); *          OtherSuperClass.call(this); *     } * *     MyClass.prototype = Object.create(SuperClass.prototype); //inherit *     mixin(MyClass.prototype, OtherSuperClass.prototype); //mixin * *     MyClass.prototype.myMethod = function() { *          // do a thing *     }; * * The mixin function would copy the functions from the superclass * prototype to the subclass prototype, the mixin function needs to be * supplied by the user. * * ## Using `propertiesObject` argument with Object.create * *     var o; * *     // create an object with null as prototype *     o = Object.create(null); * * *     o = {}; *     // is equivalent to: *     o = Object.create(Object.prototype); * * *     // Example where we create an object with a couple of sample properties. *     // (Note that the second parameter maps keys to *property descriptors*.) *     o = Object.create(Object.prototype, { *       // foo is a regular "value property" *       foo: { writable:true, configurable:true, value: "hello" }, *       // bar is a getter-and-setter (accessor) property *       bar: { *         configurable: false, *         get: function() { return 10 }, *         set: function(value) { console.log("Setting `o.bar` to", value) } *     }}) * * *     function Constructor(){} *     o = new Constructor(); *     // is equivalent to: *     o = Object.create(Constructor.prototype); *     // Of course, if there is actual initialization code in the Constructor function, the Object.create cannot reflect it * * *     // create a new object whose prototype is a new, empty object *     // and a adding single property 'p', with value 42 *     o = Object.create({}, { p: { value: 42 } }) * *     // by default properties ARE NOT writable, enumerable or configurable: *     o.p = 24 *     o.p *     //42 * *     o.q = 12 *     for (var prop in o) { *        console.log(prop) *     } *     //"q" * *     delete o.p *     //false * *     //to specify an ES3 property *     o2 = Object.create({}, { p: { value: 42, writable: true, enumerable: true, configurable: true } }); * * **NOTE:** This method is part of the ECMAScript 5 standard. * * @param {Object} proto The object which should be the prototype of * the newly-created object. * * Throws a `TypeError` exception if the `proto` parameter isn't null or * an object. * * @param {Object} [propertiesObject] If specified and not undefined, * an object whose enumerable own properties (that is, those * properties defined upon itself and not enumerable properties along * its prototype chain) specify property descriptors to be added to * the newly-created object, with the corresponding property names. * * @return {Object} the newly created object. */ /** * @method defineProperty * @static * * Defines a new property directly on an object, or modifies an * existing property on an object, and returns the object. * * This method allows precise addition to or modification of a * property on an object. Normal property addition through assignment * creates properties which show up during property enumeration * (for...in loop or {@link Object#keys} method), whose values may be * changed, and which may be deleted. This method allows these extra * details to be changed from their defaults. * * Property descriptors present in objects come in two main flavors: * data descriptors and accessor descriptors. A data descriptor is a * property that has a value, which may or may not be writable. An * accessor descriptor is a property described by a getter-setter pair * of functions. A descriptor must be one of these two flavors; it * cannot be both. * * Both data and accessor descriptor is an object with the following * optional keys: * * - **configurable** True if and only if the type of this property *   descriptor may be changed and if the property may be deleted from *   the corresponding object. Defaults to false. * * - **enumerable** True if and only if this property shows up during *   enumeration of the properties on the corresponding *   object. Defaults to false. * * A data descriptor is an object with the following optional keys: * * - **value** The value associated with the property. Can be any *   valid JavaScript value (number, object, function, etc) Defaults *   to undefined. * * - **writable** True if and only if the value associated with the *   property may be changed with an assignment operator. Defaults to *   false. * * An accessor descriptor is an object with the following optional * keys: * * - **get** A function which serves as a getter for the property, or *   undefined if there is no getter. The function return will be used *   as the value of property. Defaults to undefined. * * - **set** A function which serves as a setter for the property, or *   undefined if there is no setter. The function will receive as *   only argument the new value being assigned to the *   property. Defaults to undefined. * * Bear in mind that these options are not necessarily own properties * so, if inherited, will be considered too. In order to ensure these * defaults are preserved you might freeze the Object.prototype * upfront, specify all options explicitly, or point to null as * __proto__ property. * * **NOTE:** This method is part of the ECMAScript 5 standard. * * @param {Object} obj The object on which to define the property. * @param {String} prop The name of the property to be defined or modified. * @param {Object} descriptor The descriptor for the property being * defined or modified. */ /** * @method defineProperties * @static * * Defines new or modifies existing properties directly on an object, * returning the object. * * In essence, it defines all properties corresponding to the * enumerable own properties of props on the object. * *     Object.defineProperties(obj, { *       "property1": { *         value: true, *         writable: true *       }, *       "property2": { *         value: "Hello", *         writable: false *       } *       // etc. etc. *     }); * * **NOTE:** This method is part of the ECMAScript 5 standard. * * @param {Object} obj The object on which to define or modify properties. * @param {Object} props An object whose own enumerable properties * constitute descriptors for the properties to be defined or * modified. */ /** * @method getOwnPropertyDescriptor * @static * * Returns a property descriptor for an own property (that is, one * directly present on an object, not present by dint of being along * an object's prototype chain) of a given object. * * This method permits examination of the precise description of a * property. A property in JavaScript consists of a string-valued name * and a property descriptor. Further information about property * descriptor types and their attributes can be found in * {@link Object#defineProperty}. * * **NOTE:** This method is part of the ECMAScript 5 standard. * * @param {Object} obj The object in which to look for the property. * @param {String} prop The name of the property whose description is * to be retrieved. * * A property descriptor is a record with some of the following * attributes: * * - **value** The value associated with the property (data *   descriptors only). * * - **writable** True if and only if the value associated with *   the property may be changed (data descriptors only). * * - **get** A function which serves as a getter for the property, *    or undefined if there is no getter (accessor descriptors only). * * - **set** A function which serves as a setter for the property, *   or undefined if there is no setter (accessor descriptors only). * * - **configurable** true if and only if the type of this property *   descriptor may be changed and if the property may be deleted *   from the corresponding object. * * - **enumerable** true if and only if this property shows up *   during enumeration of the properties on the corresponding object. * * @return {Mixed} Value of the property descriptor. */ /** * @method keys * @static * * Returns an array of a given object's own enumerable properties, in * the same order as that provided by a for-in loop (the difference * being that a for-in loop enumerates properties in the prototype * chain as well). * * Returns an array whose elements are strings corresponding to the * enumerable properties found directly upon object. The ordering of * the properties is the same as that given by looping over the * properties of the object manually. * *     var arr = ["a", "b", "c"]; *     alert(Object.keys(arr)); // will alert "0,1,2" * *     // array like object *     var obj = { 0 : "a", 1 : "b", 2 : "c"}; *     alert(Object.keys(obj)); // will alert "0,1,2" * *     // getFoo is property which isn't enumerable *     var my_obj = Object.create({}, { getFoo : { value : function () { return this.foo } } }); *     my_obj.foo = 1; * *     alert(Object.keys(my_obj)); // will alert only foo * * If you want all properties, even the not enumerable, see * {@link Object#getOwnPropertyNames}. * * **NOTE:** This method is part of the ECMAScript 5 standard. * * @param {Object} obj The object whose enumerable own properties are * to be returned. * @return {String[]} Array of property names. */ /** * @method getOwnPropertyNames * @static * * Returns an array of all properties (enumerable or not) found * directly upon a given object. * * Rreturns an array whose elements are strings corresponding to the * enumerable and non-enumerable properties found directly upon * obj. The ordering of the enumerable properties in the array is * consistent with the ordering exposed by a for...in loop (or by * {@link Object#keys}) over the properties of the object. The * ordering of the non-enumerable properties in the array, and among * the enumerable properties, is not defined. * *     var arr = ["a", "b", "c"]; *     print(Object.getOwnPropertyNames(arr).sort()); // prints "0,1,2,length" * *     // Array-like object *     var obj = { 0: "a", 1: "b", 2: "c"}; *     print(Object.getOwnPropertyNames(obj).sort()); // prints "0,1,2" * *     // Printing property names and values using Array.forEach *     Object.getOwnPropertyNames(obj).forEach(function(val, idx, array) { *       print(val + " -> " + obj[val]); *     }); *     // prints *     // 0 -> a *     // 1 -> b *     // 2 -> c * *     // non-enumerable property *     var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; }, enumerable: false } }); *     my_obj.foo = 1; * *     print(Object.getOwnPropertyNames(my_obj).sort()); // prints "foo, getFoo" * * If you want only the enumerable properties, see {@link Object#keys} * or use a for...in loop (although note that this will return * enumerable properties not found directly upon that object but also * along the prototype chain for the object unless the latter is * filtered with {@link #hasOwnProperty}). * * Items on the prototype chain are not listed: * *     function ParentClass () { *     } *     ParentClass.prototype.inheritedMethod = function () { *     }; * *     function ChildClass () { *       this.prop = 5; *       this.method = function () {}; *     } *     ChildClass.prototype = new ParentClass; *     ChildClass.prototype.prototypeMethod = function () { *     }; * *     alert( *       Object.getOwnPropertyNames( *         new ChildClass() // ["prop", "method"] *       ) *     ) * * **NOTE:** This method is part of the ECMAScript 5 standard. * * @param {Object} obj The object whose enumerable and non-enumerable * own properties are to be returned. * @return {String[]} Array of property names. */ /** * @method getPrototypeOf * @static * * Returns the prototype (i.e. the internal `[[Prototype]]`) of the * specified object. * * **NOTE:** This method is part of the ECMAScript 5 standard. * * @param {Object} object The object whose prototype is to be returned. * Throws a TypeError exception if this parameter isn't an Object. * * @return {Object} the prototype */ /** * @method preventExtensions * @static * * Prevents new properties from ever being added to an object * (i.e. prevents future extensions to the object). * * An object is extensible if new properties can be added to it. * `preventExtensions` marks an object as no longer extensible, so that * it will never have properties beyond the ones it had at the time it * was marked as non-extensible.  Note that the properties of a * non-extensible object, in general, may still be deleted. Attempting * to add new properties to a non-extensible object will fail, either * silently or by throwing a TypeError (most commonly, but not * exclusively, when in strict mode). * * It only prevents addition of own properties. Properties can still * be added to the object prototype. * * If there is a way to turn an extensible object to a non-extensible * one, there is no way to do the opposite in ECMAScript 5 * * **NOTE:** This method is part of the ECMAScript 5 standard. * * @param {Object} obj The object which should be made non-extensible. */ /** * @method isExtensible * @static * * Determines if an object is extensible (whether it can have new * properties added to it). * * Objects are extensible by default: they can have new properties * added to them, and can be modified. An object can be marked as * non-extensible using {@link Object#preventExtensions}, * {@link Object#seal}, or {@link Object#freeze}. * *     // New objects are extensible. *     var empty = {}; *     assert(Object.isExtensible(empty) === true); * *     // ...but that can be changed. *     Object.preventExtensions(empty); *     assert(Object.isExtensible(empty) === false); * *     // Sealed objects are by definition non-extensible. *     var sealed = Object.seal({}); *     assert(Object.isExtensible(sealed) === false); * *     // Frozen objects are also by definition non-extensible. *     var frozen = Object.freeze({}); *     assert(Object.isExtensible(frozen) === false); * * **NOTE:** This method is part of the ECMAScript 5 standard. * * @param {Object} obj The object which should be checked. * @return {Boolean} True when object is extensible. */ /** * @method seal * @static * * Seals an object, preventing new properties from being added to it * and marking all existing properties as non-configurable. Values of * present properties can still be changed as long as they are * writable. * * By default, objects are extensible (new properties can be added to * them). Sealing an object prevents new properties from being added * and marks all existing properties as non-configurable. This has the * effect of making the set of properties on the object fixed and * immutable. Making all properties non-configurable also prevents * them from being converted from data properties to accessor * properties and vice versa, but it does not prevent the values of * data properties from being changed. Attempting to delete or add * properties to a sealed object, or to convert a data property to * accessor or vice versa, will fail, either silently or by throwing a * TypeError (most commonly, although not exclusively, when in strict * mode code). * * The prototype chain remains untouched. * * **NOTE:** This method is part of the ECMAScript 5 standard. * * @param {Object} obj The object which should be sealed. */ /** * @method isSealed * @static * * Determines if an object is sealed. * * An object is sealed if it is non-extensible and if all its * properties are non-configurable and therefore not removable (but * not necessarily non-writable). * *     // Objects aren't sealed by default. *     var empty = {}; *     assert(Object.isSealed(empty) === false); * *     // If you make an empty object non-extensible, it is vacuously sealed. *     Object.preventExtensions(empty); *     assert(Object.isSealed(empty) === true); * *     // The same is not true of a non-empty object, unless its properties are all non-configurable. *     var hasProp = { fee: "fie foe fum" }; *     Object.preventExtensions(hasProp); *     assert(Object.isSealed(hasProp) === false); * *     // But make them all non-configurable and the object becomes sealed. *     Object.defineProperty(hasProp, "fee", { configurable: false }); *     assert(Object.isSealed(hasProp) === true); * *     // The easiest way to seal an object, of course, is Object.seal. *     var sealed = {}; *     Object.seal(sealed); *     assert(Object.isSealed(sealed) === true); * *     // A sealed object is, by definition, non-extensible. *     assert(Object.isExtensible(sealed) === false); * *     // A sealed object might be frozen, but it doesn't have to be. *     assert(Object.isFrozen(sealed) === true); // all properties also non-writable * *     var s2 = Object.seal({ p: 3 }); *     assert(Object.isFrozen(s2) === false); // "p" is still writable * *     var s3 = Object.seal({ get p() { return 0; } }); *     assert(Object.isFrozen(s3) === true); // only configurability matters for accessor properties * * **NOTE:** This method is part of the ECMAScript 5 standard. * * @param {Object} obj The object which should be checked. * @return {Boolean} True if the object is sealed, otherwise false. */ /** * @method freeze * @static * * Freezes an object: that is, prevents new properties from being * added to it; prevents existing properties from being removed; and * prevents existing properties, or their enumerability, * configurability, or writability, from being changed. In essence the * object is made effectively immutable. The method returns the object * being frozen. * * Nothing can be added to or removed from the properties set of a * frozen object. Any attempt to do so will fail, either silently or * by throwing a TypeError exception (most commonly, but not * exclusively, when in strict mode). * * Values cannot be changed for data properties. Accessor properties * (getters and setters) work the same (and still give the illusion * that you are changing the value). Note that values that are objects * can still be modified, unless they are also frozen. * * **NOTE:** This method is part of the ECMAScript 5 standard. * * @param {Object} obj The object to freeze. */ /** * @method isFrozen * @static * * Determines if an object is frozen. * * An object is frozen if and only if it is not extensible, all its * properties are non-configurable, and all its data properties (that * is, properties which are not accessor properties with getter or * setter components) are non-writable. * *     // A new object is extensible, so it is not frozen. *     assert(Object.isFrozen({}) === false); * *     // An empty object which is not extensible is vacuously frozen. *     var vacuouslyFrozen = Object.preventExtensions({}); *     assert(Object.isFrozen(vacuouslyFrozen) === true); * *     // A new object with one property is also extensible, ergo not frozen. *     var oneProp = { p: 42 }; *     assert(Object.isFrozen(oneProp) === false); * *     // Preventing extensions to the object still doesn't make it frozen, *     // because the property is still configurable (and writable). *     Object.preventExtensions(oneProp); *     assert(Object.isFrozen(oneProp) === false); * *     // ...but then deleting that property makes the object vacuously frozen. *     delete oneProp.p; *     assert(Object.isFrozen(oneProp) === true); * *     // A non-extensible object with a non-writable but still configurable property is not frozen. *     var nonWritable = { e: "plep" }; *     Object.preventExtensions(nonWritable); *     Object.defineProperty(nonWritable, "e", { writable: false }); // make non-writable *     assert(Object.isFrozen(nonWritable) === false); * *     // Changing that property to non-configurable then makes the object frozen. *     Object.defineProperty(nonWritable, "e", { configurable: false }); // make non-configurable *     assert(Object.isFrozen(nonWritable) === true); * *     // A non-extensible object with a non-configurable but still writable property also isn't frozen. *     var nonConfigurable = { release: "the kraken!" }; *     Object.preventExtensions(nonConfigurable); *     Object.defineProperty(nonConfigurable, "release", { configurable: false }); *     assert(Object.isFrozen(nonConfigurable) === false); * *     // Changing that property to non-writable then makes the object frozen. *     Object.defineProperty(nonConfigurable, "release", { writable: false }); *     assert(Object.isFrozen(nonConfigurable) === true); * *     // A non-extensible object with a configurable accessor property isn't frozen. *     var accessor = { get food() { return "yum"; } }; *     Object.preventExtensions(accessor); *     assert(Object.isFrozen(accessor) === false); * *     // ...but make that property non-configurable and it becomes frozen. *     Object.defineProperty(accessor, "food", { configurable: false }); *     assert(Object.isFrozen(accessor) === true); * *     // But the easiest way for an object to be frozen is if Object.freeze has been called on it. *     var frozen = { 1: 81 }; *     assert(Object.isFrozen(frozen) === false); *     Object.freeze(frozen); *     assert(Object.isFrozen(frozen) === true); * *     // By definition, a frozen object is non-extensible. *     assert(Object.isExtensible(frozen) === false); * *     // Also by definition, a frozen object is sealed. *     assert(Object.isSealed(frozen) === true); * * **NOTE:** This method is part of the ECMAScript 5 standard. * * @param {Object} obj The object which should be checked. * @return {Boolean} True if the object is frozen, otherwise false. */