diff options
Diffstat (limited to 'ecomp-portal-FE/client/bower_components/es5-shim')
16 files changed, 3527 insertions, 0 deletions
diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/.bower.json b/ecomp-portal-FE/client/bower_components/es5-shim/.bower.json new file mode 100644 index 00000000..f398d4f8 --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/.bower.json @@ -0,0 +1,43 @@ +{ + "name": "es5-shim", + "main": "es5-shim.js", + "repository": { + "type": "git", + "url": "git://github.com/es-shims/es5-shim" + }, + "homepage": "https://github.com/es-shims/es5-shim", + "authors": [ + "Kris Kowal <kris@cixar.com> (http://github.com/kriskowal/)", + "Sami Samhuri <sami.samhuri@gmail.com> (http://samhuri.net/)", + "Florian Schäfer <florian.schaefer@gmail.com> (http://github.com/fschaefer)", + "Irakli Gozalishvili <rfobic@gmail.com> (http://jeditoolkit.com)", + "Kit Cambridge <kitcambridge@gmail.com> (http://kitcambridge.github.com)", + "Jordan Harband <ljharb@gmail.com> (https://github.com/ljharb/)" + ], + "description": "ECMAScript 5 compatibility shims for legacy JavaScript engines", + "keywords": [ + "shim", + "es5", + "es5 shim", + "javascript", + "ecmascript", + "polyfill" + ], + "license": "MIT", + "ignore": [ + "**/.*", + "node_modules", + "bower_components", + "tests" + ], + "version": "4.5.9", + "_release": "4.5.9", + "_resolution": { + "type": "version", + "tag": "v4.5.9", + "commit": "de7aa6ea2b58b1e3839438d04c023ddf3600c35a" + }, + "_source": "https://github.com/es-shims/es5-shim.git", + "_target": "~4.5.8", + "_originalSource": "es5-shim" +}
\ No newline at end of file diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/CHANGES b/ecomp-portal-FE/client/bower_components/es5-shim/CHANGES new file mode 100644 index 00000000..91f5d7a2 --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/CHANGES @@ -0,0 +1,404 @@ +4.5.9 + - [Fix] parseInt and parseFloat should both accept null/undefined (#402) + - [Tests] up to `node` `v6.2` + - [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `jscs`, `concurrently` + +4.5.8 + - [Fix] Check if property descriptor is configurable before re-defining it (#394, #373) + - [Dev Deps] update `eslint`, `jscs`, `@ljharb/eslint-config` + - [Tests] up to `node` `v5.10`, `v4.4` + - [Tests] Use `concurrently` instead of `parallelshell` + - [Tests] use `pretest` to run the linter + +4.5.7 + - [Fix] `bind` in IE 8: Update `is-callable` implementation to v1.1.3 (#390) + +4.5.6 + - [Fix] `new Date(new Date())` should work in IE 8 (#389) + - [Tests] on `node` `v5.7` + - [Dev Deps] update `uglify-js` + +4.5.5 + - [Fix] Adobe Photoshop’s JS engine bizarrely can have `+date !== date.getTime()` (#365) + - [Dev Deps] update `eslint` + - [Refactor] Update `is-callable` implementation to match latest + - [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `jscs` + +4.5.4 + - [Fix] careless error from 5cf99aca49e59bae03b5d542381424bb1b13ec42 + +4.5.3 + - [Fix] Saturday is a day in the week (#386) + - [Robustness] improve Function#bind (#381) + - [Tests] on `node` `v5.6`, `v4.3` + - [Tests] use json3 (#382) + - [Dev Deps] update `eslint`, `@ljharb/eslint-config` + - [Docs] add note about script order (#379) + +4.5.2 + - [shim: fix] use `Array#slice`, not `String#slice`, on `String#split` output (#380) + +4.5.1 + - [Fix] Make sure preexisting + broken `Array#` methods that throw don’t break the runtime (#377) + - [Dev Deps] update `jscs` + +4.5.0 + - [New] `parseFloat('-0')` should return -0 in Opera 12 (#371) + - [New] Provide and replace Date UTC methods (#360) + - [Robustness] cache `Date` getUTC* methods so that `Date#toISOString` doesn’t observably look them up on the receiver + - [Robustness] use a cached and shimmed `String#trim` + - [Tests] up to `node` `v5.5` + - [Tests] add `parallelshell` and use it in a few tasks + - [Refactor] rename cached methods to avoid linter warnings + - [Dev Deps] update `eslint`, `jscs`, '@ljharb/eslint-config' + - [Docs] Update license year to 2016 (#374) + +4.4.2 + - [shim: fix] use `Array#slice`, not `String#slice`, on `String#split` output (#380) + +4.4.1 + - [Fix] ensure that IE 11 in compatibility mode doesn't throw (#370) + - [Docs] add missing shimmed things + +4.4.0 + - [New] Detect and patch `RegExp#toString` in IE 8, which returns flags in the wrong order (#364) + - [Fix] Patch `Array#sort` on {Chrome, Safari, IE < 9, FF 4} that throws improperly, per ES5 (#354) + - [Fix] In IE 6, `window.external` makes `Object.keys` throw + - [Fix] `Array#slice`: boxed string access on IE <= 8 (#349) + - [Fix] `Array#join`: fix IE 6-8 join called on string literal (#352) + - [Fix] Ensure that `Error#message` and `Error#name` are non-enumerable (#358) + - [Fix: sham] `Object.getOwnPropertyDescriptor`: In Opera 11.6, `propertyIsEnumerable` is a nonshadowable global, like `toString` + - [Robustness] Use a bound form of `Array#slice.call` + - [Tests] Properly check for descriptor support in IE <= 8 + - [Tests] on `node` `v5.1` + - [Tests] Add `Array#slice` tests (#346) + - [Dev Deps] update `uglify-js`, `eslint`, `jscs`, `uglify-js`, `semver` + - [Docs] Fix broken UMD links (#344) + +4.3.2 + - [shim: fix] use `Array#slice`, not `String#slice`, on `String#split` output (#380) + +4.3.1 + - [Fix] `String#split`: revert part of dcce96ae21185a69d2d40e67416e7496b73e8e47 which broke in older browsers (#342) + - [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `jscs` + - [Tests] Firefox allows `Number#toPrecision` values of [1,100], which the spec permits + +4.3.0 + - [New] `Array#push`: in IE <= 7, `Array#push` was not generic (#336) + - [New] `Array#push` in Opera `10.6` has a super weird bug when pushing `undefined` + - [New] `Array#join`: In IE <= 7, passing `undefined` didn't use the default separator (#333) + - [New] `Error#toString`: prints out the proper message in IE 7 and below (#334) + - [New] `Number#toPrecision`: IE 7 and below incorrectly throw when an explicit `undefined` precision is passed (#340) + - [Fix] `String#lastIndexOf`: ensure the correct length in IE 8 + - [Fix] ensure `parseInt` accepts negative and plus-prefixed hex values (#332) + - [Robustness] Use a bound `Array#push` instead of relying on `Function#call` + - [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `jscs` + - [Tests] Add some conditionals to avoid impossible-to-fix test failures in IE 6-8, due to it being unable to distinguish between `undefined` and an absent index (#114) + - [Tests] Fix false negatives in IE 6-8 with jasmine comparing arrays to arraylikes (#114) + - [Tests] add additional `Array#shift` tests (#337) + - [Tests] Add additional `Array#splice` tests (#339) + - [Tests] Add `Array#pop` tests, just in case (#338) + - [Tests] include `global` tests in HTML test files + - [Tests] Make sure the HTML tests run with the right charset + - [Tests] ensure `node` `v0.8` tests stay passing. + - [Tests] Prevent nondeterminism in the tests - this sometime produced values that are one ms off + - [Tests] on `node` `v5.0` + - [Tests] fix npm upgrades for older nodes + +4.2.1 + - [shim: fix] use `Array#slice`, not `String#slice`, on `String#split` output (#380) + +4.2.0 + - [shim: new] Overwrite `String#lastIndexOf` in IE 9, 10, 11, and Edge, so it has proper unicode support. + - [Dev Deps] update `eslint`, `jscs` + +4.1.16 + - [shim: fix] use `Array#slice`, not `String#slice`, on `String#split` output (#380) + +4.1.15 + - [shim: fix] new Date + Date.parse: Fix a Safari 8 & 9 bug where the `ms` arg is treated as a signed instead of unsigned int (#329) + - [shim: fix] add 'frame' to blacklisted keys (#330) + - [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `jscs`, `uglify-js` + - [Tests] on `node` `v4.2` + - [Tests] Date: prevent nondeterminism in the tests - this sometime produced values that are one ms off + +4.1.14 + - [shim: fix] Wrap more things in a try/catch, because IE sucks and sometimes throws on [[Get]] of window.localStorage (#327) + - [Refactor] Use `ES.ToUint32` instead of inline `>>>` + - [Tests] up to `node` `v4.1` + - [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `semver`, `jscs` + +4.1.13 + - [shim: fix] Fix a bug where `Date(x)` threw instead of equalling `String(Date(x))` (#326) + +4.1.12 + - [fix] Make sure uglify doesn't remove function names + - [shim: fix] Use `is-arguments` implementation; don't call down legacy code path in modern engines (#325) + - [Tests] up to `io.js` `v3.3` + - [Dev Deps] update `eslint`, `@ljharb/eslint-config` + +4.1.11 + - [shim: fix] Object.keys in Safari 9 has some bugs. (Already fixed in Webkit Nightly) + - [shim: fix] Omit !Date.parse check in the if statement (#323) + - [sham: fix] Fix Object.create sham to not set __proto__ (#301) + - [sham: fix] Add a typeof check to Object.getPrototypeOf (#319, #320) + - [Tests] up to `io.js` `v3.1` + - [Tests] Make sure `Object.getPrototypeOf` tests don't fail when engines implement ES6 semantics + - [Docs] Switch from vb.teelaun.ch to versionbadg.es for the npm version badge SVG (#318) + - [Dev Deps] Update `eslint`, `uglify-js`, `jscs`; use my personal shared `eslint` config + +4.1.10 + - [Fix] Fix IE 8 issue with `window.frameElement` access in a child iframe (#322) + - [Tests] Consolidating `Date.parse` extended year tests + - [Tests] Account for a `Date.parse` precision variance in Safari 8 + - [Tests] DRY up some Date.parse tests + - [Tests] Don't create globals in Date tests + - [Tests] Better failure output when an invalid date's toJSON throws + - [Tests] Also compare lengths of array-likes + - [Tests] Extra check on Object.keys(arguments) + - [Tests] Skip appropriate tests when objects aren't extensible/freezeable/sealable + +4.1.9 + - [Fix] Remove "extended", add "unicode" in `String#split` shim, to match ES6 + - [Fix] Object.keys: Preserve the IE 8 dontEnum bugfix, and the automation equality bugfix. + - [Fix] Object.keys: Prevent a deprecation message from showing up in Chrome. + - [Performance] Speed up blacklisted key check for Object.keys automation equality bug. + - [Tests] Test on `io.js` `v2.4` + - [Dev Deps] Update `eslint`, `semver` + +4.1.8 + - [Fix] Fix an `Object.keys` IE 8 bug where `localStorage.prototype.constructor === localStorage` would throw (#275) + - [Fix] Shimmed `Object.defineProperty` should not throw for an empty descriptor (#315) + - [Fix] Fix `Date#toISOString` in Safari 5.1 (#243) + - [Fix] Use `Object#propertyIsEnumerable` to default the initial "enumerable" value in `Object.getOwnPropertyDescriptor` sham (#289) + - [Fix] Fix `Array#splice` with large sparse arrays in Safari 7/8, and Opera 12.15 (#295) + - [Robustness] Safely use and reference many builtins internally (also see #313) + - [Tests] Add `Date#{getUTCDate,getUTCMonth}` tests to expose Opera 10.6/11.61/12 `Date` bugs + - [Dev Deps] Update `eslint` + +4.1.7 + - Make sure `Date.parse` is not enumerable (#310) + +4.1.6 + - Support IE 8 when `document.domain` is set (#306, #150) + - Remove version from `bower.json` (#307) + +4.1.5 + - Add a failing runtime check for Safari 8 `Date.parse` + - Update `eslint`, `semver` + - Test on `io.js` `v2.2` + +4.1.4 + - Make sure copied `Date` properties remain non-enumerable. + - Using a more reliable check for supported property descriptors in non-IE ES3 + - Fix 'constructor' in Object.defineProperties sham in ES3 (#252, #305) + - Use a reference to `Array#concat` rather than relying on the runtime environment's `concat`. + - Test on `io.js` `v2.1` + - Clean up `Array.prototype` iteration methods + +4.1.3 + - Update `license` in `package.json` per https://docs.npmjs.com/files/package.json#license + - Update `uglify-js`, `eslint` + +4.1.2 + - In IE 6-8, `Date` inside the function expression does not reference `DateShim` (#303) + - Date: Ensure all code paths have the correct `constructor` property + - Date: Don't copy non-own properties from original `Date` + - Test up to `io.js` `v2.0.0` + - Simplify `isPrimitive` check. + - Adding sanity check tests for ES5 `Number` constants. + - Update `uglify-js`, `eslint`, `semver` + +4.1.1 + - Fix name of `parseInt` replacement. + - Update copyright year + - Update `eslint`, `jscs` + - Lock `uglify-js` down to v2.4.17, since v2.4.18 and v2.4.19 have a breaking change. + - All grade A-supported `node`/`iojs` versions now ship with an `npm` that understands `^`. + - Run `travis-ci` tests on latest `node` and `iojs`; speed up builds; allow 0.8 failures. + - Ensure some Object tests don't fail in ES6 + - Make sure `Date` instances don't have an enumerable `constructor` property, when possible. + +4.1.0 + - Update `eslint` + - Improve type checks: `Array.isArray`, `isRegex` + - Replace `isRegex`/`isString`/`isCallable` checks with inlined versions from npm modules + - Note which ES abstract methods are replaceable via `es-abstract` + - Run `travis-ci` tests on `iojs`! + +4.0.6 + - Update `jscs`, `uglify-js`, add `eslint` + - es5-sham: fix Object.defineProperty to not check for own properties (#211) + - Fix Array#splice bug in Safari 5 (#284) + - Fix `Object.keys` issue with boxed primitives with extra properties in older browsers. (#242, #285) + +4.0.5 + - Update `jscs` so tests pass + +4.0.4 + - Style/indentation/whitespace cleanups. + - README tweaks + +4.0.3 + - Fix keywords (#268) + - add some Date tests + - Note in README that the es5-sham requires the es5-shim (https://github.com/es-shims/es5-shim/issues/256#issuecomment-52875710) + +4.0.2 + - Start including version numbers in minified files (#267) + +4.0.1 + - Fix legacy arguments object detection in Object.keys (#260) + +4.0.0 + - No longer shim the ES5-spec behavior of splice when `deleteCount` is omitted - since no engines implement it, and ES6 changes it. (#255) + - Use Object.defineProperty where available, so that polyfills are non-enumerable when possible (#250) + - lots of internal refactoring + - Fixed a bug referencing String#indexOf and String#lastIndexOf before polyfilling it (#253, #254) + +3.4.0 + - Removed nonstandard SpiderMonkey extension to Array#splice - when `deleteCount` is omitted, it's now treated as 0. (#192, #239) + - Fix Object.keys with Arguments objects in Safari 5.0 + - Now shimming String#split in Opera 10.6 + - Avoid using "toString" as a variable name, since that breaks Opera + - Internal implementation and test cleanups + +3.3.2 + - Remove an internal "bind" call, which should make the shim a bit faster + - Fix a bug with object boxing in Array#reduceRight that was failing a test in IE 6 + +3.3.1 + - Fixing an Array#splice bug in IE 6/7 + - cleaning up Array#splice tests + +3.3.0 + - Fix Array#reduceRight in node 0.6 and older browsers (#238) + +3.2.0 + - Fix es5-sham UMD definition to work properly with AMD (#237) + - Ensure that Array methods do not autobox context in strict mode (#233) + +3.1.1 + - Update minified files (#231) + +3.1.0 + - Fix String#replace in Firefox up through 29 (#228) + +3.0.2 + - Fix `Function#bind` in IE 7 and 8 (#224, #225, #226) + +3.0.1 + - Version bump to ensure npm has newest minified assets + +3.0.0 + - es5-sham: fix `Object.getPrototypeOf` and `Object.getOwnPropertyDescriptor` for Opera Mini + - Better override noncompliant native ES5 methods: `Array#forEach`, `Array#map`, `Array#filter`, `Array#every`, `Array#some`, `Array#reduce`, `Date.parse`, `String#trim` + - Added spec-compliant shim for `parseInt` + - Ensure `Object.keys` handles more edge cases with `arguments` objects and boxed primitives + - Improve minification of builds + +2.3.0 + - parseInt is now properly shimmed in ES3 browsers to default the radix + - update URLs to point to the new organization + +2.2.0 + - Function.prototype.bind shim now reports correct length on a bound function + - fix node 0.6.x v8 bug in Array#forEach + - test improvements + +2.1.0 + - Object.create fixes + - tweaks to the Object.defineProperties shim + +2.0.0 + - Separate reliable shims from dubious shims (shams). + +1.2.10 + - Group-effort Style Cleanup + - Took a stab at fixing Object.defineProperty on IE8 without + bad side-effects. (@hax) + - Object.isExtensible no longer fakes it. (@xavierm) + - Date.prototype.toISOString no longer deals with partial + ISO dates, per spec (@kitcambridge) + - More (mostly from @bryanforbes) + +1.2.9 + - Corrections to toISOString by @kitcambridge + - Fixed three bugs in array methods revealed by Jasmine tests. + - Cleaned up Function.prototype.bind with more fixes and tests from + @bryanforbes. + +1.2.8 + - Actually fixed problems with Function.prototype.bind, and regressions + from 1.2.7 (@bryanforbes, @jdalton #36) + +1.2.7 - REGRESSED + - Fixed problems with Function.prototype.bind when called as a constructor. + (@jdalton #36) + +1.2.6 + - Revised Date.parse to match ES 5.1 (kitcambridge) + +1.2.5 + - Fixed a bug for padding it Date..toISOString (tadfisher issue #33) + +1.2.4 + - Fixed a descriptor bug in Object.defineProperty (raynos) + +1.2.3 + - Cleaned up RequireJS and <script> boilerplate + +1.2.2 + - Changed reduce to follow the letter of the spec with regard to having and + owning properties. + - Fixed a bug where RegExps pass as Functions in some engines in reduce. + +1.2.1 + - Adding few fixes to make jshint happy. + - Fix for issue #12, function expressions can cause scoping issues in IE. + - NPM will minify on install or when `npm run-script install` is executed. + - Adding .gitignore to avoid publishing dev dependencies. + +1.2.0 + - Making script loadable as AMD module. + - Adding `indexOf` to the list of safe shims. + +1.1.0 + - Added support for accessor properties where possible (which is all browsers + except IE). + - Stop exposing bound function's (that are returned by + `Function.prototype.bind`) internal properties (`bound, boundTo, boundArgs`) + as in some cases (when using facade objects for example) capabilities of the + enclosed functions will be leaked. + - `Object.create` now explicitly sets `__proto__` property to guarantee + correct behavior of `Object.getPrototypeOf`'s on all objects created using + `Object.create`. + - Switched to `===` from `==` where possible as it's slightly faster on older + browsers that are target of this lib. + - Added names to all anonymous functions to have a better stack traces. + +1.0.0 + - fixed Date.toISODate, using UTC accessors, as in + http://code.google.com/p/v8/source/browse/trunk/src/date.js?r=6120#986 + (arian) + +0.0.4 + - Revised Object.getPrototypeOf to work in more cases + in response to http://ejohn.org/blog/objectgetprototypeof/ + [issue #2] (fschaefer) + +0.0.3 + - Fixed typos in Object.keys (samsonjs) + +0.0.2 + Per kangax's recommendations: + - faster Object.create(null) + - fixed a function-scope function declaration statement in Object.create + +0.0.1 + - fixed Object.create(null), in so far as that's possible + - reworked Rhino Object.freeze(Function) bug detector and patcher + +0.0.0 + - forked from narwhal-lib + diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/CONTRIBUTORS.md b/ecomp-portal-FE/client/bower_components/es5-shim/CONTRIBUTORS.md new file mode 100644 index 00000000..43ebf770 --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/CONTRIBUTORS.md @@ -0,0 +1,27 @@ + +- kriskowal Kris Kowal Copyright (C) 2009-2011 MIT License +- tlrobinson Tom Robinson Copyright (C) 2009-2010 MIT License (Narwhal + Project) +- dantman Daniel Friesen Copyright (C) 2010 XXX TODO License or CLA +- fschaefer Florian Schäfer Copyright (C) 2010 MIT License +- Gozala Irakli Gozalishvili Copyright (C) 2010 MIT License +- kitcambridge Kit Cambridge Copyright (C) 2011 MIT License +- kossnocorp Sasha Koss XXX TODO License or CLA +- bryanforbes Bryan Forbes XXX TODO License or CLA +- killdream Quildreen Motta Copyright (C) 2011 MIT Licence +- michaelficarra Michael Ficarra Copyright (C) 2011 3-clause BSD + License +- sharkbrainguy Gerard Paapu Copyright (C) 2011 MIT License +- bbqsrc Brendan Molloy (C) 2011 Creative Commons Zero (public domain) +- iwyg XXX TODO License or CLA +- DomenicDenicola Domenic Denicola Copyright (C) 2011 MIT License +- xavierm02 Montillet Xavier Copyright (C) 2011 MIT License +- Raynos Jake Verbaten Copyright (C) 2011 MIT Licence +- samsonjs Sami Samhuri Copyright (C) 2010 MIT License +- rwldrn Rick Waldron Copyright (C) 2011 MIT License +- lexer Alexey Zakharov XXX TODO License or CLA +- 280 North Inc. (Now Motorola LLC, a subsidiary of Google Inc.) + Copyright (C) 2009 MIT License +- Steven Levithan Copyright (C) 2012 MIT License +- Jordan Harband (C) 2013 MIT License + diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/LICENSE b/ecomp-portal-FE/client/bower_components/es5-shim/LICENSE new file mode 100644 index 00000000..195f751b --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (C) 2009-2016 Kristopher Michael Kowal and contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/Makefile b/ecomp-portal-FE/client/bower_components/es5-shim/Makefile new file mode 100644 index 00000000..5afc70dc --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/Makefile @@ -0,0 +1,63 @@ +# Since we rely on paths relative to the makefile location, abort if make isn't being run from there. +$(if $(findstring /,$(MAKEFILE_LIST)),$(error Please only invoke this makefile from the directory it resides in)) + + # The files that need updating when incrementing the version number. +VERSIONED_FILES := *.js *.json *.map README* + + +# Add the local npm packages' bin folder to the PATH, so that `make` can find them, when invoked directly. +# Note that rather than using `$(npm bin)` the 'node_modules/.bin' path component is hard-coded, so that invocation works even from an environment +# where npm is (temporarily) unavailable due to having deactivated an nvm instance loaded into the calling shell in order to avoid interference with tests. +export PATH := $(shell printf '%s' "$$PWD/node_modules/.bin:$$PATH") +UTILS := semver +# Make sure that all required utilities can be located. +UTIL_CHECK := $(or $(shell PATH="$(PATH)" which $(UTILS) >/dev/null && echo 'ok'),$(error Did you forget to run `npm install` after cloning the repo? At least one of the required supporting utilities not found: $(UTILS))) + +# Default target (by virtue of being the first non '.'-prefixed in the file). +.PHONY: _no-target-specified +_no-target-specified: + $(error Please specify the target to make - `make list` shows targets. Alternatively, use `npm test` to run the default tests; `npm run` shows all tests) + +# Lists all targets defined in this makefile. +.PHONY: list +list: + @$(MAKE) -pRrn : -f $(MAKEFILE_LIST) 2>/dev/null | awk -v RS= -F: '/^# File/,/^# Finished Make data base/ {if ($$1 !~ "^[#.]") {print $$1}}' | command grep -v -e '^[^[:alnum:]]' -e '^$@$$command ' | sort + +# All-tests target: invokes the specified test suites for ALL shells defined in $(SHELLS). +.PHONY: test +test: + @npm test + +.PHONY: _ensure-tag +_ensure-tag: +ifndef TAG + $(error Please invoke with `make TAG=<new-version> release`, where <new-version> is either an increment specifier (patch, minor, major, prepatch, preminor, premajor, prerelease), or an explicit major.minor.patch version number) +endif + +CHANGELOG_ERROR = $(error No CHANGES specified) +.PHONY: _ensure-changelog +_ensure-changelog: + @ (git status -sb --porcelain | command grep -E '^( M|[MA] ) CHANGES' > /dev/null) || (echo no CHANGES specified && exit 2) + +# Ensures that the git workspace is clean. +.PHONY: _ensure-clean +_ensure-clean: + @[ -z "$$((git status --porcelain --untracked-files=no || echo err) | command grep -v 'CHANGES')" ] || { echo "Workspace is not clean; please commit changes first." >&2; exit 2; } + +# Makes a release; invoke with `make TAG=<versionOrIncrementSpec> release`. +.PHONY: release +release: _ensure-tag _ensure-changelog _ensure-clean + @old_ver=`git describe --abbrev=0 --tags --match 'v[0-9]*.[0-9]*.[0-9]*'` || { echo "Failed to determine current version." >&2; exit 1; }; old_ver=$${old_ver#v}; \ + new_ver=`echo "$(TAG)" | sed 's/^v//'`; new_ver=$${new_ver:-patch}; \ + if printf "$$new_ver" | command grep -q '^[0-9]'; then \ + semver "$$new_ver" >/dev/null || { echo 'Invalid version number specified: $(TAG) - must be major.minor.patch' >&2; exit 2; }; \ + semver -r "> $$old_ver" "$$new_ver" >/dev/null || { echo 'Invalid version number specified: $(TAG) - must be HIGHER than current one.' >&2; exit 2; } \ + else \ + new_ver=`semver -i "$$new_ver" "$$old_ver"` || { echo 'Invalid version-increment specifier: $(TAG)' >&2; exit 2; } \ + fi; \ + printf "=== Bumping version **$$old_ver** to **$$new_ver** before committing and tagging:\n=== TYPE 'proceed' TO PROCEED, anything else to abort: " && read response && [ "$$response" = 'proceed' ] || { echo 'Aborted.' >&2; exit 2; }; \ + npm run minify; \ + replace "$$old_ver" "$$new_ver" -- $(VERSIONED_FILES) && \ + replace "blob/master" "blob/v$$new_ver" -- *.min.js && \ + git commit -m "v$$new_ver" $(VERSIONED_FILES) CHANGES && \ + git tag -a -m "v$$new_ver" "v$$new_ver" diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/README.md b/ecomp-portal-FE/client/bower_components/es5-shim/README.md new file mode 100644 index 00000000..89c59bb8 --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/README.md @@ -0,0 +1,190 @@ +#es5-shim <sup>[![Version Badge][npm-version-svg]][npm-url]</sup> + +[![npm badge][npm-badge-png]][npm-url] + +[![Build Status][travis-svg]][travis-url] +[![dependency status][deps-svg]][deps-url] +[![dev dependency status][dev-deps-svg]][dev-deps-url] + +`es5-shim.js` and `es5-shim.min.js` monkey-patch a JavaScript context to +contain all EcmaScript 5 methods that can be faithfully emulated with a +legacy JavaScript engine. +**Note:** As `es5-shim.js` is designed to patch the native Javascript +engine, it should be the library that is loaded first. + +`es5-sham.js` and `es5-sham.min.js` monkey-patch other ES5 methods as +closely as possible. For these methods, as closely as possible to ES5 +is not very close. Many of these shams are intended only to allow code +to be written to ES5 without causing run-time errors in older engines. +In many cases, this means that these shams cause many ES5 methods to +silently fail. Decide carefully whether this is what you want. +**Note:** `es5-sham.js` requires `es5-shim.js` to be able to work properly. + + +## Tests + +The tests are written with the Jasmine BDD test framework. +To run the tests, navigate to <root-folder>/tests/ , or, +simply `npm install` and `npm test`. + +## Shims + +### Complete tests ### + +* Array.prototype.every +* Array.prototype.filter +* Array.prototype.forEach +* Array.prototype.indexOf +* Array.prototype.lastIndexOf +* Array.prototype.map +* Array.prototype.slice +* Array.prototype.some +* Array.prototype.sort +* Array.prototype.reduce +* Array.prototype.reduceRight +* Array.prototype.push +* Array.prototype.join +* Array.isArray +* Date.now +* Date.prototype.toJSON +* Function.prototype.bind + * :warning: Caveat: the bound function has a prototype property. + * :warning: Caveat: bound functions do not try too hard to keep you + from manipulating their ``arguments`` and ``caller`` properties. + * :warning: Caveat: bound functions don't have checks in ``call`` and + ``apply`` to avoid executing as a constructor. +* Number.prototype.toFixed +* Number.prototype.toPrecision +* Object.keys +* String.prototype.split +* String.prototype.trim +* String.prototype.lastIndexOf +* String.prototype.replace + * Firefox (through v29) natively handles capturing groups incorrectly. +* Date.parse (for ISO parsing) +* Date.prototype.toISOString +* parseInt +* parseFloat +* Error.prototype.toString +* Error.prototype.name +* Error.prototype.message +* RegExp.prototype.toString + +## Shams + +* :warning: Object.create + + For the case of simply "begetting" an object that inherits + prototypically from another, this should work fine across legacy + engines. + + :warning: The second argument is passed to Object.defineProperties + which will probably fail either silently or with extreme prejudice. + +* :warning: Object.getPrototypeOf + + This will return "undefined" in some cases. It uses `__proto__` if + it's available. Failing that, it uses constructor.prototype, which + depends on the constructor property of the object's prototype having + not been replaced. If your object was created like this, it won't + work: + + function Foo() { + } + Foo.prototype = {}; + + Because the prototype reassignment destroys the constructor + property. + + This will work for all objects that were created using + `Object.create` implemented with this library. + +* :warning: Object.getOwnPropertyNames + + This method uses Object.keys, so it will not be accurate on legacy + engines. + +* Object.isSealed + + Returns "false" in all legacy engines for all objects, which is + conveniently guaranteed to be accurate. + +* Object.isFrozen + + Returns "false" in all legacy engines for all objects, which is + conveniently guaranteed to be accurate. + +* Object.isExtensible + + Works like a charm, by trying very hard to extend the object then + redacting the extension. + +### May fail + +* :warning: Object.getOwnPropertyDescriptor + + The behavior of this shim does not conform to ES5. It should + probably not be used at this time, until its behavior has been + reviewed and been confirmed to be useful in legacy engines. + +* :warning: Object.defineProperty + + In the worst of circumstances, IE 8 provides a version of this + method that only works on DOM objects. This sham will not be + installed. The given version of `defineProperty` will throw an + exception if used on non-DOM objects. + + In slightly better circumstances, this method will silently fail to + set "writable", "enumerable", and "configurable" properties. + + Providing a getter or setter with "get" or "set" on a descriptor + will silently fail on engines that lack "__defineGetter__" and + "__defineSetter__", which include all versions of IE. + + https://github.com/es-shims/es5-shim/issues#issue/5 + +* :warning: Object.defineProperties + + This uses the Object.defineProperty shim. + +* Object.seal + + Silently fails on all legacy engines. This should be + fine unless you are depending on the safety and security + provisions of this method, which you cannot possibly + obtain in legacy engines. + +* Object.freeze + + Silently fails on all legacy engines. This should be + fine unless you are depending on the safety and security + provisions of this method, which you cannot possibly + obtain in legacy engines. + +* Object.preventExtensions + + Silently fails on all legacy engines. This should be + fine unless you are depending on the safety and security + provisions of this method, which you cannot possibly + obtain in legacy engines. + +### Example of applying ES compatability shims in a browser project + +```html +<script src="https://cdnjs.cloudflare.com/ajax/libs/es5-shim/4.5.7/es5-shim.min.js"></script> +<script src="https://cdnjs.cloudflare.com/ajax/libs/es5-shim/4.5.7/es5-sham.min.js"></script> +<script src="https://cdnjs.cloudflare.com/ajax/libs/json3/3.3.2/json3.min.js"></script> +<script src="https://cdnjs.cloudflare.com/ajax/libs/es6-shim/0.34.2/es6-shim.min.js"></script> +<script src="https://cdnjs.cloudflare.com/ajax/libs/es6-shim/0.34.2/es6-sham.min.js"></script> +<script src="https://wzrd.in/standalone/es7-shim@latest"></script> +<script src="other-libs.js"></script> +``` +[npm-url]: https://npmjs.org/package/es5-shim +[npm-version-svg]: http://versionbadg.es/es-shims/es5-shim.svg +[travis-svg]: https://travis-ci.org/es-shims/es5-shim.svg +[travis-url]: https://travis-ci.org/es-shims/es5-shim +[deps-svg]: https://david-dm.org/es-shims/es5-shim.svg +[deps-url]: https://david-dm.org/es-shims/es5-shim +[dev-deps-svg]: https://david-dm.org/es-shims/es5-shim/dev-status.svg +[dev-deps-url]: https://david-dm.org/es-shims/es5-shim#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/es5-shim.png?downloads=true&stars=true diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/bower.json b/ecomp-portal-FE/client/bower_components/es5-shim/bower.json new file mode 100644 index 00000000..dcc0b295 --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/bower.json @@ -0,0 +1,33 @@ +{ + "name": "es5-shim", + "main": "es5-shim.js", + "repository": { + "type": "git", + "url": "git://github.com/es-shims/es5-shim" + }, + "homepage": "https://github.com/es-shims/es5-shim", + "authors": [ + "Kris Kowal <kris@cixar.com> (http://github.com/kriskowal/)", + "Sami Samhuri <sami.samhuri@gmail.com> (http://samhuri.net/)", + "Florian Schäfer <florian.schaefer@gmail.com> (http://github.com/fschaefer)", + "Irakli Gozalishvili <rfobic@gmail.com> (http://jeditoolkit.com)", + "Kit Cambridge <kitcambridge@gmail.com> (http://kitcambridge.github.com)", + "Jordan Harband <ljharb@gmail.com> (https://github.com/ljharb/)" + ], + "description": "ECMAScript 5 compatibility shims for legacy JavaScript engines", + "keywords": [ + "shim", + "es5", + "es5 shim", + "javascript", + "ecmascript", + "polyfill" + ], + "license": "MIT", + "ignore": [ + "**/.*", + "node_modules", + "bower_components", + "tests" + ] +} diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/component.json b/ecomp-portal-FE/client/bower_components/es5-shim/component.json new file mode 100644 index 00000000..7096633a --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/component.json @@ -0,0 +1,19 @@ +{ + "name": "es5-shim", + "repo": "es-shims/es5-shim", + "description": "ECMAScript 5 compatibility shims for legacy JavaScript engines", + "version": "v4.5.1", + "keywords": [ + "shim", + "es5", + "es5 shim", + "javascript", + "ecmascript", + "polyfill" + ], + "license": "MIT", + "main": "es5-shim.js", + "scripts": [ + "es5-shim.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 + '></' + 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; + }; + } + +})); diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/es5-sham.map b/ecomp-portal-FE/client/bower_components/es5-shim/es5-sham.map new file mode 100644 index 00000000..cce47c11 --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/es5-sham.map @@ -0,0 +1 @@ +{"version":3,"sources":["es5-sham.js"],"names":["root","factory","define","amd","exports","module","returnExports","this","call","Function","prototypeOfObject","Object","prototype","owns","bind","hasOwnProperty","isEnumerable","propertyIsEnumerable","toStr","toString","defineGetter","defineSetter","lookupGetter","lookupSetter","supportsAccessors","__defineGetter__","__defineSetter__","__lookupGetter__","__lookupSetter__","isPrimitive","o","getPrototypeOf","object","proto","__proto__","constructor","doesGetOwnPropertyDescriptorWork","sentinel","getOwnPropertyDescriptor","value","exception","defineProperty","getOwnPropertyDescriptorWorksOnObject","getOwnPropertyDescriptorWorksOnDom","document","createElement","getOwnPropertyDescriptorFallback","ERR_NON_OBJECT","property","TypeError","descriptor","enumerable","configurable","notPrototypeOfObject","getter","setter","get","set","writable","getOwnPropertyNames","keys","create","createEmpty","supportsProto","shouldUseActiveX","domain","ActiveXObject","getEmptyViaActiveX","empty","xDoc","script","write","close","parentWindow","getEmptyViaIFrame","iframe","parent","body","documentElement","style","display","appendChild","src","contentWindow","removeChild","isPrototypeOf","toLocaleString","valueOf","Empty","properties","Type","defineProperties","doesDefinePropertyWork","definePropertyWorksOnObject","definePropertyWorksOnDom","definePropertyFallback","definePropertiesFallback","ERR_NON_OBJECT_DESCRIPTOR","ERR_NON_OBJECT_TARGET","ERR_ACCESSORS_NOT_SUPPORTED","hasGetter","hasSetter","forEach","seal","freeze","freezeObject","preventExtensions","isSealed","isFrozen","isExtensible","name","returnValue"],"mappings":";;;;;CAaC,SAAUA,EAAMC,GACb,YAGA,UAAWC,UAAW,YAAcA,OAAOC,IAAK,CAE5CD,OAAOD,OACJ,UAAWG,WAAY,SAAU,CAIpCC,OAAOD,QAAUH,QACd,CAEHD,EAAKM,cAAgBL,OAE3BM,KAAM,WAEJ,GAAIC,GAAOC,SAASD,IACpB,IAAIE,GAAoBC,OAAOC,SAC/B,IAAIC,GAAOL,EAAKM,KAAKJ,EAAkBK,eACvC,IAAIC,GAAeR,EAAKM,KAAKJ,EAAkBO,qBAC/C,IAAIC,GAAQV,EAAKM,KAAKJ,EAAkBS,SAGxC,IAAIC,EACJ,IAAIC,EACJ,IAAIC,EACJ,IAAIC,EACJ,IAAIC,GAAoBX,EAAKH,EAAmB,mBAChD,IAAIc,EAAmB,CAEnBJ,EAAeZ,EAAKM,KAAKJ,EAAkBe,iBAC3CJ,GAAeb,EAAKM,KAAKJ,EAAkBgB,iBAC3CJ,GAAed,EAAKM,KAAKJ,EAAkBiB,iBAC3CJ,GAAef,EAAKM,KAAKJ,EAAkBkB,kBAI/C,GAAIC,GAAc,QAASA,aAAYC,GACnC,MAAOA,IAAK,YAAgBA,KAAM,gBAAmBA,KAAM,WAK/D,KAAKnB,OAAOoB,eAAgB,CAQxBpB,OAAOoB,eAAiB,QAASA,gBAAeC,GAE5C,GAAIC,GAAQD,EAAOE,SAEnB,IAAID,GAASA,IAAU,KAAM,CACzB,MAAOA,OACJ,IAAIf,EAAMc,EAAOG,eAAiB,oBAAqB,CAC1D,MAAOH,GAAOG,YAAYvB,cACvB,IAAIoB,YAAkBrB,QAAQ,CACjC,MAAOD,OACJ,CAKH,MAAO,QAQnB,GAAI0B,GAAmC,QAASA,kCAAiCJ,GAC7E,IACIA,EAAOK,SAAW,CAClB,OAAO1B,QAAO2B,yBAAyBN,EAAQ,YAAYO,QAAU,EACvE,MAAOC,GACL,MAAO,QAKf,IAAI7B,OAAO8B,eAAgB,CACvB,GAAIC,GAAwCN,KAC5C,IAAIO,SAA4CC,YAAa,aAC7DR,EAAiCQ,SAASC,cAAc,OACxD,KAAKF,IAAuCD,EAAuC,CAC/E,GAAII,GAAmCnC,OAAO2B,0BAItD,IAAK3B,OAAO2B,0BAA4BQ,EAAkC,CACtE,GAAIC,GAAiB,0DAGrBpC,QAAO2B,yBAA2B,QAASA,0BAAyBN,EAAQgB,GACxE,GAAInB,EAAYG,GAAS,CACrB,KAAM,IAAIiB,WAAUF,EAAiBf,GAKzC,GAAIc,EAAkC,CAClC,IACI,MAAOA,GAAiCtC,KAAKG,OAAQqB,EAAQgB,GAC/D,MAAOR,KAKb,GAAIU,EAGJ,KAAKrC,EAAKmB,EAAQgB,GAAW,CACzB,MAAOE,GAKXA,GACIC,WAAYnC,EAAagB,EAAQgB,GACjCI,aAAc,KAKlB,IAAI5B,EAAmB,CAMnB,GAAIZ,GAAYoB,EAAOE,SACvB,IAAImB,GAAuBrB,IAAWtB,CAItC,IAAI2C,EAAsB,CACtBrB,EAAOE,UAAYxB,EAGvB,GAAI4C,GAAShC,EAAaU,EAAQgB,EAClC,IAAIO,GAAShC,EAAaS,EAAQgB,EAElC,IAAIK,EAAsB,CAEtBrB,EAAOE,UAAYtB,EAGvB,GAAI0C,GAAUC,EAAQ,CAClB,GAAID,EAAQ,CACRJ,EAAWM,IAAMF,EAErB,GAAIC,EAAQ,CACRL,EAAWO,IAAMF,EAIrB,MAAOL,IAMfA,EAAWX,MAAQP,EAAOgB,EAC1BE,GAAWQ,SAAW,IACtB,OAAOR,IAOf,IAAKvC,OAAOgD,oBAAqB,CAC7BhD,OAAOgD,oBAAsB,QAASA,qBAAoB3B,GACtD,MAAOrB,QAAOiD,KAAK5B,IAM3B,IAAKrB,OAAOkD,OAAQ,CAGhB,GAAIC,EACJ,IAAIC,MAAoB7B,UAAW,eAAkBvB,QAUrD,IAAIqD,GAAmB,QAASA,oBAE5B,IAAKpB,SAASqB,OAAQ,CAClB,MAAO,OAGX,IACI,QAAS,GAAIC,eAAc,YAC7B,MAAO1B,GACL,MAAO,QAOf,IAAI2B,GAAqB,QAASA,sBAC9B,GAAIC,EACJ,IAAIC,EAEJA,GAAO,GAAIH,eAAc,WAEzB,IAAII,GAAS,QACbD,GAAKE,MAAM,IAAMD,EAAS,MAAQA,EAAS,IAC3CD,GAAKG,OAELJ,GAAQC,EAAKI,aAAa9D,OAAOC,SACjCyD,GAAO,IAEP,OAAOD,GAMX,IAAIM,GAAoB,QAASA,qBAC7B,GAAIC,GAAS/B,SAASC,cAAc,SACpC,IAAI+B,GAAShC,SAASiC,MAAQjC,SAASkC,eACvC,IAAIV,EAEJO,GAAOI,MAAMC,QAAU,MACvBJ,GAAOK,YAAYN,EAEnBA,GAAOO,IAAM,aAGbd,GAAQO,EAAOQ,cAAcxE,OAAOC,SACpCgE,GAAOQ,YAAYT,EACnBA,GAAS,IAET,OAAOP,GAIX,IAAIL,SAAwBnB,YAAa,YAAa,CAClDkB,EAAc,WACV,OAAS5B,UAAW,WAErB,CAMH4B,EAAc,WAGV,GAAIM,GAAQJ,IAAqBG,IAAuBO,UAEjDN,GAAMjC,kBACNiC,GAAMrD,qBACNqD,GAAMnD,2BACNmD,GAAMiB,oBACNjB,GAAMkB,qBACNlB,GAAMjD,eACNiD,GAAMmB,OAEb,IAAIC,GAAQ,QAASA,UACrBA,GAAM5E,UAAYwD,CAElBN,GAAc,WACV,MAAO,IAAI0B,GAEf,OAAO,IAAIA,IAInB7E,OAAOkD,OAAS,QAASA,QAAOjD,EAAW6E,GAEvC,GAAIzD,EACJ,IAAI0D,GAAO,QAASA,SAEpB,IAAI9E,IAAc,KAAM,CACpBoB,EAAS8B,QACN,CACH,GAAIlD,IAAc,MAAQiB,EAAYjB,GAAY,CAM9C,KAAM,IAAIqC,WAAU,kDAExByC,EAAK9E,UAAYA,CACjBoB,GAAS,GAAI0D,EAMb1D,GAAOE,UAAYtB,EAIvB,GAAI6E,QAAoB,GAAG,CACvB9E,OAAOgF,iBAAiB3D,EAAQyD,GAGpC,MAAOzD,IAgBf,GAAI4D,GAAyB,QAASA,wBAAuB5D,GACzD,IACIrB,OAAO8B,eAAeT,EAAQ,cAC9B,OAAO,YAAcA,GACvB,MAAOQ,GACL,MAAO,QAMf,IAAI7B,OAAO8B,eAAgB,CACvB,GAAIoD,GAA8BD,KAClC,IAAIE,SAAkClD,YAAa,aAC/CgD,EAAuBhD,SAASC,cAAc,OAClD,KAAKgD,IAAgCC,EAA0B,CAC3D,GAAIC,GAAyBpF,OAAO8B,eAChCuD,EAA2BrF,OAAOgF,kBAI9C,IAAKhF,OAAO8B,gBAAkBsD,EAAwB,CAClD,GAAIE,GAA4B,0CAChC,IAAIC,GAAwB,8CAC5B,IAAIC,GAA8B,gEAElCxF,QAAO8B,eAAiB,QAASA,gBAAeT,EAAQgB,EAAUE,GAC9D,GAAIrB,EAAYG,GAAS,CACrB,KAAM,IAAIiB,WAAUiD,EAAwBlE,GAEhD,GAAIH,EAAYqB,GAAa,CACzB,KAAM,IAAID,WAAUgD,EAA4B/C,GAIpD,GAAI6C,EAAwB,CACxB,IACI,MAAOA,GAAuBvF,KAAKG,OAAQqB,EAAQgB,EAAUE,GAC/D,MAAOV,KAMb,GAAI,SAAWU,GAAY,CAevB,GAAI1B,IAAsBF,EAAaU,EAAQgB,IAAazB,EAAaS,EAAQgB,IAAY,CAMzF,GAAIpC,GAAYoB,EAAOE,SACvBF,GAAOE,UAAYxB,QAGZsB,GAAOgB,EACdhB,GAAOgB,GAAYE,EAAWX,KAE9BP,GAAOE,UAAYtB,MAEhB,CACHoB,EAAOgB,GAAYE,EAAWX,WAE/B,CACH,GAAI6D,GAAY,OAASlD,EACzB,IAAImD,GAAY,OAASnD,EACzB,KAAK1B,IAAsB4E,GAAaC,GAAY,CAChD,KAAM,IAAIpD,WAAUkD,GAGxB,GAAIC,EAAW,CACXhF,EAAaY,EAAQgB,EAAUE,EAAWM,KAE9C,GAAI6C,EAAW,CACXhF,EAAaW,EAAQgB,EAAUE,EAAWO,MAGlD,MAAOzB,IAMf,IAAKrB,OAAOgF,kBAAoBK,EAA0B,CACtDrF,OAAOgF,iBAAmB,QAASA,kBAAiB3D,EAAQyD,GAExD,GAAIO,EAA0B,CAC1B,IACI,MAAOA,GAAyBxF,KAAKG,OAAQqB,EAAQyD,GACvD,MAAOjD,KAKb7B,OAAOiD,KAAK6B,GAAYa,QAAQ,SAAUtD,GACtC,GAAIA,IAAa,YAAa,CAC1BrC,OAAO8B,eAAeT,EAAQgB,EAAUyC,EAAWzC,MAG3D,OAAOhB,IAMf,IAAKrB,OAAO4F,KAAM,CACd5F,OAAO4F,KAAO,QAASA,MAAKvE,GACxB,GAAIrB,OAAOqB,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,8CAKxB,MAAOjB,IAMf,IAAKrB,OAAO6F,OAAQ,CAChB7F,OAAO6F,OAAS,QAASA,QAAOxE,GAC5B,GAAIrB,OAAOqB,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,gDAKxB,MAAOjB,IAKf,IACIrB,OAAO6F,OAAO,cAChB,MAAOhE,GACL7B,OAAO6F,OAAU,SAAUC,GACvB,MAAO,SAASD,QAAOxE,GACnB,SAAWA,KAAW,WAAY,CAC9B,MAAOA,OACJ,CACH,MAAOyE,GAAazE,MAG9BrB,OAAO6F,QAKb,IAAK7F,OAAO+F,kBAAmB,CAC3B/F,OAAO+F,kBAAoB,QAASA,mBAAkB1E,GAClD,GAAIrB,OAAOqB,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,2DAKxB,MAAOjB,IAMf,IAAKrB,OAAOgG,SAAU,CAClBhG,OAAOgG,SAAW,QAASA,UAAS3E,GAChC,GAAIrB,OAAOqB,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,kDAExB,MAAO,QAMf,IAAKtC,OAAOiG,SAAU,CAClBjG,OAAOiG,SAAW,QAASA,UAAS5E,GAChC,GAAIrB,OAAOqB,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,kDAExB,MAAO,QAMf,IAAKtC,OAAOkG,aAAc,CACtBlG,OAAOkG,aAAe,QAASA,cAAa7E,GAExC,GAAIrB,OAAOqB,KAAYA,EAAQ,CAC3B,KAAM,IAAIiB,WAAU,sDAGxB,GAAI6D,GAAO,EACX,OAAOjG,EAAKmB,EAAQ8E,GAAO,CACvBA,GAAQ,IAEZ9E,EAAO8E,GAAQ,IACf,IAAIC,GAAclG,EAAKmB,EAAQ8E,SACxB9E,GAAO8E,EACd,OAAOC"}
\ No newline at end of file diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/es5-sham.min.js b/ecomp-portal-FE/client/bower_components/es5-shim/es5-sham.min.js new file mode 100644 index 00000000..fd13f15b --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/es5-sham.min.js @@ -0,0 +1,7 @@ +/*! + * 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/v4.5.9/LICENSE + */ +(function(e,t){"use strict";if(typeof define==="function"&&define.amd){define(t)}else if(typeof exports==="object"){module.exports=t()}else{e.returnExports=t()}})(this,function(){var e=Function.call;var t=Object.prototype;var r=e.bind(t.hasOwnProperty);var n=e.bind(t.propertyIsEnumerable);var o=e.bind(t.toString);var i;var c;var f;var a;var l=r(t,"__defineGetter__");if(l){i=e.bind(t.__defineGetter__);c=e.bind(t.__defineSetter__);f=e.bind(t.__lookupGetter__);a=e.bind(t.__lookupSetter__)}var u=function isPrimitive(e){return e==null||typeof e!=="object"&&typeof e!=="function"};if(!Object.getPrototypeOf){Object.getPrototypeOf=function getPrototypeOf(e){var r=e.__proto__;if(r||r===null){return r}else if(o(e.constructor)==="[object Function]"){return e.constructor.prototype}else if(e instanceof Object){return t}else{return null}}}var p=function doesGetOwnPropertyDescriptorWork(e){try{e.sentinel=0;return Object.getOwnPropertyDescriptor(e,"sentinel").value===0}catch(t){return false}};if(Object.defineProperty){var s=p({});var b=typeof document==="undefined"||p(document.createElement("div"));if(!b||!s){var O=Object.getOwnPropertyDescriptor}}if(!Object.getOwnPropertyDescriptor||O){var d="Object.getOwnPropertyDescriptor called on a non-object: ";Object.getOwnPropertyDescriptor=function getOwnPropertyDescriptor(e,o){if(u(e)){throw new TypeError(d+e)}if(O){try{return O.call(Object,e,o)}catch(i){}}var c;if(!r(e,o)){return c}c={enumerable:n(e,o),configurable:true};if(l){var p=e.__proto__;var s=e!==t;if(s){e.__proto__=t}var b=f(e,o);var y=a(e,o);if(s){e.__proto__=p}if(b||y){if(b){c.get=b}if(y){c.set=y}return c}}c.value=e[o];c.writable=true;return c}}if(!Object.getOwnPropertyNames){Object.getOwnPropertyNames=function getOwnPropertyNames(e){return Object.keys(e)}}if(!Object.create){var y;var j=!({__proto__:null}instanceof Object);var v=function shouldUseActiveX(){if(!document.domain){return false}try{return!!new ActiveXObject("htmlfile")}catch(e){return false}};var _=function getEmptyViaActiveX(){var e;var t;t=new ActiveXObject("htmlfile");var r="script";t.write("<"+r+"></"+r+">");t.close();e=t.parentWindow.Object.prototype;t=null;return e};var w=function getEmptyViaIFrame(){var e=document.createElement("iframe");var t=document.body||document.documentElement;var r;e.style.display="none";t.appendChild(e);e.src="javascript:";r=e.contentWindow.Object.prototype;t.removeChild(e);e=null;return r};if(j||typeof document==="undefined"){y=function(){return{__proto__:null}}}else{y=function(){var e=v()?_():w();delete e.constructor;delete e.hasOwnProperty;delete e.propertyIsEnumerable;delete e.isPrototypeOf;delete e.toLocaleString;delete e.toString;delete e.valueOf;var t=function Empty(){};t.prototype=e;y=function(){return new t};return new t}}Object.create=function create(e,t){var r;var n=function Type(){};if(e===null){r=y()}else{if(e!==null&&u(e)){throw new TypeError("Object prototype may only be an Object or null")}n.prototype=e;r=new n;r.__proto__=e}if(t!==void 0){Object.defineProperties(r,t)}return r}}var m=function doesDefinePropertyWork(e){try{Object.defineProperty(e,"sentinel",{});return"sentinel"in e}catch(t){return false}};if(Object.defineProperty){var P=m({});var E=typeof document==="undefined"||m(document.createElement("div"));if(!P||!E){var h=Object.defineProperty,g=Object.defineProperties}}if(!Object.defineProperty||h){var z="Property description must be an object: ";var T="Object.defineProperty called on non-object: ";var x="getters & setters can not be defined on this javascript engine";Object.defineProperty=function defineProperty(e,r,n){if(u(e)){throw new TypeError(T+e)}if(u(n)){throw new TypeError(z+n)}if(h){try{return h.call(Object,e,r,n)}catch(o){}}if("value"in n){if(l&&(f(e,r)||a(e,r))){var p=e.__proto__;e.__proto__=t;delete e[r];e[r]=n.value;e.__proto__=p}else{e[r]=n.value}}else{var s="get"in n;var b="set"in n;if(!l&&(s||b)){throw new TypeError(x)}if(s){i(e,r,n.get)}if(b){c(e,r,n.set)}}return e}}if(!Object.defineProperties||g){Object.defineProperties=function defineProperties(e,t){if(g){try{return g.call(Object,e,t)}catch(r){}}Object.keys(t).forEach(function(r){if(r!=="__proto__"){Object.defineProperty(e,r,t[r])}});return e}}if(!Object.seal){Object.seal=function seal(e){if(Object(e)!==e){throw new TypeError("Object.seal can only be called on Objects.")}return e}}if(!Object.freeze){Object.freeze=function freeze(e){if(Object(e)!==e){throw new TypeError("Object.freeze can only be called on Objects.")}return e}}try{Object.freeze(function(){})}catch(S){Object.freeze=function(e){return function freeze(t){if(typeof t==="function"){return t}else{return e(t)}}}(Object.freeze)}if(!Object.preventExtensions){Object.preventExtensions=function preventExtensions(e){if(Object(e)!==e){throw new TypeError("Object.preventExtensions can only be called on Objects.")}return e}}if(!Object.isSealed){Object.isSealed=function isSealed(e){if(Object(e)!==e){throw new TypeError("Object.isSealed can only be called on Objects.")}return false}}if(!Object.isFrozen){Object.isFrozen=function isFrozen(e){if(Object(e)!==e){throw new TypeError("Object.isFrozen can only be called on Objects.")}return false}}if(!Object.isExtensible){Object.isExtensible=function isExtensible(e){if(Object(e)!==e){throw new TypeError("Object.isExtensible can only be called on Objects.")}var t="";while(r(e,t)){t+="?"}e[t]=true;var n=r(e,t);delete e[t];return n}}}); +//# sourceMappingURL=es5-sham.map diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/es5-shim.js b/ecomp-portal-FE/client/bower_components/es5-shim/es5-shim.js new file mode 100644 index 00000000..f94b4334 --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/es5-shim.js @@ -0,0 +1,2065 @@ +/*! + * 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 () { + /** + * 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. This also holds a reference to known-good + // functions. + var $Array = Array; + var ArrayPrototype = $Array.prototype; + var $Object = Object; + var ObjectPrototype = $Object.prototype; + var $Function = Function; + var FunctionPrototype = $Function.prototype; + var $String = String; + var StringPrototype = $String.prototype; + var $Number = Number; + 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 array_concat = ArrayPrototype.concat; + var array_join = ArrayPrototype.join; + var call = FunctionPrototype.call; + var apply = FunctionPrototype.apply; + var max = Math.max; + var min = Math.min; + + // Having a toString local variable name breaks in Opera so use to_string. + var to_string = ObjectPrototype.toString; + + /* global Symbol */ + /* eslint-disable one-var-declaration-per-line, no-redeclare, max-statements-per-line */ + var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol'; + var isCallable; /* inlined from https://npmjs.com/is-callable */ var fnToStr = Function.prototype.toString, constructorRegex = /^\s*class /, isES6ClassFn = function isES6ClassFn(value) { try { var fnStr = fnToStr.call(value); var singleStripped = fnStr.replace(/\/\/.*\n/g, ''); var multiStripped = singleStripped.replace(/\/\*[.\s\S]*\*\//g, ''); var spaceStripped = multiStripped.replace(/\n/mg, ' ').replace(/ {2}/g, ' '); return constructorRegex.test(spaceStripped); } catch (e) { return false; /* not a function */ } }, tryFunctionObject = function tryFunctionObject(value) { try { if (isES6ClassFn(value)) { return false; } fnToStr.call(value); return true; } catch (e) { return false; } }, fnClass = '[object Function]', genClass = '[object GeneratorFunction]', isCallable = function isCallable(value) { if (!value) { return false; } if (typeof value !== 'function' && typeof value !== 'object') { return false; } if (hasToStringTag) { return tryFunctionObject(value); } if (isES6ClassFn(value)) { return false; } 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; }; + /* eslint-enable one-var-declaration-per-line, no-redeclare, max-statements-per-line */ + + /* inlined from http://npmjs.com/define-properties */ + var supportsDescriptors = $Object.defineProperty && (function () { + try { + var obj = {}; + $Object.defineProperty(obj, 'x', { enumerable: false, value: obj }); + for (var _ in obj) { // jscs:ignore disallowUnusedVariables + return false; + } + return obj.x === obj; + } catch (e) { /* this is ES3 */ + return false; + } + }()); + var defineProperties = (function (has) { + // 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; + }; + } + return function defineProperties(object, map, forceAssign) { + for (var name in map) { + if (has.call(map, name)) { + defineProperty(object, name, map[name], forceAssign); + } + } + }; + }(ObjectPrototype.hasOwnProperty)); + + // + // Util + // ====== + // + + /* replaceable with https://npmjs.com/package/es-abstract /helpers/isPrimitive */ + var isPrimitive = function isPrimitive(input) { + var type = typeof input; + return input === null || (type !== 'object' && type !== 'function'); + }; + + var isActualNaN = $Number.isNaN || function isActualNaN(x) { + return x !== x; + }; + + 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) { + var n = +num; + if (isActualNaN(n)) { + n = 0; + } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) { + n = (n > 0 || -1) * Math.floor(Math.abs(n)); + } + return n; + }, + + /* replaceable with https://npmjs.com/package/es-abstract ES5.ToPrimitive */ + ToPrimitive: function ToPrimitive(input) { + var val, valueOf, toStr; + if (isPrimitive(input)) { + return input; + } + valueOf = input.valueOf; + if (isCallable(valueOf)) { + val = valueOf.call(input); + if (isPrimitive(val)) { + return val; + } + } + toStr = input.toString; + if (isCallable(toStr)) { + val = toStr.call(input); + if (isPrimitive(val)) { + return val; + } + } + throw new TypeError(); + }, + + // ES5 9.9 + // http://es5.github.com/#x9.9 + /* replaceable with https://npmjs.com/package/es-abstract ES5.ToObject */ + ToObject: function (o) { + if (o == null) { // this matches both null and undefined + throw new TypeError("can't convert " + o + ' to object'); + } + return $Object(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 + // 1. Let Target be the this value. + var target = this; + // 2. If IsCallable(Target) is false, throw a TypeError exception. + if (!isCallable(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. + // XXX slicedArgs will stand in for "A" if used + 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. + // 12. Set the [[Call]] internal property of F as described in + // 15.3.4.5.1. + // 13. Set the [[Construct]] internal property of F as described in + // 15.3.4.5.2. + // 14. Set the [[HasInstance]] internal property of F as described in + // 15.3.4.5.3. + var bound; + 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. + // 2. If target has no [[Construct]] internal method, a + // TypeError exception is thrown. + // 3. Let boundArgs be the value of F's [[BoundArgs]] internal + // 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. + // 5. Return the result of calling the [[Construct]] internal + // method of target providing args as the arguments. + + var result = apply.call( + target, + this, + array_concat.call(args, array_slice.call(arguments)) + ); + if ($Object(result) === result) { + return result; + } + return this; + + } else { + // 15.3.4.5.1 [[Call]] + // 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. + // 2. Let boundThis be the value of F's [[BoundThis]] internal + // property. + // 3. Let target be the value of F's [[TargetFunction]] internal + // 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. + // 5. Return the result of calling the [[Call]] internal method + // of target providing boundThis as the this value and + // providing args as the arguments. + + // equiv: target.call(this, ...boundArgs, ...args) + return apply.call( + target, + that, + array_concat.call(args, 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. + // 16. Else set the length own property of F to 0. + + var boundLength = 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. + var boundArgs = []; + for (var i = 0; i < boundLength; i++) { + array_push.call(boundArgs, '$' + i); + } + + // XXX Build a dynamic function with desired amount of arguments is the only + // way to set the length property of a function. + // In environments where Content Security Policies enabled (Chrome extensions, + // for ex.) all use of eval or Function costructor throws an exception. + // However in all of these environments Function.prototype.bind exists + // and so this code will never be executed. + bound = $Function('binder', 'return function (' + array_join.call(boundArgs, ',') + '){ return binder.apply(this, arguments); }')(binder); + + if (target.prototype) { + Empty.prototype = target.prototype; + bound.prototype = new Empty(); + // Clean up dangling references. + Empty.prototype = null; + } + + // TODO + // 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. + // 21. Call the [[DefineOwnProperty]] internal method of F with + // 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 + // use it in defining shortcuts. + var owns = call.bind(ObjectPrototype.hasOwnProperty); + var toStr = call.bind(ObjectPrototype.toString); + var arraySlice = call.bind(array_slice); + var arraySliceApply = apply.bind(array_slice); + var strSlice = call.bind(StringPrototype.slice); + var strSplit = call.bind(StringPrototype.split); + var strIndexOf = call.bind(StringPrototype.indexOf); + var pushCall = call.bind(array_push); + var isEnum = call.bind(ObjectPrototype.propertyIsEnumerable); + var arraySort = call.bind(ArrayPrototype.sort); + + // + // Array + // ===== + // + + var isArray = $Array.isArray || function isArray(obj) { + return toStr(obj) === '[object Array]'; + }; + + // 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) { + // Check node 0.6.21 bug where third parameter is not boxed + var properlyBoxesNonStrict = true; + var properlyBoxesStrict = true; + var threwException = false; + if (method) { + try { + method.call('foo', function (_, __, context) { + if (typeof context !== 'object') { + properlyBoxesNonStrict = false; + } + }); + + method.call([1], function () { + 'use strict'; + + properlyBoxesStrict = typeof this === 'string'; + }, 'x'); + } catch (e) { + threwException = true; + } + } + return !!method && !threwException && properlyBoxesNonStrict && properlyBoxesStrict; + }; + + defineProperties(ArrayPrototype, { + forEach: function forEach(callbackfn/*, thisArg*/) { + var object = ES.ToObject(this); + var self = splitString && isString(this) ? strSplit(this, '') : object; + var i = -1; + var length = ES.ToUint32(self.length); + var T; + if (arguments.length > 1) { + T = arguments[1]; + } + + // If no callback function or if callback is not a callable function + if (!isCallable(callbackfn)) { + throw new TypeError('Array.prototype.forEach callback must be a function'); + } + + while (++i < length) { + if (i in self) { + // Invoke the callback function with call, passing arguments: + // context, property value, property key, thisArg object + if (typeof T === 'undefined') { + callbackfn(self[i], i, object); + } else { + callbackfn.call(T, 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 + defineProperties(ArrayPrototype, { + map: function map(callbackfn/*, thisArg*/) { + var object = ES.ToObject(this); + var self = splitString && isString(this) ? strSplit(this, '') : object; + var length = ES.ToUint32(self.length); + var result = $Array(length); + var T; + if (arguments.length > 1) { + T = arguments[1]; + } + + // If no callback function or if callback is not a callable function + if (!isCallable(callbackfn)) { + throw new TypeError('Array.prototype.map callback must be a function'); + } + + for (var i = 0; i < length; i++) { + if (i in self) { + if (typeof T === 'undefined') { + result[i] = callbackfn(self[i], i, object); + } else { + result[i] = callbackfn.call(T, 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 + defineProperties(ArrayPrototype, { + filter: function filter(callbackfn/*, thisArg*/) { + var object = ES.ToObject(this); + var self = splitString && isString(this) ? strSplit(this, '') : object; + var length = ES.ToUint32(self.length); + var result = []; + var value; + var T; + if (arguments.length > 1) { + T = arguments[1]; + } + + // If no callback function or if callback is not a callable function + if (!isCallable(callbackfn)) { + throw new TypeError('Array.prototype.filter callback must be a function'); + } + + for (var i = 0; i < length; i++) { + if (i in self) { + value = self[i]; + if (typeof T === 'undefined' ? callbackfn(value, i, object) : callbackfn.call(T, value, i, object)) { + pushCall(result, 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 + defineProperties(ArrayPrototype, { + every: function every(callbackfn/*, thisArg*/) { + var object = ES.ToObject(this); + var self = splitString && isString(this) ? strSplit(this, '') : object; + var length = ES.ToUint32(self.length); + var T; + if (arguments.length > 1) { + T = arguments[1]; + } + + // If no callback function or if callback is not a callable function + if (!isCallable(callbackfn)) { + throw new TypeError('Array.prototype.every callback must be a function'); + } + + for (var i = 0; i < length; i++) { + if (i in self && !(typeof T === 'undefined' ? callbackfn(self[i], i, object) : callbackfn.call(T, 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 + defineProperties(ArrayPrototype, { + some: function some(callbackfn/*, thisArg */) { + var object = ES.ToObject(this); + var self = splitString && isString(this) ? strSplit(this, '') : object; + var length = ES.ToUint32(self.length); + var T; + if (arguments.length > 1) { + T = arguments[1]; + } + + // If no callback function or if callback is not a callable function + if (!isCallable(callbackfn)) { + throw new TypeError('Array.prototype.some callback must be a function'); + } + + for (var i = 0; i < length; i++) { + if (i in self && (typeof T === 'undefined' ? callbackfn(self[i], i, object) : callbackfn.call(T, 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 (ArrayPrototype.reduce) { + reduceCoercesToObject = typeof ArrayPrototype.reduce.call('es5', function (_, __, ___, list) { + return list; + }) === 'object'; + } + defineProperties(ArrayPrototype, { + reduce: function reduce(callbackfn/*, initialValue*/) { + var object = ES.ToObject(this); + var self = splitString && isString(this) ? strSplit(this, '') : object; + var length = ES.ToUint32(self.length); + + // If no callback function or if callback is not a callable function + if (!isCallable(callbackfn)) { + throw new TypeError('Array.prototype.reduce callback must be a function'); + } + + // no value to return if no initial value and an empty array + if (length === 0 && arguments.length === 1) { + throw new TypeError('reduce of empty array with no initial value'); + } + + var i = 0; + var result; + if (arguments.length >= 2) { + result = arguments[1]; + } else { + do { + if (i in self) { + result = self[i++]; + break; + } + + // if array contains no values, no initial value to return + if (++i >= length) { + throw new TypeError('reduce of empty array with no initial value'); + } + } while (true); + } + + for (; i < length; i++) { + if (i in self) { + result = callbackfn(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 (ArrayPrototype.reduceRight) { + reduceRightCoercesToObject = typeof ArrayPrototype.reduceRight.call('es5', function (_, __, ___, list) { + return list; + }) === 'object'; + } + defineProperties(ArrayPrototype, { + reduceRight: function reduceRight(callbackfn/*, initial*/) { + var object = ES.ToObject(this); + var self = splitString && isString(this) ? strSplit(this, '') : object; + var length = ES.ToUint32(self.length); + + // If no callback function or if callback is not a callable function + if (!isCallable(callbackfn)) { + throw new TypeError('Array.prototype.reduceRight callback must be a function'); + } + + // no value to return if no initial value, empty array + if (length === 0 && arguments.length === 1) { + throw new TypeError('reduceRight of empty array with no initial value'); + } + + var result; + var i = length - 1; + if (arguments.length >= 2) { + result = arguments[1]; + } else { + do { + if (i in self) { + result = self[i--]; + break; + } + + // if array contains no values, no initial value to return + if (--i < 0) { + throw new TypeError('reduceRight of empty array with no initial value'); + } + } while (true); + } + + if (i < 0) { + return result; + } + + do { + if (i in self) { + result = callbackfn(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 + var hasFirefox2IndexOfBug = ArrayPrototype.indexOf && [0, 1].indexOf(1, 2) !== -1; + defineProperties(ArrayPrototype, { + indexOf: function indexOf(searchElement/*, fromIndex */) { + var self = splitString && isString(this) ? strSplit(this, '') : ES.ToObject(this); + var length = ES.ToUint32(self.length); + + if (length === 0) { + return -1; + } + + var i = 0; + if (arguments.length > 1) { + i = ES.ToInteger(arguments[1]); + } + + // handle negative indices + i = i >= 0 ? i : max(0, length + i); + for (; i < length; i++) { + if (i in self && self[i] === searchElement) { + 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 + var hasFirefox2LastIndexOfBug = ArrayPrototype.lastIndexOf && [0, 1].lastIndexOf(0, -3) !== -1; + defineProperties(ArrayPrototype, { + lastIndexOf: function lastIndexOf(searchElement/*, fromIndex */) { + var self = splitString && isString(this) ? strSplit(this, '') : ES.ToObject(this); + var length = ES.ToUint32(self.length); + + if (length === 0) { + return -1; + } + var i = length - 1; + if (arguments.length > 1) { + i = min(i, ES.ToInteger(arguments[1])); + } + // handle negative indices + i = i >= 0 ? i : length - Math.abs(i); + for (; i >= 0; i--) { + if (i in self && searchElement === self[i]) { + return i; + } + } + return -1; + } + }, hasFirefox2LastIndexOfBug); + + // 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) { + 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 []; + } + var args = arguments; + this.length = max(ES.ToInteger(this.length), 0); + if (arguments.length > 0 && typeof deleteCount !== 'number') { + args = arraySlice(arguments); + if (args.length < 2) { + pushCall(args, this.length - start); + } else { + args[1] = ES.ToInteger(deleteCount); + } + } + return array_splice.apply(this, args); + } + }, !spliceWorksWithEmptyObject); + var spliceWorksWithLargeSparseArrays = (function () { + // Per https://github.com/es-shims/es5-shim/issues/295 + // Safari 7/8 breaks with sparse arrays of size 1e5 or greater + var arr = new $Array(1e5); + // note: the index MUST be 8 or larger or the test will false pass + arr[8] = 'x'; + arr.splice(1, 1); + // note: this test must be defined *after* the indexOf shim + // per https://github.com/es-shims/es5-shim/issues/313 + return arr.indexOf('x') === 7; + }()); + var spliceWorksWithSmallSparseArrays = (function () { + // Per https://github.com/es-shims/es5-shim/issues/295 + // Opera 12.15 breaks on this, no idea why. + var n = 256; + var arr = []; + arr[n] = 'a'; + arr.splice(n + 1, 0, 'b'); + return arr[n] === 'a'; + }()); + defineProperties(ArrayPrototype, { + splice: function splice(start, deleteCount) { + var O = ES.ToObject(this); + var A = []; + var len = ES.ToUint32(O.length); + var relativeStart = ES.ToInteger(start); + var actualStart = relativeStart < 0 ? max((len + relativeStart), 0) : min(relativeStart, len); + var actualDeleteCount = min(max(ES.ToInteger(deleteCount), 0), len - actualStart); + + var k = 0; + var from; + while (k < actualDeleteCount) { + from = $String(actualStart + k); + if (owns(O, from)) { + A[k] = O[from]; + } + k += 1; + } + + var items = arraySlice(arguments, 2); + var itemCount = items.length; + var to; + if (itemCount < actualDeleteCount) { + k = actualStart; + var maxK = len - actualDeleteCount; + while (k < maxK) { + from = $String(k + actualDeleteCount); + to = $String(k + itemCount); + if (owns(O, from)) { + O[to] = O[from]; + } else { + delete O[to]; + } + k += 1; + } + k = len; + var minK = len - actualDeleteCount + itemCount; + while (k > minK) { + delete O[k - 1]; + k -= 1; + } + } else if (itemCount > actualDeleteCount) { + k = len - actualDeleteCount; + while (k > actualStart) { + from = $String(k + actualDeleteCount - 1); + to = $String(k + itemCount - 1); + if (owns(O, from)) { + O[to] = O[from]; + } else { + delete O[to]; + } + k -= 1; + } + } + k = actualStart; + for (var i = 0; i < items.length; ++i) { + O[k] = items[i]; + k += 1; + } + O.length = len - actualDeleteCount + itemCount; + + return A; + } + }, !spliceWorksWithLargeSparseArrays || !spliceWorksWithSmallSparseArrays); + + var originalJoin = ArrayPrototype.join; + var hasStringJoinBug; + try { + hasStringJoinBug = Array.prototype.join.call('123', ',') !== '1,2,3'; + } catch (e) { + hasStringJoinBug = true; + } + if (hasStringJoinBug) { + defineProperties(ArrayPrototype, { + join: function join(separator) { + var sep = typeof separator === 'undefined' ? ',' : separator; + return originalJoin.call(isString(this) ? strSplit(this, '') : this, sep); + } + }, hasStringJoinBug); + } + + var hasJoinUndefinedBug = [1, 2].join(undefined) !== '1,2'; + if (hasJoinUndefinedBug) { + defineProperties(ArrayPrototype, { + join: function join(separator) { + var sep = typeof separator === 'undefined' ? ',' : separator; + return originalJoin.call(this, sep); + } + }, hasJoinUndefinedBug); + } + + var pushShim = function push(item) { + var O = ES.ToObject(this); + var n = ES.ToUint32(O.length); + var i = 0; + while (i < arguments.length) { + O[n + i] = arguments[i]; + i += 1; + } + O.length = n + i; + return n + i; + }; + + var pushIsNotGeneric = (function () { + var obj = {}; + var result = Array.prototype.push.call(obj, undefined); + return result !== 1 || obj.length !== 1 || typeof obj[0] !== 'undefined' || !owns(obj, 0); + }()); + defineProperties(ArrayPrototype, { + push: function push(item) { + if (isArray(this)) { + return array_push.apply(this, arguments); + } + return pushShim.apply(this, arguments); + } + }, pushIsNotGeneric); + + // This fixes a very weird bug in Opera 10.6 when pushing `undefined + var pushUndefinedIsWeird = (function () { + var arr = []; + var result = arr.push(undefined); + return result !== 1 || arr.length !== 1 || typeof arr[0] !== 'undefined' || !owns(arr, 0); + }()); + defineProperties(ArrayPrototype, { push: pushShim }, pushUndefinedIsWeird); + + // ES5 15.2.3.14 + // http://es5.github.io/#x15.4.4.10 + // Fix boxed string bug + defineProperties(ArrayPrototype, { + slice: function (start, end) { + var arr = isString(this) ? strSplit(this, '') : this; + return arraySliceApply(arr, arguments); + } + }, splitString); + + var sortIgnoresNonFunctions = (function () { + try { + [1, 2].sort(null); + [1, 2].sort({}); + return true; + } catch (e) {} + return false; + }()); + var sortThrowsOnRegex = (function () { + // this is a problem in Firefox 4, in which `typeof /a/ === 'function'` + try { + [1, 2].sort(/a/); + return false; + } catch (e) {} + return true; + }()); + var sortIgnoresUndefined = (function () { + // applies in IE 8, for one. + try { + [1, 2].sort(undefined); + return true; + } catch (e) {} + return false; + }()); + defineProperties(ArrayPrototype, { + sort: function sort(compareFn) { + if (typeof compareFn === 'undefined') { + return arraySort(this); + } + if (!isCallable(compareFn)) { + throw new TypeError('Array.prototype.sort callback must be a function'); + } + return arraySort(this, compareFn); + } + }, sortIgnoresNonFunctions || !sortIgnoresUndefined || !sortThrowsOnRegex); + + // + // 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 = !isEnum({ 'toString': null }, 'toString'); + var hasProtoEnumBug = isEnum(function () {}, 'prototype'); + var hasStringEnumBug = !owns('x', '0'); + var equalsConstructorPrototype = function (o) { + var ctor = o.constructor; + return ctor && ctor.prototype === o; + }; + var blacklistedKeys = { + $window: true, + $console: true, + $parent: true, + $self: true, + $frame: true, + $frames: true, + $frameElement: true, + $webkitIndexedDB: true, + $webkitStorageInfo: true, + $external: true + }; + var hasAutomationEqualityBug = (function () { + /* globals window */ + if (typeof window === 'undefined') { + return false; + } + for (var k in window) { + try { + if (!blacklistedKeys['$' + k] && owns(window, k) && window[k] !== null && typeof window[k] === 'object') { + equalsConstructorPrototype(window[k]); + } + } catch (e) { + return true; + } + } + return false; + }()); + var equalsConstructorPrototypeIfNotBuggy = function (object) { + if (typeof window === 'undefined' || !hasAutomationEqualityBug) { + return equalsConstructorPrototype(object); + } + try { + return equalsConstructorPrototype(object); + } catch (e) { + return false; + } + }; + var dontEnums = [ + 'toString', + 'toLocaleString', + 'valueOf', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'constructor' + ]; + var dontEnumsLength = dontEnums.length; + + // taken directly from https://github.com/ljharb/is-arguments/blob/master/index.js + // can be replaced with require('is-arguments') if we ever use a build process instead + var isStandardArguments = function isArguments(value) { + return toStr(value) === '[object Arguments]'; + }; + var isLegacyArguments = function isArguments(value) { + return value !== null && + typeof value === 'object' && + typeof value.length === 'number' && + value.length >= 0 && + !isArray(value) && + isCallable(value.callee); + }; + var isArguments = isStandardArguments(arguments) ? isStandardArguments : isLegacyArguments; + + defineProperties($Object, { + keys: function keys(object) { + var isFn = isCallable(object); + var isArgs = isArguments(object); + var isObject = object !== null && typeof object === 'object'; + var 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 ((isStr && hasStringEnumBug) || isArgs) { + for (var i = 0; i < object.length; ++i) { + pushCall(theKeys, $String(i)); + } + } + + if (!isArgs) { + for (var name in object) { + if (!(skipProto && name === 'prototype') && owns(object, name)) { + pushCall(theKeys, $String(name)); + } + } + } + + if (hasDontEnumBug) { + var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object); + for (var j = 0; j < dontEnumsLength; j++) { + var dontEnum = dontEnums[j]; + if (!(skipConstructor && dontEnum === 'constructor') && owns(object, dontEnum)) { + pushCall(theKeys, dontEnum); + } + } + } + return theKeys; + } + }); + + var keysWorksWithArguments = $Object.keys && (function () { + // Safari 5.0 bug + return $Object.keys(arguments).length === 2; + }(1, 2)); + var keysHasArgumentsLengthBug = $Object.keys && (function () { + var argKeys = $Object.keys(arguments); + return arguments.length !== 1 || argKeys.length !== 1 || argKeys[0] !== 1; + }(1)); + var originalKeys = $Object.keys; + defineProperties($Object, { + keys: function keys(object) { + if (isArguments(object)) { + return originalKeys(arraySlice(object)); + } else { + return originalKeys(object); + } + } + }, !keysWorksWithArguments || keysHasArgumentsLengthBug); + + // + // Date + // ==== + // + + var hasNegativeMonthYearBug = new Date(-3509827329600292).getUTCMonth() !== 0; + var aNegativeTestDate = new Date(-1509842289600292); + var aPositiveTestDate = new Date(1449662400000); + var hasToUTCStringFormatBug = aNegativeTestDate.toUTCString() !== 'Mon, 01 Jan -45875 11:59:59 GMT'; + var hasToDateStringFormatBug; + var hasToStringFormatBug; + var timeZoneOffset = aNegativeTestDate.getTimezoneOffset(); + if (timeZoneOffset < -720) { + hasToDateStringFormatBug = aNegativeTestDate.toDateString() !== 'Tue Jan 02 -45875'; + hasToStringFormatBug = !(/^Thu Dec 10 2015 \d\d:\d\d:\d\d GMT[-\+]\d\d\d\d(?: |$)/).test(aPositiveTestDate.toString()); + } else { + hasToDateStringFormatBug = aNegativeTestDate.toDateString() !== 'Mon Jan 01 -45875'; + hasToStringFormatBug = !(/^Wed Dec 09 2015 \d\d:\d\d:\d\d GMT[-\+]\d\d\d\d(?: |$)/).test(aPositiveTestDate.toString()); + } + + var originalGetFullYear = call.bind(Date.prototype.getFullYear); + var originalGetMonth = call.bind(Date.prototype.getMonth); + var originalGetDate = call.bind(Date.prototype.getDate); + var originalGetUTCFullYear = call.bind(Date.prototype.getUTCFullYear); + var originalGetUTCMonth = call.bind(Date.prototype.getUTCMonth); + var originalGetUTCDate = call.bind(Date.prototype.getUTCDate); + var originalGetUTCDay = call.bind(Date.prototype.getUTCDay); + var originalGetUTCHours = call.bind(Date.prototype.getUTCHours); + var originalGetUTCMinutes = call.bind(Date.prototype.getUTCMinutes); + var originalGetUTCSeconds = call.bind(Date.prototype.getUTCSeconds); + var originalGetUTCMilliseconds = call.bind(Date.prototype.getUTCMilliseconds); + var dayName = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']; + var monthName = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']; + var daysInMonth = function daysInMonth(month, year) { + return originalGetDate(new Date(year, month, 0)); + }; + + defineProperties(Date.prototype, { + getFullYear: function getFullYear() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var year = originalGetFullYear(this); + if (year < 0 && originalGetMonth(this) > 11) { + return year + 1; + } + return year; + }, + getMonth: function getMonth() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var year = originalGetFullYear(this); + var month = originalGetMonth(this); + if (year < 0 && month > 11) { + return 0; + } + return month; + }, + getDate: function getDate() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var year = originalGetFullYear(this); + var month = originalGetMonth(this); + var date = originalGetDate(this); + if (year < 0 && month > 11) { + if (month === 12) { + return date; + } + var days = daysInMonth(0, year + 1); + return (days - date) + 1; + } + return date; + }, + getUTCFullYear: function getUTCFullYear() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var year = originalGetUTCFullYear(this); + if (year < 0 && originalGetUTCMonth(this) > 11) { + return year + 1; + } + return year; + }, + getUTCMonth: function getUTCMonth() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var year = originalGetUTCFullYear(this); + var month = originalGetUTCMonth(this); + if (year < 0 && month > 11) { + return 0; + } + return month; + }, + getUTCDate: function getUTCDate() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var year = originalGetUTCFullYear(this); + var month = originalGetUTCMonth(this); + var date = originalGetUTCDate(this); + if (year < 0 && month > 11) { + if (month === 12) { + return date; + } + var days = daysInMonth(0, year + 1); + return (days - date) + 1; + } + return date; + } + }, hasNegativeMonthYearBug); + + defineProperties(Date.prototype, { + toUTCString: function toUTCString() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var day = originalGetUTCDay(this); + var date = originalGetUTCDate(this); + var month = originalGetUTCMonth(this); + var year = originalGetUTCFullYear(this); + var hour = originalGetUTCHours(this); + var minute = originalGetUTCMinutes(this); + var second = originalGetUTCSeconds(this); + return dayName[day] + ', ' + + (date < 10 ? '0' + date : date) + ' ' + + monthName[month] + ' ' + + year + ' ' + + (hour < 10 ? '0' + hour : hour) + ':' + + (minute < 10 ? '0' + minute : minute) + ':' + + (second < 10 ? '0' + second : second) + ' GMT'; + } + }, hasNegativeMonthYearBug || hasToUTCStringFormatBug); + + // Opera 12 has `,` + defineProperties(Date.prototype, { + toDateString: function toDateString() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var day = this.getDay(); + var date = this.getDate(); + var month = this.getMonth(); + var year = this.getFullYear(); + return dayName[day] + ' ' + + monthName[month] + ' ' + + (date < 10 ? '0' + date : date) + ' ' + + year; + } + }, hasNegativeMonthYearBug || hasToDateStringFormatBug); + + // can't use defineProperties here because of toString enumeration issue in IE <= 8 + if (hasNegativeMonthYearBug || hasToStringFormatBug) { + Date.prototype.toString = function toString() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var day = this.getDay(); + var date = this.getDate(); + var month = this.getMonth(); + var year = this.getFullYear(); + var hour = this.getHours(); + var minute = this.getMinutes(); + var second = this.getSeconds(); + var timezoneOffset = this.getTimezoneOffset(); + var hoursOffset = Math.floor(Math.abs(timezoneOffset) / 60); + var minutesOffset = Math.floor(Math.abs(timezoneOffset) % 60); + return dayName[day] + ' ' + + monthName[month] + ' ' + + (date < 10 ? '0' + date : date) + ' ' + + year + ' ' + + (hour < 10 ? '0' + hour : hour) + ':' + + (minute < 10 ? '0' + minute : minute) + ':' + + (second < 10 ? '0' + second : second) + ' GMT' + + (timezoneOffset > 0 ? '-' : '+') + + (hoursOffset < 10 ? '0' + hoursOffset : hoursOffset) + + (minutesOffset < 10 ? '0' + minutesOffset : minutesOffset); + }; + if (supportsDescriptors) { + $Object.defineProperty(Date.prototype, 'toString', { + configurable: true, + enumerable: false, + writable: true + }); + } + } + + // 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; + var hasSafari51DateBug = Date.prototype.toISOString && new Date(-1).toISOString() !== '1969-12-31T23:59:59.999Z'; + + var getTime = call.bind(Date.prototype.getTime); + + defineProperties(Date.prototype, { + toISOString: function toISOString() { + if (!isFinite(this) || !isFinite(getTime(this))) { + // Adope Photoshop requires the second check. + throw new RangeError('Date.prototype.toISOString called on non-finite value.'); + } + + var year = originalGetUTCFullYear(this); + + var month = originalGetUTCMonth(this); + // see https://github.com/es-shims/es5-shim/issues/111 + year += Math.floor(month / 12); + month = (month % 12 + 12) % 12; + + // the date time string format is specified in 15.9.1.15. + var result = [month + 1, originalGetUTCDate(this), originalGetUTCHours(this), originalGetUTCMinutes(this), originalGetUTCSeconds(this)]; + year = ( + (year < 0 ? '-' : (year > 9999 ? '+' : '')) + + strSlice('00000' + Math.abs(year), (0 <= year && year <= 9999) ? -4 : -6) + ); + + for (var i = 0; i < result.length; ++i) { + // pad months, days, hours, minutes, and seconds to have two digits. + result[i] = strSlice('00' + result[i], -2); + } + // pad milliseconds to have three digits. + return ( + year + '-' + arraySlice(result, 0, 2).join('-') + + 'T' + arraySlice(result, 2).join(':') + '.' + + strSlice('000' + originalGetUTCMilliseconds(this), -3) + 'Z' + ); + } + }, hasNegativeDateBug || hasSafari51DateBug); + + // 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 = (function () { + try { + return 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) { + return false; + } + }()); + 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 + // value as its argument. + // 2. Let tv be ES.ToPrimitive(O, hint Number). + var O = $Object(this); + var tv = ES.ToPrimitive(O); + // 3. If tv is a Number and is not finite, return null. + if (typeof tv === 'number' && !isFinite(tv)) { + return null; + } + // 4. Let toISO be the result of calling the [[Get]] internal method of + // O with argument "toISOString". + var toISO = O.toISOString; + // 5. If IsCallable(toISO) is false, throw a TypeError exception. + if (!isCallable(toISO)) { + 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. + return toISO.call(O); + + // NOTE 1 The argument is ignored. + + // NOTE 2 The toJSON function is intentionally generic; it does not + // require that its this value be a Date object. Therefore, it can be + // transferred to other kinds of objects for use as a method. However, + // it does require that any such object have a toISOString method. An + // object is free to use the argument key to filter its + // stringification. + }; + } + + // 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')) || !isNaN(Date.parse('2012-12-31T23:59:60.000Z')); + var doesNotParseY2KNewYear = isNaN(Date.parse('2000-01-01T00:00:00.000Z')); + if (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 */ + var maxSafeUnsigned32Bit = Math.pow(2, 31) - 1; + var hasSafariSignedIntBug = isActualNaN(new Date(1970, 0, 1, 0, 0, 0, maxSafeUnsigned32Bit + 1).getTime()); + /* eslint-disable no-implicit-globals */ + Date = (function (NativeDate) { + /* eslint-enable no-implicit-globals */ + /* eslint-enable no-undef */ + // Date.length === 7 + var DateShim = function Date(Y, M, D, h, m, s, ms) { + var length = arguments.length; + var date; + if (this instanceof NativeDate) { + var seconds = s; + var millis = ms; + if (hasSafariSignedIntBug && length >= 7 && ms > maxSafeUnsigned32Bit) { + // work around a Safari 8/9 bug where it treats the seconds as signed + var msToShift = Math.floor(ms / maxSafeUnsigned32Bit) * maxSafeUnsigned32Bit; + var sToShift = Math.floor(msToShift / 1e3); + seconds += sToShift; + millis -= sToShift * 1e3; + } + date = length === 1 && $String(Y) === Y ? // isString(Y) + // We explicitly pass it through parse: + new NativeDate(DateShim.parse(Y)) : + // We have to manually make calls depending on argument + // length here + length >= 7 ? new NativeDate(Y, M, D, h, m, seconds, millis) : + length >= 6 ? new NativeDate(Y, M, D, h, m, seconds) : + length >= 5 ? new NativeDate(Y, M, D, h, m) : + length >= 4 ? new NativeDate(Y, M, D, h) : + length >= 3 ? new NativeDate(Y, M, D) : + length >= 2 ? new NativeDate(Y, M) : + length >= 1 ? new NativeDate(Y instanceof NativeDate ? +Y : Y) : + new NativeDate(); + } else { + date = NativeDate.apply(this, arguments); + } + if (!isPrimitive(date)) { + // Prevent mixups with unfixed Date object + defineProperties(date, { constructor: DateShim }, true); + } + return date; + }; + + // 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]; + + var dayFromMonth = 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) + ); + }; + + var toUTC = function toUTC(t) { + var s = 0; + var ms = t; + if (hasSafariSignedIntBug && ms > maxSafeUnsigned32Bit) { + // work around a Safari 8/9 bug where it treats the seconds as signed + var msToShift = Math.floor(ms / maxSafeUnsigned32Bit) * maxSafeUnsigned32Bit; + var sToShift = Math.floor(msToShift / 1e3); + s += sToShift; + ms -= sToShift * 1e3; + } + return $Number(new NativeDate(1970, 0, 1, 0, 0, s, ms)); + }; + + // Copy any custom methods a 3rd party library may have added + for (var key in NativeDate) { + if (owns(NativeDate, key)) { + DateShim[key] = NativeDate[key]; + } + } + + // Copy "native" methods explicitly; they may be non-enumerable + defineProperties(DateShim, { + now: NativeDate.now, + UTC: NativeDate.UTC + }, true); + DateShim.prototype = NativeDate.prototype; + defineProperties(DateShim.prototype, { + constructor: DateShim + }, true); + + // Upgrade Date.parse to handle simplified ISO 8601 strings + var parseShim = function parse(string) { + var match = isoDateExpression.exec(string); + if (match) { + // parse months, days, hours, minutes, seconds, and milliseconds + // provide default values if necessary + // parse the UTC offset component + var year = $Number(match[1]), + month = $Number(match[2] || 1) - 1, + day = $Number(match[3] || 1) - 1, + hour = $Number(match[4] || 0), + minute = $Number(match[5] || 0), + second = $Number(match[6] || 0), + millisecond = Math.floor($Number(match[7] || 0) * 1000), + // When time zone is missed, local offset should be used + // (ES 5.1 bug) + // see https://bugs.ecmascript.org/show_bug.cgi?id=112 + isLocalTime = Boolean(match[4] && !match[8]), + signOffset = match[9] === '-' ? 1 : -1, + hourOffset = $Number(match[10] || 0), + minuteOffset = $Number(match[11] || 0), + result; + var hasMinutesOrSecondsOrMilliseconds = minute > 0 || second > 0 || millisecond > 0; + if ( + hour < (hasMinutesOrSecondsOrMilliseconds ? 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)) + ) { + result = ( + (dayFromMonth(year, month) + day) * 24 + + hour + + hourOffset * signOffset + ) * 60; + result = ( + (result + minute + minuteOffset * signOffset) * 60 + + second + ) * 1000 + millisecond; + if (isLocalTime) { + result = toUTC(result); + } + if (-8.64e15 <= result && result <= 8.64e15) { + return result; + } + } + return NaN; + } + return NativeDate.parse.apply(this, arguments); + }; + defineProperties(DateShim, { parse: parseShim }); + + return DateShim; + }(Date)); + /* global Date: false */ + } + + // ES5 15.9.4.4 + // http://es5.github.com/#x15.9.4.4 + if (!Date.now) { + Date.now = function now() { + return new Date().getTime(); + }; + } + + // + // Number + // ====== + // + + // ES5.1 15.7.4.5 + // http://es5.github.com/#x15.7.4.5 + 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' + ); + + var toFixedHelpers = { + base: 1e7, + size: 6, + data: [0, 0, 0, 0, 0, 0], + multiply: function multiply(n, c) { + var i = -1; + var c2 = c; + while (++i < toFixedHelpers.size) { + c2 += n * toFixedHelpers.data[i]; + toFixedHelpers.data[i] = c2 % toFixedHelpers.base; + c2 = Math.floor(c2 / toFixedHelpers.base); + } + }, + divide: function divide(n) { + var i = toFixedHelpers.size; + var c = 0; + while (--i >= 0) { + c += toFixedHelpers.data[i]; + toFixedHelpers.data[i] = Math.floor(c / n); + c = (c % n) * toFixedHelpers.base; + } + }, + 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 += strSlice('0000000', 0, 7 - t.length) + t; + } + } + } + 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; + var x2 = x; + while (x2 >= 4096) { + n += 12; + x2 /= 4096; + } + while (x2 >= 2) { + n += 1; + x2 /= 2; + } + return n; + } + }; + + var toFixedShim = function toFixed(fractionDigits) { + var f, x, s, m, e, z, j, k; + + // Test for NaN and round fractionDigits down + f = $Number(fractionDigits); + f = isActualNaN(f) ? 0 : Math.floor(f); + + if (f < 0 || f > 20) { + throw new RangeError('Number.toFixed called with invalid number of decimals'); + } + + x = $Number(this); + + if (isActualNaN(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); + } + + s = ''; + + if (x < 0) { + s = '-'; + x = -x; + } + + m = '0'; + + 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) { + toFixedHelpers.multiply(0, z); + j = f; + + while (j >= 7) { + toFixedHelpers.multiply(1e7, 0); + j -= 7; + } + + toFixedHelpers.multiply(toFixedHelpers.pow(10, j, 1), 0); + j = e - 1; + + 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() + strSlice('0.00000000000000000000', 2, 2 + f); + } + } + + if (f > 0) { + k = m.length; + + if (k <= f) { + m = s + strSlice('0.0000000000000000000', 0, f - k + 2) + m; + } else { + m = s + strSlice(m, 0, k - f) + '.' + strSlice(m, k - f); + } + } else { + m = s + m; + } + + return m; + }; + defineProperties(NumberPrototype, { toFixed: toFixedShim }, hasToFixedBugs); + + var hasToPrecisionUndefinedBug = (function () { + try { + return 1.0.toPrecision(undefined) === '1'; + } catch (e) { + return true; + } + }()); + var originalToPrecision = NumberPrototype.toPrecision; + defineProperties(NumberPrototype, { + toPrecision: function toPrecision(precision) { + return typeof precision === 'undefined' ? originalToPrecision.call(this) : originalToPrecision.call(this, precision); + } + }, hasToPrecisionUndefinedBug); + + // + // String + // ====== + // + + // ES5 15.5.4.14 + // http://es5.github.com/#x15.5.4.14 + + // [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 ["", "", "."] + + if ( + 'ab'.split(/(?:ab)*/).length !== 2 || + '.'.split(/(.?)(.?)/).length !== 4 || + 'tesst'.split(/(s)*/)[1] === 't' || + 'test'.split(/(?:)/, -1).length !== 4 || + ''.split(/.?/).length || + '.'.split(/()()/).length > 1 + ) { + (function () { + var compliantExecNpcg = typeof (/()??/).exec('')[1] === 'undefined'; // NPCG: nonparticipating capturing group + var maxSafe32BitInt = Math.pow(2, 32) - 1; + + StringPrototype.split = function (separator, limit) { + var string = String(this); + if (typeof separator === 'undefined' && limit === 0) { + return []; + } + + // If `separator` is not a regex, use native split + if (!isRegex(separator)) { + return strSplit(this, separator, limit); + } + + var output = []; + var flags = (separator.ignoreCase ? 'i' : '') + + (separator.multiline ? 'm' : '') + + (separator.unicode ? 'u' : '') + // in ES6 + (separator.sticky ? 'y' : ''), // Firefox 3+ and ES6 + lastLastIndex = 0, + // Make `global` and avoid `lastIndex` issues by working with a copy + separator2, match, lastIndex, lastLength; + var separatorCopy = new RegExp(separator.source, flags + 'g'); + if (!compliantExecNpcg) { + // Doesn't need flags gy, but they don't hurt + separator2 = new RegExp('^' + separatorCopy.source + '$(?!\\s)', flags); + } + /* Values for `limit`, per the spec: + * If undefined: 4294967295 // maxSafe32BitInt + * If 0, Infinity, or NaN: 0 + * 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 + */ + var splitLimit = typeof limit === 'undefined' ? maxSafe32BitInt : ES.ToUint32(limit); + match = separatorCopy.exec(string); + while (match) { + // `separatorCopy.lastIndex` is not reliable cross-browser + lastIndex = match.index + match[0].length; + if (lastIndex > lastLastIndex) { + pushCall(output, strSlice(string, lastLastIndex, match.index)); + // Fix browsers whose `exec` methods don't consistently return `undefined` for + // nonparticipating capturing groups + if (!compliantExecNpcg && match.length > 1) { + /* eslint-disable no-loop-func */ + match[0].replace(separator2, function () { + for (var i = 1; i < arguments.length - 2; i++) { + if (typeof arguments[i] === 'undefined') { + match[i] = void 0; + } + } + }); + /* eslint-enable no-loop-func */ + } + if (match.length > 1 && match.index < string.length) { + array_push.apply(output, arraySlice(match, 1)); + } + lastLength = match[0].length; + lastLastIndex = lastIndex; + if (output.length >= splitLimit) { + break; + } + } + if (separatorCopy.lastIndex === match.index) { + separatorCopy.lastIndex++; // Avoid an infinite loop + } + match = separatorCopy.exec(string); + } + if (lastLastIndex === string.length) { + if (lastLength || !separatorCopy.test('')) { + pushCall(output, ''); + } + } else { + pushCall(output, strSlice(string, lastLastIndex)); + } + return output.length > splitLimit ? arraySlice(output, 0, splitLimit) : output; + }; + }()); + + // [bugfix, chrome] + // If separator is undefined, then the result array contains just one String, + // 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) { + StringPrototype.split = function split(separator, limit) { + if (typeof separator === 'undefined' && limit === 0) { + return []; + } + return strSplit(this, separator, limit); + }; + } + + var str_replace = StringPrototype.replace; + var replaceReportsGroupsCorrectly = (function () { + var groups = []; + 'x'.replace(/x(.)?/g, function (match, group) { + pushCall(groups, group); + }); + return groups.length === 1 && typeof groups[0] === 'undefined'; + }()); + + if (!replaceReportsGroupsCorrectly) { + StringPrototype.replace = function replace(searchValue, replaceValue) { + var isFn = isCallable(replaceValue); + var hasCapturingGroups = isRegex(searchValue) && (/\)[*?]/).test(searchValue.source); + if (!isFn || !hasCapturingGroups) { + return str_replace.call(this, searchValue, replaceValue); + } else { + var wrappedReplaceValue = function (match) { + var length = arguments.length; + var originalLastIndex = searchValue.lastIndex; + searchValue.lastIndex = 0; + var args = searchValue.exec(match) || []; + searchValue.lastIndex = originalLastIndex; + pushCall(args, arguments[length - 2], arguments[length - 1]); + return replaceValue.apply(this, args); + }; + return str_replace.call(this, searchValue, wrappedReplaceValue); + } + }; + } + + // 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 + var string_substr = StringPrototype.substr; + var hasNegativeSubstrBug = ''.substr && '0b'.substr(-1) !== 'b'; + defineProperties(StringPrototype, { + substr: function substr(start, length) { + var normalizedStart = start; + if (start < 0) { + normalizedStart = max(this.length + start, 0); + } + return string_substr.call(this, normalizedStart, 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'; + 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/ + trim: function trim() { + if (typeof this === 'undefined' || this === null) { + throw new TypeError("can't convert " + this + ' to object'); + } + return $String(this).replace(trimBeginRegexp, '').replace(trimEndRegexp, ''); + } + }, hasTrimWhitespaceBug); + var trim = call.bind(String.prototype.trim); + + var hasLastIndexBug = StringPrototype.lastIndexOf && 'abcあい'.lastIndexOf('あい', 2) !== -1; + defineProperties(StringPrototype, { + lastIndexOf: function lastIndexOf(searchString) { + if (typeof this === 'undefined' || this === null) { + throw new TypeError("can't convert " + this + ' to object'); + } + var S = $String(this); + var searchStr = $String(searchString); + var numPos = arguments.length > 1 ? $Number(arguments[1]) : NaN; + var pos = isActualNaN(numPos) ? Infinity : ES.ToInteger(numPos); + var start = min(max(pos, 0), S.length); + var searchLen = searchStr.length; + var k = start + searchLen; + while (k > 0) { + k = max(0, k - searchLen); + var index = strIndexOf(strSlice(S, k, start + searchLen), searchStr); + if (index !== -1) { + return k + index; + } + } + return -1; + } + }, hasLastIndexBug); + + var originalLastIndexOf = StringPrototype.lastIndexOf; + defineProperties(StringPrototype, { + lastIndexOf: function lastIndexOf(searchString) { + return originalLastIndexOf.apply(this, arguments); + } + }, StringPrototype.lastIndexOf.length !== 1); + + // ES-5 15.1.2.2 + /* eslint-disable radix */ + if (parseInt(ws + '08') !== 8 || parseInt(ws + '0x16') !== 22) { + /* eslint-enable radix */ + /* global parseInt: true */ + parseInt = (function (origParseInt) { + var hexRegex = /^[\-+]?0[xX]/; + return function parseInt(str, radix) { + var string = trim(String(str)); + var defaultedRadix = $Number(radix) || (hexRegex.test(string) ? 16 : 10); + return origParseInt(string, defaultedRadix); + }; + }(parseInt)); + } + + // https://es5.github.io/#x15.1.2.3 + if (1 / parseFloat('-0') !== -Infinity) { + /* global parseFloat: true */ + parseFloat = (function (origParseFloat) { + return function parseFloat(string) { + var inputString = trim(String(string)); + var result = origParseFloat(inputString); + return result === 0 && strSlice(inputString, 0, 1) === '-' ? -0 : result; + }; + }(parseFloat)); + } + + if (String(new RangeError('test')) !== 'RangeError: test') { + var errorToStringShim = function toString() { + if (typeof this === 'undefined' || this === null) { + throw new TypeError("can't convert " + this + ' to object'); + } + var name = this.name; + if (typeof name === 'undefined') { + name = 'Error'; + } else if (typeof name !== 'string') { + name = $String(name); + } + var msg = this.message; + if (typeof msg === 'undefined') { + msg = ''; + } else if (typeof msg !== 'string') { + msg = $String(msg); + } + if (!name) { + return msg; + } + if (!msg) { + return name; + } + return name + ': ' + msg; + }; + // can't use defineProperties here because of toString enumeration issue in IE <= 8 + Error.prototype.toString = errorToStringShim; + } + + if (supportsDescriptors) { + var ensureNonEnumerable = function (obj, prop) { + if (isEnum(obj, prop)) { + var desc = Object.getOwnPropertyDescriptor(obj, prop); + if (desc.configurable) { + desc.enumerable = false; + Object.defineProperty(obj, prop, desc); + } + } + }; + ensureNonEnumerable(Error.prototype, 'message'); + if (Error.prototype.message !== '') { + Error.prototype.message = ''; + } + ensureNonEnumerable(Error.prototype, 'name'); + } + + if (String(/a/mig) !== '/a/gim') { + var regexToString = function toString() { + var str = '/' + this.source + '/'; + if (this.global) { + str += 'g'; + } + if (this.ignoreCase) { + str += 'i'; + } + if (this.multiline) { + str += 'm'; + } + return str; + }; + // can't use defineProperties here because of toString enumeration issue in IE <= 8 + RegExp.prototype.toString = regexToString; + } +})); diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/es5-shim.map b/ecomp-portal-FE/client/bower_components/es5-shim/es5-shim.map new file mode 100644 index 00000000..51188310 --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/es5-shim.map @@ -0,0 +1 @@ +{"version":3,"sources":["es5-shim.js"],"names":["root","factory","define","amd","exports","module","returnExports","this","$Array","Array","ArrayPrototype","prototype","$Object","Object","ObjectPrototype","$Function","Function","FunctionPrototype","$String","String","StringPrototype","$Number","Number","NumberPrototype","array_slice","slice","array_splice","splice","array_push","push","array_unshift","unshift","array_concat","concat","array_join","join","call","apply","max","Math","min","to_string","toString","hasToStringTag","Symbol","toStringTag","isCallable","fnToStr","constructorRegex","isES6ClassFn","value","fnStr","singleStripped","replace","multiStripped","spaceStripped","test","e","tryFunctionObject","fnClass","genClass","strClass","isRegex","regexExec","RegExp","exec","tryRegexExec","regexClass","isString","strValue","valueOf","tryStringObject","stringClass","supportsDescriptors","defineProperty","obj","enumerable","_","x","defineProperties","has","object","name","method","forceAssign","configurable","writable","map","hasOwnProperty","isPrimitive","input","type","isActualNaN","isNaN","ES","ToInteger","num","n","floor","abs","ToPrimitive","val","toStr","TypeError","ToObject","o","ToUint32","Empty","bind","that","target","args","arguments","bound","binder","result","boundLength","length","boundArgs","i","owns","arraySlice","arraySliceApply","strSlice","strSplit","split","strIndexOf","indexOf","pushCall","isEnum","propertyIsEnumerable","arraySort","sort","isArray","hasUnshiftReturnValueBug","boxedString","splitString","properlyBoxesContext","properlyBoxed","properlyBoxesNonStrict","properlyBoxesStrict","threwException","__","context","forEach","callbackfn","self","T","filter","every","some","reduceCoercesToObject","reduce","___","list","reduceRightCoercesToObject","reduceRight","hasFirefox2IndexOfBug","searchElement","hasFirefox2LastIndexOfBug","lastIndexOf","spliceNoopReturnsEmptyArray","a","start","deleteCount","spliceWorksWithEmptyObject","spliceWorksWithLargeSparseArrays","arr","spliceWorksWithSmallSparseArrays","O","A","len","relativeStart","actualStart","actualDeleteCount","k","from","items","itemCount","to","maxK","minK","originalJoin","hasStringJoinBug","separator","sep","hasJoinUndefinedBug","undefined","pushShim","item","pushIsNotGeneric","pushUndefinedIsWeird","end","sortIgnoresNonFunctions","sortThrowsOnRegex","sortIgnoresUndefined","compareFn","hasDontEnumBug","hasProtoEnumBug","hasStringEnumBug","equalsConstructorPrototype","ctor","constructor","blacklistedKeys","$window","$console","$parent","$self","$frame","$frames","$frameElement","$webkitIndexedDB","$webkitStorageInfo","$external","hasAutomationEqualityBug","window","equalsConstructorPrototypeIfNotBuggy","dontEnums","dontEnumsLength","isStandardArguments","isArguments","isLegacyArguments","callee","keys","isFn","isArgs","isObject","isStr","theKeys","skipProto","skipConstructor","j","dontEnum","keysWorksWithArguments","keysHasArgumentsLengthBug","argKeys","originalKeys","hasNegativeMonthYearBug","Date","getUTCMonth","aNegativeTestDate","aPositiveTestDate","hasToUTCStringFormatBug","toUTCString","hasToDateStringFormatBug","hasToStringFormatBug","timeZoneOffset","getTimezoneOffset","toDateString","originalGetFullYear","getFullYear","originalGetMonth","getMonth","originalGetDate","getDate","originalGetUTCFullYear","getUTCFullYear","originalGetUTCMonth","originalGetUTCDate","getUTCDate","originalGetUTCDay","getUTCDay","originalGetUTCHours","getUTCHours","originalGetUTCMinutes","getUTCMinutes","originalGetUTCSeconds","getUTCSeconds","originalGetUTCMilliseconds","getUTCMilliseconds","dayName","monthName","daysInMonth","month","year","date","days","day","hour","minute","second","getDay","getHours","getMinutes","getSeconds","timezoneOffset","hoursOffset","minutesOffset","negativeDate","negativeYearString","hasNegativeDateBug","toISOString","hasSafari51DateBug","getTime","isFinite","RangeError","dateToJSONIsSupported","toJSON","NaN","key","tv","toISO","supportsExtendedYears","parse","acceptsInvalidDates","doesNotParseY2KNewYear","maxSafeUnsigned32Bit","pow","hasSafariSignedIntBug","NativeDate","DateShim","Y","M","D","h","m","s","ms","seconds","millis","msToShift","sToShift","isoDateExpression","months","dayFromMonth","t","toUTC","now","UTC","parseShim","string","match","millisecond","isLocalTime","Boolean","signOffset","hourOffset","minuteOffset","hasMinutesOrSecondsOrMilliseconds","hasToFixedBugs","toFixed","toFixedHelpers","base","size","data","multiply","c","c2","divide","numToString","acc","log","x2","toFixedShim","fractionDigits","f","z","hasToPrecisionUndefinedBug","toPrecision","originalToPrecision","precision","compliantExecNpcg","maxSafe32BitInt","limit","output","flags","ignoreCase","multiline","unicode","sticky","lastLastIndex","separator2","lastIndex","lastLength","separatorCopy","source","splitLimit","index","str_replace","replaceReportsGroupsCorrectly","groups","group","searchValue","replaceValue","hasCapturingGroups","wrappedReplaceValue","originalLastIndex","string_substr","substr","hasNegativeSubstrBug","normalizedStart","ws","zeroWidth","wsRegexChars","trimBeginRegexp","trimEndRegexp","hasTrimWhitespaceBug","trim","hasLastIndexBug","searchString","S","searchStr","numPos","pos","Infinity","searchLen","originalLastIndexOf","parseInt","origParseInt","hexRegex","str","radix","defaultedRadix","parseFloat","origParseFloat","inputString","errorToStringShim","msg","message","Error","ensureNonEnumerable","prop","desc","getOwnPropertyDescriptor","regexToString","global"],"mappings":"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"}
\ No newline at end of file diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/es5-shim.min.js b/ecomp-portal-FE/client/bower_components/es5-shim/es5-shim.min.js new file mode 100644 index 00000000..14b24f15 --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/es5-shim.min.js @@ -0,0 +1,7 @@ +/*! + * 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/v4.5.9/LICENSE + */ +(function(t,r){"use strict";if(typeof define==="function"&&define.amd){define(r)}else if(typeof exports==="object"){module.exports=r()}else{t.returnExports=r()}})(this,function(){var t=Array;var r=t.prototype;var e=Object;var n=e.prototype;var i=Function;var a=i.prototype;var o=String;var f=o.prototype;var u=Number;var l=u.prototype;var s=r.slice;var c=r.splice;var v=r.push;var h=r.unshift;var p=r.concat;var y=r.join;var d=a.call;var g=a.apply;var w=Math.max;var b=Math.min;var T=n.toString;var m=typeof Symbol==="function"&&typeof Symbol.toStringTag==="symbol";var D;var S=Function.prototype.toString,x=/^\s*class /,O=function isES6ClassFn(t){try{var r=S.call(t);var e=r.replace(/\/\/.*\n/g,"");var n=e.replace(/\/\*[.\s\S]*\*\//g,"");var i=n.replace(/\n/gm," ").replace(/ {2}/g," ");return x.test(i)}catch(a){return false}},j=function tryFunctionObject(t){try{if(O(t)){return false}S.call(t);return true}catch(r){return false}},E="[object Function]",I="[object GeneratorFunction]",D=function isCallable(t){if(!t){return false}if(typeof t!=="function"&&typeof t!=="object"){return false}if(m){return j(t)}if(O(t)){return false}var r=T.call(t);return r===E||r===I};var M;var U=RegExp.prototype.exec,F=function tryRegexExec(t){try{U.call(t);return true}catch(r){return false}},N="[object RegExp]";M=function isRegex(t){if(typeof t!=="object"){return false}return m?F(t):T.call(t)===N};var C;var k=String.prototype.valueOf,A=function tryStringObject(t){try{k.call(t);return true}catch(r){return false}},R="[object String]";C=function isString(t){if(typeof t==="string"){return true}if(typeof t!=="object"){return false}return m?A(t):T.call(t)===R};var P=e.defineProperty&&function(){try{var t={};e.defineProperty(t,"x",{enumerable:false,value:t});for(var r in t){return false}return t.x===t}catch(n){return false}}();var $=function(t){var r;if(P){r=function(t,r,n,i){if(!i&&r in t){return}e.defineProperty(t,r,{configurable:true,enumerable:false,writable:true,value:n})}}else{r=function(t,r,e,n){if(!n&&r in t){return}t[r]=e}}return function defineProperties(e,n,i){for(var a in n){if(t.call(n,a)){r(e,a,n[a],i)}}}}(n.hasOwnProperty);var J=function isPrimitive(t){var r=typeof t;return t===null||r!=="object"&&r!=="function"};var Y=u.isNaN||function isActualNaN(t){return t!==t};var Z={ToInteger:function ToInteger(t){var r=+t;if(Y(r)){r=0}else if(r!==0&&r!==1/0&&r!==-(1/0)){r=(r>0||-1)*Math.floor(Math.abs(r))}return r},ToPrimitive:function ToPrimitive(t){var r,e,n;if(J(t)){return t}e=t.valueOf;if(D(e)){r=e.call(t);if(J(r)){return r}}n=t.toString;if(D(n)){r=n.call(t);if(J(r)){return r}}throw new TypeError},ToObject:function(t){if(t==null){throw new TypeError("can't convert "+t+" to object")}return e(t)},ToUint32:function ToUint32(t){return t>>>0}};var z=function Empty(){};$(a,{bind:function bind(t){var r=this;if(!D(r)){throw new TypeError("Function.prototype.bind called on incompatible "+r)}var n=s.call(arguments,1);var a;var o=function(){if(this instanceof a){var i=g.call(r,this,p.call(n,s.call(arguments)));if(e(i)===i){return i}return this}else{return g.call(r,t,p.call(n,s.call(arguments)))}};var f=w(0,r.length-n.length);var u=[];for(var l=0;l<f;l++){v.call(u,"$"+l)}a=i("binder","return function ("+y.call(u,",")+"){ return binder.apply(this, arguments); }")(o);if(r.prototype){z.prototype=r.prototype;a.prototype=new z;z.prototype=null}return a}});var G=d.bind(n.hasOwnProperty);var B=d.bind(n.toString);var H=d.bind(s);var W=g.bind(s);var L=d.bind(f.slice);var X=d.bind(f.split);var q=d.bind(f.indexOf);var K=d.bind(v);var Q=d.bind(n.propertyIsEnumerable);var V=d.bind(r.sort);var _=t.isArray||function isArray(t){return B(t)==="[object Array]"};var tt=[].unshift(0)!==1;$(r,{unshift:function(){h.apply(this,arguments);return this.length}},tt);$(t,{isArray:_});var rt=e("a");var et=rt[0]!=="a"||!(0 in rt);var nt=function properlyBoxed(t){var r=true;var e=true;var n=false;if(t){try{t.call("foo",function(t,e,n){if(typeof n!=="object"){r=false}});t.call([1],function(){"use strict";e=typeof this==="string"},"x")}catch(i){n=true}}return!!t&&!n&&r&&e};$(r,{forEach:function forEach(t){var r=Z.ToObject(this);var e=et&&C(this)?X(this,""):r;var n=-1;var i=Z.ToUint32(e.length);var a;if(arguments.length>1){a=arguments[1]}if(!D(t)){throw new TypeError("Array.prototype.forEach callback must be a function")}while(++n<i){if(n in e){if(typeof a==="undefined"){t(e[n],n,r)}else{t.call(a,e[n],n,r)}}}}},!nt(r.forEach));$(r,{map:function map(r){var e=Z.ToObject(this);var n=et&&C(this)?X(this,""):e;var i=Z.ToUint32(n.length);var a=t(i);var o;if(arguments.length>1){o=arguments[1]}if(!D(r)){throw new TypeError("Array.prototype.map callback must be a function")}for(var f=0;f<i;f++){if(f in n){if(typeof o==="undefined"){a[f]=r(n[f],f,e)}else{a[f]=r.call(o,n[f],f,e)}}}return a}},!nt(r.map));$(r,{filter:function filter(t){var r=Z.ToObject(this);var e=et&&C(this)?X(this,""):r;var n=Z.ToUint32(e.length);var i=[];var a;var o;if(arguments.length>1){o=arguments[1]}if(!D(t)){throw new TypeError("Array.prototype.filter callback must be a function")}for(var f=0;f<n;f++){if(f in e){a=e[f];if(typeof o==="undefined"?t(a,f,r):t.call(o,a,f,r)){K(i,a)}}}return i}},!nt(r.filter));$(r,{every:function every(t){var r=Z.ToObject(this);var e=et&&C(this)?X(this,""):r;var n=Z.ToUint32(e.length);var i;if(arguments.length>1){i=arguments[1]}if(!D(t)){throw new TypeError("Array.prototype.every callback must be a function")}for(var a=0;a<n;a++){if(a in e&&!(typeof i==="undefined"?t(e[a],a,r):t.call(i,e[a],a,r))){return false}}return true}},!nt(r.every));$(r,{some:function some(t){var r=Z.ToObject(this);var e=et&&C(this)?X(this,""):r;var n=Z.ToUint32(e.length);var i;if(arguments.length>1){i=arguments[1]}if(!D(t)){throw new TypeError("Array.prototype.some callback must be a function")}for(var a=0;a<n;a++){if(a in e&&(typeof i==="undefined"?t(e[a],a,r):t.call(i,e[a],a,r))){return true}}return false}},!nt(r.some));var it=false;if(r.reduce){it=typeof r.reduce.call("es5",function(t,r,e,n){return n})==="object"}$(r,{reduce:function reduce(t){var r=Z.ToObject(this);var e=et&&C(this)?X(this,""):r;var n=Z.ToUint32(e.length);if(!D(t)){throw new TypeError("Array.prototype.reduce callback must be a function")}if(n===0&&arguments.length===1){throw new TypeError("reduce of empty array with no initial value")}var i=0;var a;if(arguments.length>=2){a=arguments[1]}else{do{if(i in e){a=e[i++];break}if(++i>=n){throw new TypeError("reduce of empty array with no initial value")}}while(true)}for(;i<n;i++){if(i in e){a=t(a,e[i],i,r)}}return a}},!it);var at=false;if(r.reduceRight){at=typeof r.reduceRight.call("es5",function(t,r,e,n){return n})==="object"}$(r,{reduceRight:function reduceRight(t){var r=Z.ToObject(this);var e=et&&C(this)?X(this,""):r;var n=Z.ToUint32(e.length);if(!D(t)){throw new TypeError("Array.prototype.reduceRight callback must be a function")}if(n===0&&arguments.length===1){throw new TypeError("reduceRight of empty array with no initial value")}var i;var a=n-1;if(arguments.length>=2){i=arguments[1]}else{do{if(a in e){i=e[a--];break}if(--a<0){throw new TypeError("reduceRight of empty array with no initial value")}}while(true)}if(a<0){return i}do{if(a in e){i=t(i,e[a],a,r)}}while(a--);return i}},!at);var ot=r.indexOf&&[0,1].indexOf(1,2)!==-1;$(r,{indexOf:function indexOf(t){var r=et&&C(this)?X(this,""):Z.ToObject(this);var e=Z.ToUint32(r.length);if(e===0){return-1}var n=0;if(arguments.length>1){n=Z.ToInteger(arguments[1])}n=n>=0?n:w(0,e+n);for(;n<e;n++){if(n in r&&r[n]===t){return n}}return-1}},ot);var ft=r.lastIndexOf&&[0,1].lastIndexOf(0,-3)!==-1;$(r,{lastIndexOf:function lastIndexOf(t){var r=et&&C(this)?X(this,""):Z.ToObject(this);var e=Z.ToUint32(r.length);if(e===0){return-1}var n=e-1;if(arguments.length>1){n=b(n,Z.ToInteger(arguments[1]))}n=n>=0?n:e-Math.abs(n);for(;n>=0;n--){if(n in r&&t===r[n]){return n}}return-1}},ft);var ut=function(){var t=[1,2];var r=t.splice();return t.length===2&&_(r)&&r.length===0}();$(r,{splice:function splice(t,r){if(arguments.length===0){return[]}else{return c.apply(this,arguments)}}},!ut);var lt=function(){var t={};r.splice.call(t,0,0,1);return t.length===1}();$(r,{splice:function splice(t,r){if(arguments.length===0){return[]}var e=arguments;this.length=w(Z.ToInteger(this.length),0);if(arguments.length>0&&typeof r!=="number"){e=H(arguments);if(e.length<2){K(e,this.length-t)}else{e[1]=Z.ToInteger(r)}}return c.apply(this,e)}},!lt);var st=function(){var r=new t(1e5);r[8]="x";r.splice(1,1);return r.indexOf("x")===7}();var ct=function(){var t=256;var r=[];r[t]="a";r.splice(t+1,0,"b");return r[t]==="a"}();$(r,{splice:function splice(t,r){var e=Z.ToObject(this);var n=[];var i=Z.ToUint32(e.length);var a=Z.ToInteger(t);var f=a<0?w(i+a,0):b(a,i);var u=b(w(Z.ToInteger(r),0),i-f);var l=0;var s;while(l<u){s=o(f+l);if(G(e,s)){n[l]=e[s]}l+=1}var c=H(arguments,2);var v=c.length;var h;if(v<u){l=f;var p=i-u;while(l<p){s=o(l+u);h=o(l+v);if(G(e,s)){e[h]=e[s]}else{delete e[h]}l+=1}l=i;var y=i-u+v;while(l>y){delete e[l-1];l-=1}}else if(v>u){l=i-u;while(l>f){s=o(l+u-1);h=o(l+v-1);if(G(e,s)){e[h]=e[s]}else{delete e[h]}l-=1}}l=f;for(var d=0;d<c.length;++d){e[l]=c[d];l+=1}e.length=i-u+v;return n}},!st||!ct);var vt=r.join;var ht;try{ht=Array.prototype.join.call("123",",")!=="1,2,3"}catch(pt){ht=true}if(ht){$(r,{join:function join(t){var r=typeof t==="undefined"?",":t;return vt.call(C(this)?X(this,""):this,r)}},ht)}var yt=[1,2].join(undefined)!=="1,2";if(yt){$(r,{join:function join(t){var r=typeof t==="undefined"?",":t;return vt.call(this,r)}},yt)}var dt=function push(t){var r=Z.ToObject(this);var e=Z.ToUint32(r.length);var n=0;while(n<arguments.length){r[e+n]=arguments[n];n+=1}r.length=e+n;return e+n};var gt=function(){var t={};var r=Array.prototype.push.call(t,undefined);return r!==1||t.length!==1||typeof t[0]!=="undefined"||!G(t,0)}();$(r,{push:function push(t){if(_(this)){return v.apply(this,arguments)}return dt.apply(this,arguments)}},gt);var wt=function(){var t=[];var r=t.push(undefined);return r!==1||t.length!==1||typeof t[0]!=="undefined"||!G(t,0)}();$(r,{push:dt},wt);$(r,{slice:function(t,r){var e=C(this)?X(this,""):this;return W(e,arguments)}},et);var bt=function(){try{[1,2].sort(null);[1,2].sort({});return true}catch(t){}return false}();var Tt=function(){try{[1,2].sort(/a/);return false}catch(t){}return true}();var mt=function(){try{[1,2].sort(undefined);return true}catch(t){}return false}();$(r,{sort:function sort(t){if(typeof t==="undefined"){return V(this)}if(!D(t)){throw new TypeError("Array.prototype.sort callback must be a function")}return V(this,t)}},bt||!mt||!Tt);var Dt=!Q({toString:null},"toString");var St=Q(function(){},"prototype");var xt=!G("x","0");var Ot=function(t){var r=t.constructor;return r&&r.prototype===t};var jt={$window:true,$console:true,$parent:true,$self:true,$frame:true,$frames:true,$frameElement:true,$webkitIndexedDB:true,$webkitStorageInfo:true,$external:true};var Et=function(){if(typeof window==="undefined"){return false}for(var t in window){try{if(!jt["$"+t]&&G(window,t)&&window[t]!==null&&typeof window[t]==="object"){Ot(window[t])}}catch(r){return true}}return false}();var It=function(t){if(typeof window==="undefined"||!Et){return Ot(t)}try{return Ot(t)}catch(r){return false}};var Mt=["toString","toLocaleString","valueOf","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","constructor"];var Ut=Mt.length;var Ft=function isArguments(t){return B(t)==="[object Arguments]"};var Nt=function isArguments(t){return t!==null&&typeof t==="object"&&typeof t.length==="number"&&t.length>=0&&!_(t)&&D(t.callee)};var Ct=Ft(arguments)?Ft:Nt;$(e,{keys:function keys(t){var r=D(t);var e=Ct(t);var n=t!==null&&typeof t==="object";var i=n&&C(t);if(!n&&!r&&!e){throw new TypeError("Object.keys called on a non-object")}var a=[];var f=St&&r;if(i&&xt||e){for(var u=0;u<t.length;++u){K(a,o(u))}}if(!e){for(var l in t){if(!(f&&l==="prototype")&&G(t,l)){K(a,o(l))}}}if(Dt){var s=It(t);for(var c=0;c<Ut;c++){var v=Mt[c];if(!(s&&v==="constructor")&&G(t,v)){K(a,v)}}}return a}});var kt=e.keys&&function(){return e.keys(arguments).length===2}(1,2);var At=e.keys&&function(){var t=e.keys(arguments);return arguments.length!==1||t.length!==1||t[0]!==1}(1);var Rt=e.keys;$(e,{keys:function keys(t){if(Ct(t)){return Rt(H(t))}else{return Rt(t)}}},!kt||At);var Pt=new Date(-0xc782b5b342b24).getUTCMonth()!==0;var $t=new Date(-0x55d318d56a724);var Jt=new Date(14496624e5);var Yt=$t.toUTCString()!=="Mon, 01 Jan -45875 11:59:59 GMT";var Zt;var zt;var Gt=$t.getTimezoneOffset();if(Gt<-720){Zt=$t.toDateString()!=="Tue Jan 02 -45875";zt=!/^Thu Dec 10 2015 \d\d:\d\d:\d\d GMT[-\+]\d\d\d\d(?: |$)/.test(Jt.toString())}else{Zt=$t.toDateString()!=="Mon Jan 01 -45875";zt=!/^Wed Dec 09 2015 \d\d:\d\d:\d\d GMT[-\+]\d\d\d\d(?: |$)/.test(Jt.toString())}var Bt=d.bind(Date.prototype.getFullYear);var Ht=d.bind(Date.prototype.getMonth);var Wt=d.bind(Date.prototype.getDate);var Lt=d.bind(Date.prototype.getUTCFullYear);var Xt=d.bind(Date.prototype.getUTCMonth);var qt=d.bind(Date.prototype.getUTCDate);var Kt=d.bind(Date.prototype.getUTCDay);var Qt=d.bind(Date.prototype.getUTCHours);var Vt=d.bind(Date.prototype.getUTCMinutes);var _t=d.bind(Date.prototype.getUTCSeconds);var tr=d.bind(Date.prototype.getUTCMilliseconds);var rr=["Sun","Mon","Tue","Wed","Thu","Fri","Sat"];var er=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];var nr=function daysInMonth(t,r){return Wt(new Date(r,t,0))};$(Date.prototype,{getFullYear:function getFullYear(){if(!this||!(this instanceof Date)){throw new TypeError("this is not a Date object.")}var t=Bt(this);if(t<0&&Ht(this)>11){return t+1}return t},getMonth:function getMonth(){if(!this||!(this instanceof Date)){throw new TypeError("this is not a Date object.")}var t=Bt(this);var r=Ht(this);if(t<0&&r>11){return 0}return r},getDate:function getDate(){if(!this||!(this instanceof Date)){throw new TypeError("this is not a Date object.")}var t=Bt(this);var r=Ht(this);var e=Wt(this);if(t<0&&r>11){if(r===12){return e}var n=nr(0,t+1);return n-e+1}return e},getUTCFullYear:function getUTCFullYear(){if(!this||!(this instanceof Date)){throw new TypeError("this is not a Date object.")}var t=Lt(this);if(t<0&&Xt(this)>11){return t+1}return t},getUTCMonth:function getUTCMonth(){if(!this||!(this instanceof Date)){throw new TypeError("this is not a Date object.")}var t=Lt(this);var r=Xt(this);if(t<0&&r>11){return 0}return r},getUTCDate:function getUTCDate(){if(!this||!(this instanceof Date)){throw new TypeError("this is not a Date object.")}var t=Lt(this);var r=Xt(this);var e=qt(this);if(t<0&&r>11){if(r===12){return e}var n=nr(0,t+1);return n-e+1}return e}},Pt);$(Date.prototype,{toUTCString:function toUTCString(){if(!this||!(this instanceof Date)){throw new TypeError("this is not a Date object.")}var t=Kt(this);var r=qt(this);var e=Xt(this);var n=Lt(this);var i=Qt(this);var a=Vt(this);var o=_t(this);return rr[t]+", "+(r<10?"0"+r:r)+" "+er[e]+" "+n+" "+(i<10?"0"+i:i)+":"+(a<10?"0"+a:a)+":"+(o<10?"0"+o:o)+" GMT"}},Pt||Yt);$(Date.prototype,{toDateString:function toDateString(){if(!this||!(this instanceof Date)){throw new TypeError("this is not a Date object.")}var t=this.getDay();var r=this.getDate();var e=this.getMonth();var n=this.getFullYear();return rr[t]+" "+er[e]+" "+(r<10?"0"+r:r)+" "+n}},Pt||Zt);if(Pt||zt){Date.prototype.toString=function toString(){if(!this||!(this instanceof Date)){throw new TypeError("this is not a Date object.")}var t=this.getDay();var r=this.getDate();var e=this.getMonth();var n=this.getFullYear();var i=this.getHours();var a=this.getMinutes();var o=this.getSeconds();var f=this.getTimezoneOffset();var u=Math.floor(Math.abs(f)/60);var l=Math.floor(Math.abs(f)%60);return rr[t]+" "+er[e]+" "+(r<10?"0"+r:r)+" "+n+" "+(i<10?"0"+i:i)+":"+(a<10?"0"+a:a)+":"+(o<10?"0"+o:o)+" GMT"+(f>0?"-":"+")+(u<10?"0"+u:u)+(l<10?"0"+l:l)};if(P){e.defineProperty(Date.prototype,"toString",{configurable:true,enumerable:false,writable:true})}}var ir=-621987552e5;var ar="-000001";var or=Date.prototype.toISOString&&new Date(ir).toISOString().indexOf(ar)===-1;var fr=Date.prototype.toISOString&&new Date(-1).toISOString()!=="1969-12-31T23:59:59.999Z";var ur=d.bind(Date.prototype.getTime);$(Date.prototype,{toISOString:function toISOString(){if(!isFinite(this)||!isFinite(ur(this))){throw new RangeError("Date.prototype.toISOString called on non-finite value.")}var t=Lt(this);var r=Xt(this);t+=Math.floor(r/12);r=(r%12+12)%12;var e=[r+1,qt(this),Qt(this),Vt(this),_t(this)];t=(t<0?"-":t>9999?"+":"")+L("00000"+Math.abs(t),0<=t&&t<=9999?-4:-6);for(var n=0;n<e.length;++n){e[n]=L("00"+e[n],-2)}return t+"-"+H(e,0,2).join("-")+"T"+H(e,2).join(":")+"."+L("000"+tr(this),-3)+"Z"}},or||fr);var lr=function(){try{return Date.prototype.toJSON&&new Date(NaN).toJSON()===null&&new Date(ir).toJSON().indexOf(ar)!==-1&&Date.prototype.toJSON.call({toISOString:function(){return true}})}catch(t){return false}}();if(!lr){Date.prototype.toJSON=function toJSON(t){var r=e(this);var n=Z.ToPrimitive(r);if(typeof n==="number"&&!isFinite(n)){return null}var i=r.toISOString;if(!D(i)){throw new TypeError("toISOString property is not callable")}return i.call(r)}}var sr=Date.parse("+033658-09-27T01:46:40.000Z")===1e15;var cr=!isNaN(Date.parse("2012-04-04T24:00:00.500Z"))||!isNaN(Date.parse("2012-11-31T23:59:59.000Z"))||!isNaN(Date.parse("2012-12-31T23:59:60.000Z"));var vr=isNaN(Date.parse("2000-01-01T00:00:00.000Z"));if(vr||cr||!sr){var hr=Math.pow(2,31)-1;var pr=Y(new Date(1970,0,1,0,0,0,hr+1).getTime());Date=function(t){var r=function Date(e,n,i,a,f,u,l){var s=arguments.length;var c;if(this instanceof t){var v=u;var h=l;if(pr&&s>=7&&l>hr){var p=Math.floor(l/hr)*hr;var y=Math.floor(p/1e3);v+=y;h-=y*1e3}c=s===1&&o(e)===e?new t(r.parse(e)):s>=7?new t(e,n,i,a,f,v,h):s>=6?new t(e,n,i,a,f,v):s>=5?new t(e,n,i,a,f):s>=4?new t(e,n,i,a):s>=3?new t(e,n,i):s>=2?new t(e,n):s>=1?new t(e instanceof t?+e:e):new t}else{c=t.apply(this,arguments)}if(!J(c)){$(c,{constructor:r},true)}return c};var e=new RegExp("^"+"(\\d{4}|[+-]\\d{6})"+"(?:-(\\d{2})"+"(?:-(\\d{2})"+"(?:"+"T(\\d{2})"+":(\\d{2})"+"(?:"+":(\\d{2})"+"(?:(\\.\\d{1,}))?"+")?"+"("+"Z|"+"(?:"+"([-+])"+"(\\d{2})"+":(\\d{2})"+")"+")?)?)?)?"+"$");var n=[0,31,59,90,120,151,181,212,243,273,304,334,365];var i=function dayFromMonth(t,r){var e=r>1?1:0;return n[r]+Math.floor((t-1969+e)/4)-Math.floor((t-1901+e)/100)+Math.floor((t-1601+e)/400)+365*(t-1970)};var a=function toUTC(r){var e=0;var n=r;if(pr&&n>hr){var i=Math.floor(n/hr)*hr;var a=Math.floor(i/1e3);e+=a;n-=a*1e3}return u(new t(1970,0,1,0,0,e,n))};for(var f in t){if(G(t,f)){r[f]=t[f]}}$(r,{now:t.now,UTC:t.UTC},true);r.prototype=t.prototype;$(r.prototype,{constructor:r},true);var l=function parse(r){var n=e.exec(r);if(n){var o=u(n[1]),f=u(n[2]||1)-1,l=u(n[3]||1)-1,s=u(n[4]||0),c=u(n[5]||0),v=u(n[6]||0),h=Math.floor(u(n[7]||0)*1e3),p=Boolean(n[4]&&!n[8]),y=n[9]==="-"?1:-1,d=u(n[10]||0),g=u(n[11]||0),w;var b=c>0||v>0||h>0;if(s<(b?24:25)&&c<60&&v<60&&h<1e3&&f>-1&&f<12&&d<24&&g<60&&l>-1&&l<i(o,f+1)-i(o,f)){w=((i(o,f)+l)*24+s+d*y)*60;w=((w+c+g*y)*60+v)*1e3+h;if(p){w=a(w)}if(-864e13<=w&&w<=864e13){return w}}return NaN}return t.parse.apply(this,arguments)};$(r,{parse:l});return r}(Date)}if(!Date.now){Date.now=function now(){return(new Date).getTime()}}var yr=l.toFixed&&(8e-5.toFixed(3)!=="0.000"||.9.toFixed(0)!=="1"||1.255.toFixed(2)!=="1.25"||0xde0b6b3a7640080.toFixed(0)!=="1000000000000000128");var dr={base:1e7,size:6,data:[0,0,0,0,0,0],multiply:function multiply(t,r){var e=-1;var n=r;while(++e<dr.size){n+=t*dr.data[e];dr.data[e]=n%dr.base;n=Math.floor(n/dr.base)}},divide:function divide(t){var r=dr.size;var e=0;while(--r>=0){e+=dr.data[r];dr.data[r]=Math.floor(e/t);e=e%t*dr.base}},numToString:function numToString(){var t=dr.size;var r="";while(--t>=0){if(r!==""||t===0||dr.data[t]!==0){var e=o(dr.data[t]);if(r===""){r=e}else{r+=L("0000000",0,7-e.length)+e}}}return r},pow:function pow(t,r,e){return r===0?e:r%2===1?pow(t,r-1,e*t):pow(t*t,r/2,e)},log:function log(t){var r=0;var e=t;while(e>=4096){r+=12;e/=4096}while(e>=2){r+=1;e/=2}return r}};var gr=function toFixed(t){var r,e,n,i,a,f,l,s;r=u(t);r=Y(r)?0:Math.floor(r);if(r<0||r>20){throw new RangeError("Number.toFixed called with invalid number of decimals")}e=u(this);if(Y(e)){return"NaN"}if(e<=-1e21||e>=1e21){return o(e)}n="";if(e<0){n="-";e=-e}i="0";if(e>1e-21){a=dr.log(e*dr.pow(2,69,1))-69;f=a<0?e*dr.pow(2,-a,1):e/dr.pow(2,a,1);f*=4503599627370496;a=52-a;if(a>0){dr.multiply(0,f);l=r;while(l>=7){dr.multiply(1e7,0);l-=7}dr.multiply(dr.pow(10,l,1),0);l=a-1;while(l>=23){dr.divide(1<<23);l-=23}dr.divide(1<<l);dr.multiply(1,1);dr.divide(2);i=dr.numToString()}else{dr.multiply(0,f);dr.multiply(1<<-a,0);i=dr.numToString()+L("0.00000000000000000000",2,2+r)}}if(r>0){s=i.length;if(s<=r){i=n+L("0.0000000000000000000",0,r-s+2)+i}else{i=n+L(i,0,s-r)+"."+L(i,s-r)}}else{i=n+i}return i};$(l,{toFixed:gr},yr);var wr=function(){try{return 1..toPrecision(undefined)==="1"}catch(t){return true}}();var br=l.toPrecision;$(l,{toPrecision:function toPrecision(t){return typeof t==="undefined"?br.call(this):br.call(this,t)}},wr);if("ab".split(/(?:ab)*/).length!==2||".".split(/(.?)(.?)/).length!==4||"tesst".split(/(s)*/)[1]==="t"||"test".split(/(?:)/,-1).length!==4||"".split(/.?/).length||".".split(/()()/).length>1){(function(){var t=typeof/()??/.exec("")[1]==="undefined";var r=Math.pow(2,32)-1;f.split=function(e,n){var i=String(this);if(typeof e==="undefined"&&n===0){return[]}if(!M(e)){return X(this,e,n)}var a=[];var o=(e.ignoreCase?"i":"")+(e.multiline?"m":"")+(e.unicode?"u":"")+(e.sticky?"y":""),f=0,u,l,s,c;var h=new RegExp(e.source,o+"g");if(!t){u=new RegExp("^"+h.source+"$(?!\\s)",o)}var p=typeof n==="undefined"?r:Z.ToUint32(n);l=h.exec(i);while(l){s=l.index+l[0].length;if(s>f){K(a,L(i,f,l.index));if(!t&&l.length>1){l[0].replace(u,function(){for(var t=1;t<arguments.length-2;t++){if(typeof arguments[t]==="undefined"){l[t]=void 0}}})}if(l.length>1&&l.index<i.length){v.apply(a,H(l,1))}c=l[0].length;f=s;if(a.length>=p){break}}if(h.lastIndex===l.index){h.lastIndex++}l=h.exec(i)}if(f===i.length){if(c||!h.test("")){K(a,"")}}else{K(a,L(i,f))}return a.length>p?H(a,0,p):a}})()}else if("0".split(void 0,0).length){f.split=function split(t,r){if(typeof t==="undefined"&&r===0){return[]}return X(this,t,r)}}var Tr=f.replace;var mr=function(){var t=[];"x".replace(/x(.)?/g,function(r,e){K(t,e)});return t.length===1&&typeof t[0]==="undefined"}();if(!mr){f.replace=function replace(t,r){var e=D(r);var n=M(t)&&/\)[*?]/.test(t.source);if(!e||!n){return Tr.call(this,t,r)}else{var i=function(e){var n=arguments.length;var i=t.lastIndex;t.lastIndex=0;var a=t.exec(e)||[];t.lastIndex=i;K(a,arguments[n-2],arguments[n-1]);return r.apply(this,a)};return Tr.call(this,t,i)}}}var Dr=f.substr;var Sr="".substr&&"0b".substr(-1)!=="b";$(f,{substr:function substr(t,r){var e=t;if(t<0){e=w(this.length+t,0)}return Dr.call(this,e,r)}},Sr);var xr=" \n\x0B\f\r \xa0\u1680\u180e\u2000\u2001\u2002\u2003"+"\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028"+"\u2029\ufeff";var Or="\u200b";var jr="["+xr+"]";var Er=new RegExp("^"+jr+jr+"*");var Ir=new RegExp(jr+jr+"*$");var Mr=f.trim&&(xr.trim()||!Or.trim());$(f,{trim:function trim(){if(typeof this==="undefined"||this===null){throw new TypeError("can't convert "+this+" to object")}return o(this).replace(Er,"").replace(Ir,"")}},Mr);var Ur=d.bind(String.prototype.trim);var Fr=f.lastIndexOf&&"abc\u3042\u3044".lastIndexOf("\u3042\u3044",2)!==-1;$(f,{lastIndexOf:function lastIndexOf(t){if(typeof this==="undefined"||this===null){throw new TypeError("can't convert "+this+" to object")}var r=o(this);var e=o(t);var n=arguments.length>1?u(arguments[1]):NaN;var i=Y(n)?Infinity:Z.ToInteger(n);var a=b(w(i,0),r.length);var f=e.length;var l=a+f;while(l>0){l=w(0,l-f);var s=q(L(r,l,a+f),e);if(s!==-1){return l+s}}return-1}},Fr);var Nr=f.lastIndexOf;$(f,{lastIndexOf:function lastIndexOf(t){return Nr.apply(this,arguments)}},f.lastIndexOf.length!==1);if(parseInt(xr+"08")!==8||parseInt(xr+"0x16")!==22){parseInt=function(t){var r=/^[\-+]?0[xX]/;return function parseInt(e,n){var i=Ur(String(e));var a=u(n)||(r.test(i)?16:10);return t(i,a)}}(parseInt)}if(1/parseFloat("-0")!==-Infinity){parseFloat=function(t){return function parseFloat(r){var e=Ur(String(r));var n=t(e);return n===0&&L(e,0,1)==="-"?-0:n}}(parseFloat)}if(String(new RangeError("test"))!=="RangeError: test"){var Cr=function toString(){if(typeof this==="undefined"||this===null){throw new TypeError("can't convert "+this+" to object")}var t=this.name;if(typeof t==="undefined"){t="Error"}else if(typeof t!=="string"){t=o(t)}var r=this.message;if(typeof r==="undefined"){r=""}else if(typeof r!=="string"){r=o(r)}if(!t){return r}if(!r){return t}return t+": "+r};Error.prototype.toString=Cr}if(P){var kr=function(t,r){if(Q(t,r)){var e=Object.getOwnPropertyDescriptor(t,r);if(e.configurable){e.enumerable=false;Object.defineProperty(t,r,e)}}};kr(Error.prototype,"message");if(Error.prototype.message!==""){Error.prototype.message=""}kr(Error.prototype,"name")}if(String(/a/gim)!=="/a/gim"){var Ar=function toString(){var t="/"+this.source+"/";if(this.global){t+="g"}if(this.ignoreCase){t+="i"}if(this.multiline){t+="m"}return t};RegExp.prototype.toString=Ar}}); +//# sourceMappingURL=es5-shim.map diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/package.json b/ecomp-portal-FE/client/bower_components/es5-shim/package.json new file mode 100644 index 00000000..2c049819 --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/package.json @@ -0,0 +1,75 @@ +{ + "name": "es5-shim", + "version": "4.5.9", + "description": "ECMAScript 5 compatibility shims for legacy JavaScript engines", + "homepage": "http://github.com/es-shims/es5-shim/", + "contributors": [ + "Kris Kowal <kris@cixar.com> (http://github.com/kriskowal/)", + "Sami Samhuri <sami.samhuri@gmail.com> (http://samhuri.net/)", + "Florian Schäfer <florian.schaefer@gmail.com> (http://github.com/fschaefer)", + "Irakli Gozalishvili <rfobic@gmail.com> (http://jeditoolkit.com)", + "Kit Cambridge <kitcambridge@gmail.com> (http://kitcambridge.github.com)", + "Jordan Harband <ljharb@gmail.com> (https://github.com/ljharb/)" + ], + "bugs": { + "mail": "ljharb@gmail.com", + "url": "http://github.com/es-shims/es5-shim/issues" + }, + "license": "MIT", + "main": "es5-shim.js", + "repository": { + "type": "git", + "url": "http://github.com/es-shims/es5-shim.git" + }, + "scripts": { + "minify": "concurrently --raw 'npm run --silent minify-shim' 'npm run --silent minify-sham'", + "minify-shim": "uglifyjs es5-shim.js --keep-fnames --comments --source-map=es5-shim.map -m -b ascii_only=true,beautify=false > es5-shim.min.js", + "minify-sham": "uglifyjs es5-sham.js --keep-fnames --comments --source-map=es5-sham.map -m -b ascii_only=true,beautify=false > es5-sham.min.js", + "pretest": "npm run --silent lint", + "test": "npm run --silent tests-only", + "tests-only": "jasmine-node --matchall ./ tests/spec/", + "test-native": "jasmine-node --matchall tests/spec/", + "lint": "concurrently --raw 'npm run --silent jscs' 'npm run --silent eslint'", + "eslint": "eslint tests/helpers/*.js tests/spec/*.js es5-shim.js es5-sham.js", + "jscs": "jscs tests/helpers/*.js tests/spec/*.js es5-shim.js es5-sham.js" + }, + "devDependencies": { + "eslint": "^2.12.0", + "@ljharb/eslint-config": "^5.0.0", + "jasmine-node": "^1.14.5", + "jscs": "^3.0.4", + "uglify-js": "^2.6.2", + "replace": "^0.3.0", + "semver": "^5.1.0", + "concurrently": "^2.1.0" + }, + "engines": { + "node": ">=0.4.0" + }, + "testling": { + "browsers": [ + "iexplore/6.0..latest", + "firefox/3.0..6.0", + "firefox/18.0..latest", + "firefox/nightly", + "chrome/4.0..10.0", + "chrome/25.0..latest", + "chrome/canary", + "opera/10.0..latest", + "opera/next", + "safari/4.0..latest", + "ipad/6.0..latest", + "iphone/6.0..latest", + "android-browser/4.2" + ] + }, + "keywords": [ + "shim", + "es5", + "es5 shim", + "javascript", + "ecmascript", + "polyfill" + ] +} + diff --git a/ecomp-portal-FE/client/bower_components/es5-shim/shims.json b/ecomp-portal-FE/client/bower_components/es5-shim/shims.json new file mode 100644 index 00000000..0c5430a8 --- /dev/null +++ b/ecomp-portal-FE/client/bower_components/es5-shim/shims.json @@ -0,0 +1,7 @@ +{ + "Object": { + "prototype": {}, + "keys": "object-keys" + } +} + |