summaryrefslogtreecommitdiffstats
path: root/ecomp-portal-FE/client/bower_components/es5-shim/es5-sham.js
diff options
context:
space:
mode:
Diffstat (limited to 'ecomp-portal-FE/client/bower_components/es5-shim/es5-sham.js')
-rw-r--r--ecomp-portal-FE/client/bower_components/es5-shim/es5-sham.js563
1 files changed, 563 insertions, 0 deletions
diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/es5-sham.js b/ecomp-portal-FE/client/bower_components/es5-shim/es5-sham.js
new file mode 100644
index 00000000..580cdde9
--- /dev/null
+++ b/ecomp-portal-FE/client/bower_components/es5-shim/es5-sham.js
@@ -0,0 +1,563 @@
+/*!
+ * 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 */
+ 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 */
+ }
+
+ 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 no-proto */
+ var proto = object.__proto__;
+ /* eslint-enable no-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 no-script-url */
+ iframe.src = 'javascript:';
+ /* eslint-enable no-script-url */
+
+ 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 no-proto */
+ object.__proto__ = prototype;
+ /* eslint-enable no-proto */
+ }
+
+ 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;
+ };
+ }
+
+}));