global-es5.js

Jump To … +

asm-llvm.js bcompile.js binterp.js browsercanvas.js bytecode-table.js canvastest.js ccanvas.js crender-styles.js crender.js ctiles.js events.js eventtests.js extensions.js global-es5.js global.js html-escape.js jcompile.js json2.js nodemain.js parse.js render.js render2.js require.js stdlib.js str-escape.js tdop.js tests.js text.js tiles.js tokenize.js top-level.js ts.js write-lua-bytecode.js write-lua-ops.js write-php-bytecode.js write-php-ops.js write-rust-bytecode.js write-rust-ops.js

global-es5.js

/*! -- kriskowal Kris Kowal Copyright (C) 2009-2010 MIT License
    -- tlrobinson Tom Robinson
   dantman Daniel Friesen
*/

/*!
    Copyright (c) 2009, 280 North Inc. http://280north.com/
    MIT License. http://github.com/280north/narwhal/blob/master/README.md
*/

¶

Brings an environment as close to ECMAScript 5 compliance as is possible with the facilities of erstwhile engines.

ES5 Draft http://www.ecma-international.org/publications/files/drafts/tc39-2009-050.pdf

NOTE: this is a draft, and as such, the URL is subject to change. If the link is broken, check in the parent directory for the latest TC39 PDF. http://www.ecma-international.org/publications/files/drafts/

Previous ES5 Draft http://www.ecma-international.org/publications/files/drafts/tc39-2009-025.pdf This is a broken link to the previous draft of ES5 on which most of the numbered specification references and quotes herein were taken. Updating these references and quotes to reflect the new document would be a welcome volunteer project.

Array

ES5 15.4.3.2

if (!Array.isArray) {
    Array.isArray = function(obj) {
        return Object.prototype.toString.call(obj) == "[object Array]";
    };
}

ES5 15.4.4.18

if (!Array.prototype.forEach) {
    Array.prototype.forEach =  function(block, thisObject) {
        var len = this.length >>> 0;
        for (var i = 0; i < len; i++) {
            if (i in this) {
                block.call(thisObject, this[i], i, this);
            }
        }
    };
}

ES5 15.4.4.19 https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map

if (!Array.prototype.map) {
    Array.prototype.map = function(fun /*, thisp*/) {
        var len = this.length >>> 0;
        if (typeof fun != "function")
          throw new TypeError();

        var res = new Array(len);
        var thisp = arguments[1];
        for (var i = 0; i < len; i++) {
            if (i in this)
                res[i] = fun.call(thisp, this[i], i, this);
        }

        return res;
    };
}

ES5 15.4.4.20

if (!Array.prototype.filter) {
    Array.prototype.filter = function (block /*, thisp */) {
        var values = [];
        var thisp = arguments[1];
        for (var i = 0; i < this.length; i++)
            if (block.call(thisp, this[i]))
                values.push(this[i]);
        return values;
    };
}

ES5 15.4.4.16

if (!Array.prototype.every) {
    Array.prototype.every = function (block /*, thisp */) {
        var thisp = arguments[1];
        for (var i = 0; i < this.length; i++)
            if (!block.call(thisp, this[i]))
                return false;
        return true;
    };
}

ES5 15.4.4.17

if (!Array.prototype.some) {
    Array.prototype.some = function (block /*, thisp */) {
        var thisp = arguments[1];
        for (var i = 0; i < this.length; i++)
            if (block.call(thisp, this[i]))
                return true;
        return false;
    };
}

ES5 15.4.4.21 https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduce

if (!Array.prototype.reduce) {
    Array.prototype.reduce = function(fun /*, initial*/) {
        var len = this.length >>> 0;
        if (typeof fun != "function")
            throw new TypeError();

no value to return if no initial value and an empty array

        if (len == 0 && arguments.length == 1)
            throw new TypeError();

        var i = 0;
        if (arguments.length >= 2) {
            var rv = arguments[1];
        } else {
            do {
                if (i in this) {
                    rv = this[i++];
                    break;
                }

if array contains no values, no initial value to return

                if (++i >= len)
                    throw new TypeError();
            } while (true);
        }

        for (; i < len; i++) {
            if (i in this)
                rv = fun.call(null, rv, this[i], i, this);
        }

        return rv;
    };
}

ES5 15.4.4.22 https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduceRight

if (!Array.prototype.reduceRight) {
    Array.prototype.reduceRight = function(fun /*, initial*/) {
        var len = this.length >>> 0;
        if (typeof fun != "function")
            throw new TypeError();

no value to return if no initial value, empty array

        if (len == 0 && arguments.length == 1)
            throw new TypeError();

        var i = len - 1;
        if (arguments.length >= 2) {
            var rv = arguments[1];
        } else {
            do {
                if (i in this) {
                    rv = this[i--];
                    break;
                }

if array contains no values, no initial value to return

                if (--i < 0)
                    throw new TypeError();
            } while (true);
        }

        for (; i >= 0; i--) {
            if (i in this)
                rv = fun.call(null, rv, this[i], i, this);
        }

        return rv;
    };
}

ES5 15.4.4.14

if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function (value /*, fromIndex */ ) {
        var length = this.length;
        if (!length)
            return -1;
        var i = arguments[1] || 0;
        if (i >= length)
            return -1;
        if (i < 0)
            i += length;
        for (; i < length; i++) {
            if (!Object.prototype.hasOwnProperty.call(this, i))
                continue;
            if (value === this[i])
                return i;
        }
        return -1;
    };
}

ES5 15.4.4.15

if (!Array.prototype.lastIndexOf) {
    Array.prototype.lastIndexOf = function (value /*, fromIndex */) {
        var length = this.length;
        if (!length)
            return -1;
        var i = arguments[1] || length;
        if (i < 0)
            i += length;
        i = Math.min(i, length - 1);
        for (; i >= 0; i--) {
            if (!Object.prototype.hasOwnProperty.call(this, i))
                continue;
            if (value === this[i])
                return i;
        }
        return -1;
    };
}

¶

Object

ES5 15.2.3.2

if (!Object.getPrototypeOf) {
    Object.getPrototypeOf = function (object) {
        return object.__proto__;

¶

or undefined if not available in this engine
```
    };
}
```

ES5 15.2.3.3

if (!Object.getOwnPropertyDescriptor) {
    Object.getOwnPropertyDescriptor = function (object) {
        return {}; // XXX
    };
}

ES5 15.2.3.4

if (!Object.getOwnPropertyNames) {
    Object.getOwnPropertyNames = function (object) {
        return Object.keys(object);
    };
}

ES5 15.2.3.5

if (!Object.create) {
    Object.create = function(prototype, properties) {
        if (typeof prototype != "object" || prototype === null)
            throw new TypeError("typeof prototype["+(typeof prototype)+"] != 'object'");
        function Type() {};
        Type.prototype = prototype;
        var object = new Type();
        if (typeof properties !== "undefined")
            Object.defineProperties(object, properties);
        return object;
    };
}

ES5 15.2.3.6

if (!Object.defineProperty) {
    Object.defineProperty = function(object, property, descriptor) {
        var has = Object.prototype.hasOwnProperty;
        if (typeof descriptor == "object" && object.__defineGetter__) {
            if (has.call(descriptor, "value")) {
                if (!object.__lookupGetter__(property) && !object.__lookupSetter__(property))

data property defined and no pre-existing accessors

                    object[property] = descriptor.value;
                if (has.call(descriptor, "get") || has.call(descriptor, "set"))

descriptor has a value property but accessor already exists

                    throw new TypeError("Object doesn't support this action");
            }

¶

fail silently if "writable", "enumerable", or "configurable" are requested but not supported
```
            /*
```

alternate approach:

            if ( // can't implement these features; allow false but not true
                !(has.call(descriptor, "writable") ? descriptor.writable : true) ||
                !(has.call(descriptor, "enumerable") ? descriptor.enumerable : true) ||
                !(has.call(descriptor, "configurable") ? descriptor.configurable : true)
            )
                throw new RangeError(
                    "This implementation of Object.defineProperty does not " +
                    "support configurable, enumerable, or writable."
                );
            */
            else if (typeof descriptor.get == "function")
                object.__defineGetter__(property, descriptor.get);
            if (typeof descriptor.set == "function")
                object.__defineSetter__(property, descriptor.set);
        }
        return object;
    };
}

ES5 15.2.3.7

if (!Object.defineProperties) {
    Object.defineProperties = function(object, properties) {
        for (var property in properties) {
            if (Object.prototype.hasOwnProperty.call(properties, property))
                Object.defineProperty(object, property, properties[property]);
        }
        return object;
    };
}

ES5 15.2.3.8

if (!Object.seal) {
    Object.seal = function (object) {
        return object;
    };
}

ES5 15.2.3.9

try {
if (!Object.freeze) {
    Object.freeze = function (object) {
        return object;
    };
} else if (require("./engine").engine.indexOf("rhino") >= 0) {

TODO feature-detect XXX workaround for a Rhino bug.

    var freeze = Object.freeze;
    Object.freeze = function (object) {
        if (typeof object == "function") {
            return object;
        } else {
            return freeze(object);
        }
    };
}
} catch(e) { /* require('engine') often fails */ }

ES5 15.2.3.10

if (!Object.preventExtensions) {
    Object.preventExtensions = function (object) {
        return object;
    };
}

ES5 15.2.3.11

if (!Object.isSealed) {
    Object.isSealed = function (object) {
        return false;
    };
}

ES5 15.2.3.12

if (!Object.isFrozen) {
    Object.isFrozen = function (object) {
        return false;
    };
}

ES5 15.2.3.13

if (!Object.isExtensible) {
    Object.isExtensible = function (object) {
        return true;
    };
}

ES5 15.2.3.14

if (!Object.keys) {
    Object.keys = function (object) {
        var keys = [];
        for (var name in object) {
            if (Object.prototype.hasOwnProperty.call(object, name)) {
                keys.push(name);
            }
        }
        return keys;
    };
}

¶

Date

ES5 15.9.5.43 Format a Date object as a string according to a subset of the ISO-8601 standard. Useful in Atom, among other things.

if (!Date.prototype.toISOString) {
    Date.prototype.toISOString = function() {
        return (
            this.getFullYear() + "-" +
            (this.getMonth() + 1) + "-" +
            this.getDate() + "T" +
            this.getHours() + ":" +
            this.getMinutes() + ":" +
            this.getSeconds() + "Z"
        );
    }
}

ES5 15.9.4.4

if (!Date.now) {
    Date.now = function () {
        return new Date().getTime();
    };
}

ES5 15.9.5.44

if (!Date.prototype.toJSON) {
    Date.prototype.toJSON = function (key) {

¶

This function provides a String representation of a Date object for use by JSON.stringify (15.12.3). When the toJSON method is called with argument key, the following steps are taken:
1. Let O be the result of calling ToObject, giving it the this value as its argument.
2. Let tv be ToPrimitive(O, hint Number).
3. If tv is a Number and is not finite, return null. XXX
4. Let toISO be the result of calling the [[Get]] internal method of O with argument "toISOString".
5. If IsCallable(toISO) is false, throw a TypeError exception.
```
        if (typeof this.toISOString != "function")
            throw new TypeError();
```
¶
1. Return the result of calling the [[Call]] internal method of toISO with O as the this value and an empty argument list.
```
        return this.toISOString();
```
¶

NOTE 1 The argument is ignored.

NOTE 2 The toJSON function is intentionally generic; it does not require that its this value be a Date object. Therefore, it can be transferred to other kinds of objects for use as a method. However, it does require that any such object have a toISOString method. An object is free to use the argument key to filter its stringification.
```
    };
}
```
¶

15.9.4.2 Date.parse (string) 15.9.1.15 Date Time String Format Date.parse based on work shared by Daniel Friesen (dantman) http://gist.github.com/303249
```
if (isNaN(Date.parse("T00:00"))) {
```
¶

XXX global assignment won't work in embeddings that use an alternate object for the context.
```
    Date = (function(NativeDate) {
```

Date.length === 7

        var Date = function(Y, M, D, h, m, s, ms) {
            var length = arguments.length;
            if (this instanceof NativeDate) {
                var date = length === 1 && String(Y) === Y ? // isString(Y)

We explicitly pass it through parse:

                    new NativeDate(Date.parse(Y)) :

We have to manually make calls depending on argument length here

                    length >= 7 ? new NativeDate(Y, M, D, h, m, s, ms) :
                    length >= 6 ? new NativeDate(Y, M, D, h, m, s) :
                    length >= 5 ? new NativeDate(Y, M, D, h, m) :
                    length >= 4 ? new NativeDate(Y, M, D, h) :
                    length >= 3 ? new NativeDate(Y, M, D) :
                    length >= 2 ? new NativeDate(Y, M) :
                    length >= 1 ? new NativeDate(Y) :
                                  new NativeDate();

Prevent mixups with unfixed Date object

                date.constructor = Date;
                return date;
            }
            return NativeDate.apply(this, arguments);
        };

15.9.1.15 Date Time String Format

        var isoDateExpression = new RegExp("^" +
            "(?:" + // optional year-month-day
                "(" + // year capture
                    "(?:[+-]\\d\\d)?" + // 15.9.1.15.1 Extended years
                    "\\d\\d\\d\\d" + // four-digit year
                ")" +
                "(?:-" + // optional month-day
                    "(\\d\\d)" + // month capture
                    "(?:-" + // optional day
                        "(\\d\\d)" + // day capture
                    ")?" +
                ")?" +
            ")?" +
            "(?:T" + // hour:minute:second.subsecond
                "(\\d\\d)" + // hour capture
                ":(\\d\\d)" + // minute capture
                "(?::" + // optional :second.subsecond
                    "(\\d\\d)" + // second capture
                    "(?:\\.(\\d\\d\\d))?" + // milisecond capture
                ")?" +
            ")?" +
            "(?:" + // time zone
                "Z|" + // UTC capture
                "([+-])(\\d\\d):(\\d\\d)" + // timezone offset

¶

capture sign, hour, minute
```
            ")?" +
        "$");
```

Copy any custom methods a 3rd party library may have added

        for (var key in NativeDate)
            Date[key] = NativeDate[key];

Copy "native" methods explicitly; they may be non-enumerable

        Date.now = NativeDate.now;
        Date.UTC = NativeDate.UTC;
        Date.prototype = NativeDate.prototype;
        Date.prototype.constructor = Date;

Upgrade Date.parse to handle the ISO dates we use TODO review specification to ascertain whether it is necessary to implement partial ISO date strings.

        Date.parse = function(string) {
            var match = isoDateExpression.exec(string);
            if (match) {
                match.shift(); // kill match[0], the full match

¶

recognize times without dates before normalizing the numeric values, for later use
```
                var timeOnly = match[0] === undefined;
```

parse numerics

                for (var i = 0; i < 10; i++) {

skip + or - for the timezone offset

                    if (i === 7)
                        continue;

¶

Note: parseInt would read 0-prefix numbers as octal. Number constructor or unary + work better here:
```
                    match[i] = +(match[i] || (i < 3 ? 1 : 0));
```
¶

match[1] is the month. Months are 0-11 in JavaScript Date objects, but 1-12 in ISO notation, so we decrement.
```
                    if (i === 1)
                        match[i]--;
                }
```

if no year-month-date is provided, return a milisecond quantity instead of a UTC date number value.

                if (timeOnly)
                    return ((match[3] * 60 + match[4]) * 60 + match[5]) * 1000 + match[6];

account for an explicit time zone offset if provided

                var offset = (match[8] * 60 + match[9]) * 60 * 1000;
                if (match[6] === "-")
                    offset = -offset;

                return NativeDate.UTC.apply(this, match.slice(0, 7)) + offset;
            }
            return NativeDate.parse.apply(this, arguments);
        };

        return Date;
    })(Date);
}

¶

Function

ES-5 15.3.4.5 http://www.ecma-international.org/publications/files/drafts/tc39-2009-025.pdf

var slice = Array.prototype.slice;
if (!Function.prototype.bind) {
    Function.prototype.bind = function (that) { // .length is 1

¶
1. Let Target be the this value.
```
        var target = this;
```
¶
1. If IsCallable(Target) is false, throw a TypeError exception. XXX this gets pretty close, for all intents and purposes, letting some duck-types slide
```
        if (typeof target.apply != "function" || typeof target.call != "function")
            return new TypeError();
```
¶
1. Let A be a new (possibly empty) internal list of all of the argument values provided after thisArg (arg1, arg2 etc), in order.
```
        var args = slice.call(arguments);
```
¶
1. Let F be a new native ECMAScript object.
2. Set the [[Prototype]] internal property of F to the standard built-in Function prototype object as specified in 15.3.3.1.
3. Set the [[Call]] internal property of F as described in 15.3.4.5.1.
4. Set the [[Construct]] internal property of F as described in 15.3.4.5.2.
5. Set the [[HasInstance]] internal property of F as described in 15.3.4.5.3.
6. The [[Scope]] internal property of F is unused and need not exist.
```
        var bound = function () {

            if (this instanceof bound) {
```
¶

15.3.4.5.2 [[Construct]] When the [[Construct]] internal method of a function object, F that was created using the bind function is called with a list of arguments ExtraArgs the following steps are taken:
1. Let target be the value of F's [[TargetFunction]] internal property.
2. If target has no [[Construct]] internal method, a TypeError exception is thrown.
3. Let boundArgs be the value of F's [[BoundArgs]] internal property.
4. Let args be a new list containing the same values as the list boundArgs in the same order followed by the same values as the list ExtraArgs in the same order.
```
                var self = Object.create(target.prototype);
                target.apply(self, args.concat(slice.call(arguments)));
                return self;

            } else {
```
¶

15.3.4.5.1 [[Call]] When the [[Call]] internal method of a function object, F, which was created using the bind function is called with a this value and a list of arguments ExtraArgs the following steps are taken:
1. Let boundArgs be the value of F's [[BoundArgs]] internal property.
2. Let boundThis be the value of F's [[BoundThis]] internal property.
3. Let target be the value of F's [[TargetFunction]] internal property.
4. Let args be a new list containing the same values as the list boundArgs in the same order followed by the same values as the list ExtraArgs in the same order. 5. Return the result of calling the [[Call]] internal method of target providing boundThis as the this value and providing args as the arguments.
equiv: target.call(this, ...boundArgs, ...args)
```
                return target.call.apply(
                    target,
                    args.concat(slice.call(arguments))
                );

            }

        };
```
¶
1. Set the [[TargetFunction]] internal property of F to Target. extra:
```
        bound.bound = target;
```
¶
1. Set the [[BoundThis]] internal property of F to the value of thisArg. extra:
```
        bound.boundTo = that;
```

Set the [[BoundArgs]] internal property of F to A. extra:

        bound.boundArgs = args;
        bound.length = (

¶
1. If the [[Class]] internal property of Target is "Function", then
```
            typeof target == "function" ?
```
¶

a. Let L be the length property of Target minus the length of A. b. Set the length own property of F to either 0 or L, whichever is larger.
```
            Math.max(target.length - args.length, 0) :
```
¶
1. Else set the length own property of F to 0.
```
            0
        )
```
¶
1. The length own property of F is given attributes as specified in 15.3.5.1. TODO
2. Set the [[Extensible]] internal property of F to true. TODO
3. Call the [[DefineOwnProperty]] internal method of F with arguments "caller", PropertyDescriptor {[[Value]]: null, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false}, and false. TODO
4. Call the [[DefineOwnProperty]] internal method of F with arguments "arguments", PropertyDescriptor {[[Value]]: null, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false}, and false. TODO NOTE Function objects created using Function.prototype.bind do not have a prototype property. XXX can't delete it in pure-js.
```
        return bound;
    };
}
```
¶

String
¶

ES5 15.5.4.20
```
if (!String.prototype.trim) {
```

http://blog.stevenlevithan.com/archives/faster-trim-javascript

    var trimBeginRegexp = /^\s\s*/;
    var trimEndRegexp = /\s\s*$/;
    String.prototype.trim = function () {
        return String(this).replace(trimBeginRegexp, '').replace(trimEndRegexp, '');
    };
}