vendor/assets/javascripts/webshims/shims/es5.js in webshims-rails-1.15.3 vs vendor/assets/javascripts/webshims/shims/es5.js in webshims-rails-1.15.4

@@ -14,97 +14,204 @@
 	 * 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 call = Function.prototype.call;
-	var prototypeOfArray = Array.prototype;
-	var prototypeOfObject = Object.prototype;
-	var _Array_slice_ = prototypeOfArray.slice;
-	var array_splice = Array.prototype.splice;
-	var array_push = Array.prototype.push;
-	var array_unshift = Array.prototype.unshift;
+	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 = prototypeOfObject.toString;
+	var _toString = ObjectPrototype.toString;
 
 	var isFunction = function (val) {
-		return prototypeOfObject.toString.call(val) === '[object Function]';
+		return ObjectPrototype.toString.call(val) === '[object Function]';
 	};
 	var isRegex = function (val) {
-		return prototypeOfObject.toString.call(val) === '[object RegExp]';
+		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(str)
-				&& value !== null
-				&& typeof value === 'object'
-				&& typeof value.length === 'number'
-				&& value.length >= 0
-				&& isFunction(value.callee);
+			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(n) {
+		n = +n;
+		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() {}
 
-	if (!Function.prototype.bind) {
-		Function.prototype.bind = function bind(that) { // .length is 1
+	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.
+			//   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
+			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.
+			//   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.
+			//   15.3.4.5.1.
 			// 13. Set the [[Construct]] internal property of F as described in
-			// 15.3.4.5.2.
+			//   15.3.4.5.2.
 			// 14. Set the [[HasInstance]] internal property of F as described in
-			// 15.3.4.5.3.
+			//   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.
+					//   internal property.
 					// 2. If target has no [[Construct]] internal method, a
-					// TypeError exception is thrown.
+					//   TypeError exception is thrown.
 					// 3. Let boundArgs be the value of F's [[BoundArgs]] internal
-					// property.
+					//   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.
+					//   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.
+					//   method of target providing args as the arguments.
 
 					var result = target.apply(
 						this,
-						args.concat(_Array_slice_.call(arguments))
+						args.concat(array_slice.call(arguments))
 					);
 					if (Object(result) === result) {
 						return result;
 					}
 					return this;
@@ -114,42 +221,42 @@
 					// 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.
+					//   property.
 					// 2. Let boundThis be the value of F's [[BoundThis]] internal
-					// property.
+					//   property.
 					// 3. Let target be the value of F's [[TargetFunction]] internal
-					// property.
+					//   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.
+					//   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.
+					//   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))
+						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.
+			//     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.
+			//   specified in 15.3.5.1.
 			var boundArgs = [];
 			for (var i = 0; i < boundLength; i++) {
 				boundArgs.push("$" + i);
 			}
 
@@ -172,110 +279,115 @@
 			// 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.
+			//   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.
+			//   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(prototypeOfObject.hasOwnProperty);
+	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(prototypeOfObject, "__defineGetter__"))) {
-		defineGetter = call.bind(prototypeOfObject.__defineGetter__);
-		defineSetter = call.bind(prototypeOfObject.__defineSetter__);
-		lookupGetter = call.bind(prototypeOfObject.__lookupGetter__);
-		lookupSetter = call.bind(prototypeOfObject.__lookupSetter__);
+	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 spliceWorksWithEmptyObject = (function () {
-		var obj = {};
-		Array.prototype.splice.call(obj, 0, 0, 1);
-		return obj.length === 1;
-	}());
-	var omittingSecondSpliceArgIsNoop = [1].splice(0).length === 0;
 	var spliceNoopReturnsEmptyArray = (function () {
 		var a = [1, 2];
 		var result = a.splice();
 		return a.length === 2 && isArray(result) && result.length === 0;
 	}());
-	if (spliceNoopReturnsEmptyArray) {
-		// Safari 5.0 bug where .split() returns undefined
-		Array.prototype.splice = function splice(start, deleteCount) {
+	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 []; }
-			else { return array_splice.apply(this, arguments); }
-		};
-	}
-	if (!omittingSecondSpliceArgIsNoop || !spliceWorksWithEmptyObject) {
-		Array.prototype.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(toInteger(deleteCount)); }
-				else { args[1] = toInteger(deleteCount); }
+				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"
-	if ([].unshift(0) !== 1) {
-		Array.prototype.unshift = function () {
+	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
-	if (!Array.isArray) {
-		Array.isArray = 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
+// 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.
@@ -304,16 +416,14 @@
 			}, 'x');
 		}
 		return !!method && properlyBoxesNonStrict && properlyBoxesStrict;
 	};
 
-	if (!Array.prototype.forEach || !properlyBoxesContext(Array.prototype.forEach)) {
-		Array.prototype.forEach = function forEach(fun /*, thisp*/) {
+	defineProperties(ArrayPrototype, {
+		forEach: function forEach(fun /*, thisp*/) {
 			var object = toObject(this),
-				self = splitString && _toString.call(this) === "[object String]" ?
-					this.split("") :
-					object,
+				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
@@ -327,22 +437,20 @@
 					// 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
-	if (!Array.prototype.map || !properlyBoxesContext(Array.prototype.map)) {
-		Array.prototype.map = function map(fun /*, thisp*/) {
+	defineProperties(ArrayPrototype, {
+		map: function map(fun /*, thisp*/) {
 			var object = toObject(this),
-				self = splitString && _toString.call(this) === "[object String]" ?
-					this.split("") :
-					object,
+				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
@@ -354,22 +462,20 @@
 				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
-	if (!Array.prototype.filter || !properlyBoxesContext(Array.prototype.filter)) {
-		Array.prototype.filter = function filter(fun /*, thisp */) {
+	defineProperties(ArrayPrototype, {
+		filter: function filter(fun /*, thisp */) {
 			var object = toObject(this),
-				self = splitString && _toString.call(this) === "[object String]" ?
-					this.split("") :
-					object,
+				self = splitString && isString(this) ? this.split('') : object,
 				length = self.length >>> 0,
 				result = [],
 				value,
 				thisp = arguments[1];
 
@@ -385,22 +491,20 @@
 						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
-	if (!Array.prototype.every || !properlyBoxesContext(Array.prototype.every)) {
-		Array.prototype.every = function every(fun /*, thisp */) {
+	defineProperties(ArrayPrototype, {
+		every: function every(fun /*, thisp */) {
 			var object = toObject(this),
-				self = splitString && _toString.call(this) === "[object String]" ?
-					this.split("") :
-					object,
+				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)) {
@@ -411,22 +515,20 @@
 				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
-	if (!Array.prototype.some || !properlyBoxesContext(Array.prototype.some)) {
-		Array.prototype.some = function some(fun /*, thisp */) {
+	defineProperties(ArrayPrototype, {
+		some: function some(fun /*, thisp */) {
 			var object = toObject(this),
-				self = splitString && _toString.call(this) === "[object String]" ?
-					this.split("") :
-					object,
+				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)) {
@@ -437,26 +539,24 @@
 				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 (Array.prototype.reduce) {
-		reduceCoercesToObject = typeof Array.prototype.reduce.call('es5', function (_, __, ___, list) { return list; }) === 'object';
+	if (ArrayPrototype.reduce) {
+		reduceCoercesToObject = typeof ArrayPrototype.reduce.call('es5', function (_, __, ___, list) { return list; }) === 'object';
 	}
-	if (!Array.prototype.reduce || !reduceCoercesToObject) {
-		Array.prototype.reduce = function reduce(fun /*, initial*/) {
+	defineProperties(ArrayPrototype, {
+		reduce: function reduce(fun /*, initial*/) {
 			var object = toObject(this),
-				self = splitString && _toString.call(this) === "[object String]" ?
-					this.split("") :
-					object,
+				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");
@@ -490,26 +590,24 @@
 					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 (Array.prototype.reduceRight) {
-		reduceRightCoercesToObject = typeof Array.prototype.reduceRight.call('es5', function (_, __, ___, list) { return list; }) === 'object';
+	if (ArrayPrototype.reduceRight) {
+		reduceRightCoercesToObject = typeof ArrayPrototype.reduceRight.call('es5', function (_, __, ___, list) { return list; }) === 'object';
 	}
-	if (!Array.prototype.reduceRight || !reduceRightCoercesToObject) {
-		Array.prototype.reduceRight = function reduceRight(fun /*, initial*/) {
+	defineProperties(ArrayPrototype, {
+		reduceRight: function reduceRight(fun /*, initial*/) {
 			var object = toObject(this),
-				self = splitString && _toString.call(this) === "[object String]" ?
-					this.split("") :
-					object,
+				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");
@@ -546,21 +644,20 @@
 					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
-	if (!Array.prototype.indexOf || ([0, 1].indexOf(1, 2) !== -1)) {
-		Array.prototype.indexOf = function indexOf(sought /*, fromIndex */ ) {
-			var self = splitString && _toString.call(this) === "[object String]" ?
-					this.split("") :
-					toObject(this),
+	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;
 			}
@@ -576,21 +673,20 @@
 				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
-	if (!Array.prototype.lastIndexOf || ([0, 1].lastIndexOf(0, -3) !== -1)) {
-		Array.prototype.lastIndexOf = function lastIndexOf(sought /*, fromIndex */) {
-			var self = splitString && _toString.call(this) === "[object String]" ?
-					this.split("") :
-					toObject(this),
+	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;
 			}
@@ -604,51 +700,49 @@
 				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
-	var keysWorksWithArguments = Object.keys && (function () {
-		return Object.keys(arguments).length === 2;
-	}(1, 2));
-	if (!Object.keys) {
-		// 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;
 
-		Object.keys = function keys(object) {
+// 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',
-				isString = isObject && _toString.call(object) === '[object String]';
+				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 (isString || isArgs) {
+			if (isStr || isArgs) {
 				for (var i = 0; i < object.length; ++i) {
 					theKeys.push(String(i));
 				}
 			} else {
 				for (var name in object) {
@@ -667,22 +761,27 @@
 						theKeys.push(dontEnum);
 					}
 				}
 			}
 			return theKeys;
-		};
-	} else if (!keysWorksWithArguments) {
-		// Safari 5.0 bug
-		var originalKeys = Object.keys;
-		Object.keys = function keys(object) {
+		}
+	});
+
+	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(Array.prototype.slice.call(object));
+				return originalKeys(ArrayPrototype.slice.call(object));
 			} else {
 				return originalKeys(object);
 			}
-		};
-	}
+		}
+	}, !keysWorksWithArguments);
 
 //
 // Date
 // ====
 //
@@ -692,17 +791,16 @@
 // 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,
-		negativeYearString = "-000001";
-	if (
-		!Date.prototype.toISOString ||
-			(new Date(negativeDate).toISOString().indexOf(negativeYearString) === -1)
-		) {
-		Date.prototype.toISOString = function toISOString() {
+	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.");
 			}
 
@@ -714,13 +812,13 @@
 			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)
-				);
+			(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
@@ -729,42 +827,42 @@
 					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"
-				);
-		};
-	}
+			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;
-					}
-				})
-			);
+		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
+			// 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;
@@ -778,11 +876,11 @@
 			// 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.
+			//  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
@@ -830,44 +928,44 @@
 				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
-				")" +
-				")?)?)?)?" +
-				"$");
+			"(\\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)
-					);
+				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));
 			}
@@ -907,29 +1005,29 @@
 						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)
-								)
-						) {
+						) &&
+						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;
+						(dayFromMonth(year, month) + day) * 24 +
+						hour +
+						hourOffset * signOffset
+						) * 60;
 						result = (
-							(result + minute + minuteOffset * signOffset) * 60 +
-								second
-							) * 1000 + millisecond;
+						(result + minute + minuteOffset * signOffset) * 60 +
+						second
+						) * 1000 + millisecond;
 						if (isLocalTime) {
 							result = toUTC(result);
 						}
 						if (-8.64e15 <= result && result <= 8.64e15) {
 							return result;
@@ -958,156 +1056,155 @@
 // ======
 //
 
 // ES5.1 15.7.4.5
 // http://es5.github.com/#x15.7.4.5
-	if (!Number.prototype.toFixed || (0.00008).toFixed(3) !== '0.000' || (0.9).toFixed(0) === '0' || (1.255).toFixed(2) !== '1.25' || (1000000000000000128).toFixed(0) !== "1000000000000000128") {
-		// Hide these variables and functions
-		(function () {
-			var base, size, data, i;
+	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"
+		);
 
-			base = 1e7;
-			size = 6;
-			data = [0, 0, 0, 0, 0, 0];
-
-			function multiply(n, c) {
-				var i = -1;
-				while (++i < size) {
-					c += n * data[i];
-					data[i] = c % base;
-					c = Math.floor(c / base);
-				}
+	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);
 			}
-
-			function divide(n) {
-				var i = size, c = 0;
-				while (--i >= 0) {
-					c += data[i];
-					data[i] = Math.floor(c / n);
-					c = (c % n) * 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;
 			}
-
-			function numToString() {
-				var i = size;
-				var s = '';
-				while (--i >= 0) {
-					if (s !== '' || i === 0 || data[i] !== 0) {
-						var t = String(data[i]);
-						if (s === '') {
-							s = t;
-						} else {
-							s += '0000000'.slice(0, 7 - t.length) + t;
-						}
+		},
+		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;
 			}
-
-			function pow(x, n, acc) {
-				return (n === 0 ? acc : (n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc)));
+			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;
 			}
-
-			function log(x) {
-				var n = 0;
-				while (x >= 4096) {
-					n += 12;
-					x /= 4096;
-				}
-				while (x >= 2) {
-					n += 1;
-					x /= 2;
-				}
-				return n;
+			while (x >= 2) {
+				n += 1;
+				x /= 2;
 			}
+			return n;
+		}
+	};
 
-			Number.prototype.toFixed = function toFixed(fractionDigits) {
-				var f, x, s, m, e, z, j, k;
+	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);
+			// 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");
-				}
+			if (f < 0 || f > 20) {
+				throw new RangeError("Number.toFixed called with invalid number of decimals");
+			}
 
-				x = Number(this);
+			x = Number(this);
 
-				// Test for NaN
-				if (x !== x) {
-					return "NaN";
-				}
+			// 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);
-				}
+			// If it is too big or small, return the string value of the number
+			if (x <= -1e21 || x >= 1e21) {
+				return String(x);
+			}
 
-				s = "";
+			s = "";
 
-				if (x < 0) {
-					s = "-";
-					x = -x;
-				}
+			if (x < 0) {
+				s = "-";
+				x = -x;
+			}
 
-				m = "0";
+			m = "0";
 
-				if (x > 1e-21) {
-					// 1e-21 < x < 1e21
-					// -70 < log2(x) < 70
-					e = log(x * pow(2, 69, 1)) - 69;
-					z = (e < 0 ? x * pow(2, -e, 1) : x / pow(2, e, 1));
-					z *= 0x10000000000000; // Math.pow(2, 52);
-					e = 52 - e;
+			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) {
-						multiply(0, z);
-						j = f;
+				// -18 < e < 122
+				// x = z / 2 ^ e
+				if (e > 0) {
+					toFixedHelpers.multiply(0, z);
+					j = f;
 
-						while (j >= 7) {
-							multiply(1e7, 0);
-							j -= 7;
-						}
+					while (j >= 7) {
+						toFixedHelpers.multiply(1e7, 0);
+						j -= 7;
+					}
 
-						multiply(pow(10, j, 1), 0);
-						j = e - 1;
+					toFixedHelpers.multiply(toFixedHelpers.pow(10, j, 1), 0);
+					j = e - 1;
 
-						while (j >= 23) {
-							divide(1 << 23);
-							j -= 23;
-						}
-
-						divide(1 << j);
-						multiply(1, 1);
-						divide(2);
-						m = numToString();
-					} else {
-						multiply(0, z);
-						multiply(1 << (-e), 0);
-						m = numToString() + '0.00000000000000000000'.slice(2, 2 + f);
+					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 (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);
-					}
+				if (k <= f) {
+					m = s + '0.0000000000000000000'.slice(0, f - k + 2) + m;
 				} else {
-					m = s + m;
+					m = s + m.slice(0, k - f) + '.' + m.slice(k - f);
 				}
+			} else {
+				m = s + m;
+			}
 
-				return m;
-			};
-		}());
-	}
+			return m;
+		}
+	}, hasToFixedBugs);
 
 
 //
 // String
 // ======
@@ -1119,30 +1216,30 @@
 // [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 ["", "", "."]
+//    '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 = String.prototype.split;
+	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
-		) {
+		'.'.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
 
-			String.prototype.split = function (separator, limit) {
+			StringPrototype.split = function (separator, limit) {
 				var string = this;
 				if (separator === void 0 && limit === 0) {
 					return [];
 				}
 
@@ -1151,13 +1248,13 @@
 					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+
+						(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
@@ -1171,11 +1268,11 @@
 				 * 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
+				-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) {
@@ -1190,11 +1287,11 @@
 									}
 								}
 							});
 						}
 						if (match.length > 1 && match.index < string.length) {
-							Array.prototype.push.apply(output, match.slice(1));
+							ArrayPrototype.push.apply(output, match.slice(1));
 						}
 						lastLength = match[0].length;
 						lastLastIndex = lastIndex;
 						if (output.length >= limit) {
 							break;
@@ -1220,27 +1317,27 @@
 // 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) {
-		String.prototype.split = function split(separator, limit) {
+		StringPrototype.split = function split(separator, limit) {
 			if (separator === void 0 && limit === 0) { return []; }
 			return string_split.call(this, separator, limit);
 		};
 	}
 
-	var str_replace = String.prototype.replace;
+	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) {
-		String.prototype.replace = function replace(searchValue, replaceValue) {
+		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 {
@@ -1261,48 +1358,42 @@
 // 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
-	if ("".substr && "0b".substr(-1) !== "b") {
-		var string_substr = String.prototype.substr;
-		/**
-		 * Get the substring of a string
-		 * @param {integer} start where to start the substring
-		 * @param {integer} length how many characters to return
-		 * @return {string}
-		 */
-		String.prototype.substr = function substr(start, length) {
+	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';
-	if (!String.prototype.trim || ws.trim() || !zeroWidth.trim()) {
+	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/
-		ws = "[" + ws + "]";
-		var trimBeginRegexp = new RegExp("^" + ws + ws + "*"),
-			trimEndRegexp = new RegExp(ws + ws + "*$");
-		String.prototype.trim = function trim() {
+		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, "");
-		};
-	}
+			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]/;
@@ -1313,74 +1404,9 @@
 				}
 				return origParseInt(str, radix);
 			};
 		}(parseInt));
 	}
-
-//
-// Util
-// ======
-//
-
-// ES5 9.4
-// http://es5.github.com/#x9.4
-// http://jsperf.com/to-integer
-
-	function toInteger(n) {
-		n = +n;
-		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;
-	};
 
 })();