(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
var api = {
  letConst: { passes: "'use strict'; let a; const b = 2;" },
  letLoop: { passes: "'use strict'; for(let i in {}){}; for(let i=0;;){break}" },
  constLoop: { passes: "'use strict'; for(const i in {}){}; for (const i=0;;){break}" },
  defaultParameter: { passes: "'use strict'; function a(b=2){}" },
  spreadRest: { passes: "'use strict'; var a = [1,2]; +function b(...c){}(...a);" },
  destructuring: { passes: "'use strict'; var a = [1,2], [b,c] = a, d = {e:1,f:2}, {e:E,f} = d;" },
  parameterDestructuring: { passes: "'use strict'; function a({b,c}){}" },
  templateString: { passes: "'use strict'; var a = 1, b = `c${a}d`;" },
  forOf: { passes: "'use strict'; for (var a of [1]) {}" },
  arrow: { passes: "'use strict'; var a = () => {};" },
  generator: { passes: "'use strict'; function *a(){ yield; }" },
  conciseMethodProperty: { passes: "'use strict'; var a = 1, b = { c(){}, a };" },
  computedProperty: { passes: "'use strict'; var a = 1, b = { ['x'+a]: 2 };" },
  moduleExport: { passes: "'use strict'; export var a = 1;" },
  moduleImport: { passes: "'use strict'; import {a} from 'b';" },
  classes: { passes: "'use strict'; class Foo {}; class Bar extends Foo {};" },
  numericLiteral: { passes: "'use strict'; var a = 0o1, b = 0b10;" },
  oldOctalLiteral: { fails: "'use strict'; var a = 01;" },
  symbol: { passes: "'use strict'; var a = Symbol('b');" },
  symbolImplicitCoercion: { dependencies: ["symbol"], fails: "'use strict'; var a = Symbol('a'); a + '';" },
  unicodeEscape: { passes: "'use strict'; var a = '\\u{20BB7}';" },
  unicodeIdentifier: { passes: "'use strict'; var \\u{20BB7};" },
  unicodeRegExp: { passes: "'use strict'; var a = /\\u{20BB7}/u;" },
  stickyRegExp: { passes: "'use strict'; var a = /b/y;" },
  letTDZ: { dependencies: ["letConst"], fails: "'use strict'; a = 1; let a;" },
  letLoopScope: { dependencies: ["letLoop","forOf"], passes: "'use strict'; var x=[],i=0;for(let i=2;i<3;i++){x.push(function(){return i})};for(let i in {3:0}){x.push(function(){return i})};for(let i of [4]){x.push(function(){return i})};if(x[0]()*x[1]()*x[2]()!=24) throw 0;" },
  constRedef: { dependencies: ["letConst"], fails: "'use strict'; const a = 1; a = 2;" },
  objectProto: { passes: "'use strict'; var a = { b: 2 }, c = { __proto__: a }; if (c.b !== 2) throw 0;" },
  objectSuper: { passes: "'use strict'; var a = { b: 2 }, c = { d() { return super.b; } }; Object.setPrototypeOf(c,a); if (c.d() !== 2) throw 0;" },
  extendNatives: { dependencies: ["class"], passes: "'use strict'; class Foo extends Array { }; var a = new Foo(); a.push(1,2,3); if (a.length !== 3) throw 0;" },
  TCO: { passes: "'use strict'; +function a(b){ if (b<6E4) return a(b+1); }(0);" },
  functionNameInference: { passes: "'use strict'; var a = { b: function(){} }; if (a.b.name != 'b') throw 0;" },
  ObjectStatics: { is: "'use strict'; return ('getOwnPropertySymbols' in Object) && ('assign' in Object) && ('is' in Object);" },
  ArrayStatics: { is: "'use strict'; return ('from' in Array) && ('of' in Array);" },
  ArrayMethods: { is: "'use strict'; return ('fill' in Array.prototype) && ('find' in Array.prototype) && ('findIndex' in Array.prototype) && ('entries' in Array.prototype) && ('keys' in Array.prototype) && ('values' in Array.prototype);" },
  TypedArrays: { is: "'use strict'; return ('ArrayBuffer' in global) && ('Int8Array' in global) && ('Uint8Array' in global) && ('Int32Array' in global) && ('Float64Array' in global);" },
  TypedArrayStatics: { dependencies: ["TypedArrays"], is: "'use strict'; return ('from' in Uint32Array) && ('of' in Uint32Array);" },
  TypedArrayMethods: { dependencies: ["TypedArrays"], is: "'use strict'; var x = new Int8Array(1); return ('slice' in x) && ('join' in x) && ('map' in x) && ('forEach' in x);" },
  StringMethods: { is: "'use strict'; return ('includes' in String.prototype) && ('repeat' in String.prototype);" },
  NumberStatics: { is: "'use strict'; return ('isNaN' in Number) && ('isInteger' in Number);" },
  MathStatics: { is: "'use strict'; return ('hypot' in Math) && ('acosh' in Math) && ('imul' in Math);" },
  collections: { is: "'use strict'; return ('Map' in global) && ('Set' in global) && ('WeakMap' in global) && ('WeakSet' in global);" },
  Proxy: { is: "'use strict'; return ('Proxy' in global);" },
  Promise: { is: "'use strict'; return ('Promise' in global);"},
  Reflect: { is: "'use strict'; return ('Reflect' in global);" },
};

module.exports = api;

},{}],2:[function(require,module,exports){
var Supports = function(){
  // Variables
  this.letConst = 'letConst';
  this.letTDZ = 'letTDZ';
  this.constRedef = 'constRedef';
  this.destructuring = 'destructuring';
  this.spreadRest = 'spreadRest';
  // Data Types
  this.forOf = 'forOf';
  this.collections = 'collections';
  this.symbol = 'symbol';
  this.Symbol = this.symbol;
  this.symbolImplicitCoercion = 'symbolImplicitCoercion';
  // Number
  this.numericLiteral = 'numericLiteral';
  this.oldOctalLiteral = 'oldOctalLiteral';
  this.MathStatics = 'MathStatics';
  this.mathStatics = this.MathStatics;
  this.NumberStatics = 'NumberStatics';
  this.numberStatics = this.NumberStatics;
  // String
  this.StringMethods = 'StringMethods';
  this.stringMethods = this.StringMethods;
  this.unicodeEscape = 'unicodeEscape';
  this.unicodeIdentifier = 'unicodeIdentifier';
  this.unicodeRegExp = 'unicodeRegExp';
  this.stickyRegExp = 'stickyRegExp';
  this.templateString = 'templateString';
  // Function
  this.arrow = 'arrow';
  this.defaultParameter = 'defaultParameter';
  this.parameterDestructuring = 'parameterDestructuring';
  this.functionNameInference = 'functionNameInference';
  this.TCO = 'TCO';
  this.tco = this.TCO;
  // Array
  this.ArrayMethods = 'ArrayMethods';
  this.arrayMethods = this.ArrayMethods;
  this.ArrayStatics = 'ArrayStatics';
  this.arrayStatics = this.ArrayStatics;
  this.TypedArrayMethods = 'TypedArrayMethods';
  this.typedArrayMethods = this.TypedArrayMethods;
  this.TypedArrayStatics = 'TypedArrayStatics';
  this.typedArrayStatics = this.TypedArrayStatics;
  this.TypedArrays = 'TypedArrays';
  this.typedArrays = this.TypedArrays;
  // Object
  this.objectProto = 'objectProto';
  this.ObjectStatics = 'ObjectStatics';
  this.objectStatics = this.ObjectStatics;
  this.computedProperty = 'computedProperty';
  this.conciseMethodProperty = 'conciseMethodProperty';
  this.Proxy = 'Proxy';
  this.proxy = this.Proxy;
  this.Reflect = 'Reflect';
  this.reflect = this.Reflect;
  // Generator and Promise
  this.generator = 'generator';
  this.Promise = 'Promise';
  this.promise = this.Promise;
  // Class
  this.classes = 'classes';
  this.class = this.classes;
  this.objectSuper = 'objectSuper';
  this.extendNatives = 'extendNatives';
  // Module
  this.moduleExport = 'moduleExport';
  this.moduleImport = 'moduleImport';
};

module.exports = new Supports();

},{}],3:[function(require,module,exports){
var api = require('./api');
var supports = {};
supports._api = api;

function runTest(key){
  if (key === 'class') key = 'classes';
  if (supports._api[key].dependencies) {
    for(var i = 0; i < supports._api[key].dependencies.length; i++){
      var depKey = supports._api[key].dependencies[i];
      if (runTest(depKey) === false) return false;
    }
  }

  if (supports._api[key].passes) {
    return tryPassFail(supports._api[key].passes);
  } else if (supports._api[key].fails) {
    return !tryPassFail(supports._api[key].fails);
  } else if (supports._api[key].is) {
    return tryReturn(supports._api[key].is);
  } else if (supports._api[key].not) {
    return !tryReturn(supports._api[key].not);
  }
}

function tryPassFail(code) {
  try {
    runIt(code);
    return true;
  }
  catch (err) {
    return false;
  }
}

function tryReturn(code) {
  try {
    return runIt(code);
  }
  catch (err) {
    return false;
  }
}

function runIt(code) {
  return (new Function(code))();
}

module.exports =  runTest;

},{"./api":1}],4:[function(require,module,exports){
var supports = require('../../lib/interface');
var api = require('../../lib/api');
var runTest = require('../../lib/runtest');

global = window;
for (var key in supports){
  supports[key] = runTest(supports[key]);
}

supports._api = api;
window.Supports = supports;

},{"../../lib/api":1,"../../lib/interface":2,"../../lib/runtest":3}]},{},[4]);