561 lines
22 KiB
JavaScript
561 lines
22 KiB
JavaScript
/*!
|
|
* https://github.com/es-shims/es5-shim
|
|
* @license es5-shim Copyright 2009-2015 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/templates/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 () {
|
|
|
|
var call = Function.call;
|
|
var prototypeOfObject = Object.prototype;
|
|
var owns = call.bind(prototypeOfObject.hasOwnProperty);
|
|
var isEnumerable = call.bind(prototypeOfObject.propertyIsEnumerable);
|
|
var toStr = call.bind(prototypeOfObject.toString);
|
|
|
|
// If JS engine supports accessors creating shortcuts.
|
|
var defineGetter;
|
|
var defineSetter;
|
|
var lookupGetter;
|
|
var lookupSetter;
|
|
var supportsAccessors = owns(prototypeOfObject, '__defineGetter__');
|
|
if (supportsAccessors) {
|
|
/* eslint-disable no-underscore-dangle, no-restricted-properties */
|
|
defineGetter = call.bind(prototypeOfObject.__defineGetter__);
|
|
defineSetter = call.bind(prototypeOfObject.__defineSetter__);
|
|
lookupGetter = call.bind(prototypeOfObject.__lookupGetter__);
|
|
lookupSetter = call.bind(prototypeOfObject.__lookupSetter__);
|
|
/* eslint-enable no-underscore-dangle, no-restricted-properties */
|
|
}
|
|
|
|
var isPrimitive = function isPrimitive(o) {
|
|
return o == null || (typeof o !== 'object' && typeof o !== 'function');
|
|
};
|
|
|
|
// ES5 15.2.3.2
|
|
// http://es5.github.com/#x15.2.3.2
|
|
if (!Object.getPrototypeOf) {
|
|
// https://github.com/es-shims/es5-shim/issues#issue/2
|
|
// http://ejohn.org/blog/objectgetprototypeof/
|
|
// recommended by fschaefer on github
|
|
//
|
|
// sure, and webreflection says ^_^
|
|
// ... this will nerever possibly return null
|
|
// ... Opera Mini breaks here with infinite loops
|
|
Object.getPrototypeOf = function getPrototypeOf(object) {
|
|
// eslint-disable-next-line no-proto
|
|
var proto = object.__proto__;
|
|
if (proto || proto === null) {
|
|
return proto;
|
|
} else if (toStr(object.constructor) === '[object Function]') {
|
|
return object.constructor.prototype;
|
|
} else if (object instanceof Object) {
|
|
return prototypeOfObject;
|
|
} else {
|
|
// Correctly return null for Objects created with `Object.create(null)`
|
|
// (shammed or native) or `{ __proto__: null}`. Also returns null for
|
|
// cross-realm objects on browsers that lack `__proto__` support (like
|
|
// IE <11), but that's the best we can do.
|
|
return null;
|
|
}
|
|
};
|
|
}
|
|
|
|
// ES5 15.2.3.3
|
|
// http://es5.github.com/#x15.2.3.3
|
|
|
|
var doesGetOwnPropertyDescriptorWork = function doesGetOwnPropertyDescriptorWork(object) {
|
|
try {
|
|
object.sentinel = 0;
|
|
return Object.getOwnPropertyDescriptor(object, 'sentinel').value === 0;
|
|
} catch (exception) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// check whether getOwnPropertyDescriptor works if it's given. Otherwise, shim partially.
|
|
if (Object.defineProperty) {
|
|
var getOwnPropertyDescriptorWorksOnObject = doesGetOwnPropertyDescriptorWork({});
|
|
var getOwnPropertyDescriptorWorksOnDom = typeof document === 'undefined'
|
|
|| doesGetOwnPropertyDescriptorWork(document.createElement('div'));
|
|
if (!getOwnPropertyDescriptorWorksOnDom || !getOwnPropertyDescriptorWorksOnObject) {
|
|
var getOwnPropertyDescriptorFallback = Object.getOwnPropertyDescriptor;
|
|
}
|
|
}
|
|
|
|
if (!Object.getOwnPropertyDescriptor || getOwnPropertyDescriptorFallback) {
|
|
var ERR_NON_OBJECT = 'Object.getOwnPropertyDescriptor called on a non-object: ';
|
|
|
|
/* eslint-disable no-proto */
|
|
Object.getOwnPropertyDescriptor = function getOwnPropertyDescriptor(object, property) {
|
|
if (isPrimitive(object)) {
|
|
throw new TypeError(ERR_NON_OBJECT + object);
|
|
}
|
|
|
|
// make a valiant attempt to use the real getOwnPropertyDescriptor
|
|
// for I8's DOM elements.
|
|
if (getOwnPropertyDescriptorFallback) {
|
|
try {
|
|
return getOwnPropertyDescriptorFallback.call(Object, object, property);
|
|
} catch (exception) {
|
|
// try the shim if the real one doesn't work
|
|
}
|
|
}
|
|
|
|
var descriptor;
|
|
|
|
// If object does not owns property return undefined immediately.
|
|
if (!owns(object, property)) {
|
|
return descriptor;
|
|
}
|
|
|
|
// If object has a property then it's for sure `configurable`, and
|
|
// probably `enumerable`. Detect enumerability though.
|
|
descriptor = {
|
|
enumerable: isEnumerable(object, property),
|
|
configurable: true
|
|
};
|
|
|
|
// If JS engine supports accessor properties then property may be a
|
|
// getter or setter.
|
|
if (supportsAccessors) {
|
|
// Unfortunately `__lookupGetter__` will return a getter even
|
|
// if object has own non getter property along with a same named
|
|
// inherited getter. To avoid misbehavior we temporary remove
|
|
// `__proto__` so that `__lookupGetter__` will return getter only
|
|
// if it's owned by an object.
|
|
var prototype = object.__proto__;
|
|
var notPrototypeOfObject = object !== prototypeOfObject;
|
|
// avoid recursion problem, breaking in Opera Mini when
|
|
// Object.getOwnPropertyDescriptor(Object.prototype, 'toString')
|
|
// or any other Object.prototype accessor
|
|
if (notPrototypeOfObject) {
|
|
object.__proto__ = prototypeOfObject;
|
|
}
|
|
|
|
var getter = lookupGetter(object, property);
|
|
var setter = lookupSetter(object, property);
|
|
|
|
if (notPrototypeOfObject) {
|
|
// Once we have getter and setter we can put values back.
|
|
object.__proto__ = prototype;
|
|
}
|
|
|
|
if (getter || setter) {
|
|
if (getter) {
|
|
descriptor.get = getter;
|
|
}
|
|
if (setter) {
|
|
descriptor.set = setter;
|
|
}
|
|
// If it was accessor property we're done and return here
|
|
// in order to avoid adding `value` to the descriptor.
|
|
return descriptor;
|
|
}
|
|
}
|
|
|
|
// If we got this far we know that object has an own property that is
|
|
// not an accessor so we set it as a value and return descriptor.
|
|
descriptor.value = object[property];
|
|
descriptor.writable = true;
|
|
return descriptor;
|
|
};
|
|
/* eslint-enable no-proto */
|
|
}
|
|
|
|
// ES5 15.2.3.4
|
|
// http://es5.github.com/#x15.2.3.4
|
|
if (!Object.getOwnPropertyNames) {
|
|
Object.getOwnPropertyNames = function getOwnPropertyNames(object) {
|
|
return Object.keys(object);
|
|
};
|
|
}
|
|
|
|
// ES5 15.2.3.5
|
|
// http://es5.github.com/#x15.2.3.5
|
|
if (!Object.create) {
|
|
|
|
// Contributed by Brandon Benvie, October, 2012
|
|
var createEmpty;
|
|
var supportsProto = !({ __proto__: null } instanceof Object);
|
|
// the following produces false positives
|
|
// in Opera Mini => not a reliable check
|
|
// Object.prototype.__proto__ === null
|
|
|
|
// Check for document.domain and active x support
|
|
// No need to use active x approach when document.domain is not set
|
|
// see https://github.com/es-shims/es5-shim/issues/150
|
|
// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
|
|
/* global ActiveXObject */
|
|
var shouldUseActiveX = function shouldUseActiveX() {
|
|
// return early if document.domain not set
|
|
if (!document.domain) {
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
return !!new ActiveXObject('htmlfile');
|
|
} catch (exception) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// This supports IE8 when document.domain is used
|
|
// see https://github.com/es-shims/es5-shim/issues/150
|
|
// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
|
|
var getEmptyViaActiveX = function getEmptyViaActiveX() {
|
|
var empty;
|
|
var xDoc;
|
|
|
|
xDoc = new ActiveXObject('htmlfile');
|
|
|
|
var script = 'script';
|
|
xDoc.write('<' + script + '></' + script + '>');
|
|
xDoc.close();
|
|
|
|
empty = xDoc.parentWindow.Object.prototype;
|
|
xDoc = null;
|
|
|
|
return empty;
|
|
};
|
|
|
|
// The original implementation using an iframe
|
|
// before the activex approach was added
|
|
// see https://github.com/es-shims/es5-shim/issues/150
|
|
var getEmptyViaIFrame = function getEmptyViaIFrame() {
|
|
var iframe = document.createElement('iframe');
|
|
var parent = document.body || document.documentElement;
|
|
var empty;
|
|
|
|
iframe.style.display = 'none';
|
|
parent.appendChild(iframe);
|
|
// eslint-disable-next-line no-script-url
|
|
iframe.src = 'javascript:';
|
|
|
|
empty = iframe.contentWindow.Object.prototype;
|
|
parent.removeChild(iframe);
|
|
iframe = null;
|
|
|
|
return empty;
|
|
};
|
|
|
|
/* global document */
|
|
if (supportsProto || typeof document === 'undefined') {
|
|
createEmpty = function () {
|
|
return { __proto__: null };
|
|
};
|
|
} else {
|
|
// In old IE __proto__ can't be used to manually set `null`, nor does
|
|
// any other method exist to make an object that inherits from nothing,
|
|
// aside from Object.prototype itself. Instead, create a new global
|
|
// object and *steal* its Object.prototype and strip it bare. This is
|
|
// used as the prototype to create nullary objects.
|
|
createEmpty = function () {
|
|
// Determine which approach to use
|
|
// see https://github.com/es-shims/es5-shim/issues/150
|
|
var empty = shouldUseActiveX() ? getEmptyViaActiveX() : getEmptyViaIFrame();
|
|
|
|
delete empty.constructor;
|
|
delete empty.hasOwnProperty;
|
|
delete empty.propertyIsEnumerable;
|
|
delete empty.isPrototypeOf;
|
|
delete empty.toLocaleString;
|
|
delete empty.toString;
|
|
delete empty.valueOf;
|
|
|
|
var Empty = function Empty() {};
|
|
Empty.prototype = empty;
|
|
// short-circuit future calls
|
|
createEmpty = function () {
|
|
return new Empty();
|
|
};
|
|
return new Empty();
|
|
};
|
|
}
|
|
|
|
Object.create = function create(prototype, properties) {
|
|
|
|
var object;
|
|
var Type = function Type() {}; // An empty constructor.
|
|
|
|
if (prototype === null) {
|
|
object = createEmpty();
|
|
} else {
|
|
if (prototype !== null && isPrimitive(prototype)) {
|
|
// In the native implementation `parent` can be `null`
|
|
// OR *any* `instanceof Object` (Object|Function|Array|RegExp|etc)
|
|
// Use `typeof` tho, b/c in old IE, DOM elements are not `instanceof Object`
|
|
// like they are in modern browsers. Using `Object.create` on DOM elements
|
|
// is...err...probably inappropriate, but the native version allows for it.
|
|
throw new TypeError('Object prototype may only be an Object or null'); // same msg as Chrome
|
|
}
|
|
Type.prototype = prototype;
|
|
object = new Type();
|
|
// IE has no built-in implementation of `Object.getPrototypeOf`
|
|
// neither `__proto__`, but this manually setting `__proto__` will
|
|
// guarantee that `Object.getPrototypeOf` will work as expected with
|
|
// objects created using `Object.create`
|
|
// eslint-disable-next-line no-proto
|
|
object.__proto__ = prototype;
|
|
}
|
|
|
|
if (properties !== void 0) {
|
|
Object.defineProperties(object, properties);
|
|
}
|
|
|
|
return object;
|
|
};
|
|
}
|
|
|
|
// ES5 15.2.3.6
|
|
// http://es5.github.com/#x15.2.3.6
|
|
|
|
// Patch for WebKit and IE8 standard mode
|
|
// Designed by hax <hax.github.com>
|
|
// related issue: https://github.com/es-shims/es5-shim/issues#issue/5
|
|
// IE8 Reference:
|
|
// http://msdn.microsoft.com/en-us/library/dd282900.aspx
|
|
// http://msdn.microsoft.com/en-us/library/dd229916.aspx
|
|
// WebKit Bugs:
|
|
// https://bugs.webkit.org/show_bug.cgi?id=36423
|
|
|
|
var doesDefinePropertyWork = function doesDefinePropertyWork(object) {
|
|
try {
|
|
Object.defineProperty(object, 'sentinel', {});
|
|
return 'sentinel' in object;
|
|
} catch (exception) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// check whether defineProperty works if it's given. Otherwise,
|
|
// shim partially.
|
|
if (Object.defineProperty) {
|
|
var definePropertyWorksOnObject = doesDefinePropertyWork({});
|
|
var definePropertyWorksOnDom = typeof document === 'undefined'
|
|
|| doesDefinePropertyWork(document.createElement('div'));
|
|
if (!definePropertyWorksOnObject || !definePropertyWorksOnDom) {
|
|
var definePropertyFallback = Object.defineProperty,
|
|
definePropertiesFallback = Object.defineProperties;
|
|
}
|
|
}
|
|
|
|
if (!Object.defineProperty || definePropertyFallback) {
|
|
var ERR_NON_OBJECT_DESCRIPTOR = 'Property description must be an object: ';
|
|
var ERR_NON_OBJECT_TARGET = 'Object.defineProperty called on non-object: ';
|
|
var ERR_ACCESSORS_NOT_SUPPORTED = 'getters & setters can not be defined on this javascript engine';
|
|
|
|
Object.defineProperty = function defineProperty(object, property, descriptor) {
|
|
if (isPrimitive(object)) {
|
|
throw new TypeError(ERR_NON_OBJECT_TARGET + object);
|
|
}
|
|
if (isPrimitive(descriptor)) {
|
|
throw new TypeError(ERR_NON_OBJECT_DESCRIPTOR + descriptor);
|
|
}
|
|
// make a valiant attempt to use the real defineProperty
|
|
// for I8's DOM elements.
|
|
if (definePropertyFallback) {
|
|
try {
|
|
return definePropertyFallback.call(Object, object, property, descriptor);
|
|
} catch (exception) {
|
|
// try the shim if the real one doesn't work
|
|
}
|
|
}
|
|
|
|
// If it's a data property.
|
|
if ('value' in descriptor) {
|
|
// fail silently if 'writable', 'enumerable', or 'configurable'
|
|
// are requested but not supported
|
|
/*
|
|
// alternate approach:
|
|
if ( // can't implement these features; allow false but not true
|
|
('writable' in descriptor && !descriptor.writable) ||
|
|
('enumerable' in descriptor && !descriptor.enumerable) ||
|
|
('configurable' in descriptor && !descriptor.configurable)
|
|
))
|
|
throw new RangeError(
|
|
'This implementation of Object.defineProperty does not support configurable, enumerable, or writable.'
|
|
);
|
|
*/
|
|
|
|
if (supportsAccessors && (lookupGetter(object, property) || lookupSetter(object, property))) {
|
|
// As accessors are supported only on engines implementing
|
|
// `__proto__` we can safely override `__proto__` while defining
|
|
// a property to make sure that we don't hit an inherited
|
|
// accessor.
|
|
/* eslint-disable no-proto */
|
|
var prototype = object.__proto__;
|
|
object.__proto__ = prototypeOfObject;
|
|
// Deleting a property anyway since getter / setter may be
|
|
// defined on object itself.
|
|
delete object[property];
|
|
object[property] = descriptor.value;
|
|
// Setting original `__proto__` back now.
|
|
object.__proto__ = prototype;
|
|
/* eslint-enable no-proto */
|
|
} else {
|
|
object[property] = descriptor.value;
|
|
}
|
|
} else {
|
|
var hasGetter = 'get' in descriptor;
|
|
var hasSetter = 'set' in descriptor;
|
|
if (!supportsAccessors && (hasGetter || hasSetter)) {
|
|
throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
|
|
}
|
|
// If we got that far then getters and setters can be defined !!
|
|
if (hasGetter) {
|
|
defineGetter(object, property, descriptor.get);
|
|
}
|
|
if (hasSetter) {
|
|
defineSetter(object, property, descriptor.set);
|
|
}
|
|
}
|
|
return object;
|
|
};
|
|
}
|
|
|
|
// ES5 15.2.3.7
|
|
// http://es5.github.com/#x15.2.3.7
|
|
if (!Object.defineProperties || definePropertiesFallback) {
|
|
Object.defineProperties = function defineProperties(object, properties) {
|
|
// make a valiant attempt to use the real defineProperties
|
|
if (definePropertiesFallback) {
|
|
try {
|
|
return definePropertiesFallback.call(Object, object, properties);
|
|
} catch (exception) {
|
|
// try the shim if the real one doesn't work
|
|
}
|
|
}
|
|
|
|
Object.keys(properties).forEach(function (property) {
|
|
if (property !== '__proto__') {
|
|
Object.defineProperty(object, property, properties[property]);
|
|
}
|
|
});
|
|
return object;
|
|
};
|
|
}
|
|
|
|
// ES5 15.2.3.8
|
|
// http://es5.github.com/#x15.2.3.8
|
|
if (!Object.seal) {
|
|
Object.seal = function seal(object) {
|
|
if (Object(object) !== object) {
|
|
throw new TypeError('Object.seal can only be called on Objects.');
|
|
}
|
|
// this is misleading and breaks feature-detection, but
|
|
// allows "securable" code to "gracefully" degrade to working
|
|
// but insecure code.
|
|
return object;
|
|
};
|
|
}
|
|
|
|
// ES5 15.2.3.9
|
|
// http://es5.github.com/#x15.2.3.9
|
|
if (!Object.freeze) {
|
|
Object.freeze = function freeze(object) {
|
|
if (Object(object) !== object) {
|
|
throw new TypeError('Object.freeze can only be called on Objects.');
|
|
}
|
|
// this is misleading and breaks feature-detection, but
|
|
// allows "securable" code to "gracefully" degrade to working
|
|
// but insecure code.
|
|
return object;
|
|
};
|
|
}
|
|
|
|
// detect a Rhino bug and patch it
|
|
try {
|
|
Object.freeze(function () {});
|
|
} catch (exception) {
|
|
Object.freeze = (function (freezeObject) {
|
|
return function freeze(object) {
|
|
if (typeof object === 'function') {
|
|
return object;
|
|
} else {
|
|
return freezeObject(object);
|
|
}
|
|
};
|
|
}(Object.freeze));
|
|
}
|
|
|
|
// ES5 15.2.3.10
|
|
// http://es5.github.com/#x15.2.3.10
|
|
if (!Object.preventExtensions) {
|
|
Object.preventExtensions = function preventExtensions(object) {
|
|
if (Object(object) !== object) {
|
|
throw new TypeError('Object.preventExtensions can only be called on Objects.');
|
|
}
|
|
// this is misleading and breaks feature-detection, but
|
|
// allows "securable" code to "gracefully" degrade to working
|
|
// but insecure code.
|
|
return object;
|
|
};
|
|
}
|
|
|
|
// ES5 15.2.3.11
|
|
// http://es5.github.com/#x15.2.3.11
|
|
if (!Object.isSealed) {
|
|
Object.isSealed = function isSealed(object) {
|
|
if (Object(object) !== object) {
|
|
throw new TypeError('Object.isSealed can only be called on Objects.');
|
|
}
|
|
return false;
|
|
};
|
|
}
|
|
|
|
// ES5 15.2.3.12
|
|
// http://es5.github.com/#x15.2.3.12
|
|
if (!Object.isFrozen) {
|
|
Object.isFrozen = function isFrozen(object) {
|
|
if (Object(object) !== object) {
|
|
throw new TypeError('Object.isFrozen can only be called on Objects.');
|
|
}
|
|
return false;
|
|
};
|
|
}
|
|
|
|
// ES5 15.2.3.13
|
|
// http://es5.github.com/#x15.2.3.13
|
|
if (!Object.isExtensible) {
|
|
Object.isExtensible = function isExtensible(object) {
|
|
// 1. If Type(O) is not Object throw a TypeError exception.
|
|
if (Object(object) !== object) {
|
|
throw new TypeError('Object.isExtensible can only be called on Objects.');
|
|
}
|
|
// 2. Return the Boolean value of the [[Extensible]] internal property of O.
|
|
var name = '';
|
|
while (owns(object, name)) {
|
|
name += '?';
|
|
}
|
|
object[name] = true;
|
|
var returnValue = owns(object, name);
|
|
delete object[name];
|
|
return returnValue;
|
|
};
|
|
}
|
|
|
|
}));
|