| /*! |
| * https://github.com/es-shims/es5-shim |
| * @license es5-shim Copyright 2009-2014 by contributors, MIT License |
| * see https://github.com/es-shims/es5-shim/blob/master/LICENSE |
| */ |
| |
| // vim: ts=4 sts=4 sw=4 expandtab |
| |
| //Add semicolon to prevent IIFE from being passed as argument to concatenated code. |
| ; |
| |
| // UMD (Universal Module Definition) |
| // see https://github.com/umdjs/umd/blob/master/returnExports.js |
| (function (root, factory) { |
| if (typeof define === 'function' && define.amd) { |
| // AMD. Register as an anonymous module. |
| define(factory); |
| } else if (typeof exports === 'object') { |
| // Node. Does not work with strict CommonJS, but |
| // only CommonJS-like enviroments that support module.exports, |
| // like Node. |
| module.exports = factory(); |
| } else { |
| // Browser globals (root is window) |
| root.returnExports = factory(); |
| } |
| }(this, function () { |
| |
| /** |
| * Brings an environment as close to ECMAScript 5 compliance |
| * as is possible with the facilities of erstwhile engines. |
| * |
| * Annotated ES5: http://es5.github.com/ (specific links below) |
| * ES5 Spec: http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf |
| * Required reading: http://javascriptweblog.wordpress.com/2011/12/05/extending-javascript-natives/ |
| */ |
| |
| // Shortcut to an often accessed properties, in order to avoid multiple |
| // dereference that costs universally. |
| var ArrayPrototype = Array.prototype; |
| var ObjectPrototype = Object.prototype; |
| var FunctionPrototype = Function.prototype; |
| var StringPrototype = String.prototype; |
| var NumberPrototype = Number.prototype; |
| var array_slice = ArrayPrototype.slice; |
| var array_splice = ArrayPrototype.splice; |
| var array_push = ArrayPrototype.push; |
| var array_unshift = ArrayPrototype.unshift; |
| var call = FunctionPrototype.call; |
| |
| // Having a toString local variable name breaks in Opera so use _toString. |
| var _toString = ObjectPrototype.toString; |
| |
| var isFunction = function (val) { |
| return ObjectPrototype.toString.call(val) === '[object Function]'; |
| }; |
| var isRegex = function (val) { |
| return ObjectPrototype.toString.call(val) === '[object RegExp]'; |
| }; |
| var isArray = function isArray(obj) { |
| return _toString.call(obj) === '[object Array]'; |
| }; |
| var isString = function isString(obj) { |
| return _toString.call(obj) === '[object String]'; |
| }; |
| var isArguments = function isArguments(value) { |
| var str = _toString.call(value); |
| var isArgs = str === '[object Arguments]'; |
| if (!isArgs) { |
| isArgs = !isArray(value) |
| && value !== null |
| && typeof value === 'object' |
| && typeof value.length === 'number' |
| && value.length >= 0 |
| && isFunction(value.callee); |
| } |
| return isArgs; |
| }; |
| |
| var supportsDescriptors = Object.defineProperty && (function () { |
| try { |
| Object.defineProperty({}, 'x', {}); |
| return true; |
| } catch (e) { /* this is ES3 */ |
| return false; |
| } |
| }()); |
| |
| // Define configurable, writable and non-enumerable props |
| // if they don't exist. |
| var defineProperty; |
| if (supportsDescriptors) { |
| defineProperty = function (object, name, method, forceAssign) { |
| if (!forceAssign && (name in object)) { return; } |
| Object.defineProperty(object, name, { |
| configurable: true, |
| enumerable: false, |
| writable: true, |
| value: method |
| }); |
| }; |
| } else { |
| defineProperty = function (object, name, method, forceAssign) { |
| if (!forceAssign && (name in object)) { return; } |
| object[name] = method; |
| }; |
| } |
| var defineProperties = function (object, map, forceAssign) { |
| for (var name in map) { |
| if (ObjectPrototype.hasOwnProperty.call(map, name)) { |
| defineProperty(object, name, map[name], forceAssign); |
| } |
| } |
| }; |
| |
| // |
| // Util |
| // ====== |
| // |
| |
| // ES5 9.4 |
| // http://es5.github.com/#x9.4 |
| // http://jsperf.com/to-integer |
| |
| function toInteger(num) { |
| var n = +num; |
| if (n !== n) { // isNaN |
| n = 0; |
| } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) { |
| n = (n > 0 || -1) * Math.floor(Math.abs(n)); |
| } |
| return n; |
| } |
| |
| function isPrimitive(input) { |
| var type = typeof input; |
| return ( |
| input === null || |
| type === 'undefined' || |
| type === 'boolean' || |
| type === 'number' || |
| type === 'string' |
| ); |
| } |
| |
| function toPrimitive(input) { |
| var val, valueOf, toStr; |
| if (isPrimitive(input)) { |
| return input; |
| } |
| valueOf = input.valueOf; |
| if (isFunction(valueOf)) { |
| val = valueOf.call(input); |
| if (isPrimitive(val)) { |
| return val; |
| } |
| } |
| toStr = input.toString; |
| if (isFunction(toStr)) { |
| val = toStr.call(input); |
| if (isPrimitive(val)) { |
| return val; |
| } |
| } |
| throw new TypeError(); |
| } |
| |
| // ES5 9.9 |
| // http://es5.github.com/#x9.9 |
| var toObject = function (o) { |
| if (o == null) { // this matches both null and undefined |
| throw new TypeError("can't convert " + o + ' to object'); |
| } |
| return Object(o); |
| }; |
| |
| var ToUint32 = function ToUint32(x) { |
| return x >>> 0; |
| }; |
| |
| // |
| // Function |
| // ======== |
| // |
| |
| // ES-5 15.3.4.5 |
| // http://es5.github.com/#x15.3.4.5 |
| |
| function Empty() {} |
| |
| defineProperties(FunctionPrototype, { |
| bind: function bind(that) { // .length is 1 |
| // 1. Let Target be the this value. |
| var target = this; |
| // 2. If IsCallable(Target) is false, throw a TypeError exception. |
| if (!isFunction(target)) { |
| throw new TypeError('Function.prototype.bind called on incompatible ' + target); |
| } |
| // 3. Let A be a new (possibly empty) internal list of all of the |
| // argument values provided after thisArg (arg1, arg2 etc), in order. |
| // XXX slicedArgs will stand in for "A" if used |
| var args = array_slice.call(arguments, 1); // for normal call |
| // 4. Let F be a new native ECMAScript object. |
| // 11. Set the [[Prototype]] internal property of F to the standard |
| // built-in Function prototype object as specified in 15.3.3.1. |
| // 12. Set the [[Call]] internal property of F as described in |
| // 15.3.4.5.1. |
| // 13. Set the [[Construct]] internal property of F as described in |
| // 15.3.4.5.2. |
| // 14. Set the [[HasInstance]] internal property of F as described in |
| // 15.3.4.5.3. |
| var binder = 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. |
| // 5. Return the result of calling the [[Construct]] internal |
| // method of target providing args as the arguments. |
| |
| var result = target.apply( |
| this, |
| args.concat(array_slice.call(arguments)) |
| ); |
| if (Object(result) === result) { |
| return result; |
| } |
| return this; |
| |
| } 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.apply( |
| that, |
| args.concat(array_slice.call(arguments)) |
| ); |
| |
| } |
| |
| }; |
| |
| // 15. If the [[Class]] internal property of Target is "Function", then |
| // 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. |
| // 16. Else set the length own property of F to 0. |
| |
| var boundLength = Math.max(0, target.length - args.length); |
| |
| // 17. Set the attributes of the length own property of F to the values |
| // specified in 15.3.5.1. |
| var boundArgs = []; |
| for (var i = 0; i < boundLength; i++) { |
| boundArgs.push('$' + i); |
| } |
| |
| // XXX Build a dynamic function with desired amount of arguments is the only |
| // way to set the length property of a function. |
| // In environments where Content Security Policies enabled (Chrome extensions, |
| // for ex.) all use of eval or Function costructor throws an exception. |
| // However in all of these environments Function.prototype.bind exists |
| // and so this code will never be executed. |
| var bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this, arguments); }')(binder); |
| |
| if (target.prototype) { |
| Empty.prototype = target.prototype; |
| bound.prototype = new Empty(); |
| // Clean up dangling references. |
| Empty.prototype = null; |
| } |
| |
| // TODO |
| // 18. Set the [[Extensible]] internal property of F to true. |
| |
| // TODO |
| // 19. Let thrower be the [[ThrowTypeError]] function Object (13.2.3). |
| // 20. Call the [[DefineOwnProperty]] internal method of F with |
| // arguments "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]: |
| // thrower, [[Enumerable]]: false, [[Configurable]]: false}, and |
| // false. |
| // 21. Call the [[DefineOwnProperty]] internal method of F with |
| // arguments "arguments", PropertyDescriptor {[[Get]]: thrower, |
| // [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false}, |
| // and false. |
| |
| // TODO |
| // NOTE Function objects created using Function.prototype.bind do not |
| // have a prototype property or the [[Code]], [[FormalParameters]], and |
| // [[Scope]] internal properties. |
| // XXX can't delete prototype in pure-js. |
| |
| // 22. Return F. |
| return bound; |
| } |
| }); |
| |
| // _Please note: Shortcuts are defined after `Function.prototype.bind` as we |
| // us it in defining shortcuts. |
| var owns = call.bind(ObjectPrototype.hasOwnProperty); |
| |
| // If JS engine supports accessors creating shortcuts. |
| var defineGetter; |
| var defineSetter; |
| var lookupGetter; |
| var lookupSetter; |
| var supportsAccessors; |
| if ((supportsAccessors = owns(ObjectPrototype, '__defineGetter__'))) { |
| defineGetter = call.bind(ObjectPrototype.__defineGetter__); |
| defineSetter = call.bind(ObjectPrototype.__defineSetter__); |
| lookupGetter = call.bind(ObjectPrototype.__lookupGetter__); |
| lookupSetter = call.bind(ObjectPrototype.__lookupSetter__); |
| } |
| |
| // |
| // Array |
| // ===== |
| // |
| |
| // ES5 15.4.4.12 |
| // http://es5.github.com/#x15.4.4.12 |
| var spliceNoopReturnsEmptyArray = (function () { |
| var a = [1, 2]; |
| var result = a.splice(); |
| return a.length === 2 && isArray(result) && result.length === 0; |
| }()); |
| defineProperties(ArrayPrototype, { |
| // Safari 5.0 bug where .splice() returns undefined |
| splice: function splice(start, deleteCount) { |
| if (arguments.length === 0) { |
| return []; |
| } else { |
| return array_splice.apply(this, arguments); |
| } |
| } |
| }, spliceNoopReturnsEmptyArray); |
| |
| var spliceWorksWithEmptyObject = (function () { |
| var obj = {}; |
| ArrayPrototype.splice.call(obj, 0, 0, 1); |
| return obj.length === 1; |
| }()); |
| defineProperties(ArrayPrototype, { |
| splice: function splice(start, deleteCount) { |
| if (arguments.length === 0) { return []; } |
| var args = arguments; |
| this.length = Math.max(toInteger(this.length), 0); |
| if (arguments.length > 0 && typeof deleteCount !== 'number') { |
| args = array_slice.call(arguments); |
| if (args.length < 2) { |
| args.push(this.length - start); |
| } else { |
| args[1] = toInteger(deleteCount); |
| } |
| } |
| return array_splice.apply(this, args); |
| } |
| }, !spliceWorksWithEmptyObject); |
| |
| // ES5 15.4.4.12 |
| // http://es5.github.com/#x15.4.4.13 |
| // Return len+argCount. |
| // [bugfix, ielt8] |
| // IE < 8 bug: [].unshift(0) === undefined but should be "1" |
| var hasUnshiftReturnValueBug = [].unshift(0) !== 1; |
| defineProperties(ArrayPrototype, { |
| unshift: function () { |
| array_unshift.apply(this, arguments); |
| return this.length; |
| } |
| }, hasUnshiftReturnValueBug); |
| |
| // ES5 15.4.3.2 |
| // http://es5.github.com/#x15.4.3.2 |
| // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/isArray |
| defineProperties(Array, { isArray: isArray }); |
| |
| // The IsCallable() check in the Array functions |
| // has been replaced with a strict check on the |
| // internal class of the object to trap cases where |
| // the provided function was actually a regular |
| // expression literal, which in V8 and |
| // JavaScriptCore is a typeof "function". Only in |
| // V8 are regular expression literals permitted as |
| // reduce parameters, so it is desirable in the |
| // general case for the shim to match the more |
| // strict and common behavior of rejecting regular |
| // expressions. |
| |
| // ES5 15.4.4.18 |
| // http://es5.github.com/#x15.4.4.18 |
| // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/forEach |
| |
| // Check failure of by-index access of string characters (IE < 9) |
| // and failure of `0 in boxedString` (Rhino) |
| var boxedString = Object('a'); |
| var splitString = boxedString[0] !== 'a' || !(0 in boxedString); |
| |
| var properlyBoxesContext = function properlyBoxed(method) { |
| // Check node 0.6.21 bug where third parameter is not boxed |
| var properlyBoxesNonStrict = true; |
| var properlyBoxesStrict = true; |
| if (method) { |
| method.call('foo', function (_, __, context) { |
| if (typeof context !== 'object') { properlyBoxesNonStrict = false; } |
| }); |
| |
| method.call([1], function () { |
| 'use strict'; |
| properlyBoxesStrict = typeof this === 'string'; |
| }, 'x'); |
| } |
| return !!method && properlyBoxesNonStrict && properlyBoxesStrict; |
| }; |
| |
| defineProperties(ArrayPrototype, { |
| forEach: function forEach(fun /*, thisp*/) { |
| var object = toObject(this), |
| self = splitString && isString(this) ? this.split('') : object, |
| thisp = arguments[1], |
| i = -1, |
| length = self.length >>> 0; |
| |
| // If no callback function or if callback is not a callable function |
| if (!isFunction(fun)) { |
| throw new TypeError(); // TODO message |
| } |
| |
| while (++i < length) { |
| if (i in self) { |
| // Invoke the callback function with call, passing arguments: |
| // context, property value, property key, thisArg object |
| // context |
| fun.call(thisp, self[i], i, object); |
| } |
| } |
| } |
| }, !properlyBoxesContext(ArrayPrototype.forEach)); |
| |
| // ES5 15.4.4.19 |
| // http://es5.github.com/#x15.4.4.19 |
| // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map |
| defineProperties(ArrayPrototype, { |
| map: function map(fun /*, thisp*/) { |
| var object = toObject(this), |
| self = splitString && isString(this) ? this.split('') : object, |
| length = self.length >>> 0, |
| result = Array(length), |
| thisp = arguments[1]; |
| |
| // If no callback function or if callback is not a callable function |
| if (!isFunction(fun)) { |
| throw new TypeError(fun + ' is not a function'); |
| } |
| |
| for (var i = 0; i < length; i++) { |
| if (i in self) { |
| result[i] = fun.call(thisp, self[i], i, object); |
| } |
| } |
| return result; |
| } |
| }, !properlyBoxesContext(ArrayPrototype.map)); |
| |
| // ES5 15.4.4.20 |
| // http://es5.github.com/#x15.4.4.20 |
| // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter |
| defineProperties(ArrayPrototype, { |
| filter: function filter(fun /*, thisp */) { |
| var object = toObject(this), |
| self = splitString && isString(this) ? this.split('') : object, |
| length = self.length >>> 0, |
| result = [], |
| value, |
| thisp = arguments[1]; |
| |
| // If no callback function or if callback is not a callable function |
| if (!isFunction(fun)) { |
| throw new TypeError(fun + ' is not a function'); |
| } |
| |
| for (var i = 0; i < length; i++) { |
| if (i in self) { |
| value = self[i]; |
| if (fun.call(thisp, value, i, object)) { |
| result.push(value); |
| } |
| } |
| } |
| return result; |
| } |
| }, !properlyBoxesContext(ArrayPrototype.filter)); |
| |
| // ES5 15.4.4.16 |
| // http://es5.github.com/#x15.4.4.16 |
| // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every |
| defineProperties(ArrayPrototype, { |
| every: function every(fun /*, thisp */) { |
| var object = toObject(this), |
| self = splitString && isString(this) ? this.split('') : object, |
| length = self.length >>> 0, |
| thisp = arguments[1]; |
| |
| // If no callback function or if callback is not a callable function |
| if (!isFunction(fun)) { |
| throw new TypeError(fun + ' is not a function'); |
| } |
| |
| for (var i = 0; i < length; i++) { |
| if (i in self && !fun.call(thisp, self[i], i, object)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| }, !properlyBoxesContext(ArrayPrototype.every)); |
| |
| // ES5 15.4.4.17 |
| // http://es5.github.com/#x15.4.4.17 |
| // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some |
| defineProperties(ArrayPrototype, { |
| some: function some(fun /*, thisp */) { |
| var object = toObject(this), |
| self = splitString && isString(this) ? this.split('') : object, |
| length = self.length >>> 0, |
| thisp = arguments[1]; |
| |
| // If no callback function or if callback is not a callable function |
| if (!isFunction(fun)) { |
| throw new TypeError(fun + ' is not a function'); |
| } |
| |
| for (var i = 0; i < length; i++) { |
| if (i in self && fun.call(thisp, self[i], i, object)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| }, !properlyBoxesContext(ArrayPrototype.some)); |
| |
| // ES5 15.4.4.21 |
| // http://es5.github.com/#x15.4.4.21 |
| // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduce |
| var reduceCoercesToObject = false; |
| if (ArrayPrototype.reduce) { |
| reduceCoercesToObject = typeof ArrayPrototype.reduce.call('es5', function (_, __, ___, list) { return list; }) === 'object'; |
| } |
| defineProperties(ArrayPrototype, { |
| reduce: function reduce(fun /*, initial*/) { |
| var object = toObject(this), |
| self = splitString && isString(this) ? this.split('') : object, |
| length = self.length >>> 0; |
| |
| // If no callback function or if callback is not a callable function |
| if (!isFunction(fun)) { |
| throw new TypeError(fun + ' is not a function'); |
| } |
| |
| // no value to return if no initial value and an empty array |
| if (!length && arguments.length === 1) { |
| throw new TypeError('reduce of empty array with no initial value'); |
| } |
| |
| var i = 0; |
| var result; |
| if (arguments.length >= 2) { |
| result = arguments[1]; |
| } else { |
| do { |
| if (i in self) { |
| result = self[i++]; |
| break; |
| } |
| |
| // if array contains no values, no initial value to return |
| if (++i >= length) { |
| throw new TypeError('reduce of empty array with no initial value'); |
| } |
| } while (true); |
| } |
| |
| for (; i < length; i++) { |
| if (i in self) { |
| result = fun.call(void 0, result, self[i], i, object); |
| } |
| } |
| |
| return result; |
| } |
| }, !reduceCoercesToObject); |
| |
| // ES5 15.4.4.22 |
| // http://es5.github.com/#x15.4.4.22 |
| // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduceRight |
| var reduceRightCoercesToObject = false; |
| if (ArrayPrototype.reduceRight) { |
| reduceRightCoercesToObject = typeof ArrayPrototype.reduceRight.call('es5', function (_, __, ___, list) { return list; }) === 'object'; |
| } |
| defineProperties(ArrayPrototype, { |
| reduceRight: function reduceRight(fun /*, initial*/) { |
| var object = toObject(this), |
| self = splitString && isString(this) ? this.split('') : object, |
| length = self.length >>> 0; |
| |
| // If no callback function or if callback is not a callable function |
| if (!isFunction(fun)) { |
| throw new TypeError(fun + ' is not a function'); |
| } |
| |
| // no value to return if no initial value, empty array |
| if (!length && arguments.length === 1) { |
| throw new TypeError('reduceRight of empty array with no initial value'); |
| } |
| |
| var result, i = length - 1; |
| if (arguments.length >= 2) { |
| result = arguments[1]; |
| } else { |
| do { |
| if (i in self) { |
| result = self[i--]; |
| break; |
| } |
| |
| // if array contains no values, no initial value to return |
| if (--i < 0) { |
| throw new TypeError('reduceRight of empty array with no initial value'); |
| } |
| } while (true); |
| } |
| |
| if (i < 0) { |
| return result; |
| } |
| |
| do { |
| if (i in self) { |
| result = fun.call(void 0, result, self[i], i, object); |
| } |
| } while (i--); |
| |
| return result; |
| } |
| }, !reduceRightCoercesToObject); |
| |
| // ES5 15.4.4.14 |
| // http://es5.github.com/#x15.4.4.14 |
| // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf |
| var hasFirefox2IndexOfBug = Array.prototype.indexOf && [0, 1].indexOf(1, 2) !== -1; |
| defineProperties(ArrayPrototype, { |
| indexOf: function indexOf(sought /*, fromIndex */ ) { |
| var self = splitString && isString(this) ? this.split('') : toObject(this), |
| length = self.length >>> 0; |
| |
| if (!length) { |
| return -1; |
| } |
| |
| var i = 0; |
| if (arguments.length > 1) { |
| i = toInteger(arguments[1]); |
| } |
| |
| // handle negative indices |
| i = i >= 0 ? i : Math.max(0, length + i); |
| for (; i < length; i++) { |
| if (i in self && self[i] === sought) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| }, hasFirefox2IndexOfBug); |
| |
| // ES5 15.4.4.15 |
| // http://es5.github.com/#x15.4.4.15 |
| // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/lastIndexOf |
| var hasFirefox2LastIndexOfBug = Array.prototype.lastIndexOf && [0, 1].lastIndexOf(0, -3) !== -1; |
| defineProperties(ArrayPrototype, { |
| lastIndexOf: function lastIndexOf(sought /*, fromIndex */) { |
| var self = splitString && isString(this) ? this.split('') : toObject(this), |
| length = self.length >>> 0; |
| |
| if (!length) { |
| return -1; |
| } |
| var i = length - 1; |
| if (arguments.length > 1) { |
| i = Math.min(i, toInteger(arguments[1])); |
| } |
| // handle negative indices |
| i = i >= 0 ? i : length - Math.abs(i); |
| for (; i >= 0; i--) { |
| if (i in self && sought === self[i]) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| }, hasFirefox2LastIndexOfBug); |
| |
| // |
| // Object |
| // ====== |
| // |
| |
| // ES5 15.2.3.14 |
| // http://es5.github.com/#x15.2.3.14 |
| |
| // http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation |
| var hasDontEnumBug = !({'toString': null}).propertyIsEnumerable('toString'), |
| hasProtoEnumBug = (function () {}).propertyIsEnumerable('prototype'), |
| dontEnums = [ |
| 'toString', |
| 'toLocaleString', |
| 'valueOf', |
| 'hasOwnProperty', |
| 'isPrototypeOf', |
| 'propertyIsEnumerable', |
| 'constructor' |
| ], |
| dontEnumsLength = dontEnums.length; |
| |
| defineProperties(Object, { |
| keys: function keys(object) { |
| var isFn = isFunction(object), |
| isArgs = isArguments(object), |
| isObject = object !== null && typeof object === 'object', |
| isStr = isObject && isString(object); |
| |
| if (!isObject && !isFn && !isArgs) { |
| throw new TypeError('Object.keys called on a non-object'); |
| } |
| |
| var theKeys = []; |
| var skipProto = hasProtoEnumBug && isFn; |
| if (isStr || isArgs) { |
| for (var i = 0; i < object.length; ++i) { |
| theKeys.push(String(i)); |
| } |
| } else { |
| for (var name in object) { |
| if (!(skipProto && name === 'prototype') && owns(object, name)) { |
| theKeys.push(String(name)); |
| } |
| } |
| } |
| |
| if (hasDontEnumBug) { |
| var ctor = object.constructor, |
| skipConstructor = ctor && ctor.prototype === object; |
| for (var j = 0; j < dontEnumsLength; j++) { |
| var dontEnum = dontEnums[j]; |
| if (!(skipConstructor && dontEnum === 'constructor') && owns(object, dontEnum)) { |
| theKeys.push(dontEnum); |
| } |
| } |
| } |
| return theKeys; |
| } |
| }); |
| |
| var keysWorksWithArguments = Object.keys && (function () { |
| // Safari 5.0 bug |
| return Object.keys(arguments).length === 2; |
| }(1, 2)); |
| var originalKeys = Object.keys; |
| defineProperties(Object, { |
| keys: function keys(object) { |
| if (isArguments(object)) { |
| return originalKeys(ArrayPrototype.slice.call(object)); |
| } else { |
| return originalKeys(object); |
| } |
| } |
| }, !keysWorksWithArguments); |
| |
| // |
| // Date |
| // ==== |
| // |
| |
| // ES5 15.9.5.43 |
| // http://es5.github.com/#x15.9.5.43 |
| // This function returns a String value represent the instance in time |
| // represented by this Date object. The format of the String is the Date Time |
| // string format defined in 15.9.1.15. All fields are present in the String. |
| // The time zone is always UTC, denoted by the suffix Z. If the time value of |
| // this object is not a finite Number a RangeError exception is thrown. |
| var negativeDate = -62198755200000; |
| var negativeYearString = '-000001'; |
| var hasNegativeDateBug = Date.prototype.toISOString && new Date(negativeDate).toISOString().indexOf(negativeYearString) === -1; |
| |
| defineProperties(Date.prototype, { |
| toISOString: function toISOString() { |
| var result, length, value, year, month; |
| if (!isFinite(this)) { |
| throw new RangeError('Date.prototype.toISOString called on non-finite value.'); |
| } |
| |
| year = this.getUTCFullYear(); |
| |
| month = this.getUTCMonth(); |
| // see https://github.com/es-shims/es5-shim/issues/111 |
| year += Math.floor(month / 12); |
| month = (month % 12 + 12) % 12; |
| |
| // the date time string format is specified in 15.9.1.15. |
| result = [month + 1, this.getUTCDate(), this.getUTCHours(), this.getUTCMinutes(), this.getUTCSeconds()]; |
| year = ( |
| (year < 0 ? '-' : (year > 9999 ? '+' : '')) + |
| ('00000' + Math.abs(year)).slice(0 <= year && year <= 9999 ? -4 : -6) |
| ); |
| |
| length = result.length; |
| while (length--) { |
| value = result[length]; |
| // pad months, days, hours, minutes, and seconds to have two |
| // digits. |
| if (value < 10) { |
| result[length] = '0' + value; |
| } |
| } |
| // pad milliseconds to have three digits. |
| return ( |
| year + '-' + result.slice(0, 2).join('-') + |
| 'T' + result.slice(2).join(':') + '.' + |
| ('000' + this.getUTCMilliseconds()).slice(-3) + 'Z' |
| ); |
| } |
| }, hasNegativeDateBug); |
| |
| |
| // ES5 15.9.5.44 |
| // http://es5.github.com/#x15.9.5.44 |
| // This function provides a String representation of a Date object for use by |
| // JSON.stringify (15.12.3). |
| var dateToJSONIsSupported = false; |
| try { |
| dateToJSONIsSupported = ( |
| Date.prototype.toJSON && |
| new Date(NaN).toJSON() === null && |
| new Date(negativeDate).toJSON().indexOf(negativeYearString) !== -1 && |
| Date.prototype.toJSON.call({ // generic |
| toISOString: function () { |
| return true; |
| } |
| }) |
| ); |
| } catch (e) { |
| } |
| if (!dateToJSONIsSupported) { |
| Date.prototype.toJSON = function toJSON(key) { |
| // 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). |
| var o = Object(this), |
| tv = toPrimitive(o), |
| toISO; |
| // 3. If tv is a Number and is not finite, return null. |
| if (typeof tv === 'number' && !isFinite(tv)) { |
| return null; |
| } |
| // 4. Let toISO be the result of calling the [[Get]] internal method of |
| // O with argument "toISOString". |
| toISO = o.toISOString; |
| // 5. If IsCallable(toISO) is false, throw a TypeError exception. |
| if (typeof toISO !== 'function') { |
| throw new TypeError('toISOString property is not callable'); |
| } |
| // 6. Return the result of calling the [[Call]] internal method of |
| // toISO with O as the this value and an empty argument list. |
| return toISO.call(o); |
| |
| // 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. |
| }; |
| } |
| |
| // ES5 15.9.4.2 |
| // http://es5.github.com/#x15.9.4.2 |
| // based on work shared by Daniel Friesen (dantman) |
| // http://gist.github.com/303249 |
| var supportsExtendedYears = Date.parse('+033658-09-27T01:46:40.000Z') === 1e15; |
| var acceptsInvalidDates = !isNaN(Date.parse('2012-04-04T24:00:00.500Z')) || !isNaN(Date.parse('2012-11-31T23:59:59.000Z')); |
| var doesNotParseY2KNewYear = isNaN(Date.parse('2000-01-01T00:00:00.000Z')); |
| if (!Date.parse || doesNotParseY2KNewYear || acceptsInvalidDates || !supportsExtendedYears) { |
| // XXX global assignment won't work in embeddings that use |
| // an alternate object for the context. |
| Date = (function (NativeDate) { |
| |
| // Date.length === 7 |
| function Date(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('^' + |
| '(\\d{4}|[\+\-]\\d{6})' + // four-digit year capture or sign + |
| // 6-digit extended year |
| '(?:-(\\d{2})' + // optional month capture |
| '(?:-(\\d{2})' + // optional day capture |
| '(?:' + // capture hours:minutes:seconds.milliseconds |
| 'T(\\d{2})' + // hours capture |
| ':(\\d{2})' + // minutes capture |
| '(?:' + // optional :seconds.milliseconds |
| ':(\\d{2})' + // seconds capture |
| '(?:(\\.\\d{1,}))?' + // milliseconds capture |
| ')?' + |
| '(' + // capture UTC offset component |
| 'Z|' + // UTC capture |
| '(?:' + // offset specifier +/-hours:minutes |
| '([-+])' + // sign capture |
| '(\\d{2})' + // hours offset capture |
| ':(\\d{2})' + // minutes offset capture |
| ')' + |
| ')?)?)?)?' + |
| '$'); |
| |
| var months = [ |
| 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 |
| ]; |
| |
| function dayFromMonth(year, month) { |
| var t = month > 1 ? 1 : 0; |
| return ( |
| months[month] + |
| Math.floor((year - 1969 + t) / 4) - |
| Math.floor((year - 1901 + t) / 100) + |
| Math.floor((year - 1601 + t) / 400) + |
| 365 * (year - 1970) |
| ); |
| } |
| |
| function toUTC(t) { |
| return Number(new NativeDate(1970, 0, 1, 0, 0, 0, t)); |
| } |
| |
| // 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 simplified ISO 8601 strings |
| Date.parse = function parse(string) { |
| var match = isoDateExpression.exec(string); |
| if (match) { |
| // parse months, days, hours, minutes, seconds, and milliseconds |
| // provide default values if necessary |
| // parse the UTC offset component |
| var year = Number(match[1]), |
| month = Number(match[2] || 1) - 1, |
| day = Number(match[3] || 1) - 1, |
| hour = Number(match[4] || 0), |
| minute = Number(match[5] || 0), |
| second = Number(match[6] || 0), |
| millisecond = Math.floor(Number(match[7] || 0) * 1000), |
| // When time zone is missed, local offset should be used |
| // (ES 5.1 bug) |
| // see https://bugs.ecmascript.org/show_bug.cgi?id=112 |
| isLocalTime = Boolean(match[4] && !match[8]), |
| signOffset = match[9] === '-' ? 1 : -1, |
| hourOffset = Number(match[10] || 0), |
| minuteOffset = Number(match[11] || 0), |
| result; |
| if ( |
| hour < ( |
| minute > 0 || second > 0 || millisecond > 0 ? |
| 24 : 25 |
| ) && |
| minute < 60 && second < 60 && millisecond < 1000 && |
| month > -1 && month < 12 && hourOffset < 24 && |
| minuteOffset < 60 && // detect invalid offsets |
| day > -1 && |
| day < ( |
| dayFromMonth(year, month + 1) - |
| dayFromMonth(year, month) |
| ) |
| ) { |
| result = ( |
| (dayFromMonth(year, month) + day) * 24 + |
| hour + |
| hourOffset * signOffset |
| ) * 60; |
| result = ( |
| (result + minute + minuteOffset * signOffset) * 60 + |
| second |
| ) * 1000 + millisecond; |
| if (isLocalTime) { |
| result = toUTC(result); |
| } |
| if (-8.64e15 <= result && result <= 8.64e15) { |
| return result; |
| } |
| } |
| return NaN; |
| } |
| return NativeDate.parse.apply(this, arguments); |
| }; |
| |
| return Date; |
| })(Date); |
| } |
| |
| // ES5 15.9.4.4 |
| // http://es5.github.com/#x15.9.4.4 |
| if (!Date.now) { |
| Date.now = function now() { |
| return new Date().getTime(); |
| }; |
| } |
| |
| |
| // |
| // Number |
| // ====== |
| // |
| |
| // ES5.1 15.7.4.5 |
| // http://es5.github.com/#x15.7.4.5 |
| var hasToFixedBugs = NumberPrototype.toFixed && ( |
| (0.00008).toFixed(3) !== '0.000' |
| || (0.9).toFixed(0) !== '1' |
| || (1.255).toFixed(2) !== '1.25' |
| || (1000000000000000128).toFixed(0) !== '1000000000000000128' |
| ); |
| |
| var toFixedHelpers = { |
| base: 1e7, |
| size: 6, |
| data: [0, 0, 0, 0, 0, 0], |
| multiply: function multiply(n, c) { |
| var i = -1; |
| while (++i < toFixedHelpers.size) { |
| c += n * toFixedHelpers.data[i]; |
| toFixedHelpers.data[i] = c % toFixedHelpers.base; |
| c = Math.floor(c / toFixedHelpers.base); |
| } |
| }, |
| divide: function divide(n) { |
| var i = toFixedHelpers.size, c = 0; |
| while (--i >= 0) { |
| c += toFixedHelpers.data[i]; |
| toFixedHelpers.data[i] = Math.floor(c / n); |
| c = (c % n) * toFixedHelpers.base; |
| } |
| }, |
| numToString: function numToString() { |
| var i = toFixedHelpers.size; |
| var s = ''; |
| while (--i >= 0) { |
| if (s !== '' || i === 0 || toFixedHelpers.data[i] !== 0) { |
| var t = String(toFixedHelpers.data[i]); |
| if (s === '') { |
| s = t; |
| } else { |
| s += '0000000'.slice(0, 7 - t.length) + t; |
| } |
| } |
| } |
| return s; |
| }, |
| pow: function pow(x, n, acc) { |
| return (n === 0 ? acc : (n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc))); |
| }, |
| log: function log(x) { |
| var n = 0; |
| while (x >= 4096) { |
| n += 12; |
| x /= 4096; |
| } |
| while (x >= 2) { |
| n += 1; |
| x /= 2; |
| } |
| return n; |
| } |
| }; |
| |
| defineProperties(NumberPrototype, { |
| toFixed: function toFixed(fractionDigits) { |
| var f, x, s, m, e, z, j, k; |
| |
| // Test for NaN and round fractionDigits down |
| f = Number(fractionDigits); |
| f = f !== f ? 0 : Math.floor(f); |
| |
| if (f < 0 || f > 20) { |
| throw new RangeError('Number.toFixed called with invalid number of decimals'); |
| } |
| |
| x = Number(this); |
| |
| // Test for NaN |
| if (x !== x) { |
| return 'NaN'; |
| } |
| |
| // If it is too big or small, return the string value of the number |
| if (x <= -1e21 || x >= 1e21) { |
| return String(x); |
| } |
| |
| s = ''; |
| |
| if (x < 0) { |
| s = '-'; |
| x = -x; |
| } |
| |
| m = '0'; |
| |
| if (x > 1e-21) { |
| // 1e-21 < x < 1e21 |
| // -70 < log2(x) < 70 |
| e = toFixedHelpers.log(x * toFixedHelpers.pow(2, 69, 1)) - 69; |
| z = (e < 0 ? x * toFixedHelpers.pow(2, -e, 1) : x / toFixedHelpers.pow(2, e, 1)); |
| z *= 0x10000000000000; // Math.pow(2, 52); |
| e = 52 - e; |
| |
| // -18 < e < 122 |
| // x = z / 2 ^ e |
| if (e > 0) { |
| toFixedHelpers.multiply(0, z); |
| j = f; |
| |
| while (j >= 7) { |
| toFixedHelpers.multiply(1e7, 0); |
| j -= 7; |
| } |
| |
| toFixedHelpers.multiply(toFixedHelpers.pow(10, j, 1), 0); |
| j = e - 1; |
| |
| while (j >= 23) { |
| toFixedHelpers.divide(1 << 23); |
| j -= 23; |
| } |
| |
| toFixedHelpers.divide(1 << j); |
| toFixedHelpers.multiply(1, 1); |
| toFixedHelpers.divide(2); |
| m = toFixedHelpers.numToString(); |
| } else { |
| toFixedHelpers.multiply(0, z); |
| toFixedHelpers.multiply(1 << (-e), 0); |
| m = toFixedHelpers.numToString() + '0.00000000000000000000'.slice(2, 2 + f); |
| } |
| } |
| |
| if (f > 0) { |
| k = m.length; |
| |
| if (k <= f) { |
| m = s + '0.0000000000000000000'.slice(0, f - k + 2) + m; |
| } else { |
| m = s + m.slice(0, k - f) + '.' + m.slice(k - f); |
| } |
| } else { |
| m = s + m; |
| } |
| |
| return m; |
| } |
| }, hasToFixedBugs); |
| |
| |
| // |
| // String |
| // ====== |
| // |
| |
| // ES5 15.5.4.14 |
| // http://es5.github.com/#x15.5.4.14 |
| |
| // [bugfix, IE lt 9, firefox 4, Konqueror, Opera, obscure browsers] |
| // Many browsers do not split properly with regular expressions or they |
| // do not perform the split correctly under obscure conditions. |
| // See http://blog.stevenlevithan.com/archives/cross-browser-split |
| // I've tested in many browsers and this seems to cover the deviant ones: |
| // 'ab'.split(/(?:ab)*/) should be ["", ""], not [""] |
| // '.'.split(/(.?)(.?)/) should be ["", ".", "", ""], not ["", ""] |
| // 'tesst'.split(/(s)*/) should be ["t", undefined, "e", "s", "t"], not |
| // [undefined, "t", undefined, "e", ...] |
| // ''.split(/.?/) should be [], not [""] |
| // '.'.split(/()()/) should be ["."], not ["", "", "."] |
| |
| var string_split = StringPrototype.split; |
| if ( |
| 'ab'.split(/(?:ab)*/).length !== 2 || |
| '.'.split(/(.?)(.?)/).length !== 4 || |
| 'tesst'.split(/(s)*/)[1] === 't' || |
| 'test'.split(/(?:)/, -1).length !== 4 || |
| ''.split(/.?/).length || |
| '.'.split(/()()/).length > 1 |
| ) { |
| (function () { |
| var compliantExecNpcg = /()??/.exec('')[1] === void 0; // NPCG: nonparticipating capturing group |
| |
| StringPrototype.split = function (separator, limit) { |
| var string = this; |
| if (separator === void 0 && limit === 0) { |
| return []; |
| } |
| |
| // If `separator` is not a regex, use native split |
| if (_toString.call(separator) !== '[object RegExp]') { |
| return string_split.call(this, separator, limit); |
| } |
| |
| var output = [], |
| flags = (separator.ignoreCase ? 'i' : '') + |
| (separator.multiline ? 'm' : '') + |
| (separator.extended ? 'x' : '') + // Proposed for ES6 |
| (separator.sticky ? 'y' : ''), // Firefox 3+ |
| lastLastIndex = 0, |
| // Make `global` and avoid `lastIndex` issues by working with a copy |
| separator2, match, lastIndex, lastLength; |
| separator = new RegExp(separator.source, flags + 'g'); |
| string += ''; // Type-convert |
| if (!compliantExecNpcg) { |
| // Doesn't need flags gy, but they don't hurt |
| separator2 = new RegExp('^' + separator.source + '$(?!\\s)', flags); |
| } |
| /* Values for `limit`, per the spec: |
| * If undefined: 4294967295 // Math.pow(2, 32) - 1 |
| * If 0, Infinity, or NaN: 0 |
| * If positive number: limit = Math.floor(limit); if (limit > 4294967295) limit -= 4294967296; |
| * If negative number: 4294967296 - Math.floor(Math.abs(limit)) |
| * If other: Type-convert, then use the above rules |
| */ |
| limit = limit === void 0 ? |
| -1 >>> 0 : // Math.pow(2, 32) - 1 |
| ToUint32(limit); |
| while (match = separator.exec(string)) { |
| // `separator.lastIndex` is not reliable cross-browser |
| lastIndex = match.index + match[0].length; |
| if (lastIndex > lastLastIndex) { |
| output.push(string.slice(lastLastIndex, match.index)); |
| // Fix browsers whose `exec` methods don't consistently return `undefined` for |
| // nonparticipating capturing groups |
| if (!compliantExecNpcg && match.length > 1) { |
| match[0].replace(separator2, function () { |
| for (var i = 1; i < arguments.length - 2; i++) { |
| if (arguments[i] === void 0) { |
| match[i] = void 0; |
| } |
| } |
| }); |
| } |
| if (match.length > 1 && match.index < string.length) { |
| ArrayPrototype.push.apply(output, match.slice(1)); |
| } |
| lastLength = match[0].length; |
| lastLastIndex = lastIndex; |
| if (output.length >= limit) { |
| break; |
| } |
| } |
| if (separator.lastIndex === match.index) { |
| separator.lastIndex++; // Avoid an infinite loop |
| } |
| } |
| if (lastLastIndex === string.length) { |
| if (lastLength || !separator.test('')) { |
| output.push(''); |
| } |
| } else { |
| output.push(string.slice(lastLastIndex)); |
| } |
| return output.length > limit ? output.slice(0, limit) : output; |
| }; |
| }()); |
| |
| // [bugfix, chrome] |
| // If separator is undefined, then the result array contains just one String, |
| // which is the this value (converted to a String). If limit is not undefined, |
| // then the output array is truncated so that it contains no more than limit |
| // elements. |
| // "0".split(undefined, 0) -> [] |
| } else if ('0'.split(void 0, 0).length) { |
| StringPrototype.split = function split(separator, limit) { |
| if (separator === void 0 && limit === 0) { return []; } |
| return string_split.call(this, separator, limit); |
| }; |
| } |
| |
| var str_replace = StringPrototype.replace; |
| var replaceReportsGroupsCorrectly = (function () { |
| var groups = []; |
| 'x'.replace(/x(.)?/g, function (match, group) { |
| groups.push(group); |
| }); |
| return groups.length === 1 && typeof groups[0] === 'undefined'; |
| }()); |
| |
| if (!replaceReportsGroupsCorrectly) { |
| StringPrototype.replace = function replace(searchValue, replaceValue) { |
| var isFn = isFunction(replaceValue); |
| var hasCapturingGroups = isRegex(searchValue) && (/\)[*?]/).test(searchValue.source); |
| if (!isFn || !hasCapturingGroups) { |
| return str_replace.call(this, searchValue, replaceValue); |
| } else { |
| var wrappedReplaceValue = function (match) { |
| var length = arguments.length; |
| var originalLastIndex = searchValue.lastIndex; |
| searchValue.lastIndex = 0; |
| var args = searchValue.exec(match) || []; |
| searchValue.lastIndex = originalLastIndex; |
| args.push(arguments[length - 2], arguments[length - 1]); |
| return replaceValue.apply(this, args); |
| }; |
| return str_replace.call(this, searchValue, wrappedReplaceValue); |
| } |
| }; |
| } |
| |
| // ECMA-262, 3rd B.2.3 |
| // Not an ECMAScript standard, although ECMAScript 3rd Edition has a |
| // non-normative section suggesting uniform semantics and it should be |
| // normalized across all browsers |
| // [bugfix, IE lt 9] IE < 9 substr() with negative value not working in IE |
| var string_substr = StringPrototype.substr; |
| var hasNegativeSubstrBug = ''.substr && '0b'.substr(-1) !== 'b'; |
| defineProperties(StringPrototype, { |
| substr: function substr(start, length) { |
| return string_substr.call( |
| this, |
| start < 0 ? ((start = this.length + start) < 0 ? 0 : start) : start, |
| length |
| ); |
| } |
| }, hasNegativeSubstrBug); |
| |
| // ES5 15.5.4.20 |
| // whitespace from: http://es5.github.io/#x15.5.4.20 |
| var ws = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' + |
| '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028' + |
| '\u2029\uFEFF'; |
| var zeroWidth = '\u200b'; |
| var wsRegexChars = '[' + ws + ']'; |
| var trimBeginRegexp = new RegExp('^' + wsRegexChars + wsRegexChars + '*'); |
| var trimEndRegexp = new RegExp(wsRegexChars + wsRegexChars + '*$'); |
| var hasTrimWhitespaceBug = StringPrototype.trim && (ws.trim() || !zeroWidth.trim()); |
| defineProperties(StringPrototype, { |
| // http://blog.stevenlevithan.com/archives/faster-trim-javascript |
| // http://perfectionkills.com/whitespace-deviations/ |
| trim: function trim() { |
| if (this === void 0 || this === null) { |
| throw new TypeError("can't convert " + this + ' to object'); |
| } |
| return String(this).replace(trimBeginRegexp, '').replace(trimEndRegexp, ''); |
| } |
| }, hasTrimWhitespaceBug); |
| |
| // ES-5 15.1.2.2 |
| if (parseInt(ws + '08') !== 8 || parseInt(ws + '0x16') !== 22) { |
| parseInt = (function (origParseInt) { |
| var hexRegex = /^0[xX]/; |
| return function parseIntES5(str, radix) { |
| str = String(str).trim(); |
| if (!Number(radix)) { |
| radix = hexRegex.test(str) ? 16 : 10; |
| } |
| return origParseInt(str, radix); |
| }; |
| }(parseInt)); |
| } |
| |
| })); |