// Generated by LiveScript 1.3.1

(function(){

var module, test, toString$ = {}.toString;

module = QUnit.module, test = QUnit.test;

module('ES5');

test('Object.getOwnPropertyDescriptor', function(assert){

var getOwnPropertyDescriptor;

getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;

assert.isFunction(getOwnPropertyDescriptor);

assert.deepEqual(getOwnPropertyDescriptor({

q: 42

}, 'q'), {

writable: true,

enumerable: true,

configurable: true,

value: 42

});

return assert.ok(getOwnPropertyDescriptor({}, 'toString') === void 8);

});

test('Object.defineProperty', function(assert){

var defineProperty, rez, src;

defineProperty = Object.defineProperty;

assert.isFunction(defineProperty);

assert.ok((rez = defineProperty(src = {}, 'q', {

value: 42

})) === src);

return assert.ok(rez.q === 42);

});

test('Object.defineProperties', function(assert){

var defineProperties, rez, src;

defineProperties = Object.defineProperties;

assert.isFunction(defineProperties);

assert.ok((rez = defineProperties(src = {}, {

q: {

value: 42

},

w: {

value: 33

}

})) === src);

return assert.ok(rez.q === 42) && rez.w === 33;

});

test('Object.getPrototypeOf', function(assert){

var create, getPrototypeOf, fn, obj, foo, bar;

create = Object.create, getPrototypeOf = Object.getPrototypeOf;

assert.isFunction(getPrototypeOf);

assert.ok(getPrototypeOf({}) === Object.prototype);

assert.ok(getPrototypeOf([]) === Array.prototype);

assert.ok(getPrototypeOf(new (fn = (function(){

fn.displayName = 'fn';

var prototype = fn.prototype, constructor = fn;

function fn(){}

return fn;

}()))) === fn.prototype);

assert.ok(getPrototypeOf(create(obj = {

q: 1

})) === obj);

assert.ok(getPrototypeOf(create(null)) === null);

assert.ok(getPrototypeOf(getPrototypeOf({})) === null);

foo = function(){};

foo.prototype.foo = 'foo';

bar = function(){};

bar.prototype = create(foo.prototype);

bar.prototype.constructor = bar;

return assert.strictEqual(getPrototypeOf(bar.prototype).foo, 'foo');

});

test('Object.getOwnPropertyNames', function(assert){

var getOwnPropertyNames, fn1, fn2, names;

getOwnPropertyNames = Object.getOwnPropertyNames;

assert.isFunction(getOwnPropertyNames);

fn1 = function(w){

this.w = w != null ? w : 2;

};

fn2 = function(toString){

this.toString = toString != null ? toString : 2;

};

fn1.prototype.q = fn2.prototype.q = 1;

names = getOwnPropertyNames([1, 2, 3]);

assert.strictEqual(names.length, 4);

assert.ok(in$('0', names));

assert.ok(in$('1', names));

assert.ok(in$('2', names));

assert.ok(in$('length', names));

assert.deepEqual(getOwnPropertyNames(new fn1(1)), ['w']);

assert.deepEqual(getOwnPropertyNames(new fn2(1)), ['toString']);

assert.ok(in$('toString', getOwnPropertyNames(Array.prototype)));

assert.ok(in$('toString', getOwnPropertyNames(Object.prototype)));

return assert.ok(in$('constructor', getOwnPropertyNames(Object.prototype)));

});

test('Object.create', function(assert){

var create, getPrototypeOf, getOwnPropertyNames, isObject, isPrototype, getPropertyNames, obj, fn;

create = Object.create, getPrototypeOf = Object.getPrototypeOf, getOwnPropertyNames = Object.getOwnPropertyNames;

isObject = function(it){

return it === Object(it);

};

isPrototype = function(a, b){

return {}.isPrototypeOf.call(a, b);

};

getPropertyNames = function(object){

var result, i$, x$, ref$, len$;

result = getOwnPropertyNames(object);

while (object = getPrototypeOf(object)) {

for (i$ = 0, len$ = (ref$ = getOwnPropertyNames(object)).length; i$ < len$; ++i$) {

x$ = ref$[i$];

in$(x$, result) || result.push(x$);

}

}

return result;

};

assert.isFunction(create);

assert.ok(isPrototype(obj = {

q: 1

}, create(obj)));

assert.ok(create(obj).q === 1);

fn = function(){

return this.a = 1;

};

assert.ok(create(new fn) instanceof fn);

assert.ok(fn.prototype === getPrototypeOf(getPrototypeOf(create(new fn))));

assert.ok(create(new fn).a === 1);

assert.ok(create({}, {

a: {

value: 42

}

}).a === 42);

assert.ok(isObject(obj = create(null, {

w: {

value: 2

}

})));

assert.ok(!('toString' in obj));

assert.ok(obj.w === 2);

return assert.deepEqual(getPropertyNames(create(null)), []);

});

test('Object.keys', function(assert){

var keys, fn1, fn2;

keys = Object.keys;

assert.isFunction(keys);

fn1 = function(w){

this.w = w != null ? w : 2;

};

fn2 = function(toString){

this.toString = toString != null ? toString : 2;

};

fn1.prototype.q = fn2.prototype.q = 1;

assert.deepEqual(keys([1, 2, 3]), ['0', '1', '2']);

assert.deepEqual(keys(new fn1(1)), ['w']);

assert.deepEqual(keys(new fn2(1)), ['toString']);

return assert.ok(!in$('push', keys(Array.prototype)));

});

test('Object.seal', function(assert){

var seal, a;

seal = Object.seal;

assert.isFunction(seal);

return assert.strictEqual(seal(a = {}), a);

});

test('Object.freeze', function(assert){

var freeze, a;

freeze = Object.freeze;

assert.isFunction(freeze);

return assert.strictEqual(freeze(a = {}), a);

});

test('Object.preventExtensions', function(assert){

var preventExtensions, a;

preventExtensions = Object.preventExtensions;

assert.isFunction(preventExtensions);

return assert.strictEqual(preventExtensions(a = {}), a);

});

test('Object.isSealed', function(assert){

var isSealed;

isSealed = Object.isSealed;

assert.isFunction(isSealed);

return assert.strictEqual(isSealed({}), false);

});

test('Object.isFrozen', function(assert){

var isFrozen;

isFrozen = Object.isFrozen;

assert.isFunction(isFrozen);

return assert.strictEqual(isFrozen({}), false);

});

test('Object.isExtensible', function(assert){

var isExtensible;

isExtensible = Object.isExtensible;

assert.isFunction(isExtensible);

return assert.strictEqual(isExtensible({}), true);

});

test('Function#bind', function(assert){

var obj, fn, inst, F, date;

assert.isFunction(Function.prototype.bind);

obj = {

a: 42

};

assert.ok(42 === function(){

return this.a;

}.bind(obj)());

assert.ok(void 8 === new (function(){}.bind(obj))().a);

fn = function(a, b){

this.a = a;

this.b = b;

};

inst = new (fn.bind(null, 1))(2);

assert.ok(inst instanceof fn);

assert.strictEqual(inst.a, 1);

assert.strictEqual(inst.b, 2);

assert.ok(42 === function(it){

return it;

}.bind(null, 42)());

fn = RegExp.prototype.test.bind(/a/);

assert.ok(fn('a'));

F = Date.bind(null, 2015);

date = new F(6);

assert.ok(date instanceof Date);

assert.strictEqual(date.getFullYear(), 2015);

return assert.strictEqual(date.getMonth(), 6);

});

test('Array.isArray', function(assert){

var isArray;

isArray = Array.isArray;

assert.isFunction(isArray);

assert.ok(!isArray({}));

assert.ok(!isArray(function(){

return arguments;

}()));

return assert.ok(isArray([]));

});

test('ES5 Array prototype methods are functions', function(assert){

var i$, x$, ref$, len$, results$ = [];

for (i$ = 0, len$ = (ref$ = ['indexOf', 'lastIndexOf', 'every', 'some', 'forEach', 'map', 'filter', 'reduce', 'reduceRight']).length; i$ < len$; ++i$) {

x$ = ref$[i$];

results$.push(assert.isFunction(Array.prototype[x$], "Array::" + x$ + " is function"));

}

return results$;

});

test('Array#slice', function(assert){

var slice, arr, str, list, ref$, e;

slice = Array.prototype.slice;

arr = ['1', '2', '3', '4', '5'];

assert.deepEqual(arr.slice(), arr);

assert.deepEqual(arr.slice(1, 3), ['2', '3']);

assert.deepEqual(arr.slice(1, void 8), ['2', '3', '4', '5']);

assert.deepEqual(arr.slice(1, -1), ['2', '3', '4']);

assert.deepEqual(arr.slice(-2, -1), ['4']);

assert.deepEqual(arr.slice(-2, -3), []);

str = '12345';

assert.deepEqual(slice.call(str), arr);

assert.deepEqual(slice.call(str, 1, 3), ['2', '3']);

assert.deepEqual(slice.call(str, 1, void 8), ['2', '3', '4', '5']);

assert.deepEqual(slice.call(str, 1, -1), ['2', '3', '4']);

assert.deepEqual(slice.call(str, -2, -1), ['4']);

assert.deepEqual(slice.call(str, -2, -3), []);

if (list = typeof document != 'undefined' && document !== null ? (ref$ = document.body) != null ? ref$.childNodes : void 8 : void 8) {

try {

assert.strictEqual(toString$.call(slice.call(list)).slice(8, -1), 'Array');

} catch (e$) {

e = e$;

assert.ok(false);

}

}

if (NATIVE) {

return assert.deepEqual(slice.call({

length: -1,

0: 1

}, 0, 1), [], 'uses ToLength');

}

});

test('Array#join', function(assert){

assert.arity(Array.prototype.join, 1);

assert.strictEqual(Array.prototype.join.call([1, 2, 3], void 8), '1,2,3');

assert.strictEqual(Array.prototype.join.call('123'), '1,2,3');

return assert.strictEqual(Array.prototype.join.call('123', '|'), '1|2|3');

});

test('Array#indexOf', function(assert){

assert.ok(0 === [1, 1, 1].indexOf(1));

assert.ok(-1 === [1, 2, 3].indexOf(1, 1));

assert.ok(1 === [1, 2, 3].indexOf(2, 1));

assert.ok(-1 === [1, 2, 3].indexOf(2, -1));

assert.ok(1 === [1, 2, 3].indexOf(2, -2));

assert.ok(-1 === [NaN].indexOf(NaN));

assert.ok(3 === Array(2).concat([1, 2, 3]).indexOf(2));

assert.ok(-1 === Array(1).indexOf(void 8));

if (NATIVE && DESCRIPTORS) {

return assert.ok((function(){

try {

return -1 === Array.prototype.indexOf.call(Object.defineProperty({

length: -1

}, 0, {

get: function(){

throw Error();

}

}), 1);

} catch (e$) {}

}()), 'uses ToLength');

}

});

test('Array#lastIndexOf', function(assert){

assert.strictEqual(2, [1, 1, 1].lastIndexOf(1));

assert.strictEqual(-1, [1, 2, 3].lastIndexOf(3, 1));

assert.strictEqual(1, [1, 2, 3].lastIndexOf(2, 1));

assert.strictEqual(-1, [1, 2, 3].lastIndexOf(2, -3));

assert.strictEqual(1, [1, 2, 3].lastIndexOf(2, -2));

assert.strictEqual(-1, [NaN].lastIndexOf(NaN));

assert.strictEqual(1, [1, 2, 3].concat(Array(2)).lastIndexOf(2));

if (NATIVE && DESCRIPTORS) {

return assert.ok((function(){

try {

return -1 === Array.prototype.lastIndexOf.call(Object.defineProperties({

length: -1

}, {

2147483646: {

get: function(){

throw Error();

}

},

4294967294: {

get: function(){

throw Error();

}

}

}), 1);

} catch (e$) {}

}()), 'uses ToLength');

}

});

test('Array#every', function(assert){

var a, ctx, rez, arr;

(a = [1]).every(function(val, key, that){

assert.same(arguments.length, 3, 'correct number of callback arguments');

assert.same(val, 1, 'correct value in callback');

assert.same(key, 0, 'correct index in callback');

assert.same(that, a, 'correct link to array in callback');

return assert.same(this, ctx, 'correct callback context');

}, ctx = {});

assert.ok([1, 2, 3].every(function(it){

return toString$.call(it).slice(8, -1) === 'Number';

}));

assert.ok([1, 2, 3].every((function(it){

return it < 4;

})));

assert.ok(![1, 2, 3].every((function(it){

return it < 3;

})));

assert.ok(![1, 2, 3].every(function(it){

return toString$.call(it).slice(8, -1) === 'String';

}));

assert.ok([1, 2, 3].every(function(){

return +this === 1;

}, 1));

rez = '';

[1, 2, 3].every(function(){

return rez += arguments[1];

});

assert.ok(rez === '012');

assert.ok((arr = [1, 2, 3]).every(function(){

return arguments[2] === arr;

}));

if (NATIVE) {

return assert.ok((function(){

try {

return true === Array.prototype.every.call({

length: -1,

0: 1

}, function(){

throw 42;

});

} catch (e$) {}

}()), 'uses ToLength');

}

});

test('Array#some', function(assert){

var a, ctx, rez, arr;

(a = [1]).some(function(val, key, that){

assert.same(arguments.length, 3, 'correct number of callback arguments');

assert.same(val, 1, 'correct value in callback');

assert.same(key, 0, 'correct index in callback');

assert.same(that, a, 'correct link to array in callback');

return assert.same(this, ctx, 'correct callback context');

}, ctx = {});

assert.ok([1, '2', 3].some(function(it){

return toString$.call(it).slice(8, -1) === 'Number';

}));

assert.ok([1, 2, 3].some((function(it){

return it < 3;

})));

assert.ok(![1, 2, 3].some((function(it){

return it < 0;

})));

assert.ok(![1, 2, 3].some(function(it){

return toString$.call(it).slice(8, -1) === 'String';

}));

assert.ok(![1, 2, 3].some(function(){

return +this !== 1;

}, 1));

rez = '';

[1, 2, 3].some(function(){

rez += arguments[1];

return false;

});

assert.ok(rez === '012');

assert.ok(!(arr = [1, 2, 3]).some(function(){

return arguments[2] !== arr;

}));

if (NATIVE) {

return assert.ok((function(){

try {

return false === Array.prototype.some.call({

length: -1,

0: 1

}, function(){

throw 42;

});

} catch (e$) {}

}()), 'uses ToLength');

}

});

test('Array#forEach', function(assert){

var a, ctx, rez, arr;

(a = [1]).forEach(function(val, key, that){

assert.same(arguments.length, 3, 'correct number of callback arguments');

assert.same(val, 1, 'correct value in callback');

assert.same(key, 0, 'correct index in callback');

assert.same(that, a, 'correct link to array in callback');

assert.same(this, ctx, 'correct callback context');

}, ctx = {});

rez = '';

[1, 2, 3].forEach(function(it){

rez += it;

});

assert.ok(rez === '123');

rez = '';

[1, 2, 3].forEach(function(){

rez += arguments[1];

});

assert.ok(rez === '012');

rez = '';

[1, 2, 3].forEach(function(){

rez += arguments[2];

});

assert.ok(rez === '1,2,31,2,31,2,3');

rez = '';

[1, 2, 3].forEach(function(){

rez += this;

}, 1);

assert.ok(rez === '111');

rez = '';

arr = [];

arr[5] = '';

arr.forEach(function(arg$, k){

rez += k;

});

assert.ok(rez === '5');

if (NATIVE) {

return assert.ok((function(){

try {

return void 8 === Array.prototype.forEach.call({

length: -1,

0: 1

}, function(){

throw 42;

});

} catch (e$) {}

}()), 'uses ToLength');

}

});

test('Array#map', function(assert){

var a, ctx;

(a = [1]).map(function(val, key, that){

assert.same(arguments.length, 3, 'correct number of callback arguments');

assert.same(val, 1, 'correct value in callback');

assert.same(key, 0, 'correct index in callback');

assert.same(that, a, 'correct link to array in callback');

return assert.same(this, ctx, 'correct callback context');

}, ctx = {});

assert.deepEqual([2, 3, 4], [1, 2, 3].map((function(it){

return it + 1;

})));

assert.deepEqual([1, 3, 5], [1, 2, 3].map(curry$(function(x$, y$){

return x$ + y$;

})));

assert.deepEqual([2, 2, 2], [1, 2, 3].map(function(){

return +this;

}, 2));

if (NATIVE) {

return assert.ok((function(){

try {

return Array.prototype.map.call({

length: -1,

0: 1

}, function(){

throw 42;

});

} catch (e$) {}

}()), 'uses ToLength');

}

});

test('Array#filter', function(assert){

var a, ctx;

(a = [1]).filter(function(val, key, that){

assert.same(arguments.length, 3, 'correct number of callback arguments');

assert.same(val, 1, 'correct value in callback');

assert.same(key, 0, 'correct index in callback');

assert.same(that, a, 'correct link to array in callback');

return assert.same(this, ctx, 'correct callback context');

}, ctx = {});

assert.deepEqual([1, 2, 3, 4, 5], [1, 2, 3, 'q', {}, 4, true, 5].filter(function(it){

return typeof it === 'number';

}));

if (NATIVE) {

return assert.ok((function(){

try {

return Array.prototype.map.call({

length: -1,

0: 1

}, function(){

throw 42;

});

} catch (e$) {}

}()), 'uses ToLength');

}

});

test('Array#reduce', function(assert){

var a, accumulator, v, k;

(a = [1]).reduce(function(memo, val, key, that){

assert.same(arguments.length, 4, 'correct number of callback arguments');

assert.same(memo, accumulator, 'correct callback accumulator');

assert.same(val, 1, 'correct value in callback');

assert.same(key, 0, 'correct index in callback');

return assert.same(that, a, 'correct link to array in callback');

}, accumulator = {});

assert.same([1, 2, 3].reduce(curry$(function(x$, y$){

return x$ + y$;

}), 1), 7, 'works with initial accumulator');

(a = [1, 2]).reduce(function(memo, val, key, that){

assert.same(memo, 1, 'correct default accumulator');

assert.same(val, 2, 'correct start value without initial accumulator');

return assert.same(key, 1, 'correct start index without initial accumulator');

});

assert.same([1, 2, 3].reduce(curry$(function(x$, y$){

return x$ + y$;

})), 6, 'works without initial accumulator');

v = '';

k = '';

[1, 2, 3].reduce(function(memo, a, b){

v += a;

k += b;

}, 0);

assert.same(v, '123', 'correct order #1');

assert.same(k, '012', 'correct order #2');

assert.same(Array.prototype.reduce.call({

0: 1,

1: 2,

length: 2

}, curry$(function(x$, y$){

return x$ + y$;

})), 3, 'generic');

if (NATIVE) {

return assert.ok((function(){

try {

return Array.prototype.reduce.call({

length: -1,

0: 1

}, function(){

throw 42;

}, 1);

} catch (e$) {}

}()), 'uses ToLength');

}

});

test('Array#reduceRight', function(assert){

var a, accumulator, v, k;

(a = [1]).reduceRight(function(memo, val, key, that){

assert.same(arguments.length, 4, 'correct number of callback arguments');

assert.same(memo, accumulator, 'correct callback accumulator');

assert.same(val, 1, 'correct value in callback');

assert.same(key, 0, 'correct index in callback');

return assert.same(that, a, 'correct link to array in callback');

}, accumulator = {});

assert.same([1, 2, 3].reduceRight(curry$(function(x$, y$){

return x$ + y$;

}), 1), 7, 'works with initial accumulator');

(a = [1, 2]).reduceRight(function(memo, val, key, that){

assert.same(memo, 2, 'correct default accumulator');

assert.same(val, 1, 'correct start value without initial accumulator');

return assert.same(key, 0, 'correct start index without initial accumulator');

});

assert.same([1, 2, 3].reduceRight(curry$(function(x$, y$){

return x$ + y$;

})), 6, 'works without initial accumulator');

v = '';

k = '';

[1, 2, 3].reduceRight(function(memo, a, b){

v += a;

k += b;

}, 0);

assert.same(v, '321', 'correct order #1');

assert.same(k, '210', 'correct order #2');

assert.same(Array.prototype.reduceRight.call({

0: 1,

1: 2,

length: 2

}, curry$(function(x$, y$){

return x$ + y$;

})), 3, 'generic');

if (NATIVE) {

return assert.ok((function(){

try {

return Array.prototype.reduceRight.call({

length: -1,

2147483646: 0,

4294967294: 0

}, function(){

throw 42;

}, 1);

} catch (e$) {}

}()), 'uses ToLength');

}

});

test('Date.now', function(assert){

var now;

now = Date.now;

assert.isFunction(now);

return assert.ok(+new Date - now() < 10, 'Date.now() ~ +new Date');

});

test('Date#toISOString', function(assert){

var ft, bc;

assert.isFunction(Date.prototype.toISOString);

assert.strictEqual(new Date(0).toISOString(), '1970-01-01T00:00:00.000Z');

assert.strictEqual(new Date(1e12 + 1).toISOString(), '2001-09-09T01:46:40.001Z');

assert.strictEqual(new Date(-5e13 - 1).toISOString(), '0385-07-25T07:06:39.999Z');

ft = new Date(1e15 + 1).toISOString();

assert.ok(ft === '+033658-09-27T01:46:40.001Z' || ft === '33658-09-27T01:46:40.001Z');

bc = new Date(-1e15 + 1).toISOString();

assert.ok(bc === '-029719-04-05T22:13:20.001Z' || bc === '-29719-04-05T22:13:20.001Z');

return assert.throws(function(){

return new Date(NaN).toISOString();

}, RangeError);

});

function in$(x, xs){

var i = -1, l = xs.length >>> 0;

while (++i < l) if (x === xs[i]) return true;

return false;

}

function curry$(f, bound){

var context,

_curry = function(args) {

return f.length > 1 ? function(){

var params = args ? args.concat() : [];

context = bound ? context || this : this;

return params.push.apply(params, arguments) <

f.length && arguments.length ?

_curry.call(context, params) : f.apply(context, params);

} : f;

};

return _curry();

}

}).call(this);

// Generated by LiveScript 1.3.1

(function(){

var module, test;

module = QUnit.module, test = QUnit.test;

module('ES6');

test('Array#copyWithin', function(assert){

var a;

assert.isFunction(Array.prototype.copyWithin);

assert.arity(Array.prototype.copyWithin, 2);

assert.name(Array.prototype.copyWithin, 'copyWithin');

assert.looksNative(Array.prototype.copyWithin);

assert.strictEqual(a = [1].copyWithin(0), a);

assert.deepEqual([1, 2, 3, 4, 5].copyWithin(0, 3), [4, 5, 3, 4, 5]);

assert.deepEqual([1, 2, 3, 4, 5].copyWithin(1, 3), [1, 4, 5, 4, 5]);

assert.deepEqual([1, 2, 3, 4, 5].copyWithin(1, 2), [1, 3, 4, 5, 5]);

assert.deepEqual([1, 2, 3, 4, 5].copyWithin(2, 2), [1, 2, 3, 4, 5]);

assert.deepEqual([1, 2, 3, 4, 5].copyWithin(0, 3, 4), [4, 2, 3, 4, 5]);

assert.deepEqual([1, 2, 3, 4, 5].copyWithin(1, 3, 4), [1, 4, 3, 4, 5]);

assert.deepEqual([1, 2, 3, 4, 5].copyWithin(1, 2, 4), [1, 3, 4, 4, 5]);

assert.deepEqual([1, 2, 3, 4, 5].copyWithin(0, -2), [4, 5, 3, 4, 5]);

assert.deepEqual([1, 2, 3, 4, 5].copyWithin(0, -2, -1), [4, 2, 3, 4, 5]);

assert.deepEqual([1, 2, 3, 4, 5].copyWithin(-4, -3, -2), [1, 3, 3, 4, 5]);

assert.deepEqual([1, 2, 3, 4, 5].copyWithin(-4, -3, -1), [1, 3, 4, 4, 5]);

assert.deepEqual([1, 2, 3, 4, 5].copyWithin(-4, -3), [1, 3, 4, 5, 5]);

if (STRICT) {

assert.throws(function(){

return Array.prototype.copyWithin.call(null, 0);

}, TypeError);

assert.throws(function(){

return Array.prototype.copyWithin.call(void 8, 0);

}, TypeError);

}

if (NATIVE) {

assert.deepEqual(Array.prototype.copyWithin.call({

0: 1,

1: 2,

2: 3,

length: -1

}, 1, 2), {

0: 1,

1: 2,

2: 3,

length: -1

}, 'uses ToLength');

}

return assert.ok('copyWithin' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');

});

}).call(this);

// Generated by LiveScript 1.3.1

(function(){

var module, test;

module = QUnit.module, test = QUnit.test;

module('ES6');

test('Array#fill', function(assert){

var a;

assert.isFunction(Array.prototype.fill);

assert.arity(Array.prototype.fill, 1);

assert.name(Array.prototype.fill, 'fill');

assert.looksNative(Array.prototype.fill);

assert.strictEqual(a = Array(5).fill(5), a);

assert.deepEqual(Array(5).fill(5), [5, 5, 5, 5, 5]);

assert.deepEqual(Array(5).fill(5, 1), [void 8, 5, 5, 5, 5]);

assert.deepEqual(Array(5).fill(5, 1, 4), [void 8, 5, 5, 5, void 8]);

assert.deepEqual(Array(5).fill(5, 6, 1), [void 8, void 8, void 8, void 8, void 8]);

assert.deepEqual(Array(5).fill(5, -3, 4), [void 8, void 8, 5, 5, void 8]);

if (STRICT) {

assert.throws(function(){

return Array.prototype.fill.call(null, 0);

}, TypeError);

assert.throws(function(){

return Array.prototype.fill.call(void 8, 0);

}, TypeError);

}

if (NATIVE && DESCRIPTORS) {

assert.ok((function(){

try {

return Array.prototype.fill.call(Object.defineProperty({

length: -1

}, 0, {

set: function(){

throw Error();

}

}));

} catch (e$) {}

}()), 'uses ToLength');

}

return assert.ok('fill' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');

});

}).call(this);

// Generated by LiveScript 1.3.1

(function(){

var module, test;

module = QUnit.module, test = QUnit.test;

module('ES6');

test('Array#findIndex', function(assert){

var a, ctx;

assert.isFunction(Array.prototype.findIndex);

assert.arity(Array.prototype.findIndex, 1);

assert.name(Array.prototype.findIndex, 'findIndex');

assert.looksNative(Array.prototype.findIndex);

(a = [1]).findIndex(function(val, key, that){

assert.same(arguments.length, 3, 'correct number of callback arguments');

assert.same(val, 1, 'correct value in callback');

assert.same(key, 0, 'correct index in callback');

assert.same(that, a, 'correct link to array in callback');

return assert.same(this, ctx, 'correct callback context');

}, ctx = {});

assert.same([1, 3, NaN, 42, {}].findIndex((function(it){

return it === 42;

})), 3);

assert.same([1, 3, NaN, 42, {}].findIndex((function(it){

return it === 43;

})), -1);

if (STRICT) {

assert.throws(function(){

return Array.prototype.findIndex.call(null, 0);

}, TypeError);

assert.throws(function(){

return Array.prototype.findIndex.call(void 8, 0);

}, TypeError);

}

if (NATIVE && DESCRIPTORS) {

assert.ok((function(){

try {

return -1 === Array.prototype.findIndex.call({

length: -1,

0: 1

}, function(){

throw 42;

});

} catch (e$) {}

}()), 'uses ToLength');

}

return assert.ok('findIndex' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');

});

}).call(this);

// Generated by LiveScript 1.3.1

(function(){

var module, test;

module = QUnit.module, test = QUnit.test;

module('ES6');

test('Array#find', function(assert){

var a, ctx;

assert.isFunction(Array.prototype.find);

assert.arity(Array.prototype.find, 1);

assert.name(Array.prototype.find, 'find');

assert.looksNative(Array.prototype.find);

(a = [1]).find(function(val, key, that){

assert.same(arguments.length, 3, 'correct number of callback arguments');

assert.same(val, 1, 'correct value in callback');

assert.same(key, 0, 'correct index in callback');

assert.same(that, a, 'correct link to array in callback');

return assert.same(this, ctx, 'correct callback context');

}, ctx = {});

assert.same([1, 3, NaN, 42, {}].find((function(it){

return it === 42;

})), 42);

assert.same([1, 3, NaN, 42, {}].find((function(it){

return it === 43;

})), void 8);

if (STRICT) {

assert.throws(function(){

return Array.prototype.find.call(null, 0);

}, TypeError);

assert.throws(function(){

return Array.prototype.find.call(void 8, 0);

}, TypeError);

}

if (NATIVE && DESCRIPTORS) {

assert.ok((function(){

try {

return void 8 === Array.prototype.find.call({

length: -1,

0: 1

}, function(){

throw 42;

});

} catch (e$) {}

}()), 'uses ToLength');

}

return assert.ok('find' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');

});

}).call(this);

// Generated by LiveScript 1.3.1

(function(){

var module, test;

module = QUnit.module, test = QUnit.test;

module('ES6');

test('Array.from', function(assert){

var from, al, ctx, done, iter, F, inst, a;

from = Array.from;

assert.isFunction(from);

assert.arity(from, 1);

assert.name(from, 'from');

assert.looksNative(from);

assert.deepEqual(from('123'), ['1', '2', '3']);

assert.deepEqual(from({

length: 3,

0: 1,

1: 2,

2: 3

}), [1, 2, 3]);

from(al = function(){

return arguments;

}(1), function(val, key){

assert.strictEqual(this, ctx);

assert.strictEqual(val, 1);

return assert.strictEqual(key, 0);

}, ctx = {});

from([1], function(val, key){

assert.strictEqual(this, ctx);

assert.strictEqual(val, 1);

return assert.strictEqual(key, 0);

}, ctx = {});

assert.deepEqual(from({

length: 3,

0: 1,

1: 2,

2: 3

}, (function(it){

return Math.pow(it, 2);

})), [1, 4, 9]);

assert.deepEqual(from(createIterable([1, 2, 3])), [1, 2, 3], 'Works with iterators');

assert.throws(function(){

return from(null);

}, TypeError);

assert.throws(function(){

return from(void 8);

}, TypeError);

done = true;

iter = createIterable([1, 2, 3], {

'return': function(){

return done = false;

}

});

from(iter, function(){

return false;

});

assert.ok(done, '.return #default');

done = false;

iter = createIterable([1, 2, 3], {

'return': function(){

return done = true;

}

});

try {

from(iter, function(){

throw 42;

});

} catch (e$) {}

assert.ok(done, '.return #throw');

F = function(){};

inst = from.call(F, createIterable([1, 2]));

assert.ok(inst instanceof F);

assert.strictEqual(inst[0], 1);

assert.strictEqual(inst[1], 2);

assert.strictEqual(inst.length, 2);

inst = from.call(F, {

0: 1,

1: 2,

length: 2

});

assert.ok(inst instanceof F);

assert.strictEqual(inst[0], 1);

assert.strictEqual(inst[1], 2);

assert.strictEqual(inst.length, 2);

a = [1, 2, 3];

done = false;

a[typeof Symbol != 'undefined' && Symbol !== null ? Symbol.iterator : void 8] = function(){

done = true;

return [][typeof Symbol != 'undefined' && Symbol !== null ? Symbol.iterator : void 8].call(this);

};

assert.deepEqual(from(a), [1, 2, 3]);

assert.ok(done);

if (NATIVE) {

return assert.ok((function(){

try {

return Array.from({

length: -1,

0: 1

}, function(){

throw 42;

});

} catch (e$) {}

}()), 'uses ToLength');

}

});

}).call(this);

// Generated by LiveScript 1.3.1

(function(){

var module, test;

module = QUnit.module, test = QUnit.test;

module('ES6');

test('Array#keys', function(assert){

var iter;

assert.isFunction(Array.prototype.keys);

assert.arity(Array.prototype.keys, 0);

assert.name(Array.prototype.keys, 'keys');

assert.looksNative(Array.prototype.keys);

iter = ['q', 'w', 'e'].keys();

assert.isIterator(iter);

assert.isIterable(iter);

assert.strictEqual(iter[typeof Symbol != 'undefined' && Symbol !== null ? Symbol.toStringTag : void 8], 'Array Iterator');

assert.deepEqual(iter.next(), {

value: 0,

done: false

});

assert.deepEqual(iter.next(), {

value: 1,

done: false

});

assert.deepEqual(iter.next(), {

value: 2,

done: false

});

assert.deepEqual(iter.next(), {

value: void 8,

done: true

});

if (NATIVE) {

assert.deepEqual(Array.prototype.keys.call({

length: -1

}).next(), {

value: void 8,

done: true

}, 'uses ToLength');

}

return assert.ok('keys' in Array.prototype[typeof Symbol != 'undefined' && Symbol !== null ? Symbol.unscopables : void 8], 'In Array#@@unscopables');

});

test('Array#values', function(assert){

var iter;

assert.isFunction(Array.prototype.values);

assert.arity(Array.prototype.values, 0);

assert.name(Array.prototype.values, 'values');

assert.looksNative(Array.prototype.values);

iter = ['q', 'w', 'e'].values();

assert.isIterator(iter);

assert.isIterable(iter);

assert.strictEqual(iter[typeof Symbol != 'undefined' && Symbol !== null ? Symbol.toStringTag : void 8], 'Array Iterator');