From 4ad39a5c96dd99acf819ce189b13fec946d7506b Mon Sep 17 00:00:00 2001 From: talasila Date: Tue, 7 Feb 2017 15:03:57 -0500 Subject: Initial OpenECOMP Portal commit Change-Id: I804b80e0830c092e307da1599bd9fbb5c3e2da77 Signed-off-by: talasila --- .../client/bower_components/es5-shim/es5-sham.js | 563 +++++++++++++++++++++ 1 file changed, 563 insertions(+) create mode 100644 ecomp-portal-FE/client/bower_components/es5-shim/es5-sham.js (limited to 'ecomp-portal-FE/client/bower_components/es5-shim/es5-sham.js') 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 + '>'); + 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 + // 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; + }; + } + +})); -- cgit 1.2.3-korg