From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- .../components/es5-shim/README.md | 161 +++++++++++++++++++++ 1 file changed, 161 insertions(+) create mode 100644 third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/README.md (limited to 'third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/README.md') diff --git a/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/README.md b/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/README.md new file mode 100644 index 0000000000..2972222814 --- /dev/null +++ b/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/README.md @@ -0,0 +1,161 @@ + +`es5-shim.js` and `es5-shim.min.js` monkey-patch a JavaScript context to +contain all EcmaScript 5 methods that can be faithfully emulated with a +legacy JavaScript engine. + +`es5-sham.js` and `es5-sham.min.js` monkey-patch other ES5 methods as +closely as possible. For these methods, as closely as possible to ES5 +is not very close. Many of these shams are intended only to allow code +to be written to ES5 without causing run-time errors in older engines. +In many cases, this means that these shams cause many ES5 methods to +silently fail. Decide carefully whether this is what you want. + + +## Tests + +The tests are written with the Jasmine BDD test framework. +To run the tests, navigate to /tests/. + +In order to run against the shim-code, the tests attempt to kill the current +implementation of the missing methods. This happens in /tests/helpers/h-kill.js. +So in order to run the tests against the build-in methods, invalidate that file somehow +(comment-out, delete the file, delete the script-tag, etc.). + +## Shims + +### Complete tests ### + +* Array.prototype.every +* Array.prototype.filter +* Array.prototype.forEach +* Array.prototype.indexOf +* Array.prototype.lastIndexOf +* Array.prototype.map +* Array.prototype.some +* Array.prototype.reduce +* Array.prototype.reduceRight +* Array.isArray +* Date.now +* Date.prototype.toJSON +* Function.prototype.bind + * /!\ Caveat: the bound function's length is always 0. + * /!\ Caveat: the bound function has a prototype property. + * /!\ Caveat: bound functions do not try too hard to keep you + from manipulating their ``arguments`` and ``caller`` properties. + * /!\ Caveat: bound functions don't have checks in ``call`` and + ``apply`` to avoid executing as a constructor. +* Object.keys +* String.prototype.trim + +### Untested ### + +* Date.parse (for ISO parsing) +* Date.prototype.toISOString + +## Shams + +* /?\ Object.create + + For the case of simply "begetting" an object that + inherits prototypically from another, this should work + fine across legacy engines. + + /!\ Object.create(null) will work only in browsers that + support prototype assignment. This creates an object + that does not have any properties inherited from + Object.prototype. It will silently fail otherwise. + + /!\ The second argument is passed to + Object.defineProperties which will probably fail + silently. + +* /?\ Object.getPrototypeOf + + This will return "undefined" in some cases. It uses + __proto__ if it's available. Failing that, it uses + constructor.prototype, which depends on the constructor + property of the object's prototype having not been + replaced. If your object was created like this, it + won't work: + + function Foo() { + } + Foo.prototype = {}; + + Because the prototype reassignment destroys the + constructor property. + + This will work for all objects that were created using + `Object.create` implemented with this library. + +* /!\ Object.getOwnPropertyNames + + This method uses Object.keys, so it will not be accurate + on legacy engines. + +* Object.isSealed + + Returns "false" in all legacy engines for all objects, + which is conveniently guaranteed to be accurate. + +* Object.isFrozen + + Returns "false" in all legacy engines for all objects, + which is conveniently guaranteed to be accurate. + +* Object.isExtensible + + Works like a charm, by trying very hard to extend the + object then redacting the extension. + +### Fail silently + +* /!\ Object.getOwnPropertyDescriptor + + The behavior of this shim does not conform to ES5. It + should probably not be used at this time, until its + behavior has been reviewed and been confirmed to be + useful in legacy engines. + +* /!\ Object.defineProperty + + This method will silently fail to set "writable", + "enumerable", and "configurable" properties. + + Providing a getter or setter with "get" or "set" on a + descriptor will silently fail on engines that lack + "__defineGetter__" and "__defineSetter__", which include + all versions of IE up to version 8 so far. + + IE 8 provides a version of this method but it only works + on DOM objects. Thus, the shim will not get installed + and attempts to set "value" properties will fail + silently on non-DOM objects. + + https://github.com/kriskowal/es5-shim/issues#issue/5 + +* /!\ Object.defineProperties + + This uses the Object.defineProperty shim + +* Object.seal + + Silently fails on all legacy engines. This should be + fine unless you are depending on the safety and security + provisions of this method, which you cannot possibly + obtain in legacy engines. + +* Object.freeze + + Silently fails on all legacy engines. This should be + fine unless you are depending on the safety and security + provisions of this method, which you cannot possibly + obtain in legacy engines. + +* Object.preventExtensions + + Silently fails on all legacy engines. This should be + fine unless you are depending on the safety and security + provisions of this method, which you cannot possibly + obtain in legacy engines. + -- cgit v1.2.3