/*!

* 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) {

'use strict';

/*global define, exports, module */

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 to_string.

var to_string = ObjectPrototype.toString;

var isArray = Array.isArray || function isArray(obj) {

return to_string.call(obj) === '[object Array]';

};

var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';

var isCallable; /* inlined from https://npmjs.com/is-callable */ var fnToStr = Function.prototype.toString, tryFunctionObject = function tryFunctionObject(value) { try { fnToStr.call(value); return true; } catch (e) { return false; } }, fnClass = '[object Function]', genClass = '[object GeneratorFunction]'; isCallable = function isCallable(value) { if (typeof value !== 'function') { return false; } if (hasToStringTag) { return tryFunctionObject(value); } var strClass = to_string.call(value); return strClass === fnClass || strClass === genClass; };

var isRegex; /* inlined from https://npmjs.com/is-regex */ var regexExec = RegExp.prototype.exec, tryRegexExec = function tryRegexExec(value) { try { regexExec.call(value); return true; } catch (e) { return false; } }, regexClass = '[object RegExp]'; isRegex = function isRegex(value) { if (typeof value !== 'object') { return false; } return hasToStringTag ? tryRegexExec(value) : to_string.call(value) === regexClass; };

var isString; /* inlined from https://npmjs.com/is-string */ var strValue = String.prototype.valueOf, tryStringObject = function tryStringObject(value) { try { strValue.call(value); return true; } catch (e) { return false; } }, stringClass = '[object String]'; isString = function isString(value) { if (typeof value === 'string') { return true; } if (typeof value !== 'object') { return false; } return hasToStringTag ? tryStringObject(value) : to_string.call(value) === stringClass; };

var isArguments = function isArguments(value) {

};

/* inlined from http://npmjs.com/define-properties */

var defineProperties = (function (has) {

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) {

};

} else {

defineProperty = function (object, name, method, forceAssign) {

if (!forceAssign && (name in object)) { return; }

object[name] = method;

};

}

return function defineProperties(object, map, forceAssign) {

};

}(ObjectPrototype.hasOwnProperty));

//

// Util

// ======

//

/* replaceable with https://npmjs.com/package/es-abstract /helpers/isPrimitive */

function isPrimitive(input) {

}

var ES = {

// ES5 9.4

// http://es5.github.com/#x9.4

// http://jsperf.com/to-integer

/* replaceable with https://npmjs.com/package/es-abstract ES5.ToInteger */

ToInteger: function ToInteger(num) {

},

/* replaceable with https://npmjs.com/package/es-abstract ES5.ToPrimitive */

ToPrimitive: function ToPrimitive(input) {

},

// ES5 9.9

// http://es5.github.com/#x9.9

/* replaceable with https://npmjs.com/package/es-abstract ES5.ToObject */

ToObject: function (o) {

},

/* replaceable with https://npmjs.com/package/es-abstract ES5.ToUint32 */

ToUint32: function ToUint32(x) {

return x >>> 0;

}

};

//

// Function

// ========

//

// ES-5 15.3.4.5

// http://es5.github.com/#x15.3.4.5

var Empty = function Empty() {};

defineProperties(FunctionPrototype, {

bind: function bind(that) { // .length is 1

}

});

// _Please note: Shortcuts are defined after `Function.prototype.bind` as we

// us it in defining shortcuts.

var owns = call.bind(ObjectPrototype.hasOwnProperty);

//

// 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) {

}

}, !spliceNoopReturnsEmptyArray);

var spliceWorksWithEmptyObject = (function () {

var obj = {};

ArrayPrototype.splice.call(obj, 0, 0, 1);

return obj.length === 1;

}());

defineProperties(ArrayPrototype, {

splice: function splice(start, deleteCount) {

}

}, !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) {

};

defineProperties(ArrayPrototype, {

forEach: function forEach(fun /*, thisp*/) {

}

}, !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*/) {

}

}, !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 */) {

}

}, !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 */) {

}

}, !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 */) {

}

}, !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*/) {

}

}, !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*/) {

}

}, !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 */) {

}

}, 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 */) {

}

}, 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'),

hasStringEnumBug = !owns('x', '0'),

dontEnums = [

'toString',

'toLocaleString',

'valueOf',

'hasOwnProperty',

'isPrototypeOf',

'propertyIsEnumerable',

'constructor'

],

dontEnumsLength = dontEnums.length;

defineProperties(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) {

}

}, !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() {

}

}, 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) {

};

}

// 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.

/*global Date: true */

/*eslint-disable no-undef*/

Date = (function (NativeDate) {

/*eslint-enable no-undef*/

// Date.length === 7

function Date(Y, M, D, h, m, s, ms) {

}

// 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) {

}

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;