From 104cf2afe06c7a51dee47b412a508bc9b0d83a69 Mon Sep 17 00:00:00 2001 From: Bernhard Posselt Date: Thu, 12 Nov 2015 17:21:08 +0100 Subject: update es6 shim --- js/vendor/es6-shim/.bower.json | 8 +- js/vendor/es6-shim/CHANGELOG.md | 30 ++ js/vendor/es6-shim/Gruntfile.js | 74 ++-- js/vendor/es6-shim/README.md | 67 ++-- js/vendor/es6-shim/component.json | 2 +- js/vendor/es6-shim/es6-sham.js | 14 +- js/vendor/es6-shim/es6-sham.map | 2 +- js/vendor/es6-shim/es6-sham.min.js | 4 +- js/vendor/es6-shim/es6-shim.js | 465 ++++++++++++----------- js/vendor/es6-shim/es6-shim.map | 2 +- js/vendor/es6-shim/es6-shim.min.js | 8 +- js/vendor/es6-shim/package.json | 20 +- js/vendor/es6-shim/test-sham/set-prototype-of.js | 3 +- 13 files changed, 396 insertions(+), 303 deletions(-) (limited to 'js/vendor/es6-shim') diff --git a/js/vendor/es6-shim/.bower.json b/js/vendor/es6-shim/.bower.json index a0e5ad62d..00499dbf6 100644 --- a/js/vendor/es6-shim/.bower.json +++ b/js/vendor/es6-shim/.bower.json @@ -27,12 +27,12 @@ "test" ], "homepage": "https://github.com/paulmillr/es6-shim", - "version": "0.33.8", - "_release": "0.33.8", + "version": "0.33.12", + "_release": "0.33.12", "_resolution": { "type": "version", - "tag": "0.33.8", - "commit": "bdc0510b2db1366713f084c1d2d2fde4b1500f0e" + "tag": "0.33.12", + "commit": "2fc76e7c759cbc1643722bc21132e246f935d4e1" }, "_source": "git://github.com/paulmillr/es6-shim.git", "_target": "~0.*", diff --git a/js/vendor/es6-shim/CHANGELOG.md b/js/vendor/es6-shim/CHANGELOG.md index 3bd76e678..244cd55d0 100644 --- a/js/vendor/es6-shim/CHANGELOG.md +++ b/js/vendor/es6-shim/CHANGELOG.md @@ -1,5 +1,35 @@ # es6-shim x.x.x (not yet released) +# es6-shim 0.33.12 (11 Nov 2015) +* [Fix] IE 8: more NFE madness. +* [Dev Deps] update `es5-shim` +* [Docs] removing now-fixed `Number` caveat +* [Docs] use assertions so `evalmd` will test the readme better. +* [Docs] fix incorrect isFinite note (#373) + +# es6-shim 0.33.11 (9 Nov 2015) +* [Fix] handle future change of RegExp.prototype not being a regex (#370, #371) +* [Fix] disallow invalid hex strings in `Number` (#369) +* [Tests] Tweak "polluted prototype" approach +* [Dev Deps] update `chai`, `es5-shim`, `eslint`, `@ljharb/eslint-config`, `jscs` + +# es6-shim 0.33.10 (2 Nov 2015) +* [Fix] the `Number` constructor properly trims (or not) whitespace characters (#368) +* [Fix] `Number('0b12')` and `Number('0o18')` should both be `NaN` (#366) +* [Tests] Fix npm upgrades in older nodes +* [Tests] add `npm run tests-only` +* [Tests] on `node` `v5.0` +* [Tests] ensure `JSON.stringify` has the right name +* [Tests] add `npm run eslint` +* [Dev Deps] update `es5-shim`, `jscs` +* [Cleanup] Rearrange things so that they’re defined before they’re used +* [Cleanup] Don't reassign to function or catch parameters +* [Cleanup] Remove unused variables +* [Refactor] String#trim shim should use `defineProperty`, and check more non-whitespace chars + +# es6-shim 0.33.9 (29 Oct 2015) +* [Fix] IE 8: `Number(new Number(1))` was throwing. More NFE madness. (#365) + # es6-shim 0.33.8 (23 Oct 2015) * [Fix] IE 8: `Promise.resolve(2)` was throwing. More named function expression madness. * [Tests] Reflect: Don't attempt to define properties on this test object unless we're in true ES5. diff --git a/js/vendor/es6-shim/Gruntfile.js b/js/vendor/es6-shim/Gruntfile.js index 370443762..230934d6b 100644 --- a/js/vendor/es6-shim/Gruntfile.js +++ b/js/vendor/es6-shim/Gruntfile.js @@ -1,14 +1,16 @@ +'use strict'; + module.exports = function (grunt) { var browsers = [ - { browserName: "firefox", version: "19", platform: "XP" }, - { browserName: "firefox", platform: "linux" }, - { browserName: "firefox", platform: "OS X 10.10" }, - { browserName: "chrome", platform: "linux" }, - { browserName: "chrome", platform: "OS X 10.9" }, - { browserName: "chrome", platform: "XP" }, - { browserName: "internet explorer", platform: "Windows 8.1", version: "11" }, - { browserName: "internet explorer", platform: "WIN8", version: "10" }, - { browserName: "internet explorer", platform: "VISTA", version: "9" }, + { browserName: 'firefox', version: '19', platform: 'XP' }, + { browserName: 'firefox', platform: 'linux' }, + { browserName: 'firefox', platform: 'OS X 10.10' }, + { browserName: 'chrome', platform: 'linux' }, + { browserName: 'chrome', platform: 'OS X 10.9' }, + { browserName: 'chrome', platform: 'XP' }, + { browserName: 'internet explorer', platform: 'Windows 8.1', version: '11' }, + { browserName: 'internet explorer', platform: 'WIN8', version: '10' }, + { browserName: 'internet explorer', platform: 'VISTA', version: '9' }, { browserName: 'safari', platform: 'OS X 10.6' }, { browserName: 'safari', platform: 'OS X 10.8' }, { browserName: 'safari', platform: 'OS X 10.9' }, @@ -17,16 +19,16 @@ module.exports = function (grunt) { { browserName: 'android', platform: 'Linux', version: '4.4' }, ]; var extraBrowsers = [ - { browserName: "firefox", platform: "linux", version: "30" }, - { browserName: "firefox", platform: "linux", version: "25" }, + { browserName: 'firefox', platform: 'linux', version: '30' }, + { browserName: 'firefox', platform: 'linux', version: '25' }, { browserName: 'iphone', platform: 'OS X 10.8', version: '6.1' }, { browserName: 'iphone', platform: 'OS X 10.8', version: '5.1' }, { browserName: 'android', platform: 'Linux', version: '4.2' }, // XXX haven't investigated these: - //{ browserName: "opera", platform: "Windows 7", version: "12" }, - //{ browserName: "opera", platform: "Windows 2008", version: "12" } - //{ browserName: 'iphone', platform: 'OS X 10.6', version: '4.3' }, - //{ browserName: 'android', platform: 'Linux', version: '4.0' }, + // { browserName: 'opera', platform: 'Windows 7', version: '12' }, + // { browserName: 'opera', platform: 'Windows 2008', version: '12' } + // { browserName: 'iphone', platform: 'OS X 10.6', version: '4.3' }, + // { browserName: 'android', platform: 'Linux', version: '4.0' }, ]; if (grunt.option('extra')) { browsers = browsers.concat(extraBrowsers); @@ -35,7 +37,7 @@ module.exports = function (grunt) { connect: { server: { options: { - base: "", + base: '', port: 9999, useAvailablePort: true } @@ -45,56 +47,52 @@ module.exports = function (grunt) { all: { options: { urls: (function () { - var urls = ["http://localhost:9999/test/"]; + var urls = ['http://localhost:9999/test/']; if (grunt.option('extra')) { - urls.push("http://localhost:9999/test-sham/"); + urls.push('http://localhost:9999/test-sham/'); } return urls; }()), - //tunnelTimeout: 5, + // tunnelTimeout: 5, build: process.env.TRAVIS_BUILD_NUMBER, tunneled: !process.env.SAUCE_HAS_TUNNEL, identifier: process.env.TRAVIS_JOB_NUMBER, sauceConfig: { 'tunnel-identifier': process.env.TRAVIS_JOB_NUMBER }, - //concurrency: 3, + // concurrency: 3, browsers: browsers, testname: (function () { - var testname = "mocha"; - if (process.env.TRAVIS_PULL_REQUEST && - process.env.TRAVIS_PULL_REQUEST !== 'false') { - testname += ' (PR '+process.env.TRAVIS_PULL_REQUEST+')'; + var testname = 'mocha'; + if (process.env.TRAVIS_PULL_REQUEST && process.env.TRAVIS_PULL_REQUEST !== 'false') { + testname += ' (PR ' + process.env.TRAVIS_PULL_REQUEST + ')'; } - if (process.env.TRAVIS_BRANCH && - process.env.TRAVIS_BRANCH !== 'false') { - testname += ' (branch '+process.env.TRAVIS_BRANCH+')'; + if (process.env.TRAVIS_BRANCH && process.env.TRAVIS_BRANCH !== 'false') { + testname += ' (branch ' + process.env.TRAVIS_BRANCH + ')'; } return testname; - })(), + }()), tags: (function () { var tags = []; - if (process.env.TRAVIS_PULL_REQUEST && - process.env.TRAVIS_PULL_REQUEST !== 'false') { - tags.push('PR-'+process.env.TRAVIS_PULL_REQUEST); + if (process.env.TRAVIS_PULL_REQUEST && process.env.TRAVIS_PULL_REQUEST !== 'false') { + tags.push('PR-' + process.env.TRAVIS_PULL_REQUEST); } - if (process.env.TRAVIS_BRANCH && - process.env.TRAVIS_BRANCH !== 'false') { + if (process.env.TRAVIS_BRANCH && process.env.TRAVIS_BRANCH !== 'false') { tags.push(process.env.TRAVIS_BRANCH); } return tags; - })() + }()) } } }, watch: {} }); // Loading dependencies - for (var key in grunt.file.readJSON("package.json").devDependencies) { - if (key !== "grunt" && key.indexOf("grunt") === 0) { + for (var key in grunt.file.readJSON('package.json').devDependencies) { + if (key !== 'grunt' && key.indexOf('grunt') === 0) { grunt.loadNpmTasks(key); } } - grunt.registerTask("dev", ["connect", "watch"]); - grunt.registerTask("sauce", ["connect", "saucelabs-mocha"]); + grunt.registerTask('dev', ['connect', 'watch']); + grunt.registerTask('sauce', ['connect', 'saucelabs-mocha']); }; diff --git a/js/vendor/es6-shim/README.md b/js/vendor/es6-shim/README.md index 9e1b54169..5a0955674 100644 --- a/js/vendor/es6-shim/README.md +++ b/js/vendor/es6-shim/README.md @@ -156,27 +156,43 @@ The [es6-collections](https://github.com/WebReflection/es6-collections) implemen ## Getting started ```javascript -var assert = require('assert'); require('es6-shim'); +var assert = require('assert'); + +assert.equal(true, 'abc'.startsWith('a')); +assert.equal(false, 'abc'.endsWith('a')); +assert.equal(true, 'john alice'.includes('john')); +assert.equal('123'.repeat(2), '123123'); + +assert.equal(false, NaN === NaN); +assert.equal(true, Object.is(NaN, NaN)); +assert.equal(true, -0 === 0); +assert.equal(false, Object.is(-0, 0)); -'abc'.startsWith('a'); // true -'abc'.endsWith('a'); // false -'john alice'.includes('john'); // true -'123'.repeat(2); // '123123' +var result = Object.assign({ a: 1 }, { b: 2 }); +assert.deepEqual(result, { a: 1, b: 2 }); -Object.is(NaN, NaN); // Fixes ===. 0 isnt -0, NaN is NaN -Object.assign({a: 1}, {b: 2}); // {a: 1, b: 2} +assert.equal(true, isNaN('a')); +assert.equal(false, Number.isNaN('a')); +assert.equal(true, Number.isNaN(NaN)); + +assert.equal(true, isFinite('123')); +assert.equal(false, Number.isFinite('123')); +assert.equal(false, Number.isFinite(Infinity)); -Number.isNaN('123'); // false. Global isNaN('123') will give true. -Number.isFinite('asd'); // false. Global isFinite() will give true. // Tests if value is a number, finite, // >= -9007199254740992 && <= 9007199254740992 and floor(value) === value -Number.isInteger(2.4); // false. +assert.equal(false, Number.isInteger(2.4)); + +assert.equal(1, Math.sign(400)); +assert.equal(0, Math.sign(0)); +assert.equal(-1, Math.sign(-400)); -Math.sign(400); // 1, 0 or -1 depending on sign. In this case 1. +var found = [5, 10, 15, 10].find(function (item) { return item / 2 === 5; }); +assert.equal(10, found); -[5, 10, 15, 10].find(function (item) { return item / 2 === 5; }); // 10 -[5, 10, 15, 10].findIndex(function (item) { return item / 2 === 5; }); // 1 +var foundIndex = [5, 10, 15, 10].findIndex(function (item) { return item / 2 === 5; }); +assert.equal(1, foundIndex); // Replacement for `{}` key-value storage. // Keys can be anything. @@ -184,30 +200,35 @@ var map = new Map([['Bob', 42], ['Foo', 'bar']]); map.set('John', 25); map.set('Alice', 400); map.set(['meh'], 555); -assert(map.get(['meh']) === undefined); // undefined because you need to use exactly the same object. +assert.equal(undefined, map.get(['meh'])); // undefined because you need to use exactly the same object. map.delete('Alice'); map.keys(); map.values(); -assert(map.size === 4); +assert.equal(4, map.size); // Useful for storing unique items. var set = new Set([0, 1]); set.add(2); set.add(5); -assert(set.has(0) === true); -assert(set.has(1) === true); -assert(set.has(2) === true); -assert(set.has(4) === false); +assert.equal(true, set.has(0)); +assert.equal(true, set.has(1)); +assert.equal(true, set.has(2)); +assert.equal(false, set.has(4)); +assert.equal(true, set.has(5)); set.delete(5); +assert.equal(false, set.has(5)); // Promises, see // http://www.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript // https://github.com/petkaantonov/bluebird/#what-are-promises-and-why-should-i-use-them Promise.resolve(5).then(function (value) { - if (value) throw new Error("whoops!"); + assert.equal(value, 5); + if (value) throw new Error('whoops!'); // do some stuff return anotherPromise(); }).catch(function (e) { + assert.equal(e.message, 'whoops!'); + assert.equal(true, e instanceof Error); // any errors thrown asynchronously end up here }); ``` @@ -216,12 +237,6 @@ Promise.resolve(5).then(function (value) { - `Object.setPrototypeOf` / `Reflect.setPrototypeOf` - Note that null objects (`Object.create(null)`, eg, an object with `null` as its `[[Prototype]]`) can not have their `[[Prototype]]` changed except via a native `Object.setPrototypeOf`. - - `Number`: - - In order to support binary literals (`Number('0b1')`) and octal literals (`Number('0o7')`), the global `Number` constructor is wrapped in a shim. However, this can cause issues in the exceedingly unlikely event that you ever call `Number` as a function with a receiver (a “this” value) that is itself a number. Some problematic examples: -```js - assert(typeof Number.call(2, 3) === 'number'); // will fail when `Number` is wrapped, is "object" - assert(typeof (1).constructor(2) === 'number'); // will fail when `Number` is wrapped, is "object" -``` ## [License][license-url] diff --git a/js/vendor/es6-shim/component.json b/js/vendor/es6-shim/component.json index fd52e0b97..c0f5fbcd0 100644 --- a/js/vendor/es6-shim/component.json +++ b/js/vendor/es6-shim/component.json @@ -1,6 +1,6 @@ { "name": "es6-shim", - "version": "0.33.8", + "version": "0.33.12", "repo": "paulmillr/es6-shim", "description": "ECMAScript 6 (Harmony) compatibility shims for legacy JavaScript engines", "keywords": [ diff --git a/js/vendor/es6-shim/es6-sham.js b/js/vendor/es6-shim/es6-sham.js index 851b83046..65f0f5cc6 100644 --- a/js/vendor/es6-shim/es6-sham.js +++ b/js/vendor/es6-shim/es6-sham.js @@ -2,8 +2,8 @@ * https://github.com/paulmillr/es6-shim * @license es6-shim Copyright 2013-2015 by Paul Miller (http://paulmillr.com) * and contributors, MIT License - * es6-sham: v0.33.8 - * see https://github.com/paulmillr/es6-shim/blob/0.33.8/LICENSE + * es6-sham: v0.33.12 + * see https://github.com/paulmillr/es6-shim/blob/0.33.12/LICENSE * Details and documentation: * https://github.com/paulmillr/es6-shim/ */ @@ -28,7 +28,9 @@ 'use strict'; /*jshint evil: true */ + /* eslint-disable no-new-func */ var getGlobal = new Function('return this;'); + /* eslint-enable no-new-func */ /*jshint evil: false */ var globals = getGlobal(); @@ -85,20 +87,24 @@ }; } catch (e) { // do one or more feature detections - set = {__proto__: null}; + set = { __proto__: null }; // if proto does not work, needs to fallback // some Opera, Rhino, ducktape if (set instanceof Object) { setPrototypeOf = createAndCopy; } else { // verify if null objects are buggy + /* eslint-disable no-proto */ set.__proto__ = objProto; + /* eslint-enable no-proto */ // if null objects are buggy // nodejs 0.8 to 0.10 if (set instanceof Object) { setPrototypeOf = function (origin, proto) { // use such bug to promote + /* eslint-disable no-proto */ origin.__proto__ = proto; + /* eslint-enable no-proto */ return origin; }; } else { @@ -108,7 +114,9 @@ // if proto is not null if (getPrototypeOf(origin)) { // use __proto__ to promote + /* eslint-disable no-proto */ origin.__proto__ = proto; + /* eslint-enable no-proto */ return origin; } else { // otherwise unable to promote: fallback diff --git a/js/vendor/es6-shim/es6-sham.map b/js/vendor/es6-shim/es6-sham.map index aed17fdff..8f3589e2e 100644 --- a/js/vendor/es6-shim/es6-sham.map +++ b/js/vendor/es6-shim/es6-sham.map @@ -1 +1 @@ -{"version":3,"sources":["es6-sham.js"],"names":["root","factory","define","amd","exports","module","returnExports","this","getGlobal","Function","globals","Object","setPrototypeOf","getOwnPropertyNames","getOwnPropertyDescriptor","create","defineProperty","getPrototypeOf","objProto","prototype","copyDescriptors","target","source","forEach","key","createAndCopy","origin","proto","set","call","e","__proto__"],"mappings":";;;;;;;;;CAYC,SAAUA,EAAMC,GAEf,SAAWC,UAAW,YAAcA,OAAOC,IAAK,CAE9CD,OAAOD,OACF,UAAWG,WAAY,SAAU,CAItCC,OAAOD,QAAUH,QACZ,CAELD,EAAKM,cAAgBL,OAEvBM,KAAM,WACN,YAGA,IAAIC,GAAY,GAAIC,UAAS,eAG7B,IAAIC,GAAUF,GACd,IAAIG,GAASD,EAAQC,QAWpB,WACC,GAAIA,EAAOC,eAAgB,CAAE,OAK7B,GAAIC,GAAsBF,EAAOE,mBACjC,IAAIC,GAA2BH,EAAOG,wBACtC,IAAIC,GAASJ,EAAOI,MACpB,IAAIC,GAAiBL,EAAOK,cAC5B,IAAIC,GAAiBN,EAAOM,cAC5B,IAAIC,GAAWP,EAAOQ,SAEtB,IAAIC,GAAkB,SAAUC,EAAQC,GAEtCT,EAAoBS,GAAQC,QAAQ,SAAUC,GAC5CR,EACEK,EACAG,EACAV,EAAyBQ,EAAQE,KAGrC,OAAOH,GAGT,IAAII,GAAgB,SAAUC,EAAQC,GACpC,MAAOP,GAAgBL,EAAOY,GAAQD,GAExC,IAAIE,GAAKhB,CACT,KAGEgB,EAAMd,EAAyBI,EAAU,aAAaU,GACtDA,GAAIC,QAAS,KAGbjB,GAAiB,SAAUc,EAAQC,GACjCC,EAAIC,KAAKH,EAAQC,EACjB,OAAOD,IAET,MAAOI,GAEPF,GAAOG,UAAW,KAGlB,IAAIH,YAAejB,GAAQ,CACzBC,EAAiBa,MACZ,CAELG,EAAIG,UAAYb,CAGhB,IAAIU,YAAejB,GAAQ,CACzBC,EAAiB,SAAUc,EAAQC,GAEjCD,EAAOK,UAAYJ,CACnB,OAAOD,QAEJ,CAGLd,EAAiB,SAAUc,EAAQC,GAEjC,GAAIV,EAAeS,GAAS,CAE1BA,EAAOK,UAAYJ,CACnB,OAAOD,OACF,CAEL,MAAOD,GAAcC,EAAQC,OAMvChB,EAAOC,eAAiBA"} \ No newline at end of file +{"version":3,"sources":["es6-sham.js"],"names":["root","factory","define","amd","exports","module","returnExports","this","getGlobal","Function","globals","Object","setPrototypeOf","getOwnPropertyNames","getOwnPropertyDescriptor","create","defineProperty","getPrototypeOf","objProto","prototype","copyDescriptors","target","source","forEach","key","createAndCopy","origin","proto","set","call","e","__proto__"],"mappings":";;;;;;;;;CAYC,SAAUA,EAAMC,GAEf,SAAWC,UAAW,YAAcA,OAAOC,IAAK,CAE9CD,OAAOD,OACF,UAAWG,WAAY,SAAU,CAItCC,OAAOD,QAAUH,QACZ,CAELD,EAAKM,cAAgBL,OAEvBM,KAAM,WACN,YAIA,IAAIC,GAAY,GAAIC,UAAS,eAI7B,IAAIC,GAAUF,GACd,IAAIG,GAASD,EAAQC,QAWpB,WACC,GAAIA,EAAOC,eAAgB,CAAE,OAK7B,GAAIC,GAAsBF,EAAOE,mBACjC,IAAIC,GAA2BH,EAAOG,wBACtC,IAAIC,GAASJ,EAAOI,MACpB,IAAIC,GAAiBL,EAAOK,cAC5B,IAAIC,GAAiBN,EAAOM,cAC5B,IAAIC,GAAWP,EAAOQ,SAEtB,IAAIC,GAAkB,SAAUC,EAAQC,GAEtCT,EAAoBS,GAAQC,QAAQ,SAAUC,GAC5CR,EACEK,EACAG,EACAV,EAAyBQ,EAAQE,KAGrC,OAAOH,GAGT,IAAII,GAAgB,SAAUC,EAAQC,GACpC,MAAOP,GAAgBL,EAAOY,GAAQD,GAExC,IAAIE,GAAKhB,CACT,KAGEgB,EAAMd,EAAyBI,EAAU,aAAaU,GACtDA,GAAIC,QAAS,KAGbjB,GAAiB,SAAUc,EAAQC,GACjCC,EAAIC,KAAKH,EAAQC,EACjB,OAAOD,IAET,MAAOI,GAEPF,GAAQG,UAAW,KAGnB,IAAIH,YAAejB,GAAQ,CACzBC,EAAiBa,MACZ,CAGLG,EAAIG,UAAYb,CAIhB,IAAIU,YAAejB,GAAQ,CACzBC,EAAiB,SAAUc,EAAQC,GAGjCD,EAAOK,UAAYJ,CAEnB,OAAOD,QAEJ,CAGLd,EAAiB,SAAUc,EAAQC,GAEjC,GAAIV,EAAeS,GAAS,CAG1BA,EAAOK,UAAYJ,CAEnB,OAAOD,OACF,CAEL,MAAOD,GAAcC,EAAQC,OAMvChB,EAAOC,eAAiBA"} \ No newline at end of file diff --git a/js/vendor/es6-shim/es6-sham.min.js b/js/vendor/es6-shim/es6-sham.min.js index f8372331f..a0f862efe 100644 --- a/js/vendor/es6-shim/es6-sham.min.js +++ b/js/vendor/es6-shim/es6-sham.min.js @@ -2,8 +2,8 @@ * https://github.com/paulmillr/es6-shim * @license es6-shim Copyright 2013-2015 by Paul Miller (http://paulmillr.com) * and contributors, MIT License - * es6-sham: v0.33.8 - * see https://github.com/paulmillr/es6-shim/blob/0.33.8/LICENSE + * es6-sham: v0.33.12 + * see https://github.com/paulmillr/es6-shim/blob/0.33.12/LICENSE * Details and documentation: * https://github.com/paulmillr/es6-shim/ */ diff --git a/js/vendor/es6-shim/es6-shim.js b/js/vendor/es6-shim/es6-shim.js index feb438909..d1d052fe3 100644 --- a/js/vendor/es6-shim/es6-shim.js +++ b/js/vendor/es6-shim/es6-shim.js @@ -2,8 +2,8 @@ * https://github.com/paulmillr/es6-shim * @license es6-shim Copyright 2013-2015 by Paul Miller (http://paulmillr.com) * and contributors, MIT License - * es6-shim: v0.33.8 - * see https://github.com/paulmillr/es6-shim/blob/0.33.8/LICENSE + * es6-shim: v0.33.12 + * see https://github.com/paulmillr/es6-shim/blob/0.33.12/LICENSE * Details and documentation: * https://github.com/paulmillr/es6-shim/ */ @@ -61,26 +61,8 @@ var _forEach = Function.call.bind(Array.prototype.forEach); var _reduce = Function.call.bind(Array.prototype.reduce); var _filter = Function.call.bind(Array.prototype.filter); - var _every = Function.call.bind(Array.prototype.every); + var _some = Function.call.bind(Array.prototype.some); - var createDataProperty = function createDataProperty(object, name, value) { - if (supportsDescriptors) { - Object.defineProperty(object, name, { - configurable: true, - enumerable: true, - writable: true, - value: value - }); - } else { - object[name] = value; - } - }; - var createDataPropertyOrThrow = function createDataPropertyOrThrow(object, name, value) { - createDataProperty(object, name, value); - if (!ES.SameValue(object[name], value)) { - throw new TypeError('property is nonconfigurable'); - } - }; var defineProperty = function (object, name, value, force) { if (!force && name in object) { return; } if (supportsDescriptors) { @@ -135,6 +117,7 @@ }; var getGlobal = function () { + /* global self, window, global */ // the only reliable means to get the global object is // `Function('return this')()` // However, this causes CSP violations in Chrome apps. @@ -146,7 +129,6 @@ var globals = getGlobal(); var globalIsFinite = globals.isFinite; - var hasStrictMode = (function () { return this === null; }.call(null)); var _indexOf = Function.call.bind(String.prototype.indexOf); var _toString = Function.call.bind(Object.prototype.toString); var _concat = Function.call.bind(Array.prototype.concat); @@ -167,89 +149,6 @@ var Symbol = globals.Symbol || {}; var symbolSpecies = Symbol.species || '@@species'; - var Value = { - getter: function (object, name, getter) { - if (!supportsDescriptors) { - throw new TypeError('getters require true ES5 support'); - } - Object.defineProperty(object, name, { - configurable: true, - enumerable: false, - get: getter - }); - }, - proxy: function (originalObject, key, targetObject) { - if (!supportsDescriptors) { - throw new TypeError('getters require true ES5 support'); - } - var originalDescriptor = Object.getOwnPropertyDescriptor(originalObject, key); - Object.defineProperty(targetObject, key, { - configurable: originalDescriptor.configurable, - enumerable: originalDescriptor.enumerable, - get: function getKey() { return originalObject[key]; }, - set: function setKey(value) { originalObject[key] = value; } - }); - }, - redefine: function (object, property, newValue) { - if (supportsDescriptors) { - var descriptor = Object.getOwnPropertyDescriptor(object, property); - descriptor.value = newValue; - Object.defineProperty(object, property, descriptor); - } else { - object[property] = newValue; - } - }, - defineByDescriptor: function (object, property, descriptor) { - if (supportsDescriptors) { - Object.defineProperty(object, property, descriptor); - } else if ('value' in descriptor) { - object[property] = descriptor.value; - } - }, - preserveToString: function (target, source) { - if (source && ES.IsCallable(source.toString)) { - defineProperty(target, 'toString', source.toString.bind(source), true); - } - } - }; - - var wrapConstructor = function wrapConstructor(original, replacement, keysToSkip) { - Value.preserveToString(replacement, original); - if (Object.setPrototypeOf) { - // sets up proper prototype chain where possible - Object.setPrototypeOf(original, replacement); - } - if (supportsDescriptors) { - _forEach(Object.getOwnPropertyNames(original), function (key) { - if (key in noop || keysToSkip[key]) { return; } - Value.proxy(original, key, replacement); - }); - } else { - _forEach(Object.keys(original), function (key) { - if (key in noop || keysToSkip[key]) { return; } - replacement[key] = original[key]; - }); - } - replacement.prototype = original.prototype; - Value.redefine(original.prototype, 'constructor', replacement); - }; - - var defaultSpeciesGetter = function () { return this; }; - var addDefaultSpecies = function (C) { - if (supportsDescriptors && !_hasOwnProperty(C, symbolSpecies)) { - Value.getter(C, symbolSpecies, defaultSpeciesGetter); - } - }; - var Type = { - primitive: function (x) { return x === null || (typeof x !== 'function' && typeof x !== 'object'); }, - object: function (x) { return x !== null && typeof x === 'object'; }, - string: function (x) { return _toString(x) === '[object String]'; }, - regex: function (x) { return _toString(x) === '[object RegExp]'; }, - symbol: function (x) { - return typeof globals.Symbol === 'function' && typeof x === 'symbol'; - } - }; - var numberIsNaN = Number.isNaN || function isNaN(value) { // NaN !== NaN, but they are identical. // NaNs are the only non-reflexive value, i.e., if x !== x, @@ -262,10 +161,29 @@ return typeof value === 'number' && globalIsFinite(value); }; - var overrideNative = function overrideNative(object, property, replacement) { - var original = object[property]; - defineProperty(object, property, replacement, true); - Value.preserveToString(object[property], original); + // 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 _toString(value) === '[object Arguments]'; + }; + var isLegacyArguments = function isArguments(value) { + return value !== null && + typeof value === 'object' && + typeof value.length === 'number' && + value.length >= 0 && + _toString(value) !== '[object Array]' && + _toString(value.callee) === '[object Function]'; + }; + var isArguments = isStandardArguments(arguments) ? isStandardArguments : isLegacyArguments; + + var Type = { + primitive: function (x) { return x === null || (typeof x !== 'function' && typeof x !== 'object'); }, + object: function (x) { return x !== null && typeof x === 'object'; }, + string: function (x) { return _toString(x) === '[object String]'; }, + regex: function (x) { return _toString(x) === '[object RegExp]'; }, + symbol: function (x) { + return typeof globals.Symbol === 'function' && typeof x === 'symbol'; + } }; // This is a private name in the es6 spec, equal to '[Symbol.iterator]' @@ -280,29 +198,12 @@ if (globals.Set && typeof new globals.Set()['@@iterator'] === 'function') { $iterator$ = '@@iterator'; } - var addIterator = function (prototype, impl) { - var implementation = impl || function iterator() { return this; }; - defineProperty(prototype, $iterator$, implementation); - if (!prototype[$iterator$] && Type.symbol($iterator$)) { - // implementations are buggy when $iterator$ is a Symbol - prototype[$iterator$] = implementation; - } - }; - // 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 _toString(value) === '[object Arguments]'; - }; - var isLegacyArguments = function isArguments(value) { - return value !== null && - typeof value === 'object' && - typeof value.length === 'number' && - value.length >= 0 && - _toString(value) !== '[object Array]' && - _toString(value.callee) === '[object Function]'; - }; - var isArguments = isStandardArguments(arguments) ? isStandardArguments : isLegacyArguments; + // Reflect + if (!globals.Reflect) { + defineProperty(globals, 'Reflect', {}); + } + var Reflect = globals.Reflect; var ES = { // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-call-f-v-args @@ -459,19 +360,18 @@ }, Construct: function (C, args, newTarget, isES6internal) { - if (newTarget === void 0) { - newTarget = C; - } + var target = typeof newTarget === 'undefined' ? C : newTarget; + if (!isES6internal) { // Try to use Reflect.construct if available - return Reflect.construct(C, args, newTarget); + return Reflect.construct(C, args, target); } // OK, we have to fake it. This will only work if the // C.[[ConstructorKind]] == "base" -- but that's the only // kind we can make in ES5 code anyway. - // OrdinaryCreateFromConstructor(newTarget, "%ObjectPrototype%") - var proto = newTarget.prototype; + // OrdinaryCreateFromConstructor(target, "%ObjectPrototype%") + var proto = target.prototype; if (!ES.TypeIsObject(proto)) { proto = Object.prototype; } @@ -513,6 +413,114 @@ } }; + var Value = { + getter: function (object, name, getter) { + if (!supportsDescriptors) { + throw new TypeError('getters require true ES5 support'); + } + Object.defineProperty(object, name, { + configurable: true, + enumerable: false, + get: getter + }); + }, + proxy: function (originalObject, key, targetObject) { + if (!supportsDescriptors) { + throw new TypeError('getters require true ES5 support'); + } + var originalDescriptor = Object.getOwnPropertyDescriptor(originalObject, key); + Object.defineProperty(targetObject, key, { + configurable: originalDescriptor.configurable, + enumerable: originalDescriptor.enumerable, + get: function getKey() { return originalObject[key]; }, + set: function setKey(value) { originalObject[key] = value; } + }); + }, + redefine: function (object, property, newValue) { + if (supportsDescriptors) { + var descriptor = Object.getOwnPropertyDescriptor(object, property); + descriptor.value = newValue; + Object.defineProperty(object, property, descriptor); + } else { + object[property] = newValue; + } + }, + defineByDescriptor: function (object, property, descriptor) { + if (supportsDescriptors) { + Object.defineProperty(object, property, descriptor); + } else if ('value' in descriptor) { + object[property] = descriptor.value; + } + }, + preserveToString: function (target, source) { + if (source && ES.IsCallable(source.toString)) { + defineProperty(target, 'toString', source.toString.bind(source), true); + } + } + }; + + var wrapConstructor = function wrapConstructor(original, replacement, keysToSkip) { + Value.preserveToString(replacement, original); + if (Object.setPrototypeOf) { + // sets up proper prototype chain where possible + Object.setPrototypeOf(original, replacement); + } + if (supportsDescriptors) { + _forEach(Object.getOwnPropertyNames(original), function (key) { + if (key in noop || keysToSkip[key]) { return; } + Value.proxy(original, key, replacement); + }); + } else { + _forEach(Object.keys(original), function (key) { + if (key in noop || keysToSkip[key]) { return; } + replacement[key] = original[key]; + }); + } + replacement.prototype = original.prototype; + Value.redefine(original.prototype, 'constructor', replacement); + }; + + var defaultSpeciesGetter = function () { return this; }; + var addDefaultSpecies = function (C) { + if (supportsDescriptors && !_hasOwnProperty(C, symbolSpecies)) { + Value.getter(C, symbolSpecies, defaultSpeciesGetter); + } + }; + + var overrideNative = function overrideNative(object, property, replacement) { + var original = object[property]; + defineProperty(object, property, replacement, true); + Value.preserveToString(object[property], original); + }; + + var addIterator = function (prototype, impl) { + var implementation = impl || function iterator() { return this; }; + defineProperty(prototype, $iterator$, implementation); + if (!prototype[$iterator$] && Type.symbol($iterator$)) { + // implementations are buggy when $iterator$ is a Symbol + prototype[$iterator$] = implementation; + } + }; + + var createDataProperty = function createDataProperty(object, name, value) { + if (supportsDescriptors) { + Object.defineProperty(object, name, { + configurable: true, + enumerable: true, + writable: true, + value: value + }); + } else { + object[name] = value; + } + }; + var createDataPropertyOrThrow = function createDataPropertyOrThrow(object, name, value) { + createDataProperty(object, name, value); + if (!ES.SameValue(object[name], value)) { + throw new TypeError('property is nonconfigurable'); + } + }; + var emulateES6construct = function (o, defaultNewTarget, defaultProto, slots) { // This is an es5 approximation to es6 construct semantics. in es6, // 'new Foo' invokes Foo.[[Construct]] which (for almost all objects) @@ -531,14 +539,14 @@ if (!ES.TypeIsObject(proto)) { proto = defaultProto; } - o = create(proto); + var obj = create(proto); for (var name in slots) { if (_hasOwnProperty(slots, name)) { var value = slots[name]; - defineProperty(o, name, value, true); + defineProperty(obj, name, value, true); } } - return o; + return obj; }; // Firefox 31 reports this function's length as 0 @@ -591,7 +599,7 @@ next = nextIndex + 1 < arguments.length ? arguments[nextIndex + 1] : ''; nextSub = String(next); _push(stringElements, nextSub); - nextIndex++; + nextIndex += 1; } return stringElements.join(''); } @@ -695,26 +703,25 @@ defineProperties(String.prototype, StringPrototypeShims); - var hasStringTrimBug = '\u0085'.trim().length !== 1; - if (hasStringTrimBug) { - delete String.prototype.trim; - // whitespace from: http://es5.github.io/#x15.5.4.20 - // implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324 - 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' - ].join(''); - var trimRegexp = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g'); - defineProperties(String.prototype, { - trim: function trim() { - if (typeof this === 'undefined' || this === null) { - throw new TypeError("can't convert " + this + ' to object'); - } - return String(this).replace(trimRegexp, ''); - } - }); - } + // whitespace from: http://es5.github.io/#x15.5.4.20 + // implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324 + 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' + ].join(''); + var trimRegexp = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g'); + var trimShim = function trim() { + if (typeof this === 'undefined' || this === null) { + throw new TypeError("can't convert " + this + ' to object'); + } + return String(this).replace(trimRegexp, ''); + }; + var nonWS = ['\u0085', '\u200b', '\ufffe'].join(''); + var nonWSregex = new RegExp('[' + nonWS + ']', 'g'); + var isBadHexRegex = /^[\-+]0x[0-9a-f]+$/i; + var hasStringTrimBug = nonWS.trim().length !== nonWS.length; + defineProperty(String.prototype, 'trim', trimShim, hasStringTrimBug); // see https://people.mozilla.org/~jorendorff/es6-draft.html#sec-string.prototype-@@iterator var StringIterator = function (s) { @@ -760,10 +767,10 @@ // Note that that Arrays will use ArrayIterator: // https://bugs.ecmascript.org/show_bug.cgi?id=2416 - var usingIterator = isArguments(items) || ES.GetMethod(items, $iterator$); + var usingIterator = typeof (isArguments(items) || ES.GetMethod(items, $iterator$)) !== 'undefined'; var length, result, i; - if (usingIterator !== void 0) { + if (usingIterator) { result = ES.IsConstructor(C) ? Object(new C()) : []; var iterator = ES.GetIterator(items); var next, nextValue; @@ -777,7 +784,7 @@ nextValue = next.value; try { if (mapping) { - nextValue = T !== undefined ? _call(mapFn, T, nextValue, i) : mapFn(nextValue, i); + nextValue = T === undefined ? mapFn(nextValue, i) : _call(mapFn, T, nextValue, i); } result[i] = nextValue; } catch (e) { @@ -862,14 +869,6 @@ }); addIterator(ArrayIterator.prototype); - var ObjectIterator = function (object, kind) { - defineProperties(this, { - object: object, - array: getAllKeys(object), - kind: kind - }); - }; - var getAllKeys = function getAllKeys(object) { var keys = []; @@ -880,6 +879,14 @@ return keys; }; + var ObjectIterator = function (object, kind) { + defineProperties(this, { + object: object, + array: getAllKeys(object), + kind: kind + }); + }; + defineProperties(ObjectIterator.prototype, { next: function next() { var key; @@ -1137,10 +1144,15 @@ }, true); } - if (Number('0o10') !== 8 || Number('0b10') !== 2) { + var lacksOctalSupport = Number('0o10') !== 8; + var lacksBinarySupport = Number('0b10') !== 2; + var trimsNonWhitespace = _some(nonWS, function (c) { + return Number(c + 0 + c) === 0; + }); + if (lacksOctalSupport || lacksBinarySupport || trimsNonWhitespace) { var OrigNumber = Number; - var binaryRegex = /^0b/i; - var octalRegex = /^0o/i; + var binaryRegex = /^0b[01]+$/i; + var octalRegex = /^0o[0-7]+$/i; // Note that in IE 8, RegExp.prototype.test doesn't seem to exist: ie, "test" is an own property of regexes. wtf. var isBinary = binaryRegex.test.bind(binaryRegex); var isOctal = octalRegex.test.bind(octalRegex); @@ -1160,34 +1172,43 @@ } throw new TypeError('No default value'); }; + var hasNonWS = nonWSregex.test.bind(nonWSregex); + var isBadHex = isBadHexRegex.test.bind(isBadHexRegex); var NumberShim = (function () { // this is wrapped in an IIFE because of IE 6-8's wacky scoping issues with named function expressions. - return function Number(value) { + var NumberShim = function Number(value) { var primValue = Type.primitive(value) ? value : toPrimitive(value, 'number'); if (typeof primValue === 'string') { if (isBinary(primValue)) { primValue = parseInt(_strSlice(primValue, 2), 2); } else if (isOctal(primValue)) { primValue = parseInt(_strSlice(primValue, 2), 8); + } else if (hasNonWS(primValue) || isBadHex(primValue)) { + primValue = NaN; + } else { + primValue = _call(trimShim, primValue); } } var receiver = this; var valueOfSucceeds = valueOrFalseIfThrows(function () { - Number.prototype.valueOf.call(receiver); + OrigNumber.prototype.valueOf.call(receiver); return true; }); - if (receiver instanceof Number && !valueOfSucceeds) { + if (receiver instanceof NumberShim && !valueOfSucceeds) { return new OrigNumber(primValue); } /* jshint newcap: false */ return OrigNumber(primValue); /* jshint newcap: true */ }; + return NumberShim; }()); wrapConstructor(OrigNumber, NumberShim, {}); /*globals Number: true */ + /* eslint-disable no-undef */ Number = NumberShim; Value.redefine(globals, 'Number', NumberShim); + /* eslint-enable no-undef */ /*globals Number: false */ } @@ -1220,12 +1241,14 @@ // implementations of find/findIndex indirectly use shimmed // methods of Number, so this test has to happen down here.) /*jshint elision: true */ + /* eslint-disable no-sparse-arrays */ if (![, 1].find(function (item, idx) { return idx === 0; })) { overrideNative(Array.prototype, 'find', ArrayPrototypeShims.find); } if ([, 1].findIndex(function (item, idx) { return idx === 0; }) !== 0) { overrideNative(Array.prototype, 'findIndex', ArrayPrototypeShims.findIndex); } + /* eslint-enable no-sparse-arrays */ /*jshint elision: false */ var isEnumerableOn = Function.bind.call(Function.bind, Object.prototype.propertyIsEnumerable); @@ -1468,7 +1491,11 @@ } } - if (!RegExp.prototype.flags && supportsDescriptors) { + var hasFlags = supportsDescriptors && (function () { + var desc = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags'); + return desc && ES.IsCallable(desc.get); + }()); + if (supportsDescriptors && !hasFlags) { var regExpFlagsGetter = function flags() { if (!ES.TypeIsObject(this)) { throw new TypeError('Method called on incompatible type: must be an object.'); @@ -1501,22 +1528,26 @@ if (!regExpSupportsFlagsWithRegex && supportsDescriptors) { var OrigRegExp = RegExp; - var RegExpShim = function RegExp(pattern, flags) { - var calledWithNew = this instanceof RegExp; - if (!calledWithNew && (Type.regex(pattern) || (pattern && pattern.constructor === RegExp))) { - return pattern; - } - if (Type.regex(pattern) && Type.string(flags)) { - return new RegExp(pattern.source, flags); - } - return new OrigRegExp(pattern, flags); - }; + var RegExpShim = (function () { + return function RegExp(pattern, flags) { + var calledWithNew = this instanceof RegExp; + if (!calledWithNew && (Type.regex(pattern) || (pattern && pattern.constructor === RegExp))) { + return pattern; + } + if (Type.regex(pattern) && Type.string(flags)) { + return new RegExp(pattern.source, flags); + } + return new OrigRegExp(pattern, flags); + }; + }()); wrapConstructor(OrigRegExp, RegExpShim, { $input: true // Chrome < v39 & Opera < 26 have a nonstandard "$input" property }); /*globals RegExp: true */ + /* eslint-disable no-undef */ RegExp = RegExpShim; Value.redefine(globals, 'RegExp', RegExpShim); + /* eslint-enable no-undef */ /*globals RegExp: false */ } @@ -1975,6 +2006,7 @@ return C; }; + var Promise$prototype; var Promise = (function () { var PromiseShim = function Promise(resolver) { if (!(this instanceof PromiseShim)) { @@ -2006,7 +2038,7 @@ }; return PromiseShim; }()); - var Promise$prototype = Promise.prototype; + Promise$prototype = Promise.prototype; var _promiseAllResolver = function (index, values, capability, remaining) { var alreadyCalled = false; @@ -2042,7 +2074,7 @@ var resolveElement = _promiseAllResolver( index, values, resultCapability, remaining ); - remaining.count++; + remaining.count += 1; nextPromise.then(resolveElement, resultCapability.reject); index += 1; } @@ -2087,15 +2119,16 @@ iteratorRecord = { iterator: iterator, done: false }; return performPromiseAll(iteratorRecord, C, capability); } catch (e) { + var exception = e; if (iteratorRecord && !iteratorRecord.done) { try { ES.IteratorClose(iterator, true); } catch (ee) { - e = ee; + exception = ee; } } var reject = capability.reject; - reject(e); + reject(exception); return capability.promise; } }, @@ -2109,15 +2142,16 @@ iteratorRecord = { iterator: iterator, done: false }; return performPromiseRace(iteratorRecord, C, capability); } catch (e) { + var exception = e; if (iteratorRecord && !iteratorRecord.done) { try { ES.IteratorClose(iterator, true); } catch (ee) { - e = ee; + exception = ee; } } var reject = capability.reject; - reject(e); + reject(exception); return capability.promise; } }, @@ -2155,15 +2189,16 @@ var C = ES.SpeciesConstructor(promise, Promise); var resultCapability = new PromiseCapability(C); // PerformPromiseThen(promise, onFulfilled, onRejected, resultCapability) - if (!ES.IsCallable(onFulfilled)) { - onFulfilled = PROMISE_IDENTITY; - } - if (!ES.IsCallable(onRejected)) { - onRejected = PROMISE_THROWER; - } - var fulfillReaction = { capabilities: resultCapability, handler: onFulfilled }; - var rejectReaction = { capabilities: resultCapability, handler: onRejected }; - var _promise = promise._promise, value; + var fulfillReaction = { + capabilities: resultCapability, + handler: ES.IsCallable(onFulfilled) ? onFulfilled : PROMISE_IDENTITY + }; + var rejectReaction = { + capabilities: resultCapability, + handler: ES.IsCallable(onRejected) ? onRejected : PROMISE_THROWER + }; + var _promise = promise._promise; + var value; if (_promise.state === PROMISE_PENDING) { _push(_promise.fulfillReactions, fulfillReaction); _push(_promise.rejectReactions, rejectReaction); @@ -2219,7 +2254,9 @@ if (!promiseSupportsSubclassing || !promiseIgnoresNonFunctionThenCallbacks || !promiseRequiresObjectContext || promiseResolveBroken) { /*globals Promise: true */ + /* eslint-disable no-undef */ Promise = PromiseShim; + /* eslint-enable no-undef */ /*globals Promise: false */ overrideNative(globals, 'Promise', PromiseShim); } @@ -2399,6 +2436,7 @@ }; addIterator(MapIterator.prototype); + var Map$prototype; var MapShim = function Map() { if (!(this instanceof Map)) { throw new TypeError('Constructor Map requires "new"'); @@ -2424,7 +2462,7 @@ } return map; }; - var Map$prototype = MapShim.prototype; + Map$prototype = MapShim.prototype; Value.getter(Map$prototype, 'size', function () { if (typeof this._size === 'undefined') { @@ -2589,6 +2627,7 @@ // Sets containing only string or numeric keys, we use an object // as backing storage and lazily create a full Map only when // required. + var Set$prototype; var SetShim = function Set() { if (!(this instanceof Set)) { throw new TypeError('Constructor Set requires "new"'); @@ -2611,13 +2650,14 @@ } return set; }; - var Set$prototype = SetShim.prototype; + Set$prototype = SetShim.prototype; // Switch from the object backing storage to a full Map. var ensureMap = function ensureMap(set) { if (!set['[[SetData]]']) { var m = set['[[SetData]]'] = new collectionShims.Map(); - _forEach(Object.keys(set._storage), function (k) { + _forEach(Object.keys(set._storage), function (key) { + var k = key; if (k === '^null') { k = null; } else if (k === '^undefined') { @@ -2915,12 +2955,6 @@ addDefaultSpecies(globals.Set); } - // Reflect - if (!globals.Reflect) { - defineProperty(globals, 'Reflect', {}); - } - var Reflect = globals.Reflect; - var throwUnlessTargetIsObject = function throwUnlessTargetIsObject(target) { if (!ES.TypeIsObject(target)) { throw new TypeError('target must be an object'); @@ -2942,7 +2976,7 @@ if (!ES.IsConstructor(constructor)) { throw new TypeError('First argument must be a constructor.'); } - var newTarget = (arguments.length < 3) ? constructor : arguments[2]; + var newTarget = arguments.length < 3 ? constructor : arguments[2]; if (!ES.IsConstructor(newTarget)) { throw new TypeError('new.target must be a constructor.'); } @@ -3132,7 +3166,8 @@ } if (Object.setPrototypeOf && ReflectShims.getPrototypeOf) { - var willCreateCircularPrototype = function (object, proto) { + var willCreateCircularPrototype = function (object, lastProto) { + var proto = lastProto; while (proto) { if (object === proto) { return true; diff --git a/js/vendor/es6-shim/es6-shim.map b/js/vendor/es6-shim/es6-shim.map index 180c582c5..4d7d8c49f 100644 --- a/js/vendor/es6-shim/es6-shim.map +++ b/js/vendor/es6-shim/es6-shim.map @@ -1 +1 @@ -{"version":3,"sources":["es6-shim.js"],"names":["root","factory","define","amd","exports","module","returnExports","this","_apply","Function","call","bind","apply","_call","isArray","Array","not","notThunker","func","notThunk","arguments","throwsError","e","valueOrFalseIfThrows","isCallableWithoutNew","arePropertyDescriptorsSupported","Object","defineProperty","get","supportsDescriptors","functionsHaveNames","foo","name","_forEach","prototype","forEach","_reduce","reduce","_filter","filter","_every","every","createDataProperty","object","value","configurable","enumerable","writable","createDataPropertyOrThrow","ES","SameValue","TypeError","force","defineProperties","map","keys","method","create","properties","Prototype","key","Value","defineByDescriptor","supportsSubclassing","C","f","setPrototypeOf","Sub","Subclass","arg","o","constructor","getGlobal","self","window","global","Error","globals","globalIsFinite","isFinite","hasStrictMode","_indexOf","String","indexOf","_toString","toString","_concat","concat","_strSlice","slice","_push","push","_pushApply","_shift","shift","_max","Math","max","_min","min","_floor","floor","_abs","abs","_log","log","_sqrt","sqrt","_hasOwnProperty","hasOwnProperty","ArrayIterator","noop","Symbol","symbolSpecies","species","getter","proxy","originalObject","targetObject","originalDescriptor","getOwnPropertyDescriptor","getKey","set","setKey","redefine","property","newValue","descriptor","preserveToString","target","source","IsCallable","wrapConstructor","original","replacement","keysToSkip","getOwnPropertyNames","defaultSpeciesGetter","addDefaultSpecies","Type","primitive","x","string","regex","symbol","numberIsNaN","Number","isNaN","numberIsFinite","overrideNative","$iterator$","iterator","Set","addIterator","impl","implementation","isStandardArguments","isArguments","isLegacyArguments","length","callee","Call","F","V","args","RequireObjectCoercible","optMessage","TypeIsObject","ToObject","IsConstructor","ToInt32","ToNumber","ToUint32","ToInteger","number","ToLength","len","MAX_SAFE_INTEGER","a","b","SameValueZero","IsIterable","GetIterator","itFn","GetMethod","it","p","IteratorComplete","iterResult","IteratorClose","completionIsThrow","returnMethod","innerResult","innerException","IteratorNext","result","next","IteratorStep","done","Construct","newTarget","isES6internal","Reflect","construct","proto","obj","SpeciesConstructor","O","defaultConstructor","S","CreateHTML","tag","attribute","p1","escapedV","replace","p2","p3","emulateES6construct","defaultNewTarget","defaultProto","slots","fromCodePoint","originalFromCodePoint","codePoints","StringShims","i","RangeError","fromCharCode","join","raw","callSite","cooked","rawString","literalsegments","stringElements","nextIndex","nextKey","nextSeg","nextSub",0,1,"stringRepeat","repeat","s","times","half","stringMaxLength","Infinity","StringPrototypeShims","thisStr","numTimes","startsWith","searchString","searchStr","startArg","start","endsWith","thisLen","posArg","pos","end","includes","position","codePointAt","first","charCodeAt","isEnd","second","startsWithRejectsRegex","startsWithHandlesInfinity","hasStringTrimBug","trim","ws","trimRegexp","RegExp","StringIterator","_s","_i","substr","ArrayShims","from","items","mapFn","mapping","T","usingIterator","nextValue","undefined","arrayLike","of","A","k","iteratorResult","array","kind","retval","ObjectIterator","getAllKeys","arrayOfSupportsSubclassing","Foo","fooArr","ArrayPrototypeShims","copyWithin","relativeTarget","relativeStart","to","fin","count","direction","fill","relativeEnd","find","predicate","list","thisArg","findIndex","values","entries","unscopables","originalArrayPrototypeValues","getPrototypeOf","arrayFromSwallowsNegativeLengths","arrayFromHandlesIterables","arr","arrayFromHandlesUndefinedMapFunction","origArrayFrom","toLengthsCorrectly","reversed","originalForEach","callbackFn","originalMap","originalFilter","some","originalSome","originalEvery","originalReduce","reduceRight","originalReduceRight","OrigNumber","binaryRegex","octalRegex","isBinary","test","isOctal","toPrimitive","valueOf","NumberShim","primValue","parseInt","receiver","valueOfSucceeds","maxSafeInteger","pow","MIN_SAFE_INTEGER","EPSILON","parseFloat","isInteger","isSafeInteger","item","idx","isEnumerableOn","propertyIsEnumerable","sliceArgs","initial","desiredArgCount","assignTo","assignToSource","assignReducer","symbols","getOwnPropertySymbols","ObjectShims","assign","is","assignHasPendingExceptions","preventExtensions","thrower","ES5ObjectShims","magic","checkArgs","polyfill","FAKENULL","gpo","spo","objectKeysAcceptsPrimitives","originalObjectKeys","objectGOPNAcceptsPrimitives","cachedWindowNames","originalObjectGetOwnPropertyNames","val","objectGOPDAcceptsPrimitives","originalObjectGetOwnPropertyDescriptor","seal","objectSealAcceptsPrimitives","originalObjectSeal","isSealed","objectIsSealedAcceptsPrimitives","originalObjectIsSealed","freeze","objectFreezeAcceptsPrimitives","originalObjectFreeze","isFrozen","objectIsFrozenAcceptsPrimitives","originalObjectIsFrozen","objectPreventExtensionsAcceptsPrimitives","originalObjectPreventExtensions","isExtensible","objectIsExtensibleAcceptsPrimitives","originalObjectIsExtensible","objectGetProtoAcceptsPrimitives","originalGetProto","flags","regExpFlagsGetter","ignoreCase","multiline","unicode","sticky","regExpSupportsFlagsWithRegex","OrigRegExp","RegExpShim","pattern","calledWithNew","$input","regexGlobals","input","lastMatch","lastParen","leftContext","rightContext","prop","inverseEpsilon","roundTiesToEven","n","BINARY_32_EPSILON","BINARY_32_MAX_VALUE","BINARY_32_MIN_VALUE","numberCLZ","clz","MathShims","acosh","NaN","E","asinh","atanh","cbrt","negate","exp","clz32","LOG2E","cosh","expm1","t","sum","hypot","y","largest","log2","log10","LOG10E","log1p","sign","sinh","tanh","trunc","imul","ah","al","bh","bl","fround","v","MAX_VALUE","expm1OfTen","origMathRound","round","roundHandlesBoundaryConditions","smallestPositiveNumberWhereRoundBreaks","largestPositiveNumberWhereRoundBreaks","roundDoesNotIncreaseIntegers","num","ceil","origImul","PromiseShim","setTimeout","IsPromise","promise","_promise","PromiseCapability","capability","resolver","resolve","reject","makeZeroTimeout","postMessage","timeouts","messageName","setZeroTimeout","fn","handleMessage","event","data","stopPropagation","addEventListener","makePromiseAsap","P","Promise","task","then","enqueue","setImmediate","process","nextTick","PROMISE_IDENTITY","PROMISE_THROWER","PROMISE_PENDING","PROMISE_FULFILLED","PROMISE_REJECTED","promiseReactionJob","reaction","argument","promiseCapability","capabilities","handler","handlerResult","handlerException","triggerPromiseReactions","reactions","fulfillPromise","fulfillReactions","rejectReactions","state","rejectPromise","reason","createResolvingFunctions","alreadyResolved","resolution","promiseResolveThenableJob","thenable","resolvingFunctions","getPromiseSpecies","Promise$prototype","_promiseAllResolver","index","remaining","alreadyCalled","performPromiseAll","iteratorRecord","resultCapability","nextPromise","resolveElement","performPromiseRace","all","iterable","ee","race","rejectFunc","resolveFunc","catch","onRejected","onFulfilled","fulfillReaction","rejectReaction","accept","defer","chain","promiseSupportsSubclassing","promiseIgnoresNonFunctionThenCallbacks","promiseRequiresObjectContext","promiseResolveBroken","testOrder","preservesInsertionOrder","preservesNumericInsertionOrder","fastkey","type","emptyObject","addIterableToMap","MapConstructor","entry","iter","adder","nextItem","addIterableToSet","SetConstructor","add","collectionShims","Map","empty","MapEntry","prev","isRemoved","isMap","_es6map","requireMapSlot","MapIterator","head","_head","MapShim","Map$prototype","_storage","_size","fkey","has","delete","clear","callback","context","isSet","_es6set","requireSetSlot","SetShim","Set$prototype","[[SetData]]","ensureMap","m","charAt","size","hasFKey","entireSet","mapAcceptsArguments","OrigMapNoArgs","testMap","mapUsesSameValueZero","mapSupportsChaining","origMapSet","origMapGet","origMapHas","testSet","setUsesSameValueZero","setSupportsChaining","origSetAdd","origSetHas","origSetDel","SetDelete","mapSupportsSubclassing","M","mapFailsToSupportSubclassing","mapRequiresNew","OrigMap","setSupportsSubclassing","setFailsToSupportSubclassing","setRequiresNew","OrigSet","mapIterationThrowsStopIterator","anonymousSetHas","throwUnlessTargetIsObject","ReflectShims","deleteProperty","desc","enumerate","ownKeys","callAndCatchException","ConvertExceptionToBoolean","internalGet","parent","internalSet","existingDesc","propertyKey","attributes","objectDotGetPrototypeOf","willCreateCircularPrototype","defineOrOverrideReflectProperty","shim","acceptsPrimitives","originalReflectGetProto","basic","extensible","Date","dateToString","shimmedDateToString","stringHTMLshims","anchor","big","blink","bold","fixed","fontcolor","color","fontsize","italics","link","url","small","strike","sub","sup","shouldOverwrite","output","quotesCount","match","toLowerCase","JSONstringifiesSymbols","stringify","JSON","JSONstringifyAcceptsObjectSymbol","origStringify","replacer","replaceFn","wrappedReplacer","parsedValue"],"mappings":"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