DYEBench should use TodoMVC to test FlightJS for consistency
[WebKit-https.git] / PerformanceTests / DoYouEvenBench / resources / todomvc / dependency-examples / flight / bower_components / es5-shim / es5-sham.js
1 // Copyright 2009-2012 by contributors, MIT License
2 // vim: ts=4 sts=4 sw=4 expandtab
3
4 // Module systems magic dance
5 (function (definition) {
6     // RequireJS
7     if (typeof define == "function") {
8         define(definition);
9     // YUI3
10     } else if (typeof YUI == "function") {
11         YUI.add("es5-sham", definition);
12     // CommonJS and <script>
13     } else {
14         definition();
15     }
16 })(function () {
17
18 // ES5 15.2.3.2
19 // http://es5.github.com/#x15.2.3.2
20 if (!Object.getPrototypeOf) {
21     // https://github.com/kriskowal/es5-shim/issues#issue/2
22     // http://ejohn.org/blog/objectgetprototypeof/
23     // recommended by fschaefer on github
24     Object.getPrototypeOf = function getPrototypeOf(object) {
25         return object.__proto__ || (
26             object.constructor
27                 ? object.constructor.prototype
28                 : prototypeOfObject
29         );
30     };
31 }
32
33 // ES5 15.2.3.3
34 // http://es5.github.com/#x15.2.3.3
35 if (!Object.getOwnPropertyDescriptor) {
36     var ERR_NON_OBJECT = "Object.getOwnPropertyDescriptor called on a non-object: ";
37
38     Object.getOwnPropertyDescriptor = function getOwnPropertyDescriptor(object, property) {
39         if ((typeof object != "object" && typeof object != "function") || object === null) {
40             throw new TypeError(ERR_NON_OBJECT + object);
41         }
42         // If object does not owns property return undefined immediately.
43         if (!owns(object, property)) {
44             return;
45         }
46
47         // If object has a property then it's for sure both `enumerable` and
48         // `configurable`.
49         var descriptor =  { enumerable: true, configurable: true };
50
51         // If JS engine supports accessor properties then property may be a
52         // getter or setter.
53         if (supportsAccessors) {
54             // Unfortunately `__lookupGetter__` will return a getter even
55             // if object has own non getter property along with a same named
56             // inherited getter. To avoid misbehavior we temporary remove
57             // `__proto__` so that `__lookupGetter__` will return getter only
58             // if it's owned by an object.
59             var prototype = object.__proto__;
60             object.__proto__ = prototypeOfObject;
61
62             var getter = lookupGetter(object, property);
63             var setter = lookupSetter(object, property);
64
65             // Once we have getter and setter we can put values back.
66             object.__proto__ = prototype;
67
68             if (getter || setter) {
69                 if (getter) {
70                     descriptor.get = getter;
71                 }
72                 if (setter) {
73                     descriptor.set = setter;
74                 }
75                 // If it was accessor property we're done and return here
76                 // in order to avoid adding `value` to the descriptor.
77                 return descriptor;
78             }
79         }
80
81         // If we got this far we know that object has an own property that is
82         // not an accessor so we set it as a value and return descriptor.
83         descriptor.value = object[property];
84         return descriptor;
85     };
86 }
87
88 // ES5 15.2.3.4
89 // http://es5.github.com/#x15.2.3.4
90 if (!Object.getOwnPropertyNames) {
91     Object.getOwnPropertyNames = function getOwnPropertyNames(object) {
92         return Object.keys(object);
93     };
94 }
95
96 // ES5 15.2.3.5
97 // http://es5.github.com/#x15.2.3.5
98 if (!Object.create) {
99     Object.create = function create(prototype, properties) {
100         var object;
101         if (prototype === null) {
102             object = { "__proto__": null };
103         } else {
104             if (typeof prototype != "object") {
105                 throw new TypeError("typeof prototype["+(typeof prototype)+"] != 'object'");
106             }
107             var Type = function () {};
108             Type.prototype = prototype;
109             object = new Type();
110             // IE has no built-in implementation of `Object.getPrototypeOf`
111             // neither `__proto__`, but this manually setting `__proto__` will
112             // guarantee that `Object.getPrototypeOf` will work as expected with
113             // objects created using `Object.create`
114             object.__proto__ = prototype;
115         }
116         if (properties !== void 0) {
117             Object.defineProperties(object, properties);
118         }
119         return object;
120     };
121 }
122
123 // ES5 15.2.3.6
124 // http://es5.github.com/#x15.2.3.6
125
126 // Patch for WebKit and IE8 standard mode
127 // Designed by hax <hax.github.com>
128 // related issue: https://github.com/kriskowal/es5-shim/issues#issue/5
129 // IE8 Reference:
130 //     http://msdn.microsoft.com/en-us/library/dd282900.aspx
131 //     http://msdn.microsoft.com/en-us/library/dd229916.aspx
132 // WebKit Bugs:
133 //     https://bugs.webkit.org/show_bug.cgi?id=36423
134
135 function doesDefinePropertyWork(object) {
136     try {
137         Object.defineProperty(object, "sentinel", {});
138         return "sentinel" in object;
139     } catch (exception) {
140         // returns falsy
141     }
142 }
143
144 // check whether defineProperty works if it's given. Otherwise,
145 // shim partially.
146 if (Object.defineProperty) {
147     var definePropertyWorksOnObject = doesDefinePropertyWork({});
148     var definePropertyWorksOnDom = typeof document == "undefined" ||
149         doesDefinePropertyWork(document.createElement("div"));
150     if (!definePropertyWorksOnObject || !definePropertyWorksOnDom) {
151         var definePropertyFallback = Object.defineProperty;
152     }
153 }
154
155 if (!Object.defineProperty || definePropertyFallback) {
156     var ERR_NON_OBJECT_DESCRIPTOR = "Property description must be an object: ";
157     var ERR_NON_OBJECT_TARGET = "Object.defineProperty called on non-object: "
158     var ERR_ACCESSORS_NOT_SUPPORTED = "getters & setters can not be defined " +
159                                       "on this javascript engine";
160
161     Object.defineProperty = function defineProperty(object, property, descriptor) {
162         if ((typeof object != "object" && typeof object != "function") || object === null) {
163             throw new TypeError(ERR_NON_OBJECT_TARGET + object);
164         }
165         if ((typeof descriptor != "object" && typeof descriptor != "function") || descriptor === null) {
166             throw new TypeError(ERR_NON_OBJECT_DESCRIPTOR + descriptor);
167         }
168         // make a valiant attempt to use the real defineProperty
169         // for I8's DOM elements.
170         if (definePropertyFallback) {
171             try {
172                 return definePropertyFallback.call(Object, object, property, descriptor);
173             } catch (exception) {
174                 // try the shim if the real one doesn't work
175             }
176         }
177
178         // If it's a data property.
179         if (owns(descriptor, "value")) {
180             // fail silently if "writable", "enumerable", or "configurable"
181             // are requested but not supported
182             /*
183             // alternate approach:
184             if ( // can't implement these features; allow false but not true
185                 !(owns(descriptor, "writable") ? descriptor.writable : true) ||
186                 !(owns(descriptor, "enumerable") ? descriptor.enumerable : true) ||
187                 !(owns(descriptor, "configurable") ? descriptor.configurable : true)
188             )
189                 throw new RangeError(
190                     "This implementation of Object.defineProperty does not " +
191                     "support configurable, enumerable, or writable."
192                 );
193             */
194
195             if (supportsAccessors && (lookupGetter(object, property) ||
196                                       lookupSetter(object, property)))
197             {
198                 // As accessors are supported only on engines implementing
199                 // `__proto__` we can safely override `__proto__` while defining
200                 // a property to make sure that we don't hit an inherited
201                 // accessor.
202                 var prototype = object.__proto__;
203                 object.__proto__ = prototypeOfObject;
204                 // Deleting a property anyway since getter / setter may be
205                 // defined on object itself.
206                 delete object[property];
207                 object[property] = descriptor.value;
208                 // Setting original `__proto__` back now.
209                 object.__proto__ = prototype;
210             } else {
211                 object[property] = descriptor.value;
212             }
213         } else {
214             if (!supportsAccessors) {
215                 throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
216             }
217             // If we got that far then getters and setters can be defined !!
218             if (owns(descriptor, "get")) {
219                 defineGetter(object, property, descriptor.get);
220             }
221             if (owns(descriptor, "set")) {
222                 defineSetter(object, property, descriptor.set);
223             }
224         }
225         return object;
226     };
227 }
228
229 // ES5 15.2.3.7
230 // http://es5.github.com/#x15.2.3.7
231 if (!Object.defineProperties) {
232     Object.defineProperties = function defineProperties(object, properties) {
233         for (var property in properties) {
234             if (owns(properties, property) && property != "__proto__") {
235                 Object.defineProperty(object, property, properties[property]);
236             }
237         }
238         return object;
239     };
240 }
241
242 // ES5 15.2.3.8
243 // http://es5.github.com/#x15.2.3.8
244 if (!Object.seal) {
245     Object.seal = function seal(object) {
246         // this is misleading and breaks feature-detection, but
247         // allows "securable" code to "gracefully" degrade to working
248         // but insecure code.
249         return object;
250     };
251 }
252
253 // ES5 15.2.3.9
254 // http://es5.github.com/#x15.2.3.9
255 if (!Object.freeze) {
256     Object.freeze = function freeze(object) {
257         // this is misleading and breaks feature-detection, but
258         // allows "securable" code to "gracefully" degrade to working
259         // but insecure code.
260         return object;
261     };
262 }
263
264 // detect a Rhino bug and patch it
265 try {
266     Object.freeze(function () {});
267 } catch (exception) {
268     Object.freeze = (function freeze(freezeObject) {
269         return function freeze(object) {
270             if (typeof object == "function") {
271                 return object;
272             } else {
273                 return freezeObject(object);
274             }
275         };
276     })(Object.freeze);
277 }
278
279 // ES5 15.2.3.10
280 // http://es5.github.com/#x15.2.3.10
281 if (!Object.preventExtensions) {
282     Object.preventExtensions = function preventExtensions(object) {
283         // this is misleading and breaks feature-detection, but
284         // allows "securable" code to "gracefully" degrade to working
285         // but insecure code.
286         return object;
287     };
288 }
289
290 // ES5 15.2.3.11
291 // http://es5.github.com/#x15.2.3.11
292 if (!Object.isSealed) {
293     Object.isSealed = function isSealed(object) {
294         return false;
295     };
296 }
297
298 // ES5 15.2.3.12
299 // http://es5.github.com/#x15.2.3.12
300 if (!Object.isFrozen) {
301     Object.isFrozen = function isFrozen(object) {
302         return false;
303     };
304 }
305
306 // ES5 15.2.3.13
307 // http://es5.github.com/#x15.2.3.13
308 if (!Object.isExtensible) {
309     Object.isExtensible = function isExtensible(object) {
310         // 1. If Type(O) is not Object throw a TypeError exception.
311         if (Object(object) !== object) {
312             throw new TypeError(); // TODO message
313         }
314         // 2. Return the Boolean value of the [[Extensible]] internal property of O.
315         var name = '';
316         while (owns(object, name)) {
317             name += '?';
318         }
319         object[name] = true;
320         var returnValue = owns(object, name);
321         delete object[name];
322         return returnValue;
323     };
324 }
325
326 });