Source: polyfill/Object.js

  1. // Licensed Materials - Property of IBM
  2. //
  3. // IBM Watson Analytics
  4. //
  5. // (C) Copyright IBM Corp. 2015, 2018
  6. //
  7. // US Government Users Restricted Rights - Use, duplication or
  8. // disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  10. ( function( exports, Object )
  11. {
  12. "use strict";
  13. /*global Symbol*/
  15. var hasOwnProperty = Object.prototype.hasOwnProperty;
  16. var toString = Object.prototype.toString;
  17.  // RegExp set up to match BareJS and polyfill.io symbol strings
  18.  // polyfill uses "__\x01symbol:" and "__\x01symbol@@"
  19. var reSymbol = /^__\d*\x01?[sS]ymbol/;
  20. // By default, make members whose name does not start with _ or $ enumerable.
  21. var reEnumerable = /^[^_\$]/;
  22. var strUndef = "undefined";
  24. var NativeSymbol = typeof Symbol !== strUndef ? Symbol : null;
  25. //jshint -W122
  26. var symIt = NativeSymbol && ( typeof Symbol.iterator === "symbol" ) ? Symbol.iterator : /*istanbul ignore next*/ null;
  27. //jshint +W122
  29. /**
  30.  * Polyfills for {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object Object}.
  31.  * Module that provides implementations for methods missing on Object. Methods that cannot be polyfilled close enough to
  32.  * the spec (since they rely on Native implementations) are not added to the Object global.
  33.  * @class module:barejs/polyfill.Object
  34.  */
  36.  /** @lends module:barejs/polyfill.Object */
  37.  var stat = {};
  39. /**
  40.  * Shortcut method that only defines a property if it is not already known
  41.  * @param {object} _target The object to polyfill
  42.  * @param {object} _members The members to polyfill
  43.  * @param {object} [_copy] Optional: an object that the definitions will be copied to.
  44.  * @param {string} [_ownerName] Optional: name of the owner object
  45.  * @memberof module:barejs/polyfill.Object~
  46.  * @private
  47.  */
  48. function polyMixin( _target, _members, _copy, _ownerName )
  49. {
  50.     for ( var name in _members )
  51.     {
  52.         /*istanbul ignore else: we're working on clean objects, iterating prototype properties is unexpected*/
  53.         if ( _members.hasOwnProperty( name ) )
  54.         {
  55.             var member = _members[name], isFn = typeof member === "function";
  56.             if ( isFn && _ownerName )
  57.                 member.displayName = _ownerName + "." + name;
  58.             if ( _copy )
  59.                 _copy[name] = member;
  60.             if ( !( name in _target ) )
  61.                 exports.defineProperty( _target, name, { enumerable : false, configurable: isFn, writable: isFn, value: member } );
  62.         }
  63.     }
  64. }
  66. /**
  67.  * Helper method that allows to easily apply static and prototype properties to a native object
  68.  * @param {function} _native The native Object constructor to polyfill
  69.  * @param {object} _static The static methods to polyfill. Can be null.
  70.  * @param {object} _proto The instance members to polyfill. Can be null.
  71.  * @param {object} [_copy] Optional: an object that the definitions will be copied to.
  72.  * @param {string} [_ownerName] Optional: the name of the owner object.
  73.  * Allows to add functions to "exports" as well, for unit testing.
  74.  * @memberof module:barejs/polyfill.Object
  75.  * @private
  76.  */
  77. exports.polyfill = function polyfill( _native, _static, _proto, _copy, _ownerName )
  78. {
  79.     if ( _static )
  80.         polyMixin( _native, _static, _copy, _ownerName );
  81.     if ( _proto )
  82.         polyMixin( _native.prototype, _proto, _copy, _ownerName && ( _ownerName + ".prototype" ) );
  83.     return _native;
  84. };
  86. exports.shouldBeEnumerable = function shouldBeEnumerable( _name )
  87. {
  88.     return typeof _name === "string" && reEnumerable.test( _name );
  89. };
  91. /**
  92.  * Utility method to check if _target is an Object
  93.  * @param _arg The argument to check.
  94.  * @returns {boolean} True if the target is an object, false otherwise
  95.  */
  96. function isObject( _arg )
  97. {
  98.     switch ( _arg && typeof _arg )
  99.     {
  100.         case "object":
  101.         case "function":
  102.             return true;
  104.         default:
  105.             return false;
  106.     }
  107. }
  108. exports.isObject = isObject;
  110. /**
  111.  * Utility method to convert target to an Object (according to Ecmascript standard)
  112.  * @param _arg The argument to check.
  113.  * @param _caller The function requesting the cast. If provided, changes the exception message.
  114.  * @returns {object} The argument, as object
  115.  * @throws {TypeError} A TypeError if _arg is null or undefined.
  116.  */
  117. function toObject( _arg, _caller )
  118. {
  119.     switch ( _arg === null ? strUndef : typeof _arg )
  120.     {
  121.         case "undefined":
  122.             throw new TypeError( _caller ? _caller.displayName + " called on null or undefined" : "Cannot convert undefined or null to object" );
  124.         case "object":
  125.         case "function":
  126.             return _arg;
  128.         default:
  129.             return Object( _arg );
  130.     }
  131. }
  133. exports.toObject = toObject;
  135. /**
  136.  * Check if _arg is callable (i.e. a function).
  137.  * @param _arg The argument to check.
  138.  * @returns {boolean} True if _arg is a function, false otherwise.
  139.  * @memberof module:barejs/polyfill.Object
  140.  * @private
  141.  */
  142. exports.isCallable = function isCallable( _arg )
  143. {
  144.     // We can't check the internal [[Call]] property, so we rely on type checking.
  145.     return ( typeof _arg === "function" ) || ( toString.call( _arg ) === "[object Function]" );
  146. };
  148. /**
  149.  * Convenience method to check if _arg is callable (i.e. a function).
  150.  * Note: If a second argument is provided, that is returned instead of _arg.
  151.  * This allows inlining the ensureCallable method in convenient locations.
  152.  * @param _arg function to check
  153.  * @returns _arg, or second argument if present
  154.  * @throws {TypeError} if _arg is not callable.
  155.  * @memberof module:barejs/polyfill.Object
  156.  * @private
  157.  */
  158. exports.ensureCallable = function ensureCallable( _arg )
  159. {
  160.     if ( !exports.isCallable( _arg ) )
  161.         throw new TypeError( _arg + " is not a function" );
  163.     return arguments.length > 1 ? arguments[1] : _arg;
  164. };
  166. /**
  167.  * Helper function that will attempt to set the ES6 iterator Symbol for a class.
  168.  * @param {object} _target The object to define the iterator on.
  169.  * @param {function} _function The function that will result in the iterator.
  170.  * @returns {object} `_target`.
  171.  * @memberof module:barejs/polyfill.Object
  172.  * @private
  173.  */
  174. function setIterator( _target, _function )
  175. {
  176.     var def = { configurable: true, value: _function };
  177.     /*istanbul ignore else: always true in NodeJS*/
  178.     if ( symIt )
  179.         exports.defineProperty( _target, symIt, def );
  180.     // Set @@iterator for compliancy with polyfill libraries like core.js
  181.     exports.defineProperty( _target, "@@iterator", def );
  182.     return _target;
  183. }
  185. exports.setIterator = setIterator;
  187. /**
  188.  * Helper function that will get the ES6 iterator Symbol for a class.
  189.  * @param {function} _class The constructor function to define the iterator on
  190.  * @returns {object} The iterator, or null.
  191.  * @memberof module:barejs/polyfill.Object
  192.  * @private
  193.  */
  194. function getIterator( _target )
  195. {
  196.     var result = null;
  198.     if ( _target )
  199.     {
  200.         var obj = Object( _target );
  201.         if ( symIt && ( symIt in obj ) )
  202.             result = obj[symIt]();
  203.         else if ( "@@iterator" in obj )
  204.             result = obj["@@iterator"]();
  205.     }
  207.     return result;
  208. }
  210. exports.getIterator = getIterator;
  212. ////////////////////////////////////////////////////////////////////////////////////////////////////
  213. // Grab some methods that we may have to provide fallbacks for
  214. ////////////////////////////////////////////////////////////////////////////////////////////////////
  215. var modernPropertySupport = !!Object.defineProperties;
  216. var legacyPropertySupport = ( ( "__defineGetter__" in Object.prototype ) && ( "__defineSetter__" in Object.prototype ) );
  217. /*istanbul ignore next: We know we have Object.defineProperties in NodeJS*/
  218. exports.propertyGetSetSupport = modernPropertySupport || legacyPropertySupport;
  219. // Take care not to grab IE8's defineProperty that only works on DOM elements.
  220. /*istanbul ignore else: native in NodeJS*/
  221. if ( modernPropertySupport )
  222. {
  223.     exports.defineProperty      = Object.defineProperty;
  224.     exports.defineProperties    = Object.defineProperties;
  225.     exports.getOwnPropertyDescriptor    = Object.getOwnPropertyDescriptor;
  226.     exports.getOwnPropertyDescriptors   = Object.getOwnPropertyDescriptors;
  227. }
  228. exports.getPrototypeOf  = Object.getPrototypeOf;
  229. exports.freeze          = Object.freeze;
  230. exports.isFrozen        = Object.isFrozen;
  231. exports.seal            = Object.seal;
  232. exports.isSealed        = Object.isSealed;
  233. // ES6
  234. exports.getOwnPropertyNames = Object.getOwnPropertyNames;
  235. exports.getOwnPropertySymbols = Object.getOwnPropertySymbols;
  237. /*istanbul ignore else: The tests are run with __ES__ set to 3*/
  238. if ( __ES__ < 5 )
  239. {
  240.     ////////////////////////////////////////////////////////////////////////////////////////////////
  241.     // ES5 fallback functions
  242.     ////////////////////////////////////////////////////////////////////////////////////////////////
  243.     // The following methods are not actually polyfills; these methods cannot be polyfilled.
  244.     // However, if the fallback behavior provided by the methods is sufficient, these can be used.
  246.     /*istanbul ignore if: native in NodeJS*/
  247.     if ( !exports.defineProperty )
  248.     {
  249.         /*
  250.          * Object.defineProperty cannot be emulated on browsers that do not support it.
  251.          * However, if the intention is to just set a value (no getters/setters), and the loss of
  252.          * enumerable, writable and configurable flags is acceptable, this method can be used.
  253.          * Uses the native method where possible
  254.          *
  255.          * Note: check for compliance via Object.defineProperties, since IE8 has an Object.defineProperty,
  256.          * but that only works on DOM elements.
  257.          */
  258.         exports.defineProperty = function defineProperty( _object, _name, _definition )
  259.         {
  260.             if ( !isObject( _object ) )
  261.                 throw new TypeError( "Object.defineProperty called on non-object" );
  262.             /*
  263.              * Fallback to simple assignment or __define[GS]etter__
  264.              */
  265.             // Only assign if it actually exists.
  266.             if ( "value" in _definition )
  267.             {
  268.                 _object[_name] = _definition.value;
  269.             }
  270.             else if ( ( "get" in _definition ) || ( "set" in _definition ) )
  271.             {
  272.                 if ( !exports.propertyGetSetSupport )
  273.                     throw new Error( "Property getters and setters are not supported in this environment" );
  275.                 if (  "get" in _definition )
  276.                     _object.__defineGetter__( _name, _definition.get );
  277.                 if ( "set" in _definition )
  278.                     _object.__defineSetter__( _name, _definition.set );
  279.             }
  281.             return _object;
  282.         };
  283.     }
  285.     /*istanbul ignore if: native in NodeJS*/
  286.     if ( !exports.defineProperties )
  287.     {
  288.         /*
  289.          * Uses the possibly emulated defineProperty and behaves like Object.defineProperties.
  290.          * Can only be used to set values (no getters/setters) in environments that do not support getters/setters.
  291.          * Uses the native method where possible
  292.          */
  293.         exports.defineProperties = function defineProperties( _object, _properties )
  294.         {
  295.             if ( !isObject( _object ) )
  296.                 throw new TypeError( "Object.defineProperties called on non-object" );
  298.             _properties = toObject( _properties );
  300.             // Assume there is no Object.keys in an environment that requires this polyfill.
  301.             for ( var i in _properties )
  302.                 if ( hasOwnProperty.call( _properties, i ) && ( !reSymbol.test( i ) ) ) // Ignore Symbols
  303.                     exports.defineProperty( _object, i, _properties[i] );
  305.             return _object;
  306.         };
  307.     }
  309.     /*istanbul ignore if: native in NodeJS*/
  310.     if ( !exports.getPrototypeOf )
  311.     {
  312.         /**
  313.          * Object.getPrototypeOf cannot be fully emulated on browsers that do not support it.
  314.          * We attempt to find a __proto__ or constructor.prototype.
  315.          * Attempt to get an objects prototype, returns null on failure
  316.          * @param {object} _object The object to get the prototype of
  317.          * @returns {object} The prototype of _object
  318.          * @memberof module:barejs/polyfill.Object
  319.          * @private
  320.          */
  321.         exports.getPrototypeOf = function getPrototypeOf( _object )
  322.         {
  323.             switch ( _object === null ? strUndef : typeof _object )
  324.             {
  325.                 case "undefined":
  326.                     throw new TypeError( "Cannot convert undefined or null to object" );
  328.                 case "boolean":
  329.                     return Boolean.prototype;
  331.                 case "number":
  332.                     return Number.prototype;
  334.                 case "string":
  335.                     return String.prototype;
  337.                 case "function":
  338.                     return Function.prototype;
  340.                 // case "object", and any other host value
  341.                 default:
  342.                     // jshint -W103
  343.                     if ( "__proto__" in _object )
  344.                         return _object.__proto__;
  345.                     // jshint +W103
  347.                     // If the object has the constructor property, this is already a prototype
  348.                     if ( !hasOwnProperty.call( _object, "constructor" ) )
  349.                         return _object.constructor.prototype;
  350.                     // See if a framework set a superclass property
  351.                     else if ( _object.constructor.superclass )
  352.                         return _object.constructor.superclass.prototype;
  354.                     if ( Array.isArray( _object ) )
  355.                         return Array.prototype;
  357.                     return null;
  358.             }
  359.         };
  360.     }
  362.     /*istanbul ignore if: native in NodeJS*/
  363.     if ( !exports.freeze )
  364.     {
  365.         /*
  366.          * Object.freeze cannot be emulated. This method is a NOOP if Object.freeze is not supported.
  367.          */
  368.         exports.freeze = function freeze( _o ){ return _o; };
  369.     }
  371.     /*istanbul ignore if: native in NodeJS*/
  372.     if ( !exports.isFrozen )
  373.     {
  374.         /*
  375.          * Object.isFrozen cannot be emulated. This method is a NOOP if Object.isFrozen is not supported.
  376.          */
  377.         exports.isFrozen = function isFrozen( _o ){ return false; };
  378.     }
  380.     /*istanbul ignore if: native in NodeJS*/
  381.     if ( !exports.seal )
  382.     {
  383.         /*
  384.          * Object.seal cannot be emulated. This method is a NOOP if Object.seal is not supported.
  385.          */
  386.         exports.seal = function seal( _o ){ return _o; };
  387.     }
  389.     /*istanbul ignore if: native in NodeJS*/
  390.     if ( !exports.isSealed )
  391.     {
  392.         /*
  393.          * Object.isSealed cannot be emulated. This method is a NOOP if Object.isSealed is not supported.
  394.          */
  395.         exports.isSealed = function isSealed( _o ){ return false; };
  396.     }
  398.     ////////////////////////////////////////////////////////////////////////////////////////////////
  399.     // ES5 polyfills
  400.     ////////////////////////////////////////////////////////////////////////////////////////////////
  402.     //
  403.     // ES5 - Object
  404.     //
  406.     ( function()
  407.     {
  408.         /*global document, ActiveXObject*/
  409.         var createEmpty;
  410.         // While we generally prefer named constructors, avoid it here since it adds no value,
  411.         // and may even be confusing when looking at the prototype chain.
  412.         var Anonymous = function(){};
  414.         //jshint -W103
  415.         /*istanbul ignore else: NodeJS supports the __proto__ property*/
  416.         if ( ( !( { __proto__: null } instanceof Object ) ) || ( typeof document === strUndef ) )
  417.         {
  418.             // We can use the deprecated __proto__ property to create an object with no prototype
  419.             createEmpty = function()
  420.             {
  421.                 return { __proto__: null };
  422.             };
  423.         }
  424.         //jshint +W103
  425.         else
  426.         {
  427.             // We grab a foreign Object.prototype so any object created from it has instanceof Object return false,
  428.             // and we can safely delete all properties from it without breaking regular objects.
  429.             createEmpty = function()
  430.             {
  431.                 var shouldUseActiveX = ( function()
  432.                 {
  433.                     try
  434.                     {
  435.                         return !!( document.domain && new ActiveXObject( "htmlfile" ) );
  436.                     }
  437.                     catch ( ex )
  438.                     {
  439.                         return false;
  440.                     }
  441.                 }() );
  443.                 function Empty() {}
  445.                 if ( shouldUseActiveX )
  446.                 {
  447.                     Empty.prototype = ( function( _xDoc )
  448.                     {
  449.                         _xDoc.write( "<script><\/script>" );
  450.                         _xDoc.close();
  452.                         var empty = _xDoc.parentWindow.Object.prototype;
  453.                         _xDoc = null;
  455.                         return empty;
  456.                     }( new ActiveXObject( "htmlfile" ) ));
  457.                 }
  458.                 else
  459.                 {
  460.                     Empty.prototype = ( function( _parent, _iframe )
  461.                     {
  462.                         _iframe.style.display = "none";
  463.                         _parent.appendChild( _iframe );
  464.                         // jshint -W107
  465.                         _iframe.src = "javascript:";
  466.                         // jshint +W107
  468.                         var empty = _iframe.contentWindow.Object.prototype;
  469.                         _parent.removeChild( _iframe );
  470.                         _iframe = null;
  472.                         return empty;
  473.                     }( document.body || document.documentElement, document.createElement( "iframe" ) ) );
  474.                 }
  476.                 // Now delete all existing definitions on our "empty" object to make it truly empty
  477.                 ( function( _e )
  478.                 {
  479.                     delete _e.constructor;
  480.                     delete _e.hasOwnProperty;
  481.                     delete _e.propertyIsEnumerable;
  482.                     delete _e.isPrototypeOf;
  483.                     delete _e.toLocaleString;
  484.                     delete _e.toString;
  485.                     delete _e.valueOf;
  486.                 }( Empty.prototype ) );
  488.                 // Shortcut createEmpty for future calls
  489.                 createEmpty = function()
  490.                 {
  491.                     // This returns an object for which instanceof Object is false
  492.                     return new Empty();
  493.                 };
  494.                 return createEmpty();
  495.             };
  496.         }
  498.         /**
  499.          * Create an instance of an object that has another object as its prototype
  500.          * @param {object} _proto The prototype of the newly created object, or null.
  501.          * @param {object} _properties
  502.          * @returns {object} A new object that has the input object as prototype.
  503.          */
  504.         stat.create = function create( _proto, _properties )
  505.         {
  506.             var result;
  507.             // _proto has 3 valid values: null or an Object (a function is an Object too)
  508.             if ( _proto === null )
  509.             {
  510.                 result = createEmpty();
  511.             }
  512.             else
  513.             {
  514.                 if ( !isObject( _proto ) )
  515.                     throw new TypeError( "Object prototype may only be an Object or null: " + _proto );
  516.                 Anonymous.prototype = _proto;
  517.                 result = new Anonymous();
  518.                 Anonymous.prototype = null; // Reset prototype so we don't hold a reference to _proto
  519.             }
  521.             if ( typeof _properties !== strUndef )
  522.                 exports.defineProperties( result, toObject( _properties ) );
  524.             return result;
  525.         };
  526.     }() );
  528.     ( function()
  529.     {
  530.         var hasDontEnumBug = !( { toString: null } ).propertyIsEnumerable( "toString" ),
  531.             dontEnums = [
  532.                 "toString",
  533.                 "toLocaleString",
  534.                 "valueOf",
  535.                 "hasOwnProperty",
  536.                 "isPrototypeOf",
  537.                 "propertyIsEnumerable",
  538.                 "constructor"
  539.             ],
  540.             dontEnumsLength = dontEnums.length;
  542.         /**
  543.          * Return the property names defined directly on object
  544.          * @param {object} _obj The target object.
  545.          * @returns {Array} String[] property names.
  546.          */
  547.         stat.keys = function keys( _obj )
  548.         {
  549.             // Ensure object
  550.             _obj = toObject( _obj );
  551.             var result = [];
  553.             for ( var prop in _obj )
  554.                 if ( hasOwnProperty.call( _obj, prop ) && ( !reSymbol.test( prop ) ) ) // Ignore Symbols
  555.                     result.push(prop);
  557.             /*istanbul ignore if: not applicable in NodeJS*/
  558.             if ( hasDontEnumBug )
  559.             {
  560.                 for ( var i = 0; i < dontEnumsLength; ++i )
  561.                     if ( hasOwnProperty.call( _obj, dontEnums[i] ) )
  562.                         result.push( dontEnums[i] );
  563.             }
  564.             return result;
  565.         };
  566.     }() );
  567. }
  569. /*istanbul ignore else: The tests are run with __ES__ set to 3*/
  570. if ( __ES__ < 6 )
  571. {
  572.     // Technically most of the methods set on exports are in ES5, but BareJS relies on them so ensure there's a fallback
  573.     /*istanbul ignore if: native in NodeJS*/
  574.     if ( !exports.getOwnPropertyNames )
  575.     {
  576.         exports.getOwnPropertyNames = function( _object )
  577.         {
  578.             var result = [];
  580.             if ( _object )
  581.             {
  582.                 var obj = Object( _object );
  583.                 for ( var key in obj )
  584.                 {
  585.                     if ( hasOwnProperty.call( obj, key ) && typeof key === "string" )
  586.                         result.push( key );
  587.                 }
  588.             }
  590.             return result;
  591.         };
  592.     }
  594.     /*istanbul ignore if: native in NodeJS*/
  595.     if ( !exports.getOwnPropertySymbols )
  596.     {
  597.         exports.getOwnPropertySymbols = function getOwnPropertySymbols( _target )
  598.         {
  599.             // Ensure object
  600.             _target = toObject( _target );
  601.             var result = [];
  603.             for ( var prop in _target )
  604.                 if ( hasOwnProperty.call( _target, prop ) && ( reSymbol.test( prop ) ) )
  605.                     result.push(prop);
  606.             return result;
  607.         };
  608.     }
  610.     /*istanbul ignore if: native in NodeJS*/
  611.     if ( !exports.getOwnPropertyDescriptor )
  612.     {
  613.         exports.getOwnPropertyDescriptor = function getOwnPropertyDescriptor( _object, _key )
  614.         {
  615.             var descriptor;
  617.             if ( _object )
  618.             {
  619.                 var obj = Object( _object );
  620.                 if ( hasOwnProperty.call( obj, _key ) )
  621.                 {
  622.                     descriptor = { configurable: true, enumerable: true };
  623.                     var getter;
  624.                     var setter;
  626.                     if ( legacyPropertySupport )
  627.                     {
  628.                         getter = obj.__lookupGetter__( _key );
  629.                         setter = obj.__lookupSetter__( _key );
  630.                     }
  632.                     if ( getter || setter )
  633.                     {
  634.                         if ( getter )
  635.                             descriptor.get = getter;
  636.                         if ( setter )
  637.                             descriptor.set = setter;
  638.                     }
  639.                     else
  640.                     {
  641.                         descriptor.value = obj[_key];
  642.                     }
  643.                 }
  644.             }
  646.             return descriptor;
  647.         };
  648.     }
  650.     /*istanbul ignore if: native in NodeJS*/
  651.     if ( !exports.getOwnPropertyDescriptors )
  652.     {
  653.         exports.getOwnPropertyDescriptors = function( _object )
  654.         {
  655.             var descriptors = {};
  657.             if ( _object )
  658.             {
  659.                 var names = exports.getOwnPropertyNames( _object );
  661.                 for ( var i = 0, len = names.length; i < len; ++i )
  662.                     descriptors[names[i]] = exports.getOwnPropertyDescriptor( _object, names[i] );
  663.             }
  665.             return descriptors;
  666.         };
  667.     }
  669.     /**
  670.      * Object.is() determines whether two values are the same value. Two values are the same if one of the following holds:
  671.      *  - both undefined
  672.      *  - both null
  673.      *  - both true or both false
  674.      *  - both strings of the same length with the same characters
  675.      *  - both the same object
  676.      *  - both numbers and
  677.      *  - both +0
  678.      *  - both -0
  679.      *  - both NaN
  680.      *  - or both non-zero and both not NaN and both have the same value
  681.      * @param _v1 The first value to compare.
  682.      * @param _v2 The second value to compare.
  683.      * @returns {boolean} A new object that has the input object as prototype.
  684.      */
  685.     stat.is = function is( _v1, _v2 )
  686.     {
  687.         if ( _v1 === _v2 )
  688.             return ( _v1 !== 0 ) || ( 1 / _v1 === 1 / _v2 ); // Ensure Object.is( +0, -0 ) returns false
  689.         else
  690.             return ( _v1 !== _v1 ) && ( _v2 !== _v2 ); // Ensure Object.is( NaN, NaN ) returns true
  691.     };
  693.     /**
  694.      * The Object.assign() method only copies enumerable and own properties from a source object to a target object.
  695.      * It uses [[Get]] on the source and [[Put]] on the target, so it will invoke getters and setters.
  696.      * Therefore it assigns properties versus just copying or defining new properties.
  697.      * This may make it unsuitable for merging new properties into a prototype if the merge sources contain getters.
  698.      * For copying property definitions, including their enumerability, into prototypes Object.getOwnPropertyDescriptor() and Object.defineProperty() should be used instead.
  699.      * @param {object} _target The target to assign to.
  700.      * @param {object} _firstSource The first source object to copy from.
  701.      * @returns {object} the _target, with properties assigned.
  702.      */
  703.     stat.assign = function assign( _target, _firstSource /*assign.length should be 2*/ )
  704.     {
  705.         // Ensure object
  706.         _target = toObject( _target );
  707.         for ( var arg = 1, argLen = arguments.length, source; arg < argLen; ++arg )
  708.         {
  709.             if ( isObject( source = arguments[arg] ) )
  710.             {
  711.                 for ( var key in source )
  712.                 {
  713.                     /*istanbul ignore else: clean prototypes assumed*/
  714.                     if ( hasOwnProperty.call( source, key ) )
  715.                         _target[key] = source[key];
  716.                 }
  717.             }
  718.         }
  719.         return _target;
  720.     };
  721. // End of ES6 polyfill scope
  722. }
  724. if ( __ES__ < 7 )
  725. {
  726.     /**
  727.      * The Object.values() method returns an array of a given object's own enumerable property values,
  728.      * in the same order as that provided by a for...in loop
  729.      * (the difference being that a for-in loop enumerates properties in the prototype chain as well).
  730.      * @param {object} _target The object to enumerate.
  731.      * @returns {Array} The array of values
  732.      */
  733.     stat.values = function values( _target )
  734.     {
  735.         // Avoid using Array.map for speed (and perform in-place replacement)
  736.         for ( var t = toObject( _target ), result = Object.keys( t ), i = 0, len = result.length; i < len; ++i )
  737.             result[i] = t[result[i]];
  738.         return result;
  739.     };
  741.     /**
  742.      * The Object.entries() method returns an array of a given object's own enumerable property [key, value] pairs,
  743.      * in the same order as that provided by a for...in loop
  744.      * (the difference being that a for-in loop enumerates properties in the prototype chain as well).
  745.      * @param {object} _target The object to enumerate.
  746.      * @returns {Array} The array of values
  747.      */
  748.     stat.entries = function entries( _target )
  749.     {
  750.         // Avoid using Array.map for speed (and perform in-place replacement)
  751.         for ( var t = toObject( _target ), result = Object.keys( t ), i = 0, len = result.length; i < len; ++i )
  752.             result[i] = [ result[i], t[result[i]] ];
  753.         return result;
  754.     };
  755. // End of ES7 polyfill scope
  756. }
  758. // Apply static members (not using exports.polyfill since we only have static members)
  759. polyMixin( Object, stat, exports, "Object" );
  761. //
  762. // ES6 - ES5 Patching
  763. //
  764. /*istanbul ignore else: The tests are run with __ES__ set to 3*/
  765. if ( __ES__ < 6 )
  766. {
  767.     // It is possible Object.create exists (natively or polyfilled), but does not support the second
  768.     // argument. In this case, we replace it with a method that will call defineProperties
  769.     // We define this in the ES6 scope since we assume ES7 browsers will all support the optional second argument.
  771.     /*istanbul ignore if: NodeJS's Object.create supports the second argument*/
  772.     if ( Object.create( null, { test: { value: true } } ).test !== true )
  773.     {
  774.         Object.create = ( function( _originalCreate )
  775.         {
  776.             /**
  777.              * Object.create wrapper that adds support for an optional second argument.
  778.              */
  779.             return function create( _proto, _properties )
  780.             {
  781.                 var result = _originalCreate.call( Object, _proto ); // Call native Object.create
  783.                 if ( _properties )
  784.                     exports.defineProperties( result, _properties );
  786.                 return result;
  787.             };
  788.         }( Object.create ) );
  789.     }
  790. }
  792. // End of module
  793. }( exports, Object ) );