* Copyright (c) 2025 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
* @tc.name:arrayreflectproxy
* @tc.desc:test Array combined with Reflect and Proxy
* @tc.type: FUNC
* @tc.require: issueI5NO8G
*/
var arr = new Array(100);
var a = arr.slice(90, 100);
assert_equal(a.length, 10);
var arr1 = [1, 1, 1, 1, 1, 1];
arr1.fill(0, 2, 4);
assert_equal(arr1, [1,1,0,0,1,1]);
var arr2 = new Array(100);
arr2.fill(0, 2, 4);
var a1 = arr2.slice(0, 5);
assert_equal(arr2.length, 100);
assert_equal(a1, [,,0,0,,]);
var arr3 = [1, 2, 3, 4, 5, 6];
arr3.pop();
assert_equal(arr3.length, 5);
assert_equal(arr3, [1,2,3,4,5]);
var arr4 = [1, 3, 4];
arr4.splice(1, 0, 2);
assert_equal(arr4.length, 4);
assert_equal(arr4, [1,2,3,4]);
var arr4 = [1, 2, 3, 4];
arr4.splice(3, 1, 3);
assert_equal(arr4.length, 4);
assert_equal(arr4, [1,2,3,3]);
var arr5 = [1, 2, 3, 4, 5, 6];
arr5.shift();
assert_equal(arr5.length, 5);
assert_equal(arr5, [2,3,4,5,6]);
var arr6 = [1, 2, 3, 4, 5];
arr6.reverse();
assert_equal(arr6, [5,4,3,2,1]);
var target1 = [1, 2, 3, 4, 5];
var handler1 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy1 = new Proxy(target1, handler1);
assert_equal(proxy1[0], 1);
assert_equal(proxy1[1], 2);
assert_equal(proxy1[2], 3);
assert_equal(proxy1.length, 5);
assert_equal(proxy1[4], 5);
var target2 = [1, 2, 3, 4, 5];
var handler2 = {
set(target, prop, value) {
return Reflect.set(target, prop, value);
}
};
var proxy2 = new Proxy(target2, handler2);
proxy2[0] = 10;
assert_equal(proxy2[0], 10);
proxy2[2] = 30;
assert_equal(proxy2[2], 30);
proxy2[5] = 60;
assert_equal(proxy2[5], 60);
assert_equal(proxy2.length, 6);
var target3 = [1, 2, 3, 4, 5];
var handler3 = {
has(target, prop) {
return Reflect.has(target, prop);
}
};
var proxy3 = new Proxy(target3, handler3);
assert_true(0 in proxy3);
assert_true(4 in proxy3);
assert_true('length' in proxy3);
assert_true(!(100 in proxy3));
var target4 = [1, 2, 3, 4, 5];
var handler4 = {
deleteProperty(target, prop) {
return Reflect.deleteProperty(target, prop);
}
};
var proxy4 = new Proxy(target4, handler4);
delete proxy4[2];
assert_equal(proxy4.length, 5);
assert_equal(proxy4[2], undefined);
delete proxy4[0];
assert_equal(proxy4[0], undefined);
var target5 = [1, 2, 3];
var handler5 = {
defineProperty(target, prop, descriptor) {
return Reflect.defineProperty(target, prop, descriptor);
}
};
var proxy5 = new Proxy(target5, handler5);
Object.defineProperty(proxy5, 3, { value: 4, writable: true });
assert_equal(proxy5[3], 4);
var target6 = [1, 2, 3];
var handler6 = {
getOwnPropertyDescriptor(target, prop) {
return Reflect.getOwnPropertyDescriptor(target, prop);
}
};
var proxy6 = new Proxy(target6, handler6);
var desc6 = Object.getOwnPropertyDescriptor(proxy6, 0);
assert_equal(desc6.value, 1);
var target7 = [1, 2, 3, 4, 5];
var handler7 = {
ownKeys(target) {
return Reflect.ownKeys(target);
}
};
var proxy7 = new Proxy(target7, handler7);
var keys7 = Object.keys(proxy7);
assert_equal(keys7.length, 5);
var target8 = [1, 2, 3];
var handler8 = {
getPrototypeOf(target) {
return Reflect.getPrototypeOf(target);
}
};
var proxy8 = new Proxy(target8, handler8);
var proto8 = Object.getPrototypeOf(proxy8);
assert_equal(proto8, Array.prototype);
var target9 = [1, 2, 3];
var protoObj9 = { customMethod: function() { return 100; } };
var handler9 = {
setPrototypeOf(target, prototype) {
return Reflect.setPrototypeOf(target, prototype);
}
};
var proxy9 = new Proxy(target9, handler9);
Object.setPrototypeOf(proxy9, protoObj9);
assert_equal(Object.getPrototypeOf(proxy9), protoObj9);
var target10 = [1, 2, 3];
var handler10 = {
isExtensible(target) {
return Reflect.isExtensible(target);
}
};
var proxy10 = new Proxy(target10, handler10);
assert_true(Object.isExtensible(proxy10));
Object.preventExtensions(proxy10);
assert_true(!Object.isExtensible(proxy10));
var target11 = [1, 2, 3];
var handler11 = {
preventExtensions(target) {
return Reflect.preventExtensions(target);
}
};
var proxy11 = new Proxy(target11, handler11);
Object.preventExtensions(proxy11);
assert_true(!Object.isExtensible(proxy11));
var target12 = [1, 2, 3, 4, 5];
var handler12 = {
get(target, prop) {
if ((typeof prop === 'string' && !isNaN(prop)) || typeof prop === 'number') {
let idx = typeof prop === 'string' ? parseInt(prop) : prop;
if (idx < 0) {
return target[target.length + idx];
}
}
return Reflect.get(target, prop);
}
};
var proxy12 = new Proxy(target12, handler12);
assert_equal(proxy12[-1], 5);
assert_equal(proxy12[-2], 4);
assert_equal(proxy12[-5], 1);
var target13 = [1, 2, 3];
var handler13 = {
get(target, prop) {
if (typeof prop === 'string' || typeof prop === 'number') {
let idx = typeof prop === 'string' ? parseInt(prop) : prop;
if (idx >= target.length || idx < 0) {
return '越界';
}
}
return Reflect.get(target, prop);
}
};
var proxy13 = new Proxy(target13, handler13);
assert_equal(proxy13[0], 1);
assert_equal(proxy13[5], '越界');
assert_equal(proxy13[-1], '越界');
var target14 = [1, 2, 3, 4, 5];
var handler14 = {
get(target, prop) {
if (prop === 'length') {
return target.length;
}
return Reflect.get(target, prop);
}
};
var proxy14 = new Proxy(target14, handler14);
assert_equal(proxy14.length, 5);
var target15 = [1, 2, 3, 4, 5];
var handler15 = {
set(target, prop, value) {
if (prop === 'length') {
if (value < target.length) {
target.length = value;
return true;
}
}
return Reflect.set(target, prop, value);
}
};
var proxy15 = new Proxy(target15, handler15);
proxy15.length = 3;
assert_equal(proxy15.length, 3);
assert_equal(proxy15[3], undefined);
assert_equal(proxy15[4], undefined);
var target16 = [1, 2, 3];
var handler16 = {
get(target, prop) {
if (prop === Symbol.toStringTag) {
return 'CustomArray';
}
return Reflect.get(target, prop);
}
};
var proxy16 = new Proxy(target16, handler16);
assert_equal(Object.prototype.toString.call(proxy16), '[object CustomArray]');
var target20 = [10, 20, 30, 40, 50];
assert_equal(Reflect.get(target20, 0), 10);
assert_equal(Reflect.get(target20, 2), 30);
assert_equal(Reflect.get(target20, 'length'), 5);
assert_equal(Reflect.get(target20, 100), undefined);
var target21 = [1, 2, 3];
assert_true(Reflect.set(target21, 0, 100));
assert_equal(target21[0], 100);
assert_true(Reflect.set(target21, 5, 60));
assert_equal(target21[5], 60);
assert_equal(target21.length, 6);
var target22 = [1, 2, 3, 4, 5];
assert_true(Reflect.has(target22, 0));
assert_true(Reflect.has(target22, 4));
assert_true(Reflect.has(target22, 'length'));
assert_true(!Reflect.has(target22, 100));
var target23 = [1, 2, 3, 4, 5];
assert_true(Reflect.deleteProperty(target23, 2));
assert_equal(target23[2], undefined);
var arr25 = Reflect.construct(Array, [1, 2, 3, 4, 5]);
assert_equal(arr25.length, 5);
assert_equal(arr25[0], 1);
assert_equal(arr25[4], 5);
var target26 = [1, 2, 3];
assert_true(Reflect.defineProperty(target26, 3, { value: 4, writable: true, enumerable: true, configurable: true }));
assert_equal(target26[3], 4);
var target27 = [1, 2, 3];
var desc27 = Reflect.getOwnPropertyDescriptor(target27, 0);
assert_equal(desc27.value, 1);
var target29 = [1, 2, 3];
assert_true(Reflect.isExtensible(target29));
Reflect.preventExtensions(target29);
assert_true(!Reflect.isExtensible(target29));
var target30 = [1, 2, 3];
assert_true(Reflect.preventExtensions(target30));
assert_true(!Reflect.isExtensible(target30));
var target31 = [1, 2, 3];
var proto31 = Reflect.getPrototypeOf(target31);
assert_equal(proto31, Array.prototype);
var target32 = [1, 2, 3];
var customProto32 = { customProp: 'test' };
assert_true(Reflect.setPrototypeOf(target32, customProto32));
assert_equal(Object.getPrototypeOf(target32), customProto32);
var target33 = [1, 2, 3, 4, 5];
var sum33 = Reflect.apply(target33.reduce, target33, [(acc, val) => acc + val, 0]);
assert_equal(sum33, 15);
var target34 = [1, 2, 3];
var mapped34 = Reflect.apply(target34.map, target34, [x => x * 2]);
assert_equal(mapped34[0], 2);
assert_equal(mapped34[1], 4);
assert_equal(mapped34[2], 6);
var target35 = [1, 2, 3, 4, 5];
var filtered35 = Reflect.apply(target35.filter, target35, [x => x > 2]);
assert_equal(filtered35.length, 3);
assert_equal(filtered35[0], 3);
var target36 = [1, 2, 3];
var sum36 = 0;
Reflect.apply(target36.forEach, target36, [x => { sum36 += x; }]);
assert_equal(sum36, 6);
var target40 = [1, 2, 3];
var handler40 = {
get(target, prop) {
if (prop === 'push') {
return function(...args) {
return Array.prototype.push.apply(target, args);
};
}
return Reflect.get(target, prop);
}
};
var proxy40 = new Proxy(target40, handler40);
assert_equal(proxy40.push(4, 5), 5);
assert_equal(proxy40.length, 5);
assert_equal(proxy40[3], 4);
assert_equal(proxy40[4], 5);
var target41 = [1, 2, 3, 4, 5];
var handler41 = {
get(target, prop) {
if (prop === 'pop') {
return function() {
return Array.prototype.pop.call(target);
};
}
return Reflect.get(target, prop);
}
};
var proxy41 = new Proxy(target41, handler41);
assert_equal(proxy41.pop(), 5);
assert_equal(proxy41.length, 4);
assert_equal(proxy41[3], 4);
var target42 = [1, 2, 3, 4, 5];
var handler42 = {
get(target, prop) {
if (prop === 'shift') {
return function() {
return Array.prototype.shift.call(target);
};
}
return Reflect.get(target, prop);
}
};
var proxy42 = new Proxy(target42, handler42);
assert_equal(proxy42.shift(), 1);
assert_equal(proxy42.length, 4);
assert_equal(proxy42[0], 2);
var target43 = [3, 4, 5];
var handler43 = {
get(target, prop) {
if (prop === 'unshift') {
return function(...args) {
return Array.prototype.unshift.apply(target, args);
};
}
return Reflect.get(target, prop);
}
};
var proxy43 = new Proxy(target43, handler43);
assert_equal(proxy43.unshift(1, 2), 5);
assert_equal(proxy43.length, 5);
assert_equal(proxy43[0], 1);
assert_equal(proxy43[1], 2);
var target44 = [1, 2, 3, 4, 5];
var handler44 = {
get(target, prop) {
if (prop === 'splice') {
return function(start, deleteCount, ...items) {
return Array.prototype.splice.call(target, start, deleteCount, ...items);
};
}
return Reflect.get(target, prop);
}
};
var proxy44 = new Proxy(target44, handler44);
var removed44 = proxy44.splice(1, 2, 20, 30);
assert_equal(removed44.length, 2);
assert_equal(removed44[0], 2);
assert_equal(removed44[1], 3);
assert_equal(proxy44.length, 5);
assert_equal(proxy44[0], 1);
assert_equal(proxy44[1], 20);
assert_equal(proxy44[2], 30);
var target45 = [1, 2, 3];
var handler45 = {
get(target, prop) {
if (prop === 'concat') {
return function(...args) {
return Array.prototype.concat.apply(target, args);
};
}
return Reflect.get(target, prop);
}
};
var proxy45 = new Proxy(target45, handler45);
var result45 = proxy45.concat([4, 5], 6);
assert_equal(result45.length, 6);
assert_equal(result45[0], 1);
assert_equal(result45[5], 6);
var target46 = [1, 2, 3, 4, 5];
var handler46 = {
get(target, prop) {
if (prop === 'slice') {
return function(start, end) {
return Array.prototype.slice.call(target, start, end);
};
}
return Reflect.get(target, prop);
}
};
var proxy46 = new Proxy(target46, handler46);
var sliced46 = proxy46.slice(1, 3);
assert_equal(sliced46.length, 2);
assert_equal(sliced46[0], 2);
assert_equal(sliced46[1], 3);
var target47 = [1, 2, 3, 4, 5];
var handler47 = {
get(target, prop) {
if (prop === 'indexOf') {
return function(searchElement, fromIndex) {
return Array.prototype.indexOf.call(target, searchElement, fromIndex);
};
}
return Reflect.get(target, prop);
}
};
var proxy47 = new Proxy(target47, handler47);
assert_equal(proxy47.indexOf(3), 2);
assert_equal(proxy47.indexOf(1), 0);
assert_equal(proxy47.indexOf(6), -1);
var target48 = [1, 2, 3, 4, 5];
var handler48 = {
get(target, prop) {
if (prop === 'includes') {
return function(searchElement, fromIndex) {
return Array.prototype.includes.call(target, searchElement, fromIndex);
};
}
return Reflect.get(target, prop);
}
};
var proxy48 = new Proxy(target48, handler48);
assert_true(proxy48.includes(3));
assert_true(!proxy48.includes(6));
var target49 = [1, 2, 3, 4, 5];
var handler49 = {
get(target, prop) {
if (prop === 'find') {
return function(predicate, thisArg) {
return Array.prototype.find.call(target, predicate, thisArg);
};
}
return Reflect.get(target, prop);
}
};
var proxy49 = new Proxy(target49, handler49);
assert_equal(proxy49.find(x => x > 3), 4);
assert_equal(proxy49.find(x => x > 10), undefined);
var target50 = [1, 2, 3, 4, 5];
var handler50 = {
get(target, prop) {
if (prop === 'findIndex') {
return function(predicate, thisArg) {
return Array.prototype.findIndex.call(target, predicate, thisArg);
};
}
return Reflect.get(target, prop);
}
};
var proxy50 = new Proxy(target50, handler50);
assert_equal(proxy50.findIndex(x => x > 3), 3);
assert_equal(proxy50.findIndex(x => x > 10), -1);
var target51 = [1, 2, 3, 4, 5];
var handler51 = {
get(target, prop) {
if (prop === 'filter') {
return function(predicate, thisArg) {
return Array.prototype.filter.call(target, predicate, thisArg);
};
}
return Reflect.get(target, prop);
}
};
var proxy51 = new Proxy(target51, handler51);
var filtered51 = proxy51.filter(x => x > 2);
assert_equal(filtered51.length, 3);
assert_equal(filtered51[0], 3);
var target52 = [1, 2, 3, 4, 5];
var handler52 = {
get(target, prop) {
if (prop === 'map') {
return function(callbackfn, thisArg) {
return Array.prototype.map.call(target, callbackfn, thisArg);
};
}
return Reflect.get(target, prop);
}
};
var proxy52 = new Proxy(target52, handler52);
var mapped52 = proxy52.map(x => x * 2);
assert_equal(mapped52.length, 5);
assert_equal(mapped52[0], 2);
assert_equal(mapped52[4], 10);
var target53 = [1, 2, 3, 4, 5];
var handler53 = {
get(target, prop) {
if (prop === 'reduce') {
return function(callbackfn, initialValue) {
return Array.prototype.reduce.call(target, callbackfn, initialValue);
};
}
return Reflect.get(target, prop);
}
};
var proxy53 = new Proxy(target53, handler53);
assert_equal(proxy53.reduce((acc, val) => acc + val, 0), 15);
var target54 = [1, 2, 3, 4, 5];
var handler54 = {
get(target, prop) {
if (prop === 'reduceRight') {
return function(callbackfn, initialValue) {
return Array.prototype.reduceRight.call(target, callbackfn, initialValue);
};
}
return Reflect.get(target, prop);
}
};
var proxy54 = new Proxy(target54, handler54);
assert_equal(proxy54.reduceRight((acc, val) => acc - val, 0), -15);
var target55 = [1, 2, 3, 4, 5];
var handler55 = {
get(target, prop) {
if (prop === 'every') {
return function(predicate, thisArg) {
return Array.prototype.every.call(target, predicate, thisArg);
};
}
return Reflect.get(target, prop);
}
};
var proxy55 = new Proxy(target55, handler55);
assert_true(proxy55.every(x => x > 0));
assert_true(!proxy55.every(x => x > 2));
var target56 = [1, 2, 3, 4, 5];
var handler56 = {
get(target, prop) {
if (prop === 'some') {
return function(predicate, thisArg) {
return Array.prototype.some.call(target, predicate, thisArg);
};
}
return Reflect.get(target, prop);
}
};
var proxy56 = new Proxy(target56, handler56);
assert_true(proxy56.some(x => x > 3));
assert_true(!proxy56.some(x => x > 10));
var target57 = [1, 2, 3];
var handler57 = {
get(target, prop) {
if (prop === 'forEach') {
return function(callbackfn, thisArg) {
return Array.prototype.forEach.call(target, callbackfn, thisArg);
};
}
return Reflect.get(target, prop);
}
};
var proxy57 = new Proxy(target57, handler57);
var sum57 = 0;
proxy57.forEach(x => { sum57 += x; });
assert_equal(sum57, 6);
var target58 = [5, 2, 8, 1, 9];
var handler58 = {
get(target, prop) {
if (prop === 'sort') {
return function(compareFn) {
return Array.prototype.sort.call(target, compareFn);
};
}
return Reflect.get(target, prop);
}
};
var proxy58 = new Proxy(target58, handler58);
var sorted58 = proxy58.sort((a, b) => a - b);
assert_equal(sorted58[0], 1);
assert_equal(sorted58[4], 9);
var target59 = [1, 2, 3, 4, 5];
var handler59 = {
get(target, prop) {
if (prop === 'reverse') {
return function() {
return Array.prototype.reverse.call(target);
};
}
return Reflect.get(target, prop);
}
};
var proxy59 = new Proxy(target59, handler59);
var reversed59 = proxy59.reverse();
assert_equal(reversed59[0], 5);
assert_equal(reversed59[4], 1);
var target60 = [1, 2, 3, 4, 5];
var handler60 = {
get(target, prop) {
if (prop === 'join') {
return function(separator) {
return Array.prototype.join.call(target, separator);
};
}
return Reflect.get(target, prop);
}
};
var proxy60 = new Proxy(target60, handler60);
assert_equal(proxy60.join(), '1,2,3,4,5');
assert_equal(proxy60.join('-'), '1-2-3-4-5');
var target61 = [1, 2, 3, 4, 5];
var handler61 = {
get(target, prop) {
if (prop === 'toString') {
return function() {
return Array.prototype.toString.call(target);
};
}
return Reflect.get(target, prop);
}
};
var proxy61 = new Proxy(target61, handler61);
assert_equal(proxy61.toString(), '1,2,3,4,5');
var target62 = [1, 2, 3, 4, 5];
var handler62 = {
get(target, prop) {
if (prop === 'fill') {
return function(value, start, end) {
return Array.prototype.fill.call(target, value, start, end);
};
}
return Reflect.get(target, prop);
}
};
var proxy62 = new Proxy(target62, handler62);
proxy62.fill(0, 1, 3);
assert_equal(proxy62[0], 1);
assert_equal(proxy62[1], 0);
assert_equal(proxy62[2], 0);
assert_equal(proxy62[3], 4);
assert_equal(proxy62[4], 5);
var target63 = [1, 2, 3, 4, 5];
var handler63 = {
get(target, prop) {
if (prop === 'copyWithin') {
return function(target2, start, end) {
return Array.prototype.copyWithin.call(target, target2, start, end);
};
}
return Reflect.get(target, prop);
}
};
var proxy63 = new Proxy(target63, handler63);
proxy63.copyWithin(0, 2, 4);
assert_equal(proxy63[0], 3);
assert_equal(proxy63[1], 4);
var target64 = ['a', 'b', 'c'];
var handler64 = {
get(target, prop) {
if (prop === 'entries') {
return function() {
return Array.prototype.entries.call(target);
};
}
return Reflect.get(target, prop);
}
};
var proxy64 = new Proxy(target64, handler64);
var entries64 = proxy64.entries();
var firstEntry64 = entries64.next().value;
assert_equal(firstEntry64[0], 0);
assert_equal(firstEntry64[1], 'a');
var target65 = ['a', 'b', 'c'];
var handler65 = {
get(target, prop) {
if (prop === 'keys') {
return function() {
return Array.prototype.keys.call(target);
};
}
return Reflect.get(target, prop);
}
};
var proxy65 = new Proxy(target65, handler65);
var keys65 = proxy65.keys();
assert_equal(keys65.next().value, 0);
var target66 = ['a', 'b', 'c'];
var handler66 = {
get(target, prop) {
if (prop === 'values') {
return function() {
return Array.prototype.values.call(target);
};
}
return Reflect.get(target, prop);
}
};
var proxy66 = new Proxy(target66, handler66);
var values66 = proxy66.values();
assert_equal(values66.next().value, 'a');
var target67 = [1, [2, [3, [4]]]];
var handler67 = {
get(target, prop) {
if (prop === 'flat') {
return function(depth) {
return Array.prototype.flat.call(target, depth);
};
}
return Reflect.get(target, prop);
}
};
var proxy67 = new Proxy(target67, handler67);
var flat67 = proxy67.flat(2);
assert_equal(flat67[0], 1);
assert_equal(flat67[1], 2);
assert_equal(flat67[2], 3);
var target68 = [1, 2, 3];
var handler68 = {
get(target, prop) {
if (prop === 'flatMap') {
return function(callbackfn, thisArg) {
return Array.prototype.flatMap.call(target, callbackfn, thisArg);
};
}
return Reflect.get(target, prop);
}
};
var proxy68 = new Proxy(target68, handler68);
var flatmapped68 = proxy68.flatMap(x => [x, x * 2]);
assert_equal(flatmapped68.length, 6);
assert_equal(flatmapped68[0], 1);
assert_equal(flatmapped68[1], 2);
var target69 = [1, 2, 3, 4, 5];
var handler69 = {
get(target, prop) {
if (prop === 'at') {
return function(index) {
return Array.prototype.at.call(target, index);
};
}
return Reflect.get(target, prop);
}
};
var proxy69 = new Proxy(target69, handler69);
assert_equal(proxy69.at(0), 1);
assert_equal(proxy69.at(-1), 5);
assert_equal(proxy69.at(10), undefined);
var target70 = [5, 2, 8, 1, 9];
var handler70 = {
get(target, prop) {
if (prop === 'toSorted') {
return function(compareFn) {
return Array.prototype.toSorted.call(target, compareFn);
};
}
return Reflect.get(target, prop);
}
};
var proxy70 = new Proxy(target70, handler70);
var sorted70 = proxy70.toSorted((a, b) => a - b);
assert_equal(sorted70[0], 1);
assert_equal(sorted70[4], 9);
assert_equal(target70[0], 5);
var target71 = [1, 2, 3, 4, 5];
var handler71 = {
get(target, prop) {
if (prop === 'toReversed') {
return function() {
return Array.prototype.toReversed.call(target);
};
}
return Reflect.get(target, prop);
}
};
var proxy71 = new Proxy(target71, handler71);
var reversed71 = proxy71.toReversed();
assert_equal(reversed71[0], 5);
assert_equal(reversed71[4], 1);
assert_equal(target71[0], 1);
var target72 = [1, 2, 3, 4, 5];
var handler72 = {
get(target, prop) {
if (prop === 'with') {
return function(index, value) {
return Array.prototype.with.call(target, index, value);
};
}
return Reflect.get(target, prop);
}
};
var proxy72 = new Proxy(target72, handler72);
var result72 = proxy72.with(2, 10);
assert_equal(result72[2], 10);
assert_equal(target72[2], 3);
var target75 = [1, 2, 3, 4, 5];
var handler75_1 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var handler75_2 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy75_inner = new Proxy(target75, handler75_1);
var proxy75_outer = new Proxy(proxy75_inner, handler75_2);
assert_equal(proxy75_outer[0], 1);
assert_equal(proxy75_outer.length, 5);
var target76 = [1, 2, 3];
var handler76_1 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var handler76_2 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy76_inner = new Proxy(target76, handler76_1);
var proxy76_outer = new Proxy(proxy76_inner, handler76_2);
assert_equal(proxy76_outer[0], 1);
proxy76_outer[1] = 20;
assert_equal(proxy76_outer[1], 20);
var target77 = [1, 2, 3];
var handler77 = {
get(target, prop) {
const value = Reflect.get(target, prop);
if (typeof value === 'function') {
return function(...args) {
return Reflect.apply(value, target, args);
};
}
return value;
}
};
var proxy77 = new Proxy(target77, handler77);
var result77 = proxy77.map(x => x * 2);
assert_equal(result77[0], 2);
var target78 = [];
var proxy78_inner = new Proxy({ value: 10 }, {
get(t, p) {
return Reflect.get(t, p);
}
});
target78[0] = proxy78_inner;
var handler78 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy78 = new Proxy(target78, handler78);
assert_equal(proxy78[0].value, 10);
var target79 = [[1, 2], [3, 4], [5, 6]];
var handler79 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy79 = new Proxy(target79, handler79);
assert_equal(proxy79[0].length, 2);
assert_equal(proxy79[0][0], 1);
assert_equal(proxy79[1][1], 4);
var target80 = [1, 2, 3];
var handler80 = {
get(target, prop) {
const value = Reflect.get(target, prop);
if (typeof value === 'number') {
return new Proxy({ value }, {
get(t, p) {
return Reflect.get(t, p);
}
});
}
return value;
}
};
var proxy80 = new Proxy(target80, handler80);
assert_equal(proxy80[0].value, 1);
var target81 = [1, 2, 3, 4, 5];
var handler81 = {
get(target, prop) {
if (prop === 'sum') {
return target.reduce((a, b) => a + b, 0);
}
return Reflect.get(target, prop);
}
};
var proxy81 = new Proxy(target81, handler81);
var sum81 = proxy81.sum;
assert_equal(sum81, 15);
var target82 = [1, 2, 3];
var handler82 = {
get(target, prop) {
if (prop === 'customMap') {
return function(fn) {
return target.map(fn);
};
}
return Reflect.get(target, prop);
}
};
var proxy82 = new Proxy(target82, handler82);
var result82 = proxy82.customMap(x => x * 2);
assert_equal(result82[0], 2);
var target83 = [1, 2, 3, 4, 5];
var handler83 = {
get(target, prop) {
const method = Reflect.get(target, prop);
if (typeof method === 'function') {
return function(...args) {
const result = Reflect.apply(method, target, args);
return new Proxy(result, handler83);
};
}
return method;
}
};
var proxy83 = new Proxy(target83, handler83);
var mapped83 = proxy83.map(x => x * 2);
assert_equal(mapped83[0], 2);
var filtered83 = mapped83.filter(x => x > 4);
assert_equal(filtered83.length, 3);
var target84 = [1, 2, 3, 4, 5];
var handler84 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy84 = new Proxy(target84, handler84);
var result84 = proxy84.filter(x => x > 2).map(x => x * 2);
assert_equal(result84[0], 6);
assert_equal(result84[2], 10);
var target85 = [1, 2, 3];
var handler85_log = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var handler85_validate = {
get(target, prop) {
if (typeof target[prop] === 'number' && target[prop] < 0) {
throw new Error('Negative value not allowed');
}
return Reflect.get(target, prop);
}
};
var proxy85_1 = new Proxy(target85, handler85_log);
var proxy85_2 = new Proxy(proxy85_1, handler85_validate);
assert_equal(proxy85_2[0], 1);
var target86 = [1, 2, 3, 4, 5];
var handler86 = {
get(target, prop) {
if (prop === 'filter') {
return function(predicate) {
const result = [];
for (let i = 0; i < target.length; i++) {
if (predicate(target[i], i, target)) {
result.push(target[i] * 2);
}
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy86 = new Proxy(target86, handler86);
var filtered86 = proxy86.filter(x => x > 2);
assert_equal(filtered86[0], 6);
var target87 = [1, 2, 3, 4, 5];
var handler87 = {
get(target, prop) {
if (prop === 'generator') {
return function*() {
for (const item of target) {
yield item * 2;
}
};
}
return Reflect.get(target, prop);
}
};
var proxy87 = new Proxy(target87, handler87);
var gen87 = proxy87.generator();
assert_equal(gen87.next().value, 2);
assert_equal(gen87.next().value, 4);
var target88 = [1, 2, 3];
var handler88 = {
get(target, prop) {
return Reflect.get(target, prop);
},
defineProperty(target, prop, descriptor) {
Object.defineProperty(target, prop, descriptor);
return true;
}
};
var proxy88 = new Proxy(target88, handler88);
Object.defineProperty(proxy88, 3, { value: 4, writable: true });
assert_equal(proxy88[3], 4);
var target89 = [1, 2, 3];
var handler89 = {
get(target, prop) {
if (prop === Symbol.iterator) {
return function() {
let index = 0;
return {
next() {
if (index < target.length) {
return { value: target[index++] * 2, done: false };
}
return { done: true };
}
};
};
}
return Reflect.get(target, prop);
}
};
var proxy89 = new Proxy(target89, handler89);
var iter89 = proxy89[Symbol.iterator]();
assert_equal(iter89.next().value, 2);
assert_equal(iter89.next().value, 4);
var target90 = [];
var handler90 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy90 = new Proxy(target90, handler90);
assert_equal(proxy90.length, 0);
assert_equal(proxy90[0], undefined);
var target91 = [1, , 3, , 5];
var handler91 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy91 = new Proxy(target91, handler91);
assert_equal(proxy91[0], 1);
assert_equal(proxy91[1], undefined);
assert_equal(proxy91[2], 3);
var target92 = [1, 2, 3];
var handler92 = {
get(target, prop) {
const idx = parseInt(prop);
if (idx >= target.length || idx < 0) {
return '越界访问';
}
return Reflect.get(target, prop);
}
};
var proxy92 = new Proxy(target92, handler92);
assert_equal(proxy92[0], 1);
assert_equal(proxy92[10], '越界访问');
assert_equal(proxy92[-1], '越界访问');
var target93 = [1, 2, 3, 4, 5];
var handler93 = {
get(target, prop) {
const idx = parseInt(prop);
if (idx < 0) {
return target[target.length + idx];
}
return Reflect.get(target, prop);
},
set(target, prop, value) {
const idx = parseInt(prop);
if (idx < 0) {
target[target.length + idx] = value;
return true;
}
return Reflect.set(target, prop, value);
}
};
var proxy93 = new Proxy(target93, handler93);
assert_equal(proxy93[-1], 5);
assert_equal(proxy93[-2], 4);
proxy93[-1] = 100;
assert_equal(proxy93[4], 100);
var target94 = [1, 2, 3];
var handler94 = {
get(target, prop) {
if (prop === 'throwError') {
throw new Error('Custom error');
}
return Reflect.get(target, prop);
}
};
var proxy94 = new Proxy(target94, handler94);
var error94 = false;
try {
proxy94.throwError;
} catch (e) {
error94 = true;
}
assert_true(error94);
var target95 = [1, 2, 3];
var handler95 = {
get(target, prop) {
if (prop === 'nonexistent') {
return undefined;
}
return Reflect.get(target, prop);
}
};
var proxy95 = new Proxy(target95, handler95);
assert_equal(proxy95.nonexistent, undefined);
var target96 = [1, 2, 3];
var handler96 = {
get(target, prop) {
if (prop === 'nullValue') {
return null;
}
return Reflect.get(target, prop);
}
};
var proxy96 = new Proxy(target96, handler96);
assert_true(proxy96.nullValue === null);
var target97 = [1, 2, 3];
var handler97 = {
get(target, prop) {
if (prop === 'getTriple') {
return function() {
return target.map(x => x * 3);
};
}
return Reflect.get(target, prop);
}
};
var proxy97 = new Proxy(target97, handler97);
var triple97 = proxy97.getTriple();
assert_equal(triple97[0], 3);
var target98 = [1, 2, 3];
var handler98 = {
get(target, prop) {
if (prop === 'metadata') {
return { created: true, length: target.length };
}
return Reflect.get(target, prop);
}
};
var proxy98 = new Proxy(target98, handler98);
assert_equal(proxy98.metadata.created, true);
assert_equal(proxy98.metadata.length, 3);
var target99 = [1, 2, 3];
var customSymbol99 = Symbol('custom');
var handler99 = {
get(target, prop) {
if (prop === customSymbol99) {
return 'symbol value';
}
return Reflect.get(target, prop);
}
};
var proxy99 = new Proxy(target99, handler99);
assert_equal(proxy99[customSymbol99], 'symbol value');
var target100 = [1, 2, 3];
var handler100 = {
get(target, prop) {
if (prop === Symbol.iterator) {
return function() {
let index = 0;
return {
next() {
if (index < target.length) {
return { value: target[index++], done: false };
}
return { done: true };
}
};
};
}
return Reflect.get(target, prop);
}
};
var proxy100 = new Proxy(target100, handler100);
var arr100 = [...proxy100];
assert_equal(arr100.length, 3);
assert_equal(arr100[0], 1);
var target101 = [1, 2, 3];
var handler101 = {
get(target, prop) {
if (prop === Symbol.toStringTag) {
return 'MyArray';
}
return Reflect.get(target, prop);
}
};
var proxy101 = new Proxy(target101, handler101);
assert_equal(Object.prototype.toString.call(proxy101), '[object MyArray]');
var target103 = [];
var handler103 = {
deleteProperty(target, prop) {
return Reflect.deleteProperty(target, prop);
}
};
var proxy103 = new Proxy(target103, handler103);
delete proxy103[0];
assert_equal(proxy103[0], undefined);
var target104 = [1, 2, 3];
var handler104 = {
deleteProperty(target, prop) {
const idx = parseInt(prop);
if (idx >= target.length) {
return true;
}
return Reflect.deleteProperty(target, prop);
}
};
var proxy104 = new Proxy(target104, handler104);
delete proxy104[100];
assert_equal(proxy104.length, 3);
var target105 = [];
var handler105 = {
defineProperty(target, prop, descriptor) {
return Reflect.defineProperty(target, prop, descriptor);
}
};
var proxy105 = new Proxy(target105, handler105);
Object.defineProperty(proxy105, 0, { value: 1, writable: true });
assert_equal(proxy105[0], 1);
assert_equal(proxy105.length, 1);
var target106 = [1, 2, 3];
var handler106 = {
set(target, prop, value) {
const idx = parseInt(prop);
if (idx >= target.length) {
target.length = idx + 1;
}
return Reflect.set(target, prop, value);
}
};
var proxy106 = new Proxy(target106, handler106);
proxy106[10] = 100;
assert_equal(proxy106.length, 11);
assert_equal(proxy106[10], 100);
var target107 = [1, 2, 3, 4, 5];
var handler107 = {
set(target, prop, value) {
if (prop === 'length') {
if (value < target.length) {
target.length = value;
return true;
}
}
return Reflect.set(target, prop, value);
}
};
var proxy107 = new Proxy(target107, handler107);
proxy107.length = 2;
assert_equal(proxy107.length, 2);
assert_equal(proxy107[2], undefined);
var target108 = [1, 2, 3];
var handler108 = {
set(target, prop, value) {
if (prop === 'length') {
if (value > target.length) {
target.length = value;
return true;
}
}
return Reflect.set(target, prop, value);
}
};
var proxy108 = new Proxy(target108, handler108);
proxy108.length = 10;
assert_equal(proxy108.length, 10);
assert_equal(proxy108[5], undefined);
var target109 = [1, 2, 3];
var handler109 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy109 = new Proxy(target109, handler109);
assert_equal(proxy109['length'], 3);
assert_equal(proxy109['toString'], Array.prototype.toString);
var target110 = [1, 2, 3];
var sym110 = Symbol('test');
target110[sym110] = 'symbol value';
var handler110 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy110 = new Proxy(target110, handler110);
assert_equal(proxy110[sym110], 'symbol value');
var target111 = [1, 2, 3, 4, 5];
var handler111 = {
has(target, prop) {
if (prop === 'hidden') {
return false;
}
return Reflect.has(target, prop);
}
};
var proxy111 = new Proxy(target111, handler111);
assert_true(0 in proxy111);
assert_true(!('hidden' in proxy111));
var target113 = [1, 2, 3];
var handler113 = {
get(target, prop) {
if (prop === '0') {
return 100;
}
return Reflect.get(target, prop);
}
};
var proxy113 = new Proxy(target113, handler113);
assert_equal(proxy113[0], 100);
var target114 = [1, 2, 3];
target114.customProp = 'custom';
var handler114 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy114 = new Proxy(target114, handler114);
assert_equal(proxy114.customProp, 'custom');
var target115 = [1, 2, 3];
var handler115 = {
getPrototypeOf(target) {
return Array.prototype;
}
};
var proxy115 = new Proxy(target115, handler115);
assert_equal(Object.getPrototypeOf(proxy115), Array.prototype);
var target116 = [1, 2, 3];
var customProto116 = { customMethod: function() { return 'custom'; } };
var handler116 = {
setPrototypeOf(target, proto) {
return Reflect.setPrototypeOf(target, proto);
}
};
var proxy116 = new Proxy(target116, handler116);
Object.setPrototypeOf(proxy116, customProto116);
assert_equal(Object.getPrototypeOf(proxy116), customProto116);
var target117 = [1, 2, 3];
var handler117 = {
preventExtensions(target) {
return Reflect.preventExtensions(target);
}
};
var proxy117 = new Proxy(target117, handler117);
Object.preventExtensions(proxy117);
assert_true(!Object.isExtensible(proxy117));
var target118 = [1, 2, 3];
var handler118 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy118 = new Proxy(target118, handler118);
assert_equal(proxy118[0], 1);
var { proxy: proxy118_rev, revoke } = Proxy.revocable(target118, handler118);
revoke();
var error118 = false;
try {
proxy118_rev[0];
} catch (e) {
error118 = true;
}
assert_true(error118);
var target119 = [];
for (let i = 0; i < 100; i++) {
target119[i] = i;
}
var handler119 = {
get(target, prop) {
return Reflect.get(target, prop);
},
set(target, prop, value) {
return Reflect.set(target, prop, value);
}
};
var proxy119 = new Proxy(target119, handler119);
for (let i = 0; i < 100; i++) {
proxy119[i] = i * 2;
}
assert_equal(proxy119[99], 198);
var target120 = [1, 2, 3];
var handler120 = {
get(target, prop) {
return Reflect.get(target, prop);
},
set(target, prop, value) {
return Reflect.set(target, prop, value);
}
};
var proxy120 = new Proxy(target120, handler120);
for (let i = 0; i < 100; i++) {
proxy120[0] = i;
}
assert_equal(proxy120[0], 99);
var target121 = [];
for (let i = 0; i < 50; i++) {
target121[i] = i;
}
var handler121 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy121 = new Proxy(target121, handler121);
var sum121 = 0;
for (let i = 0; i < 50; i++) {
sum121 += proxy121[i];
}
assert_equal(sum121, 1225);
var target122 = [];
for (let i = 0; i < 30; i++) {
target122[i] = i;
}
var handler122 = {
get(target, prop) {
if (prop === 'map') {
return function(callback) {
return target.map(callback);
};
}
return Reflect.get(target, prop);
}
};
var proxy122 = new Proxy(target122, handler122);
var mapped122 = proxy122.map(x => x * 2);
assert_equal(mapped122[29], 58);
var target123 = [];
for (let i = 0; i < 30; i++) {
target123[i] = i;
}
var handler123 = {
get(target, prop) {
if (prop === 'filter') {
return function(predicate) {
return target.filter(predicate);
};
}
return Reflect.get(target, prop);
}
};
var proxy123 = new Proxy(target123, handler123);
var filtered123 = proxy123.filter(x => x % 2 === 0);
assert_equal(filtered123.length, 15);
var target124 = [];
for (let i = 0; i < 50; i++) {
target124[i] = i + 1;
}
var handler124 = {
get(target, prop) {
if (prop === 'reduce') {
return function(callback, init) {
return target.reduce(callback, init);
};
}
return Reflect.get(target, prop);
}
};
var proxy124 = new Proxy(target124, handler124);
var sum124 = proxy124.reduce((a, b) => a + b, 0);
assert_equal(sum124, 1275);
var target125 = [1, 2, 3];
var handler125 = {
get(target, prop) {
if (prop === 'concat') {
return function(...args) {
return target.concat(...args);
};
}
return Reflect.get(target, prop);
}
};
var proxy125 = new Proxy(target125, handler125);
var result125 = proxy125;
for (let i = 0; i < 10; i++) {
result125 = result125.concat([i]);
}
assert_equal(result125.length, 13);
var target126 = [];
for (let i = 0; i < 100; i++) {
target126[i] = i;
}
var handler126 = {
get(target, prop) {
if (prop === 'slice') {
return function(start, end) {
return target.slice(start, end);
};
}
return Reflect.get(target, prop);
}
};
var proxy126 = new Proxy(target126, handler126);
var sliced126 = proxy126.slice(10, 20);
assert_equal(sliced126.length, 10);
assert_equal(sliced126[0], 10);
var target127 = [1, 2, 3, 4, 5];
var handler127 = {
get(target, prop) {
if (prop === 'splice') {
return function(start, deleteCount, ...items) {
return target.splice(start, deleteCount, ...items);
};
}
return Reflect.get(target, prop);
}
};
var proxy127 = new Proxy(target127, handler127);
proxy127.splice(1, 1, 20);
proxy127.splice(2, 0, 30);
proxy127.splice(0, 1, 10);
assert_equal(proxy127.length, 6);
var target128 = [];
for (let i = 0; i < 100; i++) {
target128[i] = i * 2;
}
var handler128 = {
get(target, prop) {
if (prop === 'find') {
return function(predicate) {
return target.find(predicate);
};
}
return Reflect.get(target, prop);
}
};
var proxy128 = new Proxy(target128, handler128);
var found128 = proxy128.find(x => x > 50);
assert_equal(found128, 52);
var target129 = [];
for (let i = 0; i < 100; i++) {
target129[i] = i;
}
var handler129 = {
get(target, prop) {
if (prop === 'indexOf') {
return function(search) {
return target.indexOf(search);
};
}
return Reflect.get(target, prop);
}
};
var proxy129 = new Proxy(target129, handler129);
assert_equal(proxy129.indexOf(50), 50);
assert_equal(proxy129.indexOf(200), -1);
var target130 = [];
for (let i = 0; i < 100; i++) {
target130[i] = i;
}
var handler130 = {
get(target, prop) {
if (prop === 'includes') {
return function(search) {
return target.includes(search);
};
}
return Reflect.get(target, prop);
}
};
var proxy130 = new Proxy(target130, handler130);
assert_true(proxy130.includes(50));
assert_true(!proxy130.includes(200));
var target131 = [];
for (let i = 0; i < 50; i++) {
target131[i] = i + 1;
}
var handler131 = {
get(target, prop) {
if (prop === 'every') {
return function(predicate) {
return target.every(predicate);
};
}
return Reflect.get(target, prop);
}
};
var proxy131 = new Proxy(target131, handler131);
assert_true(proxy131.every(x => x > 0));
assert_true(!proxy131.every(x => x > 10));
var target132 = [];
for (let i = 0; i < 50; i++) {
target132[i] = i + 1;
}
var handler132 = {
get(target, prop) {
if (prop === 'some') {
return function(predicate) {
return target.some(predicate);
};
}
return Reflect.get(target, prop);
}
};
var proxy132 = new Proxy(target132, handler132);
assert_true(proxy132.some(x => x > 40));
assert_true(!proxy132.some(x => x > 100));
var target133 = [];
for (let i = 0; i < 100; i++) {
target133[i] = i;
}
var handler133 = {
get(target, prop) {
if (prop === 'forEach') {
return function(callback) {
target.forEach(callback);
};
}
return Reflect.get(target, prop);
}
};
var proxy133 = new Proxy(target133, handler133);
var sum133 = 0;
proxy133.forEach(x => { sum133 += x; });
assert_equal(sum133, 4950);
var target134 = [];
for (let i = 0; i < 20; i++) {
target134[i] = 20 - i;
}
var handler134 = {
get(target, prop) {
if (prop === 'sort') {
return function(compareFn) {
return target.sort(compareFn);
};
}
return Reflect.get(target, prop);
}
};
var proxy134 = new Proxy(target134, handler134);
var sorted134 = proxy134.sort((a, b) => a - b);
assert_equal(sorted134[0], 1);
assert_equal(sorted134[19], 20);
var target135 = [];
for (let i = 0; i < 20; i++) {
target135[i] = i;
}
var handler135 = {
get(target, prop) {
if (prop === 'reverse') {
return function() {
return target.reverse();
};
}
return Reflect.get(target, prop);
}
};
var proxy135 = new Proxy(target135, handler135);
var reversed135 = proxy135.reverse();
assert_equal(reversed135[0], 19);
assert_equal(reversed135[19], 0);
var target136 = [];
for (let i = 0; i < 10; i++) {
target136[i] = i + 1;
}
var handler136 = {
get(target, prop) {
if (prop === 'join') {
return function(sep) {
return target.join(sep);
};
}
return Reflect.get(target, prop);
}
};
var proxy136 = new Proxy(target136, handler136);
assert_equal(proxy136.join(), '1,2,3,4,5,6,7,8,9,10');
assert_equal(proxy136.join('-'), '1-2-3-4-5-6-7-8-9-10');
var target137 = new Array(20);
var handler137 = {
get(target, prop) {
if (prop === 'fill') {
return function(value, start, end) {
return target.fill(value, start, end);
};
}
return Reflect.get(target, prop);
}
};
var proxy137 = new Proxy(target137, handler137);
proxy137.fill(5);
assert_equal(proxy137[0], 5);
assert_equal(proxy137[19], 5);
var target138 = new Int8Array([1, 2, 3, 4, 5]);
var handler138 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy138 = new Proxy(target138, handler138);
assert_equal(proxy138[0], 1);
assert_equal(proxy138.length, 5);
var target139 = new Uint8Array([1, 2, 3, 4, 5]);
var handler139 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy139 = new Proxy(target139, handler139);
assert_equal(proxy139[0], 1);
assert_equal(proxy139[4], 5);
var target140 = new Int16Array([100, 200, 300]);
var handler140 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy140 = new Proxy(target140, handler140);
assert_equal(proxy140[0], 100);
assert_equal(proxy140.length, 3);
var target141 = new Float32Array([1.5, 2.5, 3.5]);
var handler141 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy141 = new Proxy(target141, handler141);
assert_equal(proxy141[0], 1.5);
assert_equal(proxy141[2], 3.5);
var target142 = new Float64Array([1.123456789, 2.987654321]);
var handler142 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy142 = new Proxy(target142, handler142);
assert_true(proxy142[0] > 1.12);
assert_true(proxy142[1] < 3.0);
var target143 = new Int8Array(5);
var handler143 = {
get(target, prop) {
if (prop === 'set') {
return function(source, offset) {
return target.set(source, offset);
};
}
return Reflect.get(target, prop);
}
};
var proxy143 = new Proxy(target143, handler143);
proxy143.set([1, 2, 3], 0);
assert_equal(proxy143[0], 1);
assert_equal(proxy143[2], 3);
var target144 = new Int8Array([1, 2, 3, 4, 5]);
var handler144 = {
get(target, prop) {
if (prop === 'subarray') {
return function(start, end) {
return target.subarray(start, end);
};
}
return Reflect.get(target, prop);
}
};
var proxy144 = new Proxy(target144, handler144);
var sub144 = proxy144.subarray(1, 3);
assert_equal(sub144.length, 2);
assert_equal(sub144[0], 2);
var target145 = new Int8Array([1, 2, 3, 4, 5]);
var handler145 = {
get(target, prop) {
if (prop === 'copyWithin') {
return function(target2, start, end) {
return target.copyWithin(target2, start, end);
};
}
return Reflect.get(target, prop);
}
};
var proxy145 = new Proxy(target145, handler145);
proxy145.copyWithin(0, 2, 4);
assert_equal(proxy145[0], 3);
assert_equal(proxy145[1], 4);
var target146 = new Int8Array(5);
var handler146 = {
get(target, prop) {
if (prop === 'fill') {
return function(value, start, end) {
return target.fill(value, start, end);
};
}
return Reflect.get(target, prop);
}
};
var proxy146 = new Proxy(target146, handler146);
proxy146.fill(7, 1, 4);
assert_equal(proxy146[0], 0);
assert_equal(proxy146[1], 7);
assert_equal(proxy146[3], 7);
assert_equal(proxy146[4], 0);
var target147 = { 0: 'a', 1: 'b', 2: 'c', length: 3 };
var handler147 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy147 = new Proxy(target147, handler147);
assert_equal(proxy147[0], 'a');
assert_equal(proxy147.length, 3);
var target148 = new ArrayBuffer(16);
var handler148 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy148 = new Proxy(target148, handler148);
assert_equal(proxy148.byteLength, 16);
var buffer149 = new ArrayBuffer(8);
var target149 = new DataView(buffer149);
var handler149 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy149 = new Proxy(target149, handler149);
assert_equal(proxy149.byteLength, 8);
proxy149.setInt8(0, 100);
assert_equal(proxy149.getInt8(0), 100);
var target150 = new Int8Array([1, 2, 3, 4, 5]);
var handler150 = {
get(target, prop) {
if (prop === 'map') {
return function(callback) {
var result = new Int8Array(target.length);
for (let i = 0; i < target.length; i++) {
result[i] = callback(target[i], i, target);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy150 = new Proxy(target150, handler150);
var mapped150 = proxy150.map(x => x * 2);
assert_equal(mapped150[0], 2);
assert_equal(mapped150[4], 10);
var target151 = new Int8Array([1, 2, 3, 4, 5, 6]);
var handler151 = {
get(target, prop) {
if (prop === 'filter') {
return function(predicate) {
var result = [];
for (let i = 0; i < target.length; i++) {
if (predicate(target[i], i, target)) {
result.push(target[i]);
}
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy151 = new Proxy(target151, handler151);
var filtered151 = proxy151.filter(x => x > 3);
assert_equal(filtered151.length, 3);
var target152 = new Int8Array([1, 2, 3, 4, 5]);
var handler152 = {
get(target, prop) {
if (prop === 'reduce') {
return function(callback, initialValue) {
var result = initialValue;
for (let i = 0; i < target.length; i++) {
result = callback(result, target[i], i, target);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy152 = new Proxy(target152, handler152);
var sum152 = proxy152.reduce((a, b) => a + b, 0);
assert_equal(sum152, 15);
var target153 = [new Int8Array([1, 2]), new Int8Array([3, 4])];
var handler153 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy153 = new Proxy(target153, handler153);
assert_equal(proxy153[0][0], 1);
assert_equal(proxy153[1][1], 4);
var target154 = new Int8Array([1, 2, 3]);
var handler154 = {
get(target, prop) {
if (prop === Symbol.iterator) {
return function() {
return target[Symbol.iterator]();
};
}
return Reflect.get(target, prop);
}
};
var proxy154 = new Proxy(target154, handler154);
var arr154 = [...proxy154];
assert_equal(arr154.length, 3);
var target155 = new Int8Array([10, 20, 30, 40, 50]);
var handler155 = {
get(target, prop) {
if (prop === 'at') {
return function(index) {
return target.at(index);
};
}
return Reflect.get(target, prop);
}
};
var proxy155 = new Proxy(target155, handler155);
assert_equal(proxy155.at(0), 10);
assert_equal(proxy155.at(-1), 50);
assert_equal(proxy155.at(10), undefined);
var target156 = new Int8Array([1, 2, 3, 4, 5]);
var handler156 = {
get(target, prop) {
if (prop === 'find') {
return function(predicate) {
return target.find(predicate);
};
}
return Reflect.get(target, prop);
}
};
var proxy156 = new Proxy(target156, handler156);
assert_equal(proxy156.find(x => x > 3), 4);
var target157 = new Int8Array([1, 2, 3, 4, 5]);
var handler157 = {
get(target, prop) {
if (prop === 'findIndex') {
return function(predicate) {
return target.findIndex(predicate);
};
}
return Reflect.get(target, prop);
}
};
var proxy157 = new Proxy(target157, handler157);
assert_equal(proxy157.findIndex(x => x > 3), 3);
var target158 = new Int8Array([1, 2, 3, 4, 5]);
var handler158 = {
get(target, prop) {
if (prop === 'includes') {
return function(search) {
return target.includes(search);
};
}
return Reflect.get(target, prop);
}
};
var proxy158 = new Proxy(target158, handler158);
assert_true(proxy158.includes(3));
assert_true(!proxy158.includes(10));
var target159 = new Int8Array([1, 2, 3, 4, 5]);
var handler159 = {
get(target, prop) {
if (prop === 'indexOf') {
return function(search) {
return target.indexOf(search);
};
}
return Reflect.get(target, prop);
}
};
var proxy159 = new Proxy(target159, handler159);
assert_equal(proxy159.indexOf(3), 2);
assert_equal(proxy159.indexOf(10), -1);
var target160 = new Int8Array([1, 2, 3, 4, 5]);
var handler160 = {
get(target, prop) {
if (prop === 'every') {
return function(predicate) {
return target.every(predicate);
};
}
return Reflect.get(target, prop);
}
};
var proxy160 = new Proxy(target160, handler160);
assert_true(proxy160.every(x => x > 0));
assert_true(!proxy160.every(x => x > 2));
var target161 = new Int8Array([1, 2, 3, 4, 5]);
var handler161 = {
get(target, prop) {
if (prop === 'some') {
return function(predicate) {
return target.some(predicate);
};
}
return Reflect.get(target, prop);
}
};
var proxy161 = new Proxy(target161, handler161);
assert_true(proxy161.some(x => x > 3));
assert_true(!proxy161.some(x => x > 10));
var target162 = new Int8Array([1, 2, 3]);
var handler162 = {
get(target, prop) {
if (prop === 'forEach') {
return function(callback) {
target.forEach(callback);
};
}
return Reflect.get(target, prop);
}
};
var proxy162 = new Proxy(target162, handler162);
var sum162 = 0;
proxy162.forEach(x => { sum162 += x; });
assert_equal(sum162, 6);
var target163 = new Int8Array([5, 2, 8, 1, 9]);
var handler163 = {
get(target, prop) {
if (prop === 'sort') {
return function(compareFn) {
return target.sort(compareFn);
};
}
return Reflect.get(target, prop);
}
};
var proxy163 = new Proxy(target163, handler163);
var sorted163 = proxy163.sort((a, b) => a - b);
assert_equal(sorted163[0], 1);
assert_equal(sorted163[4], 9);
var target164 = new Int8Array([1, 2, 3, 4, 5]);
var handler164 = {
get(target, prop) {
if (prop === 'reverse') {
return function() {
return target.reverse();
};
}
return Reflect.get(target, prop);
}
};
var proxy164 = new Proxy(target164, handler164);
var reversed164 = proxy164.reverse();
assert_equal(reversed164[0], 5);
assert_equal(reversed164[4], 1);
var target165 = new Int8Array([1, 2, 3]);
var handler165 = {
get(target, prop) {
if (prop === 'toString') {
return function() {
return target.toString();
};
}
return Reflect.get(target, prop);
}
};
var proxy165 = new Proxy(target165, handler165);
assert_equal(proxy165.toString(), '1,2,3');
var target166 = [1, , 3, , 5];
target166[10] = 11;
var handler166 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy166 = new Proxy(target166, handler166);
assert_equal(proxy166[0], 1);
assert_equal(proxy166[1], undefined);
assert_equal(proxy166[2], 3);
assert_equal(proxy166[10], 11);
var target167 = [1, 2, 3];
var handler167 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy167 = new Proxy(target167, handler167);
assert_true(typeof proxy167.push === 'function');
assert_true(typeof proxy167.pop === 'function');
assert_true(typeof proxy167.map === 'function');
var target168 = Int8Array;
var handler168 = {
construct(target, args) {
return Reflect.construct(target, args);
}
};
var ProxyInt8Array = new Proxy(target168, handler168);
var arr168 = new ProxyInt8Array([1, 2, 3]);
assert_equal(arr168.length, 3);
assert_equal(arr168[0], 1);
var target169 = new BigInt64Array([BigInt(1), BigInt(2), BigInt(3)]);
var handler169 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy169 = new Proxy(target169, handler169);
assert_equal(proxy169[0], BigInt(1));
assert_equal(proxy169.length, 3);
var target170 = new Uint16Array([100, 200, 300]);
var handler170 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy170 = new Proxy(target170, handler170);
assert_equal(proxy170[0], 100);
assert_equal(proxy170[2], 300);
var target171 = new Uint32Array([1000, 2000, 3000]);
var handler171 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy171 = new Proxy(target171, handler171);
assert_equal(proxy171[0], 1000);
assert_equal(proxy171[2], 3000);
var target172 = new Int32Array([-100, 0, 100]);
var handler172 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy172 = new Proxy(target172, handler172);
assert_equal(proxy172[0], -100);
assert_equal(proxy172[2], 100);
var target173 = new BigInt64Array([BigInt(-999), BigInt(0), BigInt(999)]);
var handler173 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy173 = new Proxy(target173, handler173);
assert_equal(proxy173[0], BigInt(-999));
assert_equal(proxy173[2], BigInt(999));
var target174 = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]];
var handler174 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy174 = new Proxy(target174, handler174);
assert_equal(proxy174[0][0][0], 1);
assert_equal(proxy174[1][1][1], 8);
var target175 = [1, 'string', true, null, undefined, { a: 1 }, [1, 2], function() { return 1; }];
var handler175 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy175 = new Proxy(target175, handler175);
assert_equal(proxy175[0], 1);
assert_equal(proxy175[1], 'string');
assert_equal(proxy175[2], true);
assert_equal(proxy175[3], null);
assert_equal(proxy175[4], undefined);
assert_equal(proxy175[5].a, 1);
assert_equal(proxy175[6][0], 1);
assert_equal(typeof proxy175[7], 'function');
var target176 = [1, 2, 3];
var handler176 = {
get(target, prop) {
if (prop === Symbol.species) {
return Array;
}
return Reflect.get(target, prop);
}
};
var proxy176 = new Proxy(target176, handler176);
assert_equal(proxy176[Symbol.species], Array);
var target177 = [1, 2, 3];
var handler177 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy177 = new Proxy(target177, handler177);
var json177 = JSON.stringify(proxy177);
assert_equal(json177, '[1,2,3]');
var json178 = '[1,2,3]';
var parsed178 = JSON.parse(json178);
assert_equal(parsed178.length, 3);
assert_equal(parsed178[0], 1);
var target179 = [1, 2, 3];
var handler179 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy179 = new Proxy(target179, handler179);
var [a179, b179, c179] = proxy179;
assert_equal(a179, 1);
assert_equal(b179, 2);
assert_equal(c179, 3);
var target180 = [1, 2, 3];
var handler180 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy180 = new Proxy(target180, handler180);
var arr180 = [...proxy180];
assert_equal(arr180.length, 3);
assert_equal(arr180[0], 1);
var target181 = [1, 2, 3];
var handler181 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy181 = new Proxy(target181, handler181);
var sum181 = 0;
for (const item of proxy181) {
sum181 += item;
}
assert_equal(sum181, 6);
var target182 = [1, 2, 3];
var handler182 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy182 = new Proxy(target182, handler182);
assert_true(Array.isArray(proxy182));
var target183 = [1, 2, 3];
var handler183 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy183 = new Proxy(target183, handler183);
var keys183 = Object.keys(proxy183);
assert_equal(keys183.length, 3);
var target184 = [1, 2, 3];
var handler184 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy184 = new Proxy(target184, handler184);
var values184 = Object.values(proxy184);
assert_equal(values184.length, 3);
assert_equal(values184[0], 1);
var target185 = [1, 2, 3];
var handler185 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy185 = new Proxy(target185, handler185);
var entries185 = Object.entries(proxy185);
assert_equal(entries185.length, 3);
assert_equal(entries185[0][0], '0');
assert_equal(entries185[0][1], 1);
var target186 = [1, 2, 3];
var handler186 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy186 = new Proxy(target186, handler186);
assert_true(proxy186 instanceof Array);
assert_equal(proxy186.constructor, Array);
var target187 = [1, 2, 3];
var handler187 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy187 = new Proxy(target187, handler187);
var names187 = Object.getOwnPropertyNames(proxy187);
assert_true(names187.includes('0'));
assert_true(names187.includes('length'));
var target188 = [1, 2, 3];
var sym188 = Symbol('test');
target188[sym188] = 'value';
var handler188 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy188 = new Proxy(target188, handler188);
var syms188 = Object.getOwnPropertySymbols(proxy188);
assert_equal(syms188.length, 1);
var target189 = [1, 2, 3];
var handler189 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy189 = new Proxy(target189, handler189);
var assigned189 = Object.assign({}, proxy189);
assert_equal(assigned189[0], 1);
var target190 = [1, 2, 3];
var handler190 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy190 = new Proxy(target190, handler190);
var obj190 = Object.create(proxy190);
assert_equal(obj190[0], 1);
var target191 = [1, 2, 3];
var handler191 = {
get(target, prop) {
if (prop === 'sum') {
return target.reduce((a, b) => a + b, 0);
}
return Reflect.get(target, prop);
}
};
var proxy191 = new Proxy(target191, handler191);
var sum191 = proxy191.sum;
assert_equal(sum191, 6);
var target192 = [1, 2, 3];
var handler192 = {
get(target, prop) {
const value = Reflect.get(target, prop);
if (typeof value === 'number') {
return new Proxy({ value: value * 10 }, {
get(t, p) {
return Reflect.get(t, p);
}
});
}
return value;
}
};
var proxy192 = new Proxy(target192, handler192);
assert_equal(proxy192[0].value, 10);
assert_equal(proxy192[1].value, 20);
assert_equal(proxy192[2].value, 30);
var target193 = [1, 2, 3, 4, 5];
var handler193 = {
get(target, prop) {
const method = Reflect.get(target, prop);
if (typeof method === 'function') {
return function(...args) {
return Reflect.apply(method, target, args);
};
}
return method;
}
};
var proxy193 = new Proxy(target193, handler193);
var result193 = proxy193.filter(x => x > 2).map(x => x * 2).slice(0, 3);
assert_equal(result193[0], 6);
assert_equal(result193[2], 10);
var target194 = [1, 2, 3, 4, 5];
var handler194 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy194 = new Proxy(target194, handler194);
var result194 = proxy194.reduceRight((acc, val) => acc - val);
assert_equal(result194, -5);
var target195 = [1, 2, 3, 4, 5];
var handler195 = {
get(target, prop) {
const method = Reflect.get(target, prop);
if (typeof method === 'function') {
return function(...args) {
const result = Reflect.apply(method, target, args);
return new Proxy(result, handler195);
};
}
return method;
}
};
var proxy195 = new Proxy(target195, handler195);
var mapped195 = proxy195.map(x => x * 2);
var first195 = mapped195[Symbol.iterator]().next().value;
assert_equal(first195, 2);
var filtered195 = mapped195.filter(x => x > 4);
assert_equal(filtered195.length, 3);
var target196 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var handler196 = {
get(target, prop) {
const method = Reflect.get(target, prop);
if (typeof method === 'function') {
return function(...args) {
return Reflect.apply(method, target, args);
};
}
return method;
}
};
var proxy196 = new Proxy(target196, handler196);
assert_equal(proxy196.find(x => x > 5), 6);
assert_equal(proxy196.findIndex(x => x > 5), 5);
assert_true(proxy196.includes(7));
assert_equal(proxy196.indexOf(8), 7);
var target197 = [1, 2, 3, 4, 5];
var handler197 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy197 = new Proxy(target197, handler197);
var sum197 = 0;
proxy197.forEach(x => { sum197 += x; });
assert_equal(sum197, 15);
var every197 = proxy197.every(x => x > 0);
assert_true(every197);
var some197 = proxy197.some(x => x > 3);
assert_true(some197);
var target198 = [1, 2, 3, 4, 5];
var handler198 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy198 = new Proxy(target198, handler198);
var mapped198 = proxy198.map(x => x * 2);
assert_equal(mapped198[0], 2);
assert_equal(mapped198[4], 10);
var filtered198 = proxy198.filter(x => x > 2);
assert_equal(filtered198.length, 3);
var reduced198 = proxy198.reduce((a, b) => a + b, 0);
assert_equal(reduced198, 15);
var target199 = [5, 2, 8, 1, 9, 3, 7, 4, 6];
var handler199 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy199 = new Proxy(target199, handler199);
var sorted199 = proxy199.sort((a, b) => a - b);
assert_equal(sorted199[0], 1);
assert_equal(sorted199[8], 9);
var reversed199 = proxy199.reverse();
assert_equal(reversed199[0], 9);
var target200 = [1, 2, 3];
var handler200 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy200 = new Proxy(target200, handler200);
proxy200.push(4, 5);
assert_equal(proxy200.length, 5);
assert_equal(proxy200[3], 4);
assert_equal(proxy200[4], 5);
proxy200.pop();
assert_equal(proxy200.length, 4);
proxy200.unshift(0);
assert_equal(proxy200[0], 0);
assert_equal(proxy200.length, 5);
proxy200.shift();
assert_equal(proxy200[0], 1);
assert_equal(proxy200.length, 4);
var target201 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var handler201 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy201 = new Proxy(target201, handler201);
var sliced201 = proxy201.slice(2, 5);
assert_equal(sliced201.length, 3);
assert_equal(sliced201[0], 3);
var spliced201 = proxy201.splice(2, 3, 30, 40, 50);
assert_equal(spliced201.length, 3);
assert_equal(proxy201.length, 12);
var target202 = [1, 2, 3];
var handler202 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy202 = new Proxy(target202, handler202);
var concat202 = proxy202.concat([4, 5], 6, [7, 8]);
assert_equal(concat202.length, 8);
assert_equal(concat202[0], 1);
assert_equal(concat202[7], 8);
var target203 = new Array(10);
var handler203 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy203 = new Proxy(target203, handler203);
proxy203.fill(5);
assert_equal(proxy203[0], 5);
assert_equal(proxy203[9], 5);
proxy203.fill(0, 2, 5);
assert_equal(proxy203[0], 5);
assert_equal(proxy203[2], 0);
assert_equal(proxy203[4], 0);
assert_equal(proxy203[5], 5);
var target204 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var handler204 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy204 = new Proxy(target204, handler204);
proxy204.copyWithin(0, 5, 8);
assert_equal(proxy204[0], 6);
assert_equal(proxy204[1], 7);
assert_equal(proxy204[2], 8);
assert_equal(proxy204[3], 4);
var target205 = [1, [2, [3, [4]]]];
var handler205 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy205 = new Proxy(target205, handler205);
var flat205 = proxy205.flat(2);
assert_equal(flat205[0], 1);
assert_equal(flat205[1], 2);
assert_equal(flat205[2], 3);
assert_true(Array.isArray(flat205[3]));
var target206 = [1, 2, 3];
var handler206 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy206 = new Proxy(target206, handler206);
var flatmapped206 = proxy206.flatMap(x => [x, x * 2]);
assert_equal(flatmapped206.length, 6);
assert_equal(flatmapped206[0], 1);
assert_equal(flatmapped206[1], 2);
var target207 = [1, 2, 3, 4, 5];
var handler207 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy207 = new Proxy(target207, handler207);
assert_equal(proxy207.at(0), 1);
assert_equal(proxy207.at(2), 3);
assert_equal(proxy207.at(-1), 5);
assert_equal(proxy207.at(-2), 4);
assert_equal(proxy207.at(10), undefined);
var target208 = [5, 2, 8, 1, 9];
var handler208 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy208 = new Proxy(target208, handler208);
var sorted208 = proxy208.toSorted((a, b) => a - b);
assert_equal(sorted208[0], 1);
assert_equal(sorted208[4], 9);
assert_equal(target208[0], 5);
var target209 = [1, 2, 3, 4, 5];
var handler209 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy209 = new Proxy(target209, handler209);
var reversed209 = proxy209.toReversed();
assert_equal(reversed209[0], 5);
assert_equal(reversed209[4], 1);
assert_equal(target209[0], 1);
var target210 = [1, 2, 3, 4, 5];
var handler210 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
return Reflect.apply(method, target, args);
};
}
};
var proxy210 = new Proxy(target210, handler210);
var result210 = proxy210.with(2, 30);
assert_equal(result210[2], 30);
assert_equal(target210[2], 3);
var target211 = [[1, 2], [3, 4], [5, 6]];
var handler211 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy211 = new Proxy(target211, handler211);
assert_equal(proxy211[0][0], 1);
assert_equal(proxy211[1][1], 4);
assert_equal(proxy211[2][0], 5);
var target212 = new Array(10);
target212[0] = 1;
target212[5] = 6;
target212[9] = 10;
var handler212 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy212 = new Proxy(target212, handler212);
assert_equal(proxy212[0], 1);
assert_equal(proxy212[1], undefined);
assert_equal(proxy212[5], 6);
assert_equal(proxy212[9], 10);
var target213 = new Array(5);
var handler213 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy213 = new Proxy(target213, handler213);
assert_equal(proxy213.length, 5);
var target214 = new Array(1, 2, 3);
var proxy214 = new Proxy(target214, handler213);
assert_equal(proxy214.length, 3);
assert_equal(proxy214[0], 1);
var target215 = Array.apply(null, { length: 5 });
var handler215 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy215 = new Proxy(target215, handler215);
assert_equal(proxy215.length, 5);
assert_equal(proxy215[0], undefined);
var target216 = Array.from([1, 2, 3], x => x * 2);
var handler216 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy216 = new Proxy(target216, handler216);
assert_equal(proxy216.length, 3);
assert_equal(proxy216[0], 2);
var target217 = Array.of(1, 2, 3, 4, 5);
var handler217 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy217 = new Proxy(target217, handler217);
assert_equal(proxy217.length, 5);
assert_equal(proxy217[0], 1);
assert_equal(proxy217[4], 5);
var target218 = [1, 2, 3];
var handler218 = {
get(target, prop) {
if (prop === Symbol.iterator) {
return function() {
let index = 0;
return {
next() {
if (index < target.length) {
return { value: target[index++] * 10, done: false };
}
return { done: true };
}
};
};
}
return Reflect.get(target, prop);
}
};
var proxy218 = new Proxy(target218, handler218);
var iter218 = proxy218[Symbol.iterator]();
assert_equal(iter218.next().value, 10);
assert_equal(iter218.next().value, 20);
var target219 = ['a', 'b', 'c'];
var handler219 = {
get(target, prop) {
if (prop === 'entries') {
return function() {
let index = 0;
return {
next() {
if (index < target.length) {
return { value: [index, target[index++]], done: false };
}
return { done: true };
}
};
};
}
return Reflect.get(target, prop);
}
};
var proxy219 = new Proxy(target219, handler219);
var entries219 = proxy219.entries();
var first219 = entries219.next().value;
assert_equal(first219[0], 0);
assert_equal(first219[1], 'a');
var target220 = ['a', 'b', 'c'];
var handler220 = {
get(target, prop) {
if (prop === 'keys') {
return function() {
let index = 0;
return {
next() {
if (index < target.length) {
return { value: index++, done: false };
}
return { done: true };
}
};
};
}
return Reflect.get(target, prop);
}
};
var proxy220 = new Proxy(target220, handler220);
var keys220 = proxy220.keys();
assert_equal(keys220.next().value, 0);
var target221 = ['a', 'b', 'c'];
var handler221 = {
get(target, prop) {
if (prop === 'values') {
return function() {
let index = 0;
return {
next() {
if (index < target.length) {
return { value: target[index++], done: false };
}
return { done: true };
}
};
};
}
return Reflect.get(target, prop);
}
};
var proxy221 = new Proxy(target221, handler221);
var values221 = proxy221.values();
assert_equal(values221.next().value, 'a');
var target222 = [1, NaN, 3, undefined, null, 5];
var handler222 = {
get(target, prop) {
if (prop === 'includes') {
return function(search) {
for (let i = 0; i < target.length; i++) {
if (search !== search && target[i] !== target[i]) return true;
if (search === target[i]) return true;
}
return false;
};
}
return Reflect.get(target, prop);
}
};
var proxy222 = new Proxy(target222, handler222);
assert_true(proxy222.includes(NaN));
assert_true(proxy222.includes(undefined));
assert_true(proxy222.includes(null));
assert_true(proxy222.includes(1));
var target223 = [1, NaN, 3, undefined, null, 5];
var handler223 = {
get(target, prop) {
if (prop === 'indexOf') {
return function(search) {
for (let i = 0; i < target.length; i++) {
if (search !== search && target[i] !== target[i]) return i;
if (search === target[i]) return i;
}
return -1;
};
}
return Reflect.get(target, prop);
}
};
var proxy223 = new Proxy(target223, handler223);
assert_equal(proxy223.indexOf(NaN), 1);
assert_equal(proxy223.indexOf(undefined), 3);
assert_equal(proxy223.indexOf(null), 4);
var target224 = [0, '', false, null, undefined, 1, 'a', true];
var handler224 = {
get(target, prop) {
if (prop === 'find') {
return function(predicate) {
for (let i = 0; i < target.length; i++) {
if (predicate(target[i], i, target)) {
return target[i];
}
}
return undefined;
};
}
return Reflect.get(target, prop);
}
};
var proxy224 = new Proxy(target224, handler224);
assert_equal(proxy224.find(x => x !== null && x !== undefined && x !== false && x !== 0 && x !== ''), 1);
var target225 = [1, 2, 3];
var handler225 = {
get(target, prop) {
if (prop === 'filter') {
return function(predicate) {
const result = [];
for (let i = 0; i < target.length; i++) {
if (predicate(target[i], i, target)) {
result.push(target[i]);
}
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy225 = new Proxy(target225, handler225);
var filtered225 = proxy225.filter(x => x > 10);
assert_equal(filtered225.length, 0);
var target226 = [];
var handler226 = {
get(target, prop) {
if (prop === 'map') {
return function(callback) {
const result = [];
for (let i = 0; i < target.length; i++) {
result.push(callback(target[i], i, target));
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy226 = new Proxy(target226, handler226);
var mapped226 = proxy226.map(x => x * 2);
assert_equal(mapped226.length, 0);
var target227 = [];
var handler227 = {
get(target, prop) {
if (prop === 'reduce') {
return function(callback, initialValue) {
if (target.length === 0 && arguments.length < 2) {
throw new TypeError('Reduce of empty array with no initial value');
}
let result = initialValue;
for (let i = 0; i < target.length; i++) {
result = callback(result, target[i], i, target);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy227 = new Proxy(target227, handler227);
var reduced227 = proxy227.reduce((a, b) => a + b, 0);
assert_equal(reduced227, 0);
var target228 = [1, 2, 3];
var thisArg228 = { multiplier: 2 };
var handler228 = {
get(target, prop) {
if (prop === 'map') {
return function(callback, thisArg) {
const result = [];
for (let i = 0; i < target.length; i++) {
result.push(callback.call(thisArg, target[i], i, target));
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy228 = new Proxy(target228, handler228);
var mapped228 = proxy228.map(function(x) { return x * this.multiplier; }, thisArg228);
assert_equal(mapped228[0], 2);
assert_equal(mapped228[2], 6);
var target229 = [{ v: 1 }, { v: 2 }, { v: 1 }, { v: 3 }];
var handler229 = {
get(target, prop) {
if (prop === 'sort') {
return function(compareFn) {
return target.sort(compareFn);
};
}
return Reflect.get(target, prop);
}
};
var proxy229 = new Proxy(target229, handler229);
var sorted229 = proxy229.sort((a, b) => a.v - b.v);
assert_equal(sorted229[0].v, 1);
assert_equal(sorted229[1].v, 1);
var target230 = [1, 2, 3, 4, 5];
var handler230 = {
get(target, prop) {
if (prop === 'splice') {
return function(start, deleteCount, ...items) {
if (start < 0) start = Math.max(target.length + start, 0);
return target.splice(start, deleteCount, ...items);
};
}
return Reflect.get(target, prop);
}
};
var proxy230 = new Proxy(target230, handler230);
proxy230.splice(-2, 1, 30);
assert_equal(proxy230[3], 30);
var target231 = [1, 2, 3, 4, 5];
var handler231 = {
get(target, prop) {
if (prop === 'slice') {
return function(start, end) {
if (start < 0) start = Math.max(target.length + start, 0);
if (end < 0) end = Math.max(target.length + end, 0);
return target.slice(start, end);
};
}
return Reflect.get(target, prop);
}
};
var proxy231 = new Proxy(target231, handler231);
var sliced231 = proxy231.slice(-3, -1);
assert_equal(sliced231[0], 3);
assert_equal(sliced231.length, 2);
var target232 = new Array(5);
var handler232 = {
get(target, prop) {
if (prop === 'fill') {
return function(value, start, end) {
start = start || 0;
end = end || target.length;
for (let i = start; i < end; i++) {
target[i] = value;
}
return target;
};
}
return Reflect.get(target, prop);
}
};
var proxy232 = new Proxy(target232, handler232);
proxy232.fill({ a: 1 }, 1, 4);
assert_equal(proxy232[0], undefined);
assert_equal(proxy232[1].a, 1);
var target233 = [1, 2, 3, 4, 5, 6, 7, 8];
var handler233 = {
get(target, prop) {
if (prop === 'copyWithin') {
return function(target2, start, end) {
target2 = target2 || 0;
start = start || 0;
end = end || target.length;
const copy = target.slice(start, end);
for (let i = 0; i < copy.length; i++) {
target[target2 + i] = copy[i];
}
return target;
};
}
return Reflect.get(target, prop);
}
};
var proxy233 = new Proxy(target233, handler233);
proxy233.copyWithin(2, 0, 4);
assert_equal(proxy233[2], 1);
assert_equal(proxy233[3], 2);
var target234 = [1, 2, 3];
var handler234 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy234 = new Proxy(target234, handler234);
var merged234 = [...proxy234, ...[4, 5, 6]];
assert_equal(merged234.length, 6);
assert_equal(merged234[5], 6);
var target235 = [1, 2, 3, 4, 5];
var handler235 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy235 = new Proxy(target235, handler235);
var [first235, , third235, ...rest235] = proxy235;
assert_equal(first235, 1);
assert_equal(third235, 3);
assert_equal(rest235.length, 2);
var target236 = [1];
var handler236 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy236 = new Proxy(target236, handler236);
var [a236 = 10, b236 = 20, c236 = 30] = proxy236;
assert_equal(a236, 1);
assert_equal(b236, 20);
assert_equal(c236, 30);
var target237 = [1, [2, 3], 4];
var handler237 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy237 = new Proxy(target237, handler237);
var [a237, [b237, c237], d237] = proxy237;
assert_equal(a237, 1);
assert_equal(b237, 2);
assert_equal(c237, 3);
assert_equal(d237, 4);
var target238 = [1, 2, 3];
var handler238 = {
get(target, prop) {
const method = Reflect.get(target, prop);
return function(...args) {
const result = Reflect.apply(method, target, args);
return new Proxy(result, handler238);
};
}
};
var proxy238 = new Proxy(target238, handler238);
var mapped238 = proxy238.map(x => x * 2);
var first238 = mapped238[Symbol.iterator]().next().value;
assert_equal(first238, 2);
var buffer239 = new ArrayBuffer(4);
var view239 = new DataView(buffer239);
view239.setInt32(0, 1, true);
var handler239 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy239 = new Proxy(view239, handler239);
assert_equal(proxy239.getInt32(0, true), 1);
var target240 = new Int8Array([-128, 0, 127]);
var handler240 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy240 = new Proxy(target240, handler240);
assert_equal(proxy240[0], -128);
assert_equal(proxy240[1], 0);
assert_equal(proxy240[2], 127);
var target241 = new Uint8Array([0, 255]);
var handler241 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy241 = new Proxy(target241, handler241);
assert_equal(proxy241[0], 0);
assert_equal(proxy241[1], 255);
var target242 = [1, 2, 3];
var handler242 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy242 = new Proxy(target242, handler242);
assert_true(proxy242.hasOwnProperty('0'));
assert_true(proxy242.hasOwnProperty('length'));
var target243 = [1, 2, 3];
var proto243 = { prop: 'value' };
var handler243 = {
setPrototypeOf(target, proto) {
return Reflect.setPrototypeOf(target, proto);
}
};
var proxy243 = new Proxy(target243, handler243);
Object.setPrototypeOf(proxy243, proto243);
assert_equal(Object.getPrototypeOf(proxy243), proto243);
var target244 = [1, 2, 3];
var handler244 = {
getPrototypeOf(target) {
return Array.prototype;
}
};
var proxy244 = new Proxy(target244, handler244);
assert_equal(Reflect.getPrototypeOf(proxy244), Array.prototype);
var target245 = [1, 2, 3, 4, 5];
var callCount245 = 0;
var handler245 = {
get(target, prop) {
callCount245++;
return Reflect.get(target, prop);
}
};
var proxy245 = new Proxy(target245, handler245);
var val245 = proxy245[0];
var len245 = proxy245.length;
assert_true(callCount245 >= 2);
var target246 = [1, 'str', true];
var handler246 = {
get(target, prop) {
if (prop === 'getString') return 'string value';
if (prop === 'getNumber') return 42;
if (prop === 'getBoolean') return true;
if (prop === 'getObject') return { a: 1 };
if (prop === 'getArray') return [1, 2, 3];
if (prop === 'getFunction') return function() { return 1; };
if (prop === 'getNull') return null;
if (prop === 'getUndefined') return undefined;
return Reflect.get(target, prop);
}
};
var proxy246 = new Proxy(target246, handler246);
assert_equal(proxy246.getString, 'string value');
assert_equal(proxy246.getNumber, 42);
assert_equal(proxy246.getBoolean, true);
assert_equal(proxy246.getObject.a, 1);
assert_equal(proxy246.getArray[0], 1);
assert_equal(typeof proxy246.getFunction, 'function');
assert_true(proxy246.getNull === null);
assert_true(proxy246.getUndefined === undefined);
var target247 = [1, 2, 3, 4, 5];
var handler247 = {
get(target, prop) {
const method = Reflect.get(target, prop);
if (typeof method === 'function') {
return function(...args) {
return Reflect.apply(method, target, args);
};
}
return method;
}
};
var proxy247 = new Proxy(target247, handler247);
var result247 = proxy247.filter(x => x > 1).map(x => x * 2).slice(1, 3);
assert_equal(result247[0], 6);
assert_equal(result247.length, 2);
var target248 = [1, 2, 3, 4, 5];
var handler248 = {
get(target, prop) {
if (prop === 'find') {
return function(predicate) {
for (let i = 0; i < target.length; i++) {
if (predicate(target[i], i, target)) {
return target[i];
}
}
return undefined;
};
}
return Reflect.get(target, prop);
}
};
var proxy248 = new Proxy(target248, handler248);
assert_equal(proxy248.find(x => x > 2), 3);
var target249 = [1, 2, 3, 4, 5];
var handler249 = {
get(target, prop) {
if (prop === 'every') {
return function(predicate) {
for (let i = 0; i < target.length; i++) {
if (!predicate(target[i], i, target)) {
return false;
}
}
return true;
};
}
return Reflect.get(target, prop);
}
};
var proxy249 = new Proxy(target249, handler249);
assert_true(proxy249.every(x => x > 0));
assert_true(!proxy249.every(x => x > 2));
var target250 = [1, 2, 3, 4, 5];
var handler250 = {
get(target, prop) {
if (prop === 'some') {
return function(predicate) {
for (let i = 0; i < target.length; i++) {
if (predicate(target[i], i, target)) {
return true;
}
}
return false;
};
}
return Reflect.get(target, prop);
}
};
var proxy250 = new Proxy(target250, handler250);
assert_true(proxy250.some(x => x > 3));
assert_true(!proxy250.some(x => x > 10));
var target251 = [1, 2, 3];
var handler251 = {
get(target, prop) {
if (prop === 'reduce') {
return function(callback, initialValue) {
let result = initialValue;
for (let i = 0; i < target.length; i++) {
result = callback(result, target[i], i, target);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy251 = new Proxy(target251, handler251);
assert_equal(proxy251.reduce((a, b) => a + b, 10), 16);
var target252 = [1, 2, 3];
var handler252 = {
get(target, prop) {
if (prop === 'reduce') {
return function(callback, initialValue) {
let result = initialValue;
let startIndex = 0;
if (arguments.length < 2) {
if (target.length === 0) {
throw new TypeError('Reduce of empty array with no initial value');
}
result = target[0];
startIndex = 1;
}
for (let i = startIndex; i < target.length; i++) {
result = callback(result, target[i], i, target);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy252 = new Proxy(target252, handler252);
assert_equal(proxy252.reduce((a, b) => a + b), 6);
var target253 = [1, 2, 3];
var handler253 = {
get(target, prop) {
if (prop === 'reduceRight') {
return function(callback, initialValue) {
let result = initialValue;
let startIndex = target.length - 1;
if (arguments.length < 2) {
result = target[startIndex];
startIndex--;
}
for (let i = startIndex; i >= 0; i--) {
result = callback(result, target[i], i, target);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy253 = new Proxy(target253, handler253);
assert_equal(proxy253.reduceRight((a, b) => a - b), 0);
var target254 = [1, [2, [3, [4, [5]]]]];
var handler254 = {
get(target, prop) {
if (prop === 'flat') {
return function(depth) {
const flatten = (arr, d) => {
if (d <= 0) return arr;
return arr.reduce((acc, val) => {
return acc.concat(Array.isArray(val) ? flatten(val, d - 1) : val);
}, []);
};
return flatten(target, depth === undefined ? Infinity : depth);
};
}
return Reflect.get(target, prop);
}
};
var proxy254 = new Proxy(target254, handler254);
var flat254 = proxy254.flat(Infinity);
assert_equal(flat254.length, 5);
assert_equal(flat254[4], 5);
var target255 = [1, 'a', null];
var handler255 = {
get(target, prop) {
if (prop === 'toLocaleString') {
return function() {
return target.map(x => x === null ? '' : String(x)).join(',');
};
}
return Reflect.get(target, prop);
}
};
var proxy255 = new Proxy(target255, handler255);
assert_equal(proxy255.toLocaleString(), '1,a,');
var target256 = [1, , 3, , 5];
var handler256 = {
get(target, prop) {
if (prop === 'join') {
return function(separator) {
let result = '';
for (let i = 0; i < target.length; i++) {
if (i > 0) result += separator;
if (target[i] !== undefined) {
result += target[i];
}
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy256 = new Proxy(target256, handler256);
assert_equal(proxy256.join('-'), '1--3--5');
var target257 = [1, 2, 3, 4, 5];
var handler257 = {
get(target, prop) {
if (prop === 'shift') {
return function() {
const first = target[0];
for (let i = 0; i < target.length - 1; i++) {
target[i] = target[i + 1];
}
target.length--;
return first;
};
}
return Reflect.get(target, prop);
}
};
var proxy257 = new Proxy(target257, handler257);
proxy257.shift();
assert_equal(proxy257.length, 4);
assert_equal(proxy257[0], 2);
var target258 = [2, 3, 4];
var handler258 = {
get(target, prop) {
if (prop === 'unshift') {
return function(...items) {
for (let i = items.length - 1; i >= 0; i--) {
target.unshift(items[i]);
}
return target.length;
};
}
return Reflect.get(target, prop);
}
};
var proxy258 = new Proxy(target258, handler258);
proxy258.unshift(0, 1);
assert_equal(proxy258.length, 5);
assert_equal(proxy258[0], 0);
assert_equal(proxy258[1], 1);
var target259 = [1, 2];
var handler259 = {
get(target, prop) {
if (prop === 'concat') {
return function(...args) {
let result = [...target];
for (const arg of args) {
if (Array.isArray(arg)) {
result = result.concat(arg);
} else {
result.push(arg);
}
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy259 = new Proxy(target259, handler259);
var result259 = proxy259.concat([3, 4], 5, [[6, 7]]);
assert_equal(result259.length, 7);
assert_equal(result259[6][0], 6);
var target260 = [1, 2, 3, 4, 5];
var handler260 = {
get(target, prop) {
if (prop === 'splice') {
return function(start, deleteCount, ...items) {
const removed = target.slice(start, start + deleteCount);
target.splice(start, deleteCount, ...items);
return removed;
};
}
return Reflect.get(target, prop);
}
};
var proxy260 = new Proxy(target260, handler260);
var removed260 = proxy260.splice(1, 2);
assert_equal(removed260.length, 2);
assert_equal(removed260[0], 2);
assert_equal(proxy260.length, 3);
var target261 = [1, 5];
var handler261 = {
get(target, prop) {
if (prop === 'splice') {
return function(start, deleteCount, ...items) {
const removed = target.slice(start, start + deleteCount);
target.splice(start, deleteCount, ...items);
return removed;
};
}
return Reflect.get(target, prop);
}
};
var proxy261 = new Proxy(target261, handler261);
proxy261.splice(1, 0, 2, 3, 4);
assert_equal(proxy261.length, 5);
assert_equal(proxy261[1], 2);
assert_equal(proxy261[3], 4);
var target262 = [1, 2, 3];
var handler262 = {
get(target, prop) {
if (prop === 'splice') {
return function(start, deleteCount, ...items) {
const removed = target.slice(start, start + deleteCount);
target.splice(start, deleteCount, ...items);
return removed;
};
}
return Reflect.get(target, prop);
}
};
var proxy262 = new Proxy(target262, handler262);
var removed262 = proxy262.splice(1, 1, 20);
assert_equal(removed262[0], 2);
assert_equal(proxy262[1], 20);
assert_equal(proxy262.length, 3);
var target263 = [10, 2, 33, 4, 55];
var handler263 = {
get(target, prop) {
if (prop === 'sort') {
return function(compareFn) {
return target.sort(compareFn);
};
}
return Reflect.get(target, prop);
}
};
var proxy263 = new Proxy(target263, handler263);
var sorted263 = proxy263.sort((a, b) => a - b);
assert_equal(sorted263[0], 2);
assert_equal(sorted263[4], 55);
var target264 = ['banana', 'apple', 'cherry'];
var handler264 = {
get(target, prop) {
if (prop === 'sort') {
return function(compareFn) {
return target.sort(compareFn);
};
}
return Reflect.get(target, prop);
}
};
var proxy264 = new Proxy(target264, handler264);
var sorted264 = proxy264.sort();
assert_equal(sorted264[0], 'apple');
assert_equal(sorted264[2], 'banana');
var target265 = [1, 2, 3, 4, 5];
var handler265 = {
get(target, prop) {
if (prop === 'reverse') {
return function() {
let left = 0;
let right = target.length - 1;
while (left < right) {
const temp = target[left];
target[left] = target[right];
target[right] = temp;
left++;
right--;
}
return target;
};
}
return Reflect.get(target, prop);
}
};
var proxy265 = new Proxy(target265, handler265);
proxy265.reverse();
assert_equal(proxy265[0], 5);
assert_equal(proxy265[4], 1);
var obj266 = { value: 0 };
var target266 = new Array(3);
var handler266 = {
get(target, prop) {
if (prop === 'fill') {
return function(value, start, end) {
start = start || 0;
end = end || target.length;
for (let i = start; i < end; i++) {
target[i] = value;
}
return target;
};
}
return Reflect.get(target, prop);
}
};
var proxy266 = new Proxy(target266, handler266);
proxy266.fill(obj266);
obj266.value = 100;
assert_equal(proxy266[0].value, 100);
assert_equal(proxy266[1].value, 100);
var target267 = [];
var handler267 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy267 = new Proxy(target267, handler267);
assert_equal(proxy267.length, 0);
assert_equal(proxy267[0], undefined);
var target268 = [1];
var handler268 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy268 = new Proxy(target268, handler268);
assert_equal(proxy268.length, 1);
assert_equal(proxy268[0], 1);
var target269 = [1, , 3];
var handler269 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy269 = new Proxy(target269, handler269);
assert_true(0 in proxy269);
assert_true(!(1 in proxy269));
assert_true(2 in proxy269);
var target270 = [1, 2, 3];
target270[10] = 11;
var handler270 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy270 = new Proxy(target270, handler270);
assert_equal(Object.keys(proxy270).length, 4);
var target271 = [1, 2, 3];
var handler271 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy271 = new Proxy(target271, handler271);
assert_equal(proxy271['0'], 1);
assert_equal(proxy271['1'], 2);
assert_equal(proxy271['2'], 3);
var target272 = [1, 2, 3];
target272.custom = 'value';
var handler272 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy272 = new Proxy(target272, handler272);
assert_equal(proxy272.custom, 'value');
var target273 = [1, 2, 3];
var handler273 = {
deleteProperty(target, prop) {
return Reflect.deleteProperty(target, prop);
}
};
var proxy273 = new Proxy(target273, handler273);
delete proxy273[1];
assert_equal(proxy273[1], undefined);
var target274 = [1, 2, 3];
var handler274 = {
has(target, prop) {
return Reflect.has(target, prop);
}
};
var proxy274 = new Proxy(target274, handler274);
assert_true(0 in proxy274);
assert_true(!(100 in proxy274));
var target275 = [1, 2, 3];
var handler275 = {
defineProperty(target, prop, descriptor) {
return Reflect.defineProperty(target, prop, descriptor);
}
};
var proxy275 = new Proxy(target275, handler275);
Object.defineProperties(proxy275, {
3: { value: 4, writable: true },
4: { value: 5, writable: true }
});
assert_equal(proxy275[3], 4);
assert_equal(proxy275[4], 5);
var target276 = [1, 2, 3];
var handler276 = {
getOwnPropertyDescriptor(target, prop) {
return Reflect.getOwnPropertyDescriptor(target, prop);
}
};
var proxy276 = new Proxy(target276, handler276);
var descs276 = Object.getOwnPropertyDescriptors(proxy276);
assert_true(descs276['0'] !== undefined);
assert_true(descs276['length'] !== undefined);
var target277 = [1, 2, 3];
Object.freeze(target277);
var handler277 = {
set(target, prop, value) {
return false;
}
};
var proxy277 = new Proxy(target277, handler277);
var success277 = true;
try {
proxy277[0] = 100;
} catch (e) {
success277 = false;
}
if (!success277) {
assert_equal(proxy277[0], 1);
}
var target278 = [1, 2, 3];
Object.seal(target278);
var handler278 = {
defineProperty(target, prop, descriptor) {
return false;
}
};
var proxy278 = new Proxy(target278, handler278);
var success278 = true;
try {
Object.defineProperty(proxy278, 3, { value: 4 });
} catch (e) {
success278 = false;
}
if (!success278) {
assert_equal(proxy278.length, 3);
}
var target279 = [1, 2, 3];
var handler279 = {
isExtensible(target) {
return Reflect.isExtensible(target);
}
};
var proxy279 = new Proxy(target279, handler279);
assert_true(Object.isExtensible(proxy279));
Object.preventExtensions(proxy279);
assert_true(!Object.isExtensible(proxy279));
var target280 = [1, 2, 3];
var handler280 = {
preventExtensions(target) {
return Reflect.preventExtensions(target);
}
};
var proxy280 = new Proxy(target280, handler280);
Object.preventExtensions(proxy280);
assert_true(!Object.isExtensible(proxy280));
var target281 = [1, 2, 3];
var handler281 = {
getPrototypeOf(target) {
return Reflect.getPrototypeOf(target);
}
};
var proxy281 = new Proxy(target281, handler281);
assert_equal(Object.getPrototypeOf(proxy281), Array.prototype);
var target282 = [[1, 2, 3], [4, 5, 6]];
var handler282 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy282 = new Proxy(target282, handler282);
assert_equal(proxy282[0].length, 3);
assert_equal(proxy282[1].length, 3);
var target283 = [[1, 2], [3, 4]];
var handler283 = {
get(target, prop) {
const method = Reflect.get(target, prop);
if (typeof method === 'function') {
return function(...args) {
return Reflect.apply(method, target, args);
};
}
return method;
}
};
var proxy283 = new Proxy(target283, handler283);
var flat283 = proxy283.flat();
assert_equal(flat283.length, 4);
assert_equal(flat283[0], 1);
assert_equal(flat283[3], 4);
var target284 = [1, 2, 3];
var handler284 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy284 = new Proxy(target284, handler284);
var copy284 = JSON.parse(JSON.stringify(proxy284));
assert_equal(copy284[0], 1);
assert_equal(copy284[2], 3);
var target285 = new Int8Array([1, 2, 3, 4, 5]);
var handler285 = {
get(target, prop) {
if (prop === 'every') {
return function(predicate) {
return target.every(predicate);
};
}
return Reflect.get(target, prop);
}
};
var proxy285 = new Proxy(target285, handler285);
assert_true(proxy285.every(x => x > 0));
var target286 = new Int8Array([1, 2, 3, 4, 5]);
var handler286 = {
get(target, prop) {
if (prop === 'some') {
return function(predicate) {
return target.some(predicate);
};
}
return Reflect.get(target, prop);
}
};
var proxy286 = new Proxy(target286, handler286);
assert_true(proxy286.some(x => x > 3));
var target287 = [1, 2, 3, undefined, 5];
var handler287 = {
get(target, prop) {
if (prop === 'filter') {
return function(predicate) {
var result = [];
for (let i = 0; i < target.length; i++) {
if (predicate(target[i], i, target)) {
result.push(target[i]);
}
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy287 = new Proxy(target287, handler287);
var filtered287 = proxy287.filter(x => x !== undefined);
assert_equal(filtered287.length, 4);
var target288 = [1, 2, 3, null, 5];
var handler288 = {
get(target, prop) {
if (prop === 'filter') {
return function(predicate) {
var result = [];
for (let i = 0; i < target.length; i++) {
if (predicate(target[i], i, target)) {
result.push(target[i]);
}
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy288 = new Proxy(target288, handler288);
var filtered288 = proxy288.filter(x => x !== null);
assert_equal(filtered288.length, 4);
var target289 = [0, false, '', null, undefined, 1];
var handler289 = {
get(target, prop) {
if (prop === 'filter') {
return function(predicate) {
var result = [];
for (let i = 0; i < target.length; i++) {
if (predicate(target[i], i, target)) {
result.push(target[i]);
}
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy289 = new Proxy(target289, handler289);
var filtered289 = proxy289.filter(x => x);
assert_equal(filtered289.length, 1);
var target290 = [1];
var handler290 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy290 = new Proxy(target290, handler290);
assert_equal(proxy290.length, 1);
var target291 = new Array(10000);
for (var i = 0; i < 10000; i++) {
target291[i] = i;
}
var handler291 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy291 = new Proxy(target291, handler291);
assert_equal(proxy291.length, 10000);
assert_equal(proxy291[9999], 9999);
var target292 = [1, 2, 3];
var handler292 = {
get(target, prop) {
if (prop === 'reduce') {
return function(callback, initialValue) {
var result = initialValue;
for (var i = 0; i < target.length; i++) {
result = callback(result, target[i], i, target);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy292 = new Proxy(target292, handler292);
var result292 = proxy292.reduce(function(acc, val) {
return acc + val;
}, 0);
assert_equal(result292, 6);
var target293 = [1, 2, 3, 4, 5];
var handler293 = {
get(target, prop) {
if (prop === 'map') {
return function(callback) {
var result = new Array(target.length);
for (var i = 0; i < target.length; i++) {
result[i] = callback(target[i], i, target);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy293 = new Proxy(target293, handler293);
var mapped293 = proxy293.map(function(x, i) {
return x * i;
});
assert_equal(mapped293[0], 0);
assert_equal(mapped293[1], 2);
assert_equal(mapped293[4], 20);
var target294 = [1, 2, 3, 4, 5];
var handler294 = {
get(target, prop) {
if (prop === 'filter') {
return function(predicate) {
var result = [];
for (var i = 0; i < target.length; i++) {
if (predicate(target[i], i, target)) {
result.push(target[i]);
}
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy294 = new Proxy(target294, handler294);
var filtered294 = proxy294.filter(function(x, i) {
return i % 2 === 0;
});
assert_equal(filtered294.length, 3);
assert_equal(filtered294[0], 1);
assert_equal(filtered294[1], 3);
assert_equal(filtered294[2], 5);
var target295 = new Int32Array([10, 20, 30]);
var handler295 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy295 = new Proxy(target295, handler295);
assert_equal(proxy295[0], 10);
assert_equal(proxy295[2], 30);
var target296 = new Float32Array([1.1, 2.2, 3.3]);
var handler296 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy296 = new Proxy(target296, handler296);
assert_true(Math.abs(proxy296[0] - 1.1) < 0.01);
assert_true(Math.abs(proxy296[2] - 3.3) < 0.01);
var target297 = new Uint8ClampedArray([0, 128, 255]);
var handler297 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy297 = new Proxy(target297, handler297);
assert_equal(proxy297[0], 0);
assert_equal(proxy297[1], 128);
assert_equal(proxy297[2], 255);
var target298 = new ArrayBuffer(8);
var handler298 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy298 = new Proxy(target298, handler298);
assert_equal(proxy298.byteLength, 8);
var target299 = [1, 2, 3];
var handler299 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy299 = new Proxy(target299, handler299);
assert_equal(proxy299.toString(), '1,2,3');
assert_equal(proxy299.valueOf().valueOf(), 1);
var t500 = [1, 2, 3, 4, 5];
var h500 = { get(t, p) { return Reflect.get(t, p); } };
var p500 = new Proxy(t500, h500);
assert_equal(p500[0], 1);
assert_equal(p500[4], 5);
var t501 = new Uint8Array([1, 2, 3]);
var h501 = { get(t, p) { return Reflect.get(t, p); } };
var p501 = new Proxy(t501, h501);
assert_equal(p501[0], 1);
var t502 = new Int16Array([10, 20]);
var h502 = { get(t, p) { return Reflect.get(t, p); } };
var p502 = new Proxy(t502, h502);
assert_equal(p502[0], 10);
var t503 = new Int32Array([100, 200]);
var h503 = { get(t, p) { return Reflect.get(t, p); } };
var p503 = new Proxy(t503, h503);
assert_equal(p503[0], 100);
var t504 = new Float64Array([1.5, 2.5]);
var h504 = { get(t, p) { return Reflect.get(t, p); } };
var p504 = new Proxy(t504, h504);
assert_equal(p504[0], 1.5);
var t505 = [1, 2, 3, 4, 5];
var h505 = { set(t, p, v) { return Reflect.set(t, p, v); } };
var p505 = new Proxy(t505, h505);
p505[0] = 10;
assert_equal(p505[0], 10);
var t506 = [1, 2, 3];
var h506 = { has(t, p) { return Reflect.has(t, p); } };
var p506 = new Proxy(t506, h506);
assert_true(0 in p506);
assert_true(!(100 in p506));
var t507 = [1, 2, 3];
var h507 = { deleteProperty(t, p) { return Reflect.deleteProperty(t, p); } };
var p507 = new Proxy(t507, h507);
delete p507[0];
assert_equal(p507[0], undefined);
var t508 = [1, 2, 3];
var h508 = { ownKeys(t) { return Reflect.ownKeys(t); } };
var p508 = new Proxy(t508, h508);
var keys508 = Object.keys(p508);
assert_equal(keys508.length, 3);
var t509 = [1, 2, 3];
var h509 = { getOwnPropertyDescriptor(t, p) { return Reflect.getOwnPropertyDescriptor(t, p); } };
var p509 = new Proxy(t509, h509);
var desc509 = Object.getOwnPropertyDescriptor(p509, 0);
assert_equal(desc509.value, 1);
var t510 = [1, 2, 3];
var h510 = { defineProperty(t, p, d) { return Reflect.defineProperty(t, p, d); } };
var p510 = new Proxy(t510, h510);
Object.defineProperty(p510, 3, { value: 4, writable: true });
assert_equal(p510[3], 4);
var t511 = [1, 2, 3];
var h511 = { isExtensible(t) { return Reflect.isExtensible(t); } };
var p511 = new Proxy(t511, h511);
assert_true(Object.isExtensible(p511));
var t512 = [1, 2, 3];
var h512 = { preventExtensions(t) { return Reflect.preventExtensions(t); } };
var p512 = new Proxy(t512, h512);
Object.preventExtensions(p512);
assert_true(!Object.isExtensible(p512));
var t513 = [1, 2, 3];
var h513 = { getPrototypeOf(t) { return Reflect.getPrototypeOf(t); } };
var p513 = new Proxy(t513, h513);
assert_equal(Object.getPrototypeOf(p513), Array.prototype);
var t514 = [1, 2, 3];
var h514 = { setPrototypeOf(t, p) { return Reflect.setPrototypeOf(t, p); } };
var p514 = new Proxy(t514, h514);
Object.setPrototypeOf(p514, { test: true });
assert_equal(Object.getPrototypeOf(p514).test, true);
var t515 = [1, 2, 3, 4, 5];
var h515 = {
get(t, p) {
if (p === 'push') {
return function(...args) { return Array.prototype.push.apply(t, args); };
}
return Reflect.get(t, p);
}
};
var p515 = new Proxy(t515, h515);
assert_equal(p515.push(6), 6);
assert_equal(p515.length, 6);
var t516 = [1, 2, 3, 4, 5];
var h516 = {
get(t, p) {
if (p === 'pop') {
return function() { return Array.prototype.pop.call(t); };
}
return Reflect.get(t, p);
}
};
var p516 = new Proxy(t516, h516);
assert_equal(p516.pop(), 5);
assert_equal(p516.length, 4);
var t517 = [1, 2, 3, 4, 5];
var h517 = {
get(t, p) {
if (p === 'shift') {
return function() { return Array.prototype.shift.call(t); };
}
return Reflect.get(t, p);
}
};
var p517 = new Proxy(t517, h517);
assert_equal(p517.shift(), 1);
assert_equal(p517.length, 4);
var t518 = [3, 4, 5];
var h518 = {
get(t, p) {
if (p === 'unshift') {
return function(...args) { return Array.prototype.unshift.apply(t, args); };
}
return Reflect.get(t, p);
}
};
var p518 = new Proxy(t518, h518);
assert_equal(p518.unshift(1, 2), 5);
assert_equal(p518[0], 1);
var t519 = [1, 2, 3, 4, 5];
var h519 = {
get(t, p) {
if (p === 'splice') {
return function(s, d, ...i) { return Array.prototype.splice.call(t, s, d, ...i); };
}
return Reflect.get(t, p);
}
};
var p519 = new Proxy(t519, h519);
var r519 = p519.splice(1, 2, 20, 30);
assert_equal(r519.length, 2);
assert_equal(p519[1], 20);
var t520 = [1, 2, 3];
var h520 = {
get(t, p) {
if (p === 'concat') {
return function(...args) { return Array.prototype.concat.apply(t, args); };
}
return Reflect.get(t, p);
}
};
var p520 = new Proxy(t520, h520);
var r520 = p520.concat([4, 5], 6);
assert_equal(r520.length, 6);
var t521 = [1, 2, 3, 4, 5];
var h521 = {
get(t, p) {
if (p === 'slice') {
return function(s, e) { return Array.prototype.slice.call(t, s, e); };
}
return Reflect.get(t, p);
}
};
var p521 = new Proxy(t521, h521);
var r521 = p521.slice(1, 3);
assert_equal(r521.length, 2);
var t522 = [1, 2, 3, 4, 5];
var h522 = {
get(t, p) {
if (p === 'indexOf') {
return function(s, f) { return Array.prototype.indexOf.call(t, s, f); };
}
return Reflect.get(t, p);
}
};
var p522 = new Proxy(t522, h522);
assert_equal(p522.indexOf(3), 2);
var t523 = [1, 2, 3, 4, 5];
var h523 = {
get(t, p) {
if (p === 'includes') {
return function(s, f) { return Array.prototype.includes.call(t, s, f); };
}
return Reflect.get(t, p);
}
};
var p523 = new Proxy(t523, h523);
assert_true(p523.includes(3));
var t524 = [1, 2, 3, 4, 5];
var h524 = {
get(t, p) {
if (p === 'find') {
return function(pred, th) { return Array.prototype.find.call(t, pred, th); };
}
return Reflect.get(t, p);
}
};
var p524 = new Proxy(t524, h524);
assert_equal(p524.find(x => x > 3), 4);
var t525 = [1, 2, 3, 4, 5];
var h525 = {
get(t, p) {
if (p === 'findIndex') {
return function(pred, th) { return Array.prototype.findIndex.call(t, pred, th); };
}
return Reflect.get(t, p);
}
};
var p525 = new Proxy(t525, h525);
assert_equal(p525.findIndex(x => x > 3), 3);
var t526 = [1, 2, 3, 4, 5];
var h526 = {
get(t, p) {
if (p === 'filter') {
return function(pred, th) { return Array.prototype.filter.call(t, pred, th); };
}
return Reflect.get(t, p);
}
};
var p526 = new Proxy(t526, h526);
var r526 = p526.filter(x => x > 2);
assert_equal(r526.length, 3);
var t527 = [1, 2, 3, 4, 5];
var h527 = {
get(t, p) {
if (p === 'map') {
return function(cb, th) { return Array.prototype.map.call(t, cb, th); };
}
return Reflect.get(t, p);
}
};
var p527 = new Proxy(t527, h527);
var r527 = p527.map(x => x * 2);
assert_equal(r527[0], 2);
var t528 = [1, 2, 3, 4, 5];
var h528 = {
get(t, p) {
if (p === 'reduce') {
return function(cb, init) { return Array.prototype.reduce.call(t, cb, init); };
}
return Reflect.get(t, p);
}
};
var p528 = new Proxy(t528, h528);
assert_equal(p528.reduce((a, b) => a + b, 0), 15);
var t529 = [1, 2, 3, 4, 5];
var h529 = {
get(t, p) {
if (p === 'reduceRight') {
return function(cb, init) { return Array.prototype.reduceRight.call(t, cb, init); };
}
return Reflect.get(t, p);
}
};
var p529 = new Proxy(t529, h529);
assert_equal(p529.reduceRight((a, b) => a - b, 0), -15);
var t530 = [1, 2, 3, 4, 5];
var h530 = {
get(t, p) {
if (p === 'every') {
return function(pred, th) { return Array.prototype.every.call(t, pred, th); };
}
return Reflect.get(t, p);
}
};
var p530 = new Proxy(t530, h530);
assert_true(p530.every(x => x > 0));
var t531 = [1, 2, 3, 4, 5];
var h531 = {
get(t, p) {
if (p === 'some') {
return function(pred, th) { return Array.prototype.some.call(t, pred, th); };
}
return Reflect.get(t, p);
}
};
var p531 = new Proxy(t531, h531);
assert_true(p531.some(x => x > 3));
var t532 = [1, 2, 3];
var h532 = {
get(t, p) {
if (p === 'forEach') {
return function(cb, th) { return Array.prototype.forEach.call(t, cb, th); };
}
return Reflect.get(t, p);
}
};
var p532 = new Proxy(t532, h532);
var sum532 = 0;
p532.forEach(x => { sum532 += x; });
assert_equal(sum532, 6);
var t533 = [5, 2, 8, 1, 9];
var h533 = {
get(t, p) {
if (p === 'sort') {
return function(cmp) { return Array.prototype.sort.call(t, cmp); };
}
return Reflect.get(t, p);
}
};
var p533 = new Proxy(t533, h533);
var s533 = p533.sort((a, b) => a - b);
assert_equal(s533[0], 1);
var t534 = [1, 2, 3, 4, 5];
var h534 = {
get(t, p) {
if (p === 'reverse') {
return function() { return Array.prototype.reverse.call(t); };
}
return Reflect.get(t, p);
}
};
var p534 = new Proxy(t534, h534);
var r534 = p534.reverse();
assert_equal(r534[0], 5);
var t535 = [1, 2, 3, 4, 5];
var h535 = {
get(t, p) {
if (p === 'join') {
return function(sep) { return Array.prototype.join.call(t, sep); };
}
return Reflect.get(t, p);
}
};
var p535 = new Proxy(t535, h535);
assert_equal(p535.join(), '1,2,3,4,5');
var t536 = [1, 2, 3, 4, 5];
var h536 = {
get(t, p) {
if (p === 'toString') {
return function() { return Array.prototype.toString.call(t); };
}
return Reflect.get(t, p);
}
};
var p536 = new Proxy(t536, h536);
assert_equal(p536.toString(), '1,2,3,4,5');
var t537 = [1, 2, 3, 4, 5];
var h537 = {
get(t, p) {
if (p === 'fill') {
return function(v, s, e) { return Array.prototype.fill.call(t, v, s, e); };
}
return Reflect.get(t, p);
}
};
var p537 = new Proxy(t537, h537);
p537.fill(0, 1, 3);
assert_equal(p537[0], 1);
assert_equal(p537[1], 0);
var t538 = [1, 2, 3, 4, 5];
var h538 = {
get(t, p) {
if (p === 'copyWithin') {
return function(t2, s, e) { return Array.prototype.copyWithin.call(t, t2, s, e); };
}
return Reflect.get(t, p);
}
};
var p538 = new Proxy(t538, h538);
p538.copyWithin(0, 2, 4);
assert_equal(p538[0], 3);
var t539 = ['a', 'b', 'c'];
var h539 = {
get(t, p) {
if (p === 'entries') {
return function() { return Array.prototype.entries.call(t); };
}
return Reflect.get(t, p);
}
};
var p539 = new Proxy(t539, h539);
var e539 = p539.entries();
assert_equal(e539.next().value[0], 0);
var t540 = ['a', 'b', 'c'];
var h540 = {
get(t, p) {
if (p === 'keys') {
return function() { return Array.prototype.keys.call(t); };
}
return Reflect.get(t, p);
}
};
var p540 = new Proxy(t540, h540);
var k540 = p540.keys();
assert_equal(k540.next().value, 0);
var t541 = ['a', 'b', 'c'];
var h541 = {
get(t, p) {
if (p === 'values') {
return function() { return Array.prototype.values.call(t); };
}
return Reflect.get(t, p);
}
};
var p541 = new Proxy(t541, h541);
var v541 = p541.values();
assert_equal(v541.next().value, 'a');
var t542 = [1, [2, [3, [4]]]];
var h542 = {
get(t, p) {
if (p === 'flat') {
return function(d) { return Array.prototype.flat.call(t, d); };
}
return Reflect.get(t, p);
}
};
var p542 = new Proxy(t542, h542);
var f542 = p542.flat(2);
assert_equal(f542[2], 3);
var t543 = [1, 2, 3];
var h543 = {
get(t, p) {
if (p === 'flatMap') {
return function(cb, th) { return Array.prototype.flatMap.call(t, cb, th); };
}
return Reflect.get(t, p);
}
};
var p543 = new Proxy(t543, h543);
var fm543 = p543.flatMap(x => [x, x * 2]);
assert_equal(fm543.length, 6);
var t544 = [1, 2, 3, 4, 5];
var h544 = {
get(t, p) {
if (p === 'at') {
return function(i) { return Array.prototype.at.call(t, i); };
}
return Reflect.get(t, p);
}
};
var p544 = new Proxy(t544, h544);
assert_equal(p544.at(0), 1);
assert_equal(p544.at(-1), 5);
var t545 = [5, 2, 8, 1, 9];
var h545 = {
get(t, p) {
if (p === 'toSorted') {
return function(cmp) { return Array.prototype.toSorted.call(t, cmp); };
}
return Reflect.get(t, p);
}
};
var p545 = new Proxy(t545, h545);
var ts545 = p545.toSorted((a, b) => a - b);
assert_equal(ts545[0], 1);
assert_equal(t545[0], 5);
var t546 = [1, 2, 3, 4, 5];
var h546 = {
get(t, p) {
if (p === 'toReversed') {
return function() { return Array.prototype.toReversed.call(t); };
}
return Reflect.get(t, p);
}
};
var p546 = new Proxy(t546, h546);
var tr546 = p546.toReversed();
assert_equal(tr546[0], 5);
assert_equal(t546[0], 1);
var t547 = [1, 2, 3, 4, 5];
var h547 = {
get(t, p) {
if (p === 'with') {
return function(i, v) { return Array.prototype.with.call(t, i, v); };
}
return Reflect.get(t, p);
}
};
var p547 = new Proxy(t547, h547);
var w547 = p547.with(2, 10);
assert_equal(w547[2], 10);
assert_equal(t547[2], 3);
var tr1 = [1, 2, 3, 4, 5];
var hr1 = {
get(t, p) {
if (typeof t[p] === 'function') {
return function(...args) {
return Reflect.apply(t[p], t, args);
};
}
return Reflect.get(t, p);
}
};
var pr1 = new Proxy(tr1, hr1);
var r1 = pr1.filter(x => x > 2).map(x => x * 2);
assert_equal(r1[0], 6);
var tr2 = [[1, 2], [3, 4], [5, 6]];
var hr2 = { get(t, p) { return Reflect.get(t, p); } };
var pr2 = new Proxy(tr2, hr2);
assert_equal(pr2[0][0], 1);
assert_equal(pr2[1][1], 4);
var tr3 = new Array(10);
tr3[0] = 1;
tr3[5] = 6;
tr3[9] = 10;
var hr3 = { get(t, p) { return Reflect.get(t, p); } };
var pr3 = new Proxy(tr3, hr3);
assert_equal(pr3[0], 1);
assert_equal(pr3[1], undefined);
assert_equal(pr3[5], 6);
var tr4 = [1, 2, 3];
var hr4 = { get(t, p) { return Reflect.get(t, p); } };
var pr4 = new Proxy(tr4, hr4);
var copy4 = JSON.parse(JSON.stringify(pr4));
assert_equal(copy4[0], 1);
var tr5 = new Int8Array([1, 2, 3, 4, 5]);
var hr5 = { get(t, p) { return Reflect.get(t, p); } };
var pr5 = new Proxy(tr5, hr5);
assert_equal(pr5[0], 1);
var tr6 = new Uint8Array([1, 2, 3]);
var hr6 = { get(t, p) { return Reflect.get(t, p); } };
var pr6 = new Proxy(tr6, hr6);
assert_equal(pr6[0], 1);
var tr7 = new Int16Array([100, 200, 300]);
var hr7 = { get(t, p) { return Reflect.get(t, p); } };
var pr7 = new Proxy(tr7, hr7);
assert_equal(pr7[0], 100);
var tr8 = new Float32Array([1.5, 2.5, 3.5]);
var hr8 = { get(t, p) { return Reflect.get(t, p); } };
var pr8 = new Proxy(tr8, hr8);
assert_equal(pr8[0], 1.5);
var tr9 = new Float64Array([1.1, 2.2]);
var hr9 = { get(t, p) { return Reflect.get(t, p); } };
var pr9 = new Proxy(tr9, hr9);
assert_true(pr9[0] > 1.1);
var tr10 = new Int8Array(5);
var hr10 = {
get(t, p) {
if (p === 'set') {
return function(s, o) { return t.set(s, o); };
}
return Reflect.get(t, p);
}
};
var pr10 = new Proxy(tr10, hr10);
pr10.set([1, 2, 3], 0);
assert_equal(pr10[0], 1);
var tr11 = new Int8Array([1, 2, 3, 4, 5]);
var hr11 = {
get(t, p) {
if (p === 'subarray') {
return function(s, e) { return t.subarray(s, e); };
}
return Reflect.get(t, p);
}
};
var pr11 = new Proxy(tr11, hr11);
var sub11 = pr11.subarray(1, 3);
assert_equal(sub11.length, 2);
var tr12 = new Int8Array([1, 2, 3, 4, 5]);
var hr12 = {
get(t, p) {
if (p === 'copyWithin') {
return function(t2, s, e) { return t.copyWithin(t2, s, e); };
}
return Reflect.get(t, p);
}
};
var pr12 = new Proxy(tr12, hr12);
pr12.copyWithin(0, 2, 4);
assert_equal(pr12[0], 3);
var tr13 = new Int8Array(5);
var hr13 = {
get(t, p) {
if (p === 'fill') {
return function(v, s, e) { return t.fill(v, s, e); };
}
return Reflect.get(t, p);
}
};
var pr13 = new Proxy(tr13, hr13);
pr13.fill(7, 1, 4);
assert_equal(pr13[1], 7);
var tr14 = { 0: 'a', 1: 'b', 2: 'c', length: 3 };
var hr14 = { get(t, p) { return Reflect.get(t, p); } };
var pr14 = new Proxy(tr14, hr14);
assert_equal(pr14[0], 'a');
var tr15 = new ArrayBuffer(16);
var hr15 = { get(t, p) { return Reflect.get(t, p); } };
var pr15 = new Proxy(tr15, hr15);
assert_equal(pr15.byteLength, 16);
var buf16 = new ArrayBuffer(8);
var tr16 = new DataView(buf16);
var hr16 = { get(t, p) { return Reflect.get(t, p); } };
var pr16 = new Proxy(tr16, hr16);
assert_equal(pr16.byteLength, 8);
pr16.setInt8(0, 100);
assert_equal(pr16.getInt8(0), 100);
var tr17 = new Int8Array([1, 2, 3, 4, 5]);
var hr17 = {
get(t, p) {
if (p === 'map') {
return function(cb) {
var r = new Int8Array(t.length);
for (var i = 0; i < t.length; i++) {
r[i] = cb(t[i], i, t);
}
return r;
};
}
return Reflect.get(t, p);
}
};
var pr17 = new Proxy(tr17, hr17);
var m17 = pr17.map(x => x * 2);
assert_equal(m17[0], 2);
var tr18 = new Int8Array([1, 2, 3, 4, 5, 6]);
var hr18 = {
get(t, p) {
if (p === 'filter') {
return function(pred) {
var r = [];
for (var i = 0; i < t.length; i++) {
if (pred(t[i], i, t)) r.push(t[i]);
}
return r;
};
}
return Reflect.get(t, p);
}
};
var pr18 = new Proxy(tr18, hr18);
var f18 = pr18.filter(x => x > 3);
assert_equal(f18.length, 3);
var tr19 = new Int8Array([1, 2, 3, 4, 5]);
var hr19 = {
get(t, p) {
if (p === 'reduce') {
return function(cb, init) {
var r = init;
for (var i = 0; i < t.length; i++) {
r = cb(r, t[i], i, t);
}
return r;
};
}
return Reflect.get(t, p);
}
};
var pr19 = new Proxy(tr19, hr19);
assert_equal(pr19.reduce((a, b) => a + b, 0), 15);
var tr20 = [new Int8Array([1, 2]), new Int8Array([3, 4])];
var hr20 = { get(t, p) { return Reflect.get(t, p); } };
var pr20 = new Proxy(tr20, hr20);
assert_equal(pr20[0][0], 1);
var tr21 = new Int8Array([1, 2, 3]);
var hr21 = {
get(t, p) {
if (p === Symbol.iterator) {
return function() { return t[Symbol.iterator](); };
}
return Reflect.get(t, p);
}
};
var pr21 = new Proxy(tr21, hr21);
var a21 = [...pr21];
assert_equal(a21.length, 3);
var tr22 = new Int8Array([10, 20, 30, 40, 50]);
var hr22 = {
get(t, p) {
if (p === 'at') {
return function(i) { return t.at(i); };
}
return Reflect.get(t, p);
}
};
var pr22 = new Proxy(tr22, hr22);
assert_equal(pr22.at(0), 10);
assert_equal(pr22.at(-1), 50);
var tr23 = new Int8Array([1, 2, 3, 4, 5]);
var hr23 = {
get(t, p) {
if (p === 'find') {
return function(pred) { return t.find(pred); };
}
return Reflect.get(t, p);
}
};
var pr23 = new Proxy(tr23, hr23);
assert_equal(pr23.find(x => x > 3), 4);
var tr24 = new Int8Array([1, 2, 3, 4, 5]);
var hr24 = {
get(t, p) {
if (p === 'findIndex') {
return function(pred) { return t.findIndex(pred); };
}
return Reflect.get(t, p);
}
};
var pr24 = new Proxy(tr24, hr24);
assert_equal(pr24.findIndex(x => x > 3), 3);
var tr25 = new Int8Array([1, 2, 3, 4, 5]);
var hr25 = {
get(t, p) {
if (p === 'includes') {
return function(s) { return t.includes(s); };
}
return Reflect.get(t, p);
}
};
var pr25 = new Proxy(tr25, hr25);
assert_true(pr25.includes(3));
var tr26 = new Int8Array([1, 2, 3, 4, 5]);
var hr26 = {
get(t, p) {
if (p === 'indexOf') {
return function(s) { return t.indexOf(s); };
}
return Reflect.get(t, p);
}
};
var pr26 = new Proxy(tr26, hr26);
assert_equal(pr26.indexOf(3), 2);
var tr27 = new Int8Array([1, 2, 3, 4, 5]);
var hr27 = {
get(t, p) {
if (p === 'every') {
return function(pred) { return t.every(pred); };
}
return Reflect.get(t, p);
}
};
var pr27 = new Proxy(tr27, hr27);
assert_true(pr27.every(x => x > 0));
var tr28 = new Int8Array([1, 2, 3, 4, 5]);
var hr28 = {
get(t, p) {
if (p === 'some') {
return function(pred) { return t.some(pred); };
}
return Reflect.get(t, p);
}
};
var pr28 = new Proxy(tr28, hr28);
assert_true(pr28.some(x => x > 3));
var tr29 = new Int8Array([1, 2, 3]);
var hr29 = {
get(t, p) {
if (p === 'forEach') {
return function(cb) { t.forEach(cb); };
}
return Reflect.get(t, p);
}
};
var pr29 = new Proxy(tr29, hr29);
var sum29 = 0;
pr29.forEach(x => { sum29 += x; });
assert_equal(sum29, 6);
var tr30 = new Int8Array([5, 2, 8, 1, 9]);
var hr30 = {
get(t, p) {
if (p === 'sort') {
return function(cmp) { return t.sort(cmp); };
}
return Reflect.get(t, p);
}
};
var pr30 = new Proxy(tr30, hr30);
var s30 = pr30.sort((a, b) => a - b);
assert_equal(s30[0], 1);
var tr31 = new Int8Array([1, 2, 3, 4, 5]);
var hr31 = {
get(t, p) {
if (p === 'reverse') {
return function() { return t.reverse(); };
}
return Reflect.get(t, p);
}
};
var pr31 = new Proxy(tr31, hr31);
var r31 = pr31.reverse();
assert_equal(r31[0], 5);
var tr32 = new Int8Array([1, 2, 3]);
var hr32 = {
get(t, p) {
if (p === 'toString') {
return function() { return t.toString(); };
}
return Reflect.get(t, p);
}
};
var pr32 = new Proxy(tr32, hr32);
assert_equal(pr32.toString(), '1,2,3');
var tr33 = [1, , 3, , 5];
tr33[10] = 11;
var hr33 = { get(t, p) { return Reflect.get(t, p); } };
var pr33 = new Proxy(tr33, hr33);
assert_equal(pr33[0], 1);
assert_equal(pr33[10], 11);
var tr34 = [1, 2, 3];
var hr34 = { get(t, p) { return Reflect.get(t, p); } };
var pr34 = new Proxy(tr34, hr34);
assert_true(typeof pr34.push === 'function');
var tr35 = Int8Array;
var hr35 = { construct(t, a) { return Reflect.construct(t, a); } };
var PrInt8Array = new Proxy(tr35, hr35);
var a35 = new PrInt8Array([1, 2, 3]);
assert_equal(a35.length, 3);
var tr36 = new BigInt64Array([BigInt(1), BigInt(2), BigInt(3)]);
var hr36 = { get(t, p) { return Reflect.get(t, p); } };
var pr36 = new Proxy(tr36, hr36);
assert_equal(pr36[0], BigInt(1));
var tr37 = new Uint16Array([100, 200, 300]);
var hr37 = { get(t, p) { return Reflect.get(t, p); } };
var pr37 = new Proxy(tr37, hr37);
assert_equal(pr37[0], 100);
var tr38 = new Uint32Array([1000, 2000, 3000]);
var hr38 = { get(t, p) { return Reflect.get(t, p); } };
var pr38 = new Proxy(tr38, hr38);
assert_equal(pr38[0], 1000);
var tr39 = new Int32Array([-100, 0, 100]);
var hr39 = { get(t, p) { return Reflect.get(t, p); } };
var pr39 = new Proxy(tr39, hr39);
assert_equal(pr39[0], -100);
var tr40 = new BigInt64Array([BigInt(-999), BigInt(0), BigInt(999)]);
var hr40 = { get(t, p) { return Reflect.get(t, p); } };
var pr40 = new Proxy(tr40, hr40);
assert_equal(pr40[0], BigInt(-999));
var tr41 = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]];
var hr41 = { get(t, p) { return Reflect.get(t, p); } };
var pr41 = new Proxy(tr41, hr41);
assert_equal(pr41[0][0][0], 1);
var tr42 = [1, 'string', true, null, undefined, { a: 1 }];
var hr42 = { get(t, p) { return Reflect.get(t, p); } };
var pr42 = new Proxy(tr42, hr42);
assert_equal(pr42[0], 1);
assert_equal(pr42[1], 'string');
assert_equal(pr42[5].a, 1);
var tr43 = [1, 2, 3];
var hr43 = { get(t, p) { return Reflect.get(t, p); } };
var pr43 = new Proxy(tr43, hr43);
var json43 = JSON.stringify(pr43);
assert_equal(json43, '[1,2,3]');
var tr44 = [1, 2, 3];
var hr44 = { get(t, p) { return Reflect.get(t, p); } };
var pr44 = new Proxy(tr44, hr44);
var [a44, b44, c44] = pr44;
assert_equal(a44, 1);
var tr45 = [1, 2, 3];
var hr45 = { get(t, p) { return Reflect.get(t, p); } };
var pr45 = new Proxy(tr45, hr45);
var a45 = [...pr45];
assert_equal(a45.length, 3);
var tr46 = [1, 2, 3];
var hr46 = { get(t, p) { return Reflect.get(t, p); } };
var pr46 = new Proxy(tr46, hr46);
var sum46 = 0;
for (var item46 of pr46) { sum46 += item46; }
assert_equal(sum46, 6);
var tr47 = [1, 2, 3];
var hr47 = { get(t, p) { return Reflect.get(t, p); } };
var pr47 = new Proxy(tr47, hr47);
assert_true(Array.isArray(pr47));
var tr48 = [1, 2, 3];
var hr48 = { get(t, p) { return Reflect.get(t, p); } };
var pr48 = new Proxy(tr48, hr48);
var keys48 = Object.keys(pr48);
assert_equal(keys48.length, 3);
var tr49 = [1, 2, 3];
var hr49 = { get(t, p) { return Reflect.get(t, p); } };
var pr49 = new Proxy(tr49, hr49);
var vals49 = Object.values(pr49);
assert_equal(vals49[0], 1);
var tr50 = [1, 2, 3];
var hr50 = { get(t, p) { return Reflect.get(t, p); } };
var pr50 = new Proxy(tr50, hr50);
assert_true(pr50 instanceof Array);
var t100 = [1, 2, 3, 4, 5];
var h100 = {
get(t, p) { return Reflect.get(t, p); },
set(t, p, v) { return Reflect.set(t, p, v); },
has(t, p) { return Reflect.has(t, p); },
deleteProperty(t, p) { return Reflect.deleteProperty(t, p); }
};
var p100 = new Proxy(t100, h100);
assert_true(0 in p100);
p100[0] = 10;
assert_equal(p100[0], 10);
delete p100[1];
assert_equal(p100[1], undefined);
var t101 = [1, 2, 3];
var h101 = {
get(t, p) {
if (p === 'map') {
return function(cb) { return Reflect.apply(Array.prototype.map, t, [cb]); };
}
return Reflect.get(t, p);
}
};
var p101 = new Proxy(t101, h101);
var m101 = p101.map(x => x * 2);
assert_equal(m101[0], 2);
var t102 = [1, 2, 3, 4, 5];
var h102 = {
get(t, p) {
if (p === 'reduce') {
return function(cb, init) { return Reflect.apply(Array.prototype.reduce, t, [cb, init]); };
}
return Reflect.get(t, p);
}
};
var p102 = new Proxy(t102, h102);
assert_equal(p102.reduce((a, b) => a + b, 0), 15);
var t103 = [1, 2, 3];
var h103 = {
get(t, p) {
if (p === 'filter') {
return function(cb) { return Reflect.apply(Array.prototype.filter, t, [cb]); };
}
return Reflect.get(t, p);
}
};
var p103 = new Proxy(t103, h103);
var f103 = p103.filter(x => x > 1);
assert_equal(f103.length, 2);
var t104 = [1, 2, 3];
var h104 = {
get(t, p) {
if (p === 'forEach') {
return function(cb) { return Reflect.apply(Array.prototype.forEach, t, [cb]); };
}
return Reflect.get(t, p);
}
};
var p104 = new Proxy(t104, h104);
var sum104 = 0;
p104.forEach(x => { sum104 += x; });
assert_equal(sum104, 6);
var t105 = [5, 2, 8, 1, 9];
var h105 = {
get(t, p) {
if (p === 'sort') {
return function(cb) { return Reflect.apply(Array.prototype.sort, t, [cb]); };
}
return Reflect.get(t, p);
}
};
var p105 = new Proxy(t105, h105);
var s105 = p105.sort((a, b) => a - b);
assert_equal(s105[0], 1);
var t106 = [1, 2, 3, 4, 5];
var h106 = {
get(t, p) {
if (p === 'find') {
return function(cb) { return Reflect.apply(Array.prototype.find, t, [cb]); };
}
return Reflect.get(t, p);
}
};
var p106 = new Proxy(t106, h106);
assert_equal(p106.find(x => x > 3), 4);
var t107 = [1, 2, 3, 4, 5];
var h107 = {
get(t, p) {
if (p === 'findIndex') {
return function(cb) { return Reflect.apply(Array.prototype.findIndex, t, [cb]); };
}
return Reflect.get(t, p);
}
};
var p107 = new Proxy(t107, h107);
assert_equal(p107.findIndex(x => x > 3), 3);
var t108 = [1, 2, 3, 4, 5];
var h108 = {
get(t, p) {
if (p === 'includes') {
return function(v) { return Reflect.apply(Array.prototype.includes, t, [v]); };
}
return Reflect.get(t, p);
}
};
var p108 = new Proxy(t108, h108);
assert_true(p108.includes(3));
var t109 = [1, 2, 3, 4, 5];
var h109 = {
get(t, p) {
if (p === 'indexOf') {
return function(v) { return Reflect.apply(Array.prototype.indexOf, t, [v]); };
}
return Reflect.get(t, p);
}
};
var p109 = new Proxy(t109, h109);
assert_equal(p109.indexOf(3), 2);
var t110 = [1, 2, 3, 4, 5];
var h110 = {
get(t, p) {
if (p === 'every') {
return function(cb) { return Reflect.apply(Array.prototype.every, t, [cb]); };
}
return Reflect.get(t, p);
}
};
var p110 = new Proxy(t110, h110);
assert_true(p110.every(x => x > 0));
var t111 = [1, 2, 3, 4, 5];
var h111 = {
get(t, p) {
if (p === 'some') {
return function(cb) { return Reflect.apply(Array.prototype.some, t, [cb]); };
}
return Reflect.get(t, p);
}
};
var p111 = new Proxy(t111, h111);
assert_true(p111.some(x => x > 3));
var t112 = [1, 2, 3, 4, 5];
var h112 = {
get(t, p) {
if (p === 'slice') {
return function(s, e) { return Reflect.apply(Array.prototype.slice, t, [s, e]); };
}
return Reflect.get(t, p);
}
};
var p112 = new Proxy(t112, h112);
var sl112 = p112.slice(1, 3);
assert_equal(sl112.length, 2);
var t113 = [1, 2, 3];
var h113 = {
get(t, p) {
if (p === 'concat') {
return function(...args) { return Reflect.apply(Array.prototype.concat, t, args); };
}
return Reflect.get(t, p);
}
};
var p113 = new Proxy(t113, h113);
var c113 = p113.concat([4, 5]);
assert_equal(c113.length, 5);
var t114 = [1, 2, 3, 4, 5];
var h114 = {
get(t, p) {
if (p === 'splice') {
return function(s, d, ...i) { return Reflect.apply(Array.prototype.splice, t, [s, d, ...i]); };
}
return Reflect.get(t, p);
}
};
var p114 = new Proxy(t114, h114);
var sp114 = p114.splice(1, 1, 20);
assert_equal(p114[1], 20);
var t115 = [1, 2, 3, 4, 5];
var h115 = {
get(t, p) {
if (p === 'reverse') {
return function() { return Reflect.apply(Array.prototype.reverse, t, []); };
}
return Reflect.get(t, p);
}
};
var p115 = new Proxy(t115, h115);
var r115 = p115.reverse();
assert_equal(r115[0], 5);
var t116 = [1, 2, 3, 4, 5];
var h116 = {
get(t, p) {
if (p === 'join') {
return function(s) { return Reflect.apply(Array.prototype.join, t, [s]); };
}
return Reflect.get(t, p);
}
};
var p116 = new Proxy(t116, h116);
assert_equal(p116.join('-'), '1-2-3-4-5');
var t117 = [1, 2, 3, 4, 5];
var h117 = {
get(t, p) {
if (p === 'toString') {
return function() { return Reflect.apply(Array.prototype.toString, t, []); };
}
return Reflect.get(t, p);
}
};
var p117 = new Proxy(t117, h117);
assert_equal(p117.toString(), '1,2,3,4,5');
var t118 = [1, 2, 3, 4, 5];
var h118 = {
get(t, p) {
if (p === 'fill') {
return function(v, s, e) { return Reflect.apply(Array.prototype.fill, t, [v, s, e]); };
}
return Reflect.get(t, p);
}
};
var p118 = new Proxy(t118, h118);
p118.fill(0, 1, 3);
assert_equal(p118[1], 0);
var t119 = [1, 2, 3, 4, 5];
var h119 = {
get(t, p) {
if (p === 'copyWithin') {
return function(t2, s, e) { return Reflect.apply(Array.prototype.copyWithin, t, [t2, s, e]); };
}
return Reflect.get(t, p);
}
};
var p119 = new Proxy(t119, h119);
p119.copyWithin(0, 2, 4);
assert_equal(p119[0], 3);
var t120 = [1, 2, 3];
var h120 = {
get(t, p) {
if (p === 'push') {
return function(...args) { return Reflect.apply(Array.prototype.push, t, args); };
}
return Reflect.get(t, p);
}
};
var p120 = new Proxy(t120, h120);
p120.push(4, 5);
assert_equal(p120.length, 5);
var t121 = [1, 2, 3, 4, 5];
var h121 = {
get(t, p) {
if (p === 'pop') {
return function() { return Reflect.apply(Array.prototype.pop, t, []); };
}
return Reflect.get(t, p);
}
};
var p121 = new Proxy(t121, h121);
p121.pop();
assert_equal(p121.length, 4);
var t122 = [1, 2, 3, 4, 5];
var h122 = {
get(t, p) {
if (p === 'shift') {
return function() { return Reflect.apply(Array.prototype.shift, t, []); };
}
return Reflect.get(t, p);
}
};
var p122 = new Proxy(t122, h122);
p122.shift();
assert_equal(p122[0], 2);
var t123 = [2, 3, 4, 5];
var h123 = {
get(t, p) {
if (p === 'unshift') {
return function(...args) { return Reflect.apply(Array.prototype.unshift, t, args); };
}
return Reflect.get(t, p);
}
};
var p123 = new Proxy(t123, h123);
p123.unshift(1);
assert_equal(p123[0], 1);
var t124 = ['a', 'b', 'c'];
var h124 = {
get(t, p) {
if (p === 'entries') {
return function() { return Reflect.apply(Array.prototype.entries, t, []); };
}
return Reflect.get(t, p);
}
};
var p124 = new Proxy(t124, h124);
var e124 = p124.entries();
assert_equal(e124.next().value[0], 0);
var t125 = ['a', 'b', 'c'];
var h125 = {
get(t, p) {
if (p === 'keys') {
return function() { return Reflect.apply(Array.prototype.keys, t, []); };
}
return Reflect.get(t, p);
}
};
var p125 = new Proxy(t125, h125);
var k125 = p125.keys();
assert_equal(k125.next().value, 0);
var t126 = ['a', 'b', 'c'];
var h126 = {
get(t, p) {
if (p === 'values') {
return function() { return Reflect.apply(Array.prototype.values, t, []); };
}
return Reflect.get(t, p);
}
};
var p126 = new Proxy(t126, h126);
var v126 = p126.values();
assert_equal(v126.next().value, 'a');
var t127 = [1, [2, [3]]];
var h127 = {
get(t, p) {
if (p === 'flat') {
return function(d) { return Reflect.apply(Array.prototype.flat, t, [d]); };
}
return Reflect.get(t, p);
}
};
var p127 = new Proxy(t127, h127);
var f127 = p127.flat(2);
assert_equal(f127.length, 3);
var t128 = [1, 2, 3];
var h128 = {
get(t, p) {
if (p === 'flatMap') {
return function(cb) { return Reflect.apply(Array.prototype.flatMap, t, [cb]); };
}
return Reflect.get(t, p);
}
};
var p128 = new Proxy(t128, h128);
var fm128 = p128.flatMap(x => [x, x * 2]);
assert_equal(fm128.length, 6);
var t129 = [1, 2, 3, 4, 5];
var h129 = {
get(t, p) {
if (p === 'at') {
return function(i) { return Reflect.apply(Array.prototype.at, t, [i]); };
}
return Reflect.get(t, p);
}
};
var p129 = new Proxy(t129, h129);
assert_equal(p129.at(-1), 5);
var t130 = [5, 2, 8, 1, 9];
var h130 = {
get(t, p) {
if (p === 'toSorted') {
return function(cb) { return Reflect.apply(Array.prototype.toSorted, t, [cb]); };
}
return Reflect.get(t, p);
}
};
var p130 = new Proxy(t130, h130);
var ts130 = p130.toSorted((a, b) => a - b);
assert_equal(ts130[0], 1);
var t131 = [1, 2, 3, 4, 5];
var h131 = {
get(t, p) {
if (p === 'toReversed') {
return function() { return Reflect.apply(Array.prototype.toReversed, t, []); };
}
return Reflect.get(t, p);
}
};
var p131 = new Proxy(t131, h131);
var tr131 = p131.toReversed();
assert_equal(tr131[0], 5);
var t132 = [1, 2, 3, 4, 5];
var h132 = {
get(t, p) {
if (p === 'with') {
return function(i, v) { return Reflect.apply(Array.prototype.with, t, [i, v]); };
}
return Reflect.get(t, p);
}
};
var p132 = new Proxy(t132, h132);
var w132 = p132.with(2, 10);
assert_equal(w132[2], 10);
var t200 = new Int8Array([1, 2, 3, 4, 5]);
var h200 = { get(t, p) { return Reflect.get(t, p); } };
var p200 = new Proxy(t200, h200);
assert_equal(p200[0], 1);
assert_equal(p200[4], 5);
var t201 = new Uint8Array([1, 2, 3, 4, 5]);
var h201 = { get(t, p) { return Reflect.get(t, p); } };
var p201 = new Proxy(t201, h201);
assert_equal(p201[0], 1);
var t202 = new Int16Array([100, 200, 300]);
var h202 = { get(t, p) { return Reflect.get(t, p); } };
var p202 = new Proxy(t202, h202);
assert_equal(p202[0], 100);
var t203 = new Uint16Array([100, 200, 300]);
var h203 = { get(t, p) { return Reflect.get(t, p); } };
var p203 = new Proxy(t203, h203);
assert_equal(p203[0], 100);
var t204 = new Int32Array([1000, 2000, 3000]);
var h204 = { get(t, p) { return Reflect.get(t, p); } };
var p204 = new Proxy(t204, h204);
assert_equal(p204[0], 1000);
var t205 = new Uint32Array([1000, 2000, 3000]);
var h205 = { get(t, p) { return Reflect.get(t, p); } };
var p205 = new Proxy(t205, h205);
assert_equal(p205[0], 1000);
var t206 = new Float32Array([1.5, 2.5, 3.5]);
var h206 = { get(t, p) { return Reflect.get(t, p); } };
var p206 = new Proxy(t206, h206);
assert_equal(p206[0], 1.5);
var t207 = new Float64Array([1.1, 2.2, 3.3]);
var h207 = { get(t, p) { return Reflect.get(t, p); } };
var p207 = new Proxy(t207, h207);
assert_true(p207[0] > 1.0);
var t208 = new BigInt64Array([BigInt(1), BigInt(2), BigInt(3)]);
var h208 = { get(t, p) { return Reflect.get(t, p); } };
var p208 = new Proxy(t208, h208);
assert_equal(p208[0], BigInt(1));
var t209 = new BigUint64Array([BigInt(1), BigInt(2), BigInt(3)]);
var h209 = { get(t, p) { return Reflect.get(t, p); } };
var p209 = new Proxy(t209, h209);
assert_equal(p209[0], BigInt(1));
var t210 = new Uint8ClampedArray([0, 128, 255]);
var h210 = { get(t, p) { return Reflect.get(t, p); } };
var p210 = new Proxy(t210, h210);
assert_equal(p210[0], 0);
var t211 = new Int8Array(5);
var h211 = { get(t, p) { return Reflect.get(t, p); } };
var p211 = new Proxy(t211, h211);
assert_equal(p211.length, 5);
var t212 = new Uint8Array(10);
var h212 = { get(t, p) { return Reflect.get(t, p); } };
var p212 = new Proxy(t212, h212);
assert_equal(p212.length, 10);
var t213 = new Int16Array(3);
var h213 = { get(t, p) { return Reflect.get(t, p); } };
var p213 = new Proxy(t213, h213);
assert_equal(p213.length, 3);
var t214 = new Int32Array(4);
var h214 = { get(t, p) { return Reflect.get(t, p); } };
var p214 = new Proxy(t214, h214);
assert_equal(p214.length, 4);
var t215 = new Float32Array(5);
var h215 = { get(t, p) { return Reflect.get(t, p); } };
var p215 = new Proxy(t215, h215);
assert_equal(p215.length, 5);
var t216 = new Float64Array(6);
var h216 = { get(t, p) { return Reflect.get(t, p); } };
var p216 = new Proxy(t216, h216);
assert_equal(p216.length, 6);
var t217 = new Int8Array([1, 2, 3]);
var h217 = { get(t, p) { return Reflect.get(t, p); } };
var p217 = new Proxy(t217, h217);
var a217 = [...p217];
assert_equal(a217.length, 3);
var t218 = new Uint8Array([1, 2, 3]);
var h218 = { get(t, p) { return Reflect.get(t, p); } };
var p218 = new Proxy(t218, h218);
var a218 = [...p218];
assert_equal(a218.length, 3);
var t219 = new Int8Array([1, 2, 3, 4, 5]);
var h219 = { get(t, p) { return Reflect.get(t, p); } };
var p219 = new Proxy(t219, h219);
var sum219 = 0;
for (var x of p219) { sum219 += x; }
assert_equal(sum219, 15);
var t220 = new Int8Array([1, 2, 3]);
var h220 = { get(t, p) { return Reflect.get(t, p); } };
var p220 = new Proxy(t220, h220);
assert_equal(JSON.stringify(p220), '[1,2,3]');
var t221 = new Int8Array([1, 2, 3]);
var h221 = { get(t, p) { return Reflect.get(t, p); } };
var p221 = new Proxy(t221, h221);
assert_equal(p221.toString(), '1,2,3');
var t222 = new Int8Array([1, 2, 3]);
var h222 = { get(t, p) { return Reflect.get(t, p); } };
var p222 = new Proxy(t222, h222);
assert_true(p222 instanceof Int8Array);
var t223 = new Uint8Array([1, 2, 3]);
var h223 = { get(t, p) { return Reflect.get(t, p); } };
var p223 = new Proxy(t223, h223);
assert_true(p223 instanceof Uint8Array);
var t224 = new Int8Array([1, 2, 3, 4, 5]);
var h224 = { get(t, p) { return Reflect.get(t, p); } };
var p224 = new Proxy(t224, h224);
assert_equal(p224.byteLength, 5);
var t225 = new Int16Array([1, 2, 3]);
var h225 = { get(t, p) { return Reflect.get(t, p); } };
var p225 = new Proxy(t225, h225);
assert_equal(p225.byteLength, 6);
var t226 = new Int32Array([1, 2, 3]);
var h226 = { get(t, p) { return Reflect.get(t, p); } };
var p226 = new Proxy(t226, h226);
assert_equal(p226.byteLength, 12);
var t227 = new Int8Array([1, 2, 3]);
var h227 = { get(t, p) { return Reflect.get(t, p); } };
var p227 = new Proxy(t227, h227);
assert_equal(p227.BYTES_PER_ELEMENT, 1);
var t228 = new Int16Array([1, 2, 3]);
var h228 = { get(t, p) { return Reflect.get(t, p); } };
var p228 = new Proxy(t228, h228);
assert_equal(p228.BYTES_PER_ELEMENT, 2);
var t229 = new Int32Array([1, 2, 3]);
var h229 = { get(t, p) { return Reflect.get(t, p); } };
var p229 = new Proxy(t229, h229);
assert_equal(p229.BYTES_PER_ELEMENT, 4);
var t230 = new Int8Array([1, 2, 3, 4, 5]);
var h230 = { get(t, p) { return Reflect.get(t, p); } };
var p230 = new Proxy(t230, h230);
var sub230 = p230.subarray(1, 3);
assert_equal(sub230.length, 2);
var t231 = new Int8Array([1, 2, 3, 4, 5]);
var h231 = { get(t, p) { return Reflect.get(t, p); } };
var p231 = new Proxy(t231, h231);
p231.fill(10, 1, 3);
assert_equal(p231[1], 10);
var t232 = new Int8Array([1, 2, 3, 4, 5]);
var h232 = { get(t, p) { return Reflect.get(t, p); } };
var p232 = new Proxy(t232, h232);
p232.set([10, 20], 1);
assert_equal(p232[1], 10);
var t233 = new Int8Array([1, 2, 3, 4, 5]);
var h233 = { get(t, p) { return Reflect.get(t, p); } };
var p233 = new Proxy(t233, h233);
p233.copyWithin(0, 2, 4);
assert_equal(p233[0], 3);
var t234 = new Int8Array([5, 2, 8, 1, 9]);
var h234 = { get(t, p) { return Reflect.get(t, p); } };
var p234 = new Proxy(t234, h234);
p234.sort();
assert_equal(p234[0], 1);
var t235 = new Int8Array([1, 2, 3, 4, 5]);
var h235 = { get(t, p) { return Reflect.get(t, p); } };
var p235 = new Proxy(t235, h235);
p235.reverse();
assert_equal(p235[0], 5);
var t236 = new Int8Array([1, 2, 3, 4, 5]);
var h236 = { get(t, p) { return Reflect.get(t, p); } };
var p236 = new Proxy(t236, h236);
assert_true(p236.includes(3));
var t237 = new Int8Array([1, 2, 3, 4, 5]);
var h237 = { get(t, p) { return Reflect.get(t, p); } };
var p237 = new Proxy(t237, h237);
assert_equal(p237.indexOf(3), 2);
var t238 = new Int8Array([1, 2, 3, 4, 5]);
var h238 = { get(t, p) { return Reflect.get(t, p); } };
var p238 = new Proxy(t238, h238);
assert_equal(p238.findIndex(x => x > 3), 3);
var t239 = new Int8Array([1, 2, 3, 4, 5]);
var h239 = { get(t, p) { return Reflect.get(t, p); } };
var p239 = new Proxy(t239, h239);
assert_equal(p239.find(x => x > 3), 4);
var t240 = new Int8Array([1, 2, 3, 4, 5]);
var h240 = { get(t, p) { return Reflect.get(t, p); } };
var p240 = new Proxy(t240, h240);
assert_true(p240.every(x => x > 0));
var t241 = new Int8Array([1, 2, 3, 4, 5]);
var h241 = { get(t, p) { return Reflect.get(t, p); } };
var p241 = new Proxy(t241, h241);
assert_true(p241.some(x => x > 3));
var t242 = new Int8Array([1, 2, 3]);
var h242 = { get(t, p) { return Reflect.get(t, p); } };
var p242 = new Proxy(t242, h242);
var sum242 = 0;
p242.forEach(x => { sum242 += x; });
assert_equal(sum242, 6);
var t243 = new Int8Array([1, 2, 3, 4, 5]);
var h243 = { get(t, p) { return Reflect.get(t, p); } };
var p243 = new Proxy(t243, h243);
assert_equal(p243.reduce((a, b) => a + b, 0), 15);
var t244 = new Int8Array([1, 2, 3, 4, 5]);
var h244 = { get(t, p) { return Reflect.get(t, p); } };
var p244 = new Proxy(t244, h244);
assert_equal(p244.reduceRight((a, b) => a - b, 0), -15);
var t245 = new Int8Array([1, 2, 3]);
var h245 = { get(t, p) { return Reflect.get(t, p); } };
var p245 = new Proxy(t245, h245);
var m245 = p245.map(x => x * 2);
assert_equal(m245[0], 2);
var t246 = new Int8Array([1, 2, 3, 4, 5]);
var h246 = { get(t, p) { return Reflect.get(t, p); } };
var p246 = new Proxy(t246, h246);
var f246 = p246.filter(x => x > 2);
assert_equal(f246.length, 3);
var t247 = new Int8Array([1, 2, 3, 4, 5]);
var h247 = { get(t, p) { return Reflect.get(t, p); } };
var p247 = new Proxy(t247, h247);
assert_equal(p247.at(0), 1);
assert_equal(p247.at(-1), 5);
var t248 = new Int8Array([1, 2, 3, 4, 5]);
var h248 = { get(t, p) { return Reflect.get(t, p); } };
var p248 = new Proxy(t248, h248);
var e248 = p248.entries();
assert_equal(e248.next().value[0], 0);
var t249 = new Int8Array([1, 2, 3]);
var h249 = { get(t, p) { return Reflect.get(t, p); } };
var p249 = new Proxy(t249, h249);
var k249 = p249.keys();
assert_equal(k249.next().value, 0);
var t250 = new Int8Array([1, 2, 3]);
var h250 = { get(t, p) { return Reflect.get(t, p); } };
var p250 = new Proxy(t250, h250);
var v250 = p250.values();
assert_equal(v250.next().value, 1);
var t300 = [1, 2, 3];
var h300 = {
get(t, p) {
if (p === 'custom') return 'custom value';
return Reflect.get(t, p);
}
};
var p300 = new Proxy(t300, h300);
assert_equal(p300.custom, 'custom value');
var t301 = [1, 2, 3];
var h301 = {
get(t, p) {
if (typeof p === 'symbol') return 'symbol';
return Reflect.get(t, p);
}
};
var p301 = new Proxy(t301, h301);
assert_equal(p301[Symbol('test')], 'symbol');
var t302 = [1, 2, 3];
var h302 = {
get(t, p) {
const v = Reflect.get(t, p);
if (typeof v === 'number') return v * 2;
return v;
}
};
var p302 = new Proxy(t302, h302);
assert_equal(p302[0], 2);
assert_equal(p302[1], 4);
var t303 = [1, 2, 3];
var h303 = {
get(t, p) {
const v = Reflect.get(t, p);
if (typeof v === 'number') return v + 10;
return v;
}
};
var p303 = new Proxy(t303, h303);
assert_equal(p303[0], 11);
var t304 = [1, 2, 3];
var h304 = {
set(t, p, v) {
if (typeof v === 'number') return Reflect.set(t, p, v * 2);
return Reflect.set(t, p, v);
}
};
var p304 = new Proxy(t304, h304);
p304[0] = 10;
assert_equal(p304[0], 20);
var t305 = [1, 2, 3];
var h305 = {
has(t, p) {
if (p === 'hidden') return false;
return Reflect.has(t, p);
}
};
var p305 = new Proxy(t305, h305);
assert_true(!(0 in p305));
assert_true(!('hidden' in p305));
var t306 = [1, 2, 3];
var h306 = {
deleteProperty(t, p) {
if (p === '0') return false;
return Reflect.deleteProperty(t, p);
}
};
var p306 = new Proxy(t306, h306);
delete p306[0];
assert_equal(p306[0], 1);
var t307 = [1, 2, 3];
var h307 = {
defineProperty(t, p, d) {
if (p === 'custom') return false;
return Reflect.defineProperty(t, p, d);
}
};
var p307 = new Proxy(t307, h307);
Object.defineProperty(p307, 3, { value: 4 });
assert_equal(p307[3], 4);
var t308 = [1, 2, 3];
var h308 = {
getOwnPropertyDescriptor(t, p) {
if (p === '0') return undefined;
return Reflect.getOwnPropertyDescriptor(t, p);
}
};
var p308 = new Proxy(t308, h308);
assert_equal(Object.getOwnPropertyDescriptor(p308, 0), undefined);
var t309 = [1, 2, 3];
var h309 = {
ownKeys(t) {
return ['0', '2'];
}
};
var p309 = new Proxy(t309, h309);
var k309 = Object.keys(p309);
assert_equal(k309.length, 2);
var t310 = [1, 2, 3];
var h310 = {
getPrototypeOf(t) {
return Object.prototype;
}
};
var p310 = new Proxy(t310, h310);
assert_equal(Object.getPrototypeOf(p310), Object.prototype);
var t311 = [1, 2, 3];
var h311 = {
setPrototypeOf(t, p) {
return false;
}
};
var p311 = new Proxy(t311, h311);
Object.setPrototypeOf(p311, {});
assert_equal(Object.getPrototypeOf(p311), Array.prototype);
var t312 = [1, 2, 3];
var h312 = {
isExtensible(t) {
return false;
}
};
var p312 = new Proxy(t312, h312);
assert_true(!Object.isExtensible(p312));
var t313 = [1, 2, 3];
var h313 = {
preventExtensions(t) {
return false;
}
};
var p313 = new Proxy(t313, h313);
Object.preventExtensions(p313);
assert_true(Object.isExtensible(p313));
var t314 = [1, 2, 3];
var h314 = {
get(t, p) {
return Reflect.get(t, p);
},
set(t, p, v) {
console.log('Setting', p, 'to', v);
return Reflect.set(t, p, v);
}
};
var p314 = new Proxy(t314, h314);
p314[0] = 10;
assert_equal(p314[0], 10);
var t315 = [1, 2, 3];
var count315 = 0;
var h315 = {
get(t, p) {
count315++;
return Reflect.get(t, p);
}
};
var p315 = new Proxy(t315, h315);
var val315 = p315[0];
assert_true(count315 > 0);
var t316 = [1, 2, 3];
var h316 = {
get(t, p) {
if (p === 'map') {
return function(cb) {
count316++;
return t.map(cb);
};
}
return Reflect.get(t, p);
}
};
var count316 = 0;
var p316 = new Proxy(t316, h316);
p316.map(x => x * 2);
assert_true(count316 > 0);
var t317 = [1, 2, 3];
var h317 = {
get(t, p) {
if (p === Symbol.iterator) {
return function() {
let i = 0;
return {
next() {
if (i < t.length) return { value: t[i++] * 10, done: false };
return { done: true };
}
};
};
}
return Reflect.get(t, p);
}
};
var p317 = new Proxy(t317, h317);
var a317 = [...p317];
assert_equal(a317[0], 10);
var t318 = [1, 2, 3];
var h318 = {
get(t, p) {
if (p === Symbol.toStringTag) {
return 'CustomArray';
}
return Reflect.get(t, p);
}
};
var p318 = new Proxy(t318, h318);
assert_equal(Object.prototype.toString.call(p318), '[object CustomArray]');
var t319 = [1, 2, 3];
var h319 = {
get(t, p) {
if (p === Symbol.isConcatSpreadable) {
return false;
}
return Reflect.get(t, p);
}
};
var p319 = new Proxy(t319, h319);
var c319 = [0].concat(p319);
assert_equal(c319.length, 2);
var t320 = [1, 2, 3];
var h320 = {
get(t, p) {
if (p === Symbol.species) {
return Array;
}
return Reflect.get(t, p);
}
};
var p320 = new Proxy(t320, h320);
assert_equal(p320[Symbol.species], Array);
var t321 = [1, 2, 3];
var h321 = {
get(t, p) {
if (p === Symbol.unscopables) {
return { 0: true };
}
return Reflect.get(t, p);
}
};
var p321 = new Proxy(t321, h321);
assert_equal(p321[Symbol.unscopables][0], true);
var t322 = [1, 2, 3];
var h322 = {
get(t, p) {
if (p === Symbol.asyncIterator) {
return async function*() {
for (const x of t) {
yield x * 2;
}
};
}
return Reflect.get(t, p);
}
};
var p322 = new Proxy(t322, h322);
var t323 = [1, 2, 3];
var h323 = {
get(t, p) {
if (p === Symbol.match) {
return function(str) {
return str.includes(t.join(''));
};
}
return Reflect.get(t, p);
}
};
var p323 = new Proxy(t323, h323);
var t324 = [1, 2, 3];
var h324 = {
get(t, p) {
if (p === Symbol.replace) {
return function(str, repl) {
return str.replace(t.join(''), repl);
};
}
return Reflect.get(t, p);
}
};
var p324 = new Proxy(t324, h324);
var t325 = [1, 2, 3];
var h325 = {
get(t, p) {
if (p === Symbol.search) {
return function(str) {
return str.indexOf(t.join(''));
};
}
return Reflect.get(t, p);
}
};
var p325 = new Proxy(t325, h325);
var t326 = [1, 2, 3];
var h326 = {
get(t, p) {
if (p === Symbol.split) {
return function(str) {
return str.split(t.join(''));
};
}
return Reflect.get(t, p);
}
};
var p326 = new Proxy(t326, h326);
var t327 = [1, 2, 3];
var h327 = {
get(t, p) {
if (p === Symbol.toPrimitive) {
return function(hint) {
return t.join(',');
};
}
return Reflect.get(t, p);
}
};
var p327 = new Proxy(t327, h327);
var t328 = [1, 2, 3];
var h328 = {
get(t, p) {
if (p === Symbol.hasInstance) {
return function(obj) {
return Array.isArray(obj);
};
}
return Reflect.get(t, p);
}
};
var p328 = new Proxy(t328, h328);
var t329 = [1, 2, 3];
var h329 = {
get(t, p) {
if (p === Symbol.isConcatSpreadable) {
return true;
}
return Reflect.get(t, p);
}
};
var p329 = new Proxy(t329, h329);
var c329 = [0].concat(p329);
assert_equal(c329.length, 4);
var t400 = [];
for (var i400 = 0; i400 < 100; i400++) {
t400[i400] = i400;
}
var h400 = { get(t, p) { return Reflect.get(t, p); } };
var p400 = new Proxy(t400, h400);
for (var i400 = 0; i400 < 100; i400++) {
assert_equal(p400[i400], i400);
}
var t401 = [];
for (var i401 = 0; i401 < 50; i401++) {
t401[i401] = i401 * 2;
}
var h401 = { get(t, p) { return Reflect.get(t, p); } };
var p401 = new Proxy(t401, h401);
var sum401 = 0;
for (var i401 = 0; i401 < 50; i401++) {
sum401 += p401[i401];
}
assert_equal(sum401, 2450);
var t402 = [];
for (var i402 = 0; i402 < 30; i402++) {
t402[i402] = i402 + 1;
}
var h402 = { get(t, p) { return Reflect.get(t, p); } };
var p402 = new Proxy(t402, h402);
var filtered402 = [];
for (var i402 = 0; i402 < 30; i402++) {
if (p402[i402] > 15) filtered402.push(p402[i402]);
}
assert_equal(filtered402.length, 15);
var t403 = [];
for (var i403 = 0; i403 < 20; i403++) {
t403[i403] = i403 + 1;
}
var h403 = { get(t, p) { return Reflect.get(t, p); } };
var p403 = new Proxy(t403, h403);
var mapped403 = [];
for (var i403 = 0; i403 < 20; i403++) {
mapped403.push(p403[i403] * 2);
}
assert_equal(mapped403[0], 2);
assert_equal(mapped403[19], 40);
var t404 = [];
for (var i404 = 0; i404 < 10; i404++) {
t404[i404] = i404 + 1;
}
var h404 = { get(t, p) { return Reflect.get(t, p); } };
var p404 = new Proxy(t404, h404);
var found404 = false;
for (var i404 = 0; i404 < 10; i404++) {
if (p404[i404] === 5) {
found404 = true;
break;
}
}
assert_true(found404);
var t405 = [];
for (var i405 = 0; i405 < 15; i405++) {
t405[i405] = i405 + 1;
}
var h405 = { get(t, p) { return Reflect.get(t, p); } };
var p405 = new Proxy(t405, h405);
var every405 = true;
for (var i405 = 0; i405 < 15; i405++) {
if (p405[i405] <= 0) {
every405 = false;
break;
}
}
assert_true(every405);
var t406 = [];
for (var i406 = 0; i406 < 12; i406++) {
t406[i406] = i406 + 1;
}
var h406 = { get(t, p) { return Reflect.get(t, p); } };
var p406 = new Proxy(t406, h406);
var some406 = false;
for (var i406 = 0; i406 < 12; i406++) {
if (p406[i406] > 10) {
some406 = true;
break;
}
}
assert_true(some406);
var t407 = [];
for (var i407 = 0; i407 < 8; i407++) {
t407[i407] = i407 + 1;
}
var h407 = { get(t, p) { return Reflect.get(t, p); } };
var p407 = new Proxy(t407, h407);
var reduced407 = 0;
for (var i407 = 0; i407 < 8; i407++) {
reduced407 += p407[i407];
}
assert_equal(reduced407, 36);
var t408 = [];
for (var i408 = 0; i408 < 6; i408++) {
t408[i408] = i408 + 1;
}
var h408 = { get(t, p) { return Reflect.get(t, p); } };
var p408 = new Proxy(t408, h408);
var reversed408 = [];
for (var i408 = 5; i408 >= 0; i408--) {
reversed408.push(p408[i408]);
}
assert_equal(reversed408[0], 6);
assert_equal(reversed408[5], 1);
var t409 = [];
for (var i409 = 0; i409 < 5; i409++) {
t409[i409] = i409 + 1;
}
var h409 = { get(t, p) { return Reflect.get(t, p); } };
var p409 = new Proxy(t409, h409);
var sliced409 = [];
for (var i409 = 1; i409 < 4; i409++) {
sliced409.push(p409[i409]);
}
assert_equal(sliced409.length, 3);
assert_equal(sliced409[0], 2);
var t410 = [1, 2, 3, 4, 5];
var h410 = { get(t, p) { return Reflect.get(t, p); } };
var p410 = new Proxy(t410, h410);
var count410 = 0;
for (var prop in p410) {
count410++;
}
assert_equal(count410, 5);
var t411 = [1, 2, 3];
var h411 = { get(t, p) { return Reflect.get(t, p); } };
var p411 = new Proxy(t411, h411);
var keys411 = [];
for (var key in p411) {
keys411.push(key);
}
assert_equal(keys411.length, 3);
var t412 = [1, 2, 3];
var h412 = { get(t, p) { return Reflect.get(t, p); } };
var p412 = new Proxy(t412, h412);
var values412 = [];
for (var key in p412) {
values412.push(p412[key]);
}
assert_equal(values412.length, 3);
var t413 = [1, 2, 3];
var h413 = { get(t, p) { return Reflect.get(t, p); } };
var p413 = new Proxy(t413, h413);
var entries413 = [];
for (var key in p413) {
entries413.push([key, p413[key]]);
}
assert_equal(entries413.length, 3);
var t414 = [1, 2, 3];
var h414 = { get(t, p) { return Reflect.get(t, p); } };
var p414 = new Proxy(t414, h414);
var copied414 = [];
for (var i414 = 0; i414 < p414.length; i414++) {
copied414.push(p414[i414]);
}
assert_equal(copied414.length, 3);
var t415 = [1, 2, 3, 4, 5];
var h415 = { get(t, p) { return Reflect.get(t, p); } };
var p415 = new Proxy(t415, h415);
var foundIndex415 = -1;
for (var i415 = 0; i415 < p415.length; i415++) {
if (p415[i415] === 3) {
foundIndex415 = i415;
break;
}
}
assert_equal(foundIndex415, 2);
var t416 = [1, 2, 3, 4, 5];
var h416 = { get(t, p) { return Reflect.get(t, p); } };
var p416 = new Proxy(t416, h416);
var lastIndex416 = -1;
for (var i416 = p416.length - 1; i416 >= 0; i416--) {
if (p416[i416] === 3) {
lastIndex416 = i416;
break;
}
}
assert_equal(lastIndex416, 2);
var t417 = [1, 2, 3, 4, 5];
var h417 = { get(t, p) { return Reflect.get(t, p); } };
var p417 = new Proxy(t417, h417);
var includes417 = false;
for (var i = 0; i < p417.length; i++) {
if (p417[i] === 3) {
includes417 = true;
break;
}
}
assert_true(includes417);
var t418 = [1, 2, 3, 4, 5];
var h418 = { get(t, p) { return Reflect.get(t, p); } };
var p418 = new Proxy(t418, h418);
var sum418 = 0;
for (var i = 0; i < p418.length; i++) {
sum418 += p418[i];
}
assert_equal(sum418, 15);
var t419 = [1, 2, 3, 4, 5];
var h419 = { get(t, p) { return Reflect.get(t, p); } };
var p419 = new Proxy(t419, h419);
var product419 = 1;
for (var i = 0; i < p419.length; i++) {
product419 *= p419[i];
}
assert_equal(product419, 120);
var t420 = [1, 2, 3, 4, 5];
var h420 = { get(t, p) { return Reflect.get(t, p); } };
var p420 = new Proxy(t420, h420);
var max420 = p420[0];
for (var i = 1; i < p420.length; i++) {
if (p420[i] > max420) max420 = p420[i];
}
assert_equal(max420, 5);
var t421 = [1, 2, 3, 4, 5];
var h421 = { get(t, p) { return Reflect.get(t, p); } };
var p421 = new Proxy(t421, h421);
var min421 = p421[0];
for (var i = 1; i < p421.length; i++) {
if (p421[i] < min421) min421 = p421[i];
}
assert_equal(min421, 1);
var t422 = [1, 2, 3, 4, 5];
var h422 = { get(t, p) { return Reflect.get(t, p); } };
var p422 = new Proxy(t422, h422);
var avg422 = 0;
for (var i = 0; i < p422.length; i++) {
avg422 += p422[i];
}
avg422 = avg422 / p422.length;
assert_equal(avg422, 3);
var t423 = [1, 2, 3, 4, 5];
var h423 = { get(t, p) { return Reflect.get(t, p); } };
var p423 = new Proxy(t423, h423);
var even423 = [];
for (var i = 0; i < p423.length; i++) {
if (p423[i] % 2 === 0) even423.push(p423[i]);
}
assert_equal(even423.length, 2);
var t424 = [1, 2, 3, 4, 5];
var h424 = { get(t, p) { return Reflect.get(t, p); } };
var p424 = new Proxy(t424, h424);
var odd424 = [];
for (var i = 0; i < p424.length; i++) {
if (p424[i] % 2 !== 0) odd424.push(p424[i]);
}
assert_equal(odd424.length, 3);
var t425 = [1, 2, 3, 4, 5];
var h425 = { get(t, p) { return Reflect.get(t, p); } };
var p425 = new Proxy(t425, h425);
var doubled425 = [];
for (var i = 0; i < p425.length; i++) {
doubled425.push(p425[i] * 2);
}
assert_equal(doubled425[0], 2);
assert_equal(doubled425[4], 10);
var t426 = [1, 2, 3, 4, 5];
var h426 = { get(t, p) { return Reflect.get(t, p); } };
var p426 = new Proxy(t426, h426);
var squared426 = [];
for (var i = 0; i < p426.length; i++) {
squared426.push(p426[i] * p426[i]);
}
assert_equal(squared426[0], 1);
assert_equal(squared426[4], 25);
var t427 = [1, 2, 3, 4, 5];
var h427 = { get(t, p) { return Reflect.get(t, p); } };
var p427 = new Proxy(t427, h427);
var cubed427 = [];
for (var i = 0; i < p427.length; i++) {
cubed427.push(p427[i] * p427[i] * p427[i]);
}
assert_equal(cubed427[0], 1);
assert_equal(cubed427[4], 125);
var t428 = [1, 2, 3, 4, 5];
var h428 = { get(t, p) { return Reflect.get(t, p); } };
var p428 = new Proxy(t428, h428);
var sum428 = 0;
for (var i = 0; i < p428.length; i++) {
sum428 += p428[i] * p428[i];
}
assert_equal(sum428, 55);
var t429 = [1, 2, 3, 4, 5];
var h429 = { get(t, p) { return Reflect.get(t, p); } };
var p429 = new Proxy(t429, h429);
var count429 = 0;
for (var i = 0; i < p429.length; i++) {
if (p429[i] > 2) count429++;
}
assert_equal(count429, 3);
var t430 = [1, 2, 3, 4, 5];
var h430 = { get(t, p) { return Reflect.get(t, p); } };
var p430 = new Proxy(t430, h430);
var first430 = p430[0];
var last430 = p430[p430.length - 1];
assert_equal(first430, 1);
assert_equal(last430, 5);
var t431 = [1, 2, 3, 4, 5];
var h431 = { get(t, p) { return Reflect.get(t, p); } };
var p431 = new Proxy(t431, h431);
var second431 = p431[1];
var secondLast431 = p431[p431.length - 2];
assert_equal(second431, 2);
assert_equal(secondLast431, 4);
var t432 = [1, 2, 3, 4, 5];
var h432 = { get(t, p) { return Reflect.get(t, p); } };
var p432 = new Proxy(t432, h432);
var middle432 = p432[Math.floor(p432.length / 2)];
assert_equal(middle432, 3);
var t433 = [1, 2, 3, 4, 5];
var h433 = { get(t, p) { return Reflect.get(t, p); } };
var p433 = new Proxy(t433, h433);
var temp433 = p433[0];
p433[0] = p433[p433.length - 1];
p433[p433.length - 1] = temp433;
assert_equal(p433[0], 5);
assert_equal(p433[4], 1);
var t434 = [1, 2, 3, 4, 5];
var h434 = { get(t, p) { return Reflect.get(t, p); } };
var p434 = new Proxy(t434, h434);
var left434 = 0;
var right434 = p434.length - 1;
while (left434 < right434) {
var temp = p434[left434];
p434[left434] = p434[right434];
p434[right434] = temp;
left434++;
right434--;
}
assert_equal(p434[0], 5);
assert_equal(p434[4], 1);
var t435 = [1, 2, 3, 4, 5];
var h435 = { get(t, p) { return Reflect.get(t, p); } };
var p435 = new Proxy(t435, h435);
var found435 = false;
for (var i = 0; i < p435.length; i++) {
for (var j = i + 1; j < p435.length; j++) {
if (p435[i] === p435[j]) {
found435 = true;
break;
}
}
if (found435) break;
}
assert_true(!found435);
var t436 = [1, 2, 3, 2, 4, 3, 5];
var h436 = { get(t, p) { return Reflect.get(t, p); } };
var p436 = new Proxy(t436, h436);
var unique436 = [];
for (var i = 0; i < p436.length; i++) {
var isUnique = true;
for (var j = 0; j < unique436.length; j++) {
if (p436[i] === unique436[j]) {
isUnique = false;
break;
}
}
if (isUnique) unique436.push(p436[i]);
}
assert_equal(unique436.length, 5);
var t437 = [1, 2, 3, 4, 5];
var h437 = { get(t, p) { return Reflect.get(t, p); } };
var p437 = new Proxy(t437, h437);
var shuffled437 = [];
for (var i = 0; i < p437.length; i++) {
shuffled437.push(p437[i]);
}
assert_equal(shuffled437.length, 5);
var t438 = [1, 2, 3, 4, 5];
var h438 = { get(t, p) { return Reflect.get(t, p); } };
var p438 = new Proxy(t438, h438);
var sorted438 = [];
for (var i = 0; i < p438.length; i++) {
sorted438.push(p438[i]);
}
for (var i = 0; i < sorted438.length - 1; i++) {
for (var j = i + 1; j < sorted438.length; j++) {
if (sorted438[i] > sorted438[j]) {
var temp = sorted438[i];
sorted438[i] = sorted438[j];
sorted438[j] = temp;
}
}
}
assert_equal(sorted438[0], 1);
assert_equal(sorted438[4], 5);
var t439 = [1, 2, 3, 4, 5];
var h439 = { get(t, p) { return Reflect.get(t, p); } };
var p439 = new Proxy(t439, h439);
var binarySearch439 = function(arr, target) {
var left = 0;
var right = arr.length - 1;
while (left <= right) {
var mid = Math.floor((left + right) / 2);
if (arr[mid] === target) return mid;
if (arr[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
};
assert_equal(binarySearch439(p439, 3), 2);
var t440 = [1, 2, 3, 4, 5];
var h440 = { get(t, p) { return Reflect.get(t, p); } };
var p440 = new Proxy(t440, h440);
var rotated440 = [];
for (var i = 1; i < p440.length; i++) {
rotated440.push(p440[i]);
}
rotated440.push(p440[0]);
assert_equal(rotated440[0], 2);
assert_equal(rotated440[4], 1);
var t441 = [1, 2, 3, 4, 5];
var h441 = { get(t, p) { return Reflect.get(t, p); } };
var p441 = new Proxy(t441, h441);
var rotated441 = [];
rotated441.push(p441[p441.length - 1]);
for (var i = 0; i < p441.length - 1; i++) {
rotated441.push(p441[i]);
}
assert_equal(rotated441[0], 5);
assert_equal(rotated441[4], 4);
var t442 = [1, 2, 3, 4, 5];
var h442 = { get(t, p) { return Reflect.get(t, p); } };
var p442 = new Proxy(t442, h442);
var chunked442 = [];
var chunkSize = 2;
for (var i = 0; i < p442.length; i += chunkSize) {
var chunk = [];
for (var j = i; j < i + chunkSize && j < p442.length; j++) {
chunk.push(p442[j]);
}
chunked442.push(chunk);
}
assert_equal(chunked442.length, 3);
var t443 = [1, 2, 3, 4, 5];
var h443 = { get(t, p) { return Reflect.get(t, p); } };
var p443 = new Proxy(t443, h443);
var flattened443 = [];
for (var i = 0; i < p443.length; i++) {
if (Array.isArray(p443[i])) {
for (var j = 0; j < p443[i].length; j++) {
flattened443.push(p443[i][j]);
}
} else {
flattened443.push(p443[i]);
}
}
assert_equal(flattened443.length, 5);
var t444 = [1, 2, 3, 4, 5];
var h444 = { get(t, p) { return Reflect.get(t, p); } };
var p444 = new Proxy(t444, h444);
var zipped444 = [];
var arr2_444 = ['a', 'b', 'c', 'd', 'e'];
for (var i = 0; i < Math.min(p444.length, arr2_444.length); i++) {
zipped444.push([p444[i], arr2_444[i]]);
}
assert_equal(zipped444.length, 5);
var t445 = [1, 2, 3, 4, 5];
var h445 = { get(t, p) { return Reflect.get(t, p); } };
var p445 = new Proxy(t445, h445);
var unzipped445 = [[], []];
for (var i = 0; i < p445.length; i++) {
unzipped445[0].push(p445[i]);
unzipped445[1].push(String.fromCharCode(97 + i));
}
assert_equal(unzipped445[0].length, 5);
assert_equal(unzipped445[1].length, 5);
var t446 = [1, 2, 3, 4, 5];
var h446 = { get(t, p) { return Reflect.get(t, p); } };
var p446 = new Proxy(t446, h446);
var partitioned446 = [[], []];
for (var i = 0; i < p446.length; i++) {
if (p446[i] % 2 === 0) {
partitioned446[0].push(p446[i]);
} else {
partitioned446[1].push(p446[i]);
}
}
assert_equal(partitioned446[0].length, 2);
assert_equal(partitioned446[1].length, 3);
var t447 = [1, 2, 3, 4, 5];
var h447 = { get(t, p) { return Reflect.get(t, p); } };
var p447 = new Proxy(t447, h447);
var grouped447 = {};
for (var i = 0; i < p447.length; i++) {
var key = p447[i] % 2;
if (!grouped447[key]) grouped447[key] = [];
grouped447[key].push(p447[i]);
}
assert_equal(grouped447[0].length, 2);
assert_equal(grouped447[1].length, 3);
var t448 = [1, 2, 3, 4, 5];
var h448 = { get(t, p) { return Reflect.get(t, p); } };
var p448 = new Proxy(t448, h448);
var accumulated448 = [];
for (var i = 0; i < p448.length; i++) {
var sum = 0;
for (var j = 0; j <= i; j++) {
sum += p448[j];
}
accumulated448.push(sum);
}
assert_equal(accumulated448[0], 1);
assert_equal(accumulated448[4], 15);
var t449 = [1, 2, 3, 4, 5];
var h449 = { get(t, p) { return Reflect.get(t, p); } };
var p449 = new Proxy(t449, h449);
var differences449 = [p449[0]];
for (var i = 1; i < p449.length; i++) {
differences449.push(p449[i] - p449[i - 1]);
}
assert_equal(differences449[0], 1);
assert_equal(differences449[1], 1);
var t450 = [1, 2, 3, 4, 5];
var h450 = { get(t, p) { return Reflect.get(t, p); } };
var p450 = new Proxy(t450, h450);
var ratios450 = [];
for (var i = 1; i < p450.length; i++) {
ratios450.push(p450[i] / p450[i - 1]);
}
assert_equal(ratios450[0], 2);
var t451 = [1, 2, 3, 4, 5];
var h451 = { get(t, p) { return Reflect.get(t, p); } };
var p451 = new Proxy(t451, h451);
var runningMax451 = [];
var currentMax = p451[0];
for (var i = 0; i < p451.length; i++) {
if (p451[i] > currentMax) currentMax = p451[i];
runningMax451.push(currentMax);
}
assert_equal(runningMax451[0], 1);
assert_equal(runningMax451[4], 5);
var t452 = [1, 2, 3, 4, 5];
var h452 = { get(t, p) { return Reflect.get(t, p); } };
var p452 = new Proxy(t452, h452);
var runningMin452 = [];
var currentMin = p452[0];
for (var i = 0; i < p452.length; i++) {
if (p452[i] < currentMin) currentMin = p452[i];
runningMin452.push(currentMin);
}
assert_equal(runningMin452[0], 1);
assert_equal(runningMin452[4], 1);
var t453 = [1, 2, 3, 4, 5];
var h453 = { get(t, p) { return Reflect.get(t, p); } };
var p453 = new Proxy(t453, h453);
var runningAvg453 = [];
var sum453 = 0;
for (var i = 0; i < p453.length; i++) {
sum453 += p453[i];
runningAvg453.push(sum453 / (i + 1));
}
assert_equal(runningAvg453[0], 1);
assert_equal(runningAvg453[4], 3);
var t454 = [1, 2, 3, 4, 5];
var h454 = { get(t, p) { return Reflect.get(t, p); } };
var p454 = new Proxy(t454, h454);
var windowed454 = [];
var windowSize = 3;
for (var i = 0; i <= p454.length - windowSize; i++) {
var window = [];
for (var j = i; j < i + windowSize; j++) {
window.push(p454[j]);
}
windowed454.push(window);
}
assert_equal(windowed454.length, 3);
var t455 = [1, 2, 3, 4, 5];
var h455 = { get(t, p) { return Reflect.get(t, p); } };
var p455 = new Proxy(t455, h455);
var padded455 = [];
var padLength = 2;
for (var i = 0; i < padLength; i++) {
padded455.push(0);
}
for (var i = 0; i < p455.length; i++) {
padded455.push(p455[i]);
}
assert_equal(padded455[0], 0);
assert_equal(padded455[2], 1);
var t456 = [1, 2, 3, 4, 5];
var h456 = { get(t, p) { return Reflect.get(t, p); } };
var p456 = new Proxy(t456, h456);
var trimmed456 = [];
var trimLength = 2;
for (var i = trimLength; i < p456.length - trimLength; i++) {
trimmed456.push(p456[i]);
}
assert_equal(trimmed456[0], 3);
var t457 = [1, 2, 3, 4, 5];
var h457 = { get(t, p) { return Reflect.get(t, p); } };
var p457 = new Proxy(t457, h457);
var repeated457 = [];
var repeatCount = 3;
for (var r = 0; r < repeatCount; r++) {
for (var i = 0; i < p457.length; i++) {
repeated457.push(p457[i]);
}
}
assert_equal(repeated457.length, 15);
var t458 = [1, 2, 3, 4, 5];
var h458 = { get(t, p) { return Reflect.get(t, p); } };
var p458 = new Proxy(t458, h458);
var sampled458 = [];
var sampleRate = 2;
for (var i = 0; i < p458.length; i += sampleRate) {
sampled458.push(p458[i]);
}
assert_equal(sampled458.length, 3);
var t459 = [1, 2, 3, 4, 5];
var h459 = { get(t, p) { return Reflect.get(t, p); } };
var p459 = new Proxy(t459, h459);
var reversed459 = [];
for (var i = p459.length - 1; i >= 0; i--) {
reversed459.push(p459[i]);
}
assert_equal(reversed459[0], 5);
assert_equal(reversed459[4], 1);
var t460 = [1, 2, 3, 4, 5];
var h460 = { get(t, p) { return Reflect.get(t, p); } };
var p460 = new Proxy(t460, h460);
var permuted460 = [];
for (var i = 0; i < p460.length; i++) {
permuted460.push(p460[(i + 2) % p460.length]);
}
assert_equal(permuted460[0], 3);
var t461 = [1, 2, 3, 4, 5];
var h461 = { get(t, p) { return Reflect.get(t, p); } };
var p461 = new Proxy(t461, h461);
var adjacentSums461 = [];
for (var i = 0; i < p461.length - 1; i++) {
adjacentSums461.push(p461[i] + p461[i + 1]);
}
assert_equal(adjacentSums461[0], 3);
assert_equal(adjacentSums461[3], 9);
var t462 = [1, 2, 3, 4, 5];
var h462 = { get(t, p) { return Reflect.get(t, p); } };
var p462 = new Proxy(t462, h462);
var adjacentProducts462 = [];
for (var i = 0; i < p462.length - 1; i++) {
adjacentProducts462.push(p462[i] * p462[i + 1]);
}
assert_equal(adjacentProducts462[0], 2);
assert_equal(adjacentProducts462[3], 20);
var t463 = [1, 2, 3, 4, 5];
var h463 = { get(t, p) { return Reflect.get(t, p); } };
var p463 = new Proxy(t463, h463);
var slidingSums463 = [];
var windowSize463 = 2;
for (var i = 0; i <= p463.length - windowSize463; i++) {
var sum = 0;
for (var j = i; j < i + windowSize463; j++) {
sum += p463[j];
}
slidingSums463.push(sum);
}
assert_equal(slidingSums463[0], 3);
assert_equal(slidingSums463[3], 9);
var t464 = [1, 2, 3, 4, 5];
var h464 = { get(t, p) { return Reflect.get(t, p); } };
var p464 = new Proxy(t464, h464);
var cumulativeProducts464 = [];
var product464 = 1;
for (var i = 0; i < p464.length; i++) {
product464 *= p464[i];
cumulativeProducts464.push(product464);
}
assert_equal(cumulativeProducts464[0], 1);
assert_equal(cumulativeProducts464[4], 120);
var t465 = [1, 2, 3, 4, 5];
var h465 = { get(t, p) { return Reflect.get(t, p); } };
var p465 = new Proxy(t465, h465);
var localMaxima465 = [];
for (var i = 1; i < p465.length - 1; i++) {
if (p465[i] > p465[i - 1] && p465[i] > p465[i + 1]) {
localMaxima465.push(p465[i]);
}
}
assert_equal(localMaxima465.length, 0);
var t466 = [1, 3, 2, 5, 4];
var h466 = { get(t, p) { return Reflect.get(t, p); } };
var p466 = new Proxy(t466, h466);
var localMaxima466 = [];
for (var i = 1; i < p466.length - 1; i++) {
if (p466[i] > p466[i - 1] && p466[i] > p466[i + 1]) {
localMaxima466.push(p466[i]);
}
}
assert_equal(localMaxima466.length, 2);
var t467 = [1, 2, 3, 4, 5];
var h467 = { get(t, p) { return Reflect.get(t, p); } };
var p467 = new Proxy(t467, h467);
var localMinima467 = [];
for (var i = 1; i < p467.length - 1; i++) {
if (p467[i] < p467[i - 1] && p467[i] < p467[i + 1]) {
localMinima467.push(p467[i]);
}
}
assert_equal(localMinima467.length, 0);
var t468 = [5, 2, 3, 1, 4];
var h468 = { get(t, p) { return Reflect.get(t, p); } };
var p468 = new Proxy(t468, h468);
var localMinima468 = [];
for (var i = 1; i < p468.length - 1; i++) {
if (p468[i] < p468[i - 1] && p468[i] < p468[i + 1]) {
localMinima468.push(p468[i]);
}
}
assert_equal(localMinima468.length, 2);
var t469 = [1, 2, 3, 4, 5];
var h469 = { get(t, p) { return Reflect.get(t, p); } };
var p469 = new Proxy(t469, h469);
var increasing469 = true;
for (var i = 1; i < p469.length; i++) {
if (p469[i] < p469[i - 1]) {
increasing469 = false;
break;
}
}
assert_true(increasing469);
var t470 = [5, 4, 3, 2, 1];
var h470 = { get(t, p) { return Reflect.get(t, p); } };
var p470 = new Proxy(t470, h470);
var decreasing470 = true;
for (var i = 1; i < p470.length; i++) {
if (p470[i] > p470[i - 1]) {
decreasing470 = false;
break;
}
}
assert_true(decreasing470);
var t471 = [1, 2, 3, 4, 5];
var h471 = { get(t, p) { return Reflect.get(t, p); } };
var p471 = new Proxy(t471, h471);
var range471 = p471[p471.length - 1] - p471[0];
assert_equal(range471, 4);
var t472 = [1, 2, 3, 4, 5];
var h472 = { get(t, p) { return Reflect.get(t, p); } };
var p472 = new Proxy(t472, h472);
var sum472 = 0;
for (var i = 0; i < p472.length; i++) {
sum472 += p472[i];
}
var mean472 = sum472 / p472.length;
var variance472 = 0;
for (var i = 0; i < p472.length; i++) {
variance472 += (p472[i] - mean472) * (p472[i] - mean472);
}
variance472 = variance472 / p472.length;
assert_true(variance472 > 0);
var t473 = [1, 2, 3, 4, 5];
var h473 = { get(t, p) { return Reflect.get(t, p); } };
var p473 = new Proxy(t473, h473);
var sum473 = 0;
for (var i = 0; i < p473.length; i++) {
sum473 += p473[i];
}
var mean473 = sum473 / p473.length;
var stdDev473 = 0;
for (var i = 0; i < p473.length; i++) {
stdDev473 += (p473[i] - mean473) * (p473[i] - mean473);
}
stdDev473 = Math.sqrt(stdDev473 / p473.length);
assert_true(stdDev473 > 0);
var t474 = [1, 2, 3, 4, 5];
var h474 = { get(t, p) { return Reflect.get(t, p); } };
var p474 = new Proxy(t474, h474);
var sorted474 = [];
for (var i = 0; i < p474.length; i++) {
sorted474.push(p474[i]);
}
for (var i = 0; i < sorted474.length - 1; i++) {
for (var j = i + 1; j < sorted474.length; j++) {
if (sorted474[i] > sorted474[j]) {
var temp = sorted474[i];
sorted474[i] = sorted474[j];
sorted474[j] = temp;
}
}
}
var median474 = sorted474[Math.floor(sorted474.length / 2)];
assert_equal(median474, 3);
var t475 = [1, 2, 3, 4, 5, 6];
var h475 = { get(t, p) { return Reflect.get(t, p); } };
var p475 = new Proxy(t475, h475);
var sorted475 = [];
for (var i = 0; i < p475.length; i++) {
sorted475.push(p475[i]);
}
for (var i = 0; i < sorted475.length - 1; i++) {
for (var j = i + 1; j < sorted475.length; j++) {
if (sorted475[i] > sorted475[j]) {
var temp = sorted475[i];
sorted475[i] = sorted475[j];
sorted475[j] = temp;
}
}
}
var median475 = (sorted475[sorted475.length / 2 - 1] + sorted475[sorted475.length / 2]) / 2;
assert_equal(median475, 3.5);
var t476 = [1, 2, 3, 4, 5];
var h476 = { get(t, p) { return Reflect.get(t, p); } };
var p476 = new Proxy(t476, h476);
var sorted476 = [];
for (var i = 0; i < p476.length; i++) {
sorted476.push(p476[i]);
}
for (var i = 0; i < sorted476.length - 1; i++) {
for (var j = i + 1; j < sorted476.length; j++) {
if (sorted476[i] > sorted476[j]) {
var temp = sorted476[i];
sorted476[i] = sorted476[j];
sorted476[j] = temp;
}
}
}
var mode476 = sorted476[0];
var maxCount476 = 1;
var currentCount476 = 1;
for (var i = 1; i < sorted476.length; i++) {
if (sorted476[i] === sorted476[i - 1]) {
currentCount476++;
} else {
if (currentCount476 > maxCount476) {
maxCount476 = currentCount476;
mode476 = sorted476[i - 1];
}
currentCount476 = 1;
}
}
assert_equal(mode476, 1);
var t477 = [1, 2, 2, 3, 3, 3, 4, 5];
var h477 = { get(t, p) { return Reflect.get(t, p); } };
var p477 = new Proxy(t477, h477);
var sorted477 = [];
for (var i = 0; i < p477.length; i++) {
sorted477.push(p477[i]);
}
for (var i = 0; i < sorted477.length - 1; i++) {
for (var j = i + 1; j < sorted477.length; j++) {
if (sorted477[i] > sorted477[j]) {
var temp = sorted477[i];
sorted477[i] = sorted477[j];
sorted477[j] = temp;
}
}
}
var mode477 = sorted477[0];
var maxCount477 = 1;
var currentCount477 = 1;
for (var i = 1; i < sorted477.length; i++) {
if (sorted477[i] === sorted477[i - 1]) {
currentCount477++;
} else {
if (currentCount477 > maxCount477) {
maxCount477 = currentCount477;
mode477 = sorted477[i - 1];
}
currentCount477 = 1;
}
}
assert_equal(mode477, 3);
var t478 = [1, 2, 3, 4, 5];
var h478 = { get(t, p) { return Reflect.get(t, p); } };
var p478 = new Proxy(t478, h478);
var sum478 = 0;
for (var i = 0; i < p478.length; i++) {
sum478 += p478[i];
}
var mean478 = sum478 / p478.length;
var mad478 = 0;
for (var i = 0; i < p478.length; i++) {
mad478 += Math.abs(p478[i] - mean478);
}
mad478 = mad478 / p478.length;
assert_true(mad478 > 0);
var t479 = [1, 2, 3, 4, 5];
var h479 = { get(t, p) { return Reflect.get(t, p); } };
var p479 = new Proxy(t479, h479);
var sum479 = 0;
for (var i = 0; i < p479.length; i++) {
sum479 += p479[i];
}
var mean479 = sum479 / p479.length;
var mse479 = 0;
for (var i = 0; i < p479.length; i++) {
mse479 += (p479[i] - mean479) * (p479[i] - mean479);
}
mse479 = mse479 / p479.length;
assert_true(mse479 > 0);
var t480 = [1, 2, 3, 4, 5];
var h480 = { get(t, p) { return Reflect.get(t, p); } };
var p480 = new Proxy(t480, h480);
var sum480 = 0;
for (var i = 0; i < p480.length; i++) {
sum480 += p480[i];
}
var mean480 = sum480 / p480.length;
var rmse480 = 0;
for (var i = 0; i < p480.length; i++) {
rmse480 += (p480[i] - mean480) * (p480[i] - mean480);
}
rmse480 = Math.sqrt(rmse480 / p480.length);
assert_true(rmse480 > 0);
var t481 = [1, 2, 3, 4, 5];
var h481 = { get(t, p) { return Reflect.get(t, p); } };
var p481 = new Proxy(t481, h481);
var sum481 = 0;
for (var i = 0; i < p481.length; i++) {
sum481 += p481[i];
}
var mean481 = sum481 / p481.length;
var covariance481 = 0;
var arr2_481 = [2, 3, 4, 5, 6];
var sum2_481 = 0;
for (var i = 0; i < arr2_481.length; i++) {
sum2_481 += arr2_481[i];
}
var mean2_481 = sum2_481 / arr2_481.length;
for (var i = 0; i < Math.min(p481.length, arr2_481.length); i++) {
covariance481 += (p481[i] - mean481) * (arr2_481[i] - mean2_481);
}
covariance481 = covariance481 / Math.min(p481.length, arr2_481.length);
assert_true(covariance481 > 0);
var t482 = [1, 2, 3, 4, 5];
var h482 = { get(t, p) { return Reflect.get(t, p); } };
var p482 = new Proxy(t482, h482);
var sum482 = 0;
var sumSq482 = 0;
for (var i = 0; i < p482.length; i++) {
sum482 += p482[i];
sumSq482 += p482[i] * p482[i];
}
var mean482 = sum482 / p482.length;
var variance482 = (sumSq482 / p482.length) - (mean482 * mean482);
assert_true(variance482 > 0);
var t483 = [1, 2, 3, 4, 5];
var h483 = { get(t, p) { return Reflect.get(t, p); } };
var p483 = new Proxy(t483, h483);
var sum483 = 0;
var sumSq483 = 0;
for (var i = 0; i < p483.length; i++) {
sum483 += p483[i];
sumSq483 += p483[i] * p483[i];
}
var mean483 = sum483 / p483.length;
var stdDev483 = Math.sqrt((sumSq483 / p483.length) - (mean483 * mean483));
assert_true(stdDev483 > 0);
var t484 = [1, 2, 3, 4, 5];
var h484 = { get(t, p) { return Reflect.get(t, p); } };
var p484 = new Proxy(t484, h484);
var sum484 = 0;
var sumSq484 = 0;
for (var i = 0; i < p484.length; i++) {
sum484 += p484[i];
sumSq484 += p484[i] * p484[i];
}
var mean484 = sum484 / p484.length;
var variance484 = (sumSq484 / p484.length) - (mean484 * mean484);
var coefficientOfVariation484 = Math.sqrt(variance484) / mean484;
assert_true(coefficientOfVariation484 > 0);
var t485 = [1, 2, 3, 4, 5];
var h485 = { get(t, p) { return Reflect.get(t, p); } };
var p485 = new Proxy(t485, h485);
var sum485 = 0;
for (var i = 0; i < p485.length; i++) {
sum485 += p485[i];
}
var mean485 = sum485 / p485.length;
var sumAbsDev485 = 0;
for (var i = 0; i < p485.length; i++) {
sumAbsDev485 += Math.abs(p485[i] - mean485);
}
var meanAbsDev485 = sumAbsDev485 / p485.length;
assert_true(meanAbsDev485 > 0);
var t486 = [1, 2, 3, 4, 5];
var h486 = { get(t, p) { return Reflect.get(t, p); } };
var p486 = new Proxy(t486, h486);
var sorted486 = [];
for (var i = 0; i < p486.length; i++) {
sorted486.push(p486[i]);
}
for (var i = 0; i < sorted486.length - 1; i++) {
for (var j = i + 1; j < sorted486.length; j++) {
if (sorted486[i] > sorted486[j]) {
var temp = sorted486[i];
sorted486[i] = sorted486[j];
sorted486[j] = temp;
}
}
}
var percentile25_486 = sorted486[Math.floor(sorted486.length * 0.25)];
var percentile50_486 = sorted486[Math.floor(sorted486.length * 0.5)];
var percentile75_486 = sorted486[Math.floor(sorted486.length * 0.75)];
assert_equal(percentile25_486, 1);
assert_equal(percentile50_486, 3);
assert_equal(percentile75_486, 4);
var t487 = [1, 2, 3, 4, 5];
var h487 = { get(t, p) { return Reflect.get(t, p); } };
var p487 = new Proxy(t487, h487);
var sorted487 = [];
for (var i = 0; i < p487.length; i++) {
sorted487.push(p487[i]);
}
for (var i = 0; i < sorted487.length - 1; i++) {
for (var j = i + 1; j < sorted487.length; j++) {
if (sorted487[i] > sorted487[j]) {
var temp = sorted487[i];
sorted487[i] = sorted487[j];
sorted487[j] = temp;
}
}
}
var q1_487 = sorted487[Math.floor(sorted487.length * 0.25)];
var q2_487 = sorted487[Math.floor(sorted487.length * 0.5)];
var q3_487 = sorted487[Math.floor(sorted487.length * 0.75)];
var iqr487 = q3_487 - q1_487;
assert_equal(iqr487, 3);
var t488 = [1, 2, 3, 4, 5];
var h488 = { get(t, p) { return Reflect.get(t, p); } };
var p488 = new Proxy(t488, h488);
var sorted488 = [];
for (var i = 0; i < p488.length; i++) {
sorted488.push(p488[i]);
}
for (var i = 0; i < sorted488.length - 1; i++) {
for (var j = i + 1; j < sorted488.length; j++) {
if (sorted488[i] > sorted488[j]) {
var temp = sorted488[i];
sorted488[i] = sorted488[j];
sorted488[j] = temp;
}
}
}
var q1_488 = sorted488[Math.floor(sorted488.length * 0.25)];
var q3_488 = sorted488[Math.floor(sorted488.length * 0.75)];
var iqr488 = q3_488 - q1_488;
var lowerFence488 = q1_488 - 1.5 * iqr488;
var upperFence488 = q3_488 + 1.5 * iqr488;
var outliers488 = [];
for (var i = 0; i < p488.length; i++) {
if (p488[i] < lowerFence488 || p488[i] > upperFence488) {
outliers488.push(p488[i]);
}
}
assert_equal(outliers488.length, 0);
var t489 = [1, 2, 3, 4, 5];
var h489 = { get(t, p) { return Reflect.get(t, p); } };
var p489 = new Proxy(t489, h489);
var sum489 = 0;
for (var i = 0; i < p489.length; i++) {
sum489 += p489[i];
}
var mean489 = sum489 / p489.length;
var sumCubedDev489 = 0;
for (var i = 0; i < p489.length; i++) {
sumCubedDev489 += Math.pow(p489[i] - mean489, 3);
}
var skewness489 = sumCubedDev489 / p489.length;
assert_true(skewness489 > 0);
var t490 = [1, 2, 3, 4, 5];
var h490 = { get(t, p) { return Reflect.get(t, p); } };
var p490 = new Proxy(t490, h490);
var sum490 = 0;
for (var i = 0; i < p490.length; i++) {
sum490 += p490[i];
}
var mean490 = sum490 / p490.length;
var sumFourthDev490 = 0;
for (var i = 0; i < p490.length; i++) {
sumFourthDev490 += Math.pow(p490[i] - mean490, 4);
}
var kurtosis490 = sumFourthDev490 / p490.length;
assert_true(kurtosis490 > 0);
var t491 = [1, 2, 3, 4, 5];
var h491 = { get(t, p) { return Reflect.get(t, p); } };
var p491 = new Proxy(t491, h491);
var sum491 = 0;
for (var i = 0; i < p491.length; i++) {
sum491 += p491[i];
}
var mean491 = sum491 / p491.length;
var sumSq491 = 0;
for (var i = 0; i < p491.length; i++) {
sumSq491 += p491[i] * p491[i];
}
var variance491 = (sumSq491 / p491.length) - (mean491 * mean491);
var stdDev491 = Math.sqrt(variance491);
var sumZScores491 = 0;
for (var i = 0; i < p491.length; i++) {
sumZScores491 += (p491[i] - mean491) / stdDev491;
}
var meanZScore491 = sumZScores491 / p491.length;
assert_true(Math.abs(meanZScore491) < 0.0001);
var t492 = [1, 2, 3, 4, 5];
var h492 = { get(t, p) { return Reflect.get(t, p); } };
var p492 = new Proxy(t492, h492);
var geometricMean492 = 1;
for (var i = 0; i < p492.length; i++) {
geometricMean492 *= p492[i];
}
geometricMean492 = Math.pow(geometricMean492, 1 / p492.length);
assert_true(geometricMean492 > 0);
var t493 = [1, 2, 3, 4, 5];
var h493 = { get(t, p) { return Reflect.get(t, p); } };
var p493 = new Proxy(t493, h493);
var harmonicMean493 = 0;
for (var i = 0; i < p493.length; i++) {
harmonicMean493 += 1 / p493[i];
}
harmonicMean493 = p493.length / harmonicMean493;
assert_true(harmonicMean493 > 0);
var t494 = [1, 2, 3, 4, 5];
var h494 = { get(t, p) { return Reflect.get(t, p); } };
var p494 = new Proxy(t494, h494);
var weightedMean494 = 0;
var weights494 = [1, 2, 3, 4, 5];
var sumWeights494 = 0;
for (var i = 0; i < Math.min(p494.length, weights494.length); i++) {
weightedMean494 += p494[i] * weights494[i];
sumWeights494 += weights494[i];
}
weightedMean494 = weightedMean494 / sumWeights494;
assert_true(weightedMean494 > 0);
var t495 = [1, 2, 3, 4, 5];
var h495 = { get(t, p) { return Reflect.get(t, p); } };
var p495 = new Proxy(t495, h495);
var sum495 = 0;
for (var i = 0; i < p495.length; i++) {
sum495 += p495[i];
}
var mean495 = sum495 / p495.length;
var sumSquaredDiff495 = 0;
for (var i = 0; i < p495.length; i++) {
sumSquaredDiff495 += (p495[i] - mean495) * (p495[i] - mean495);
}
var variance495 = sumSquaredDiff495 / p495.length;
var stdDev495 = Math.sqrt(variance495);
var sumAbsZScores495 = 0;
for (var i = 0; i < p495.length; i++) {
sumAbsZScores495 += Math.abs((p495[i] - mean495) / stdDev495);
}
var meanAbsZScore495 = sumAbsZScores495 / p495.length;
assert_true(meanAbsZScore495 > 0);
var t496 = [1, 2, 3, 4, 5];
var h496 = { get(t, p) { return Reflect.get(t, p); } };
var p496 = new Proxy(t496, h496);
var sum496 = 0;
for (var i = 0; i < p496.length; i++) {
sum496 += p496[i];
}
var mean496 = sum496 / p496.length;
var sumSquaredDiff496 = 0;
for (var i = 0; i < p496.length; i++) {
sumSquaredDiff496 += (p496[i] - mean496) * (p496[i] - mean496);
}
var variance496 = sumSquaredDiff496 / p496.length;
var stdDev496 = Math.sqrt(variance496);
var sumSquaredZScores496 = 0;
for (var i = 0; i < p496.length; i++) {
sumSquaredZScores496 += ((p496[i] - mean496) / stdDev496) * ((p496[i] - mean496) / stdDev496);
}
var meanSquaredZScore496 = sumSquaredZScores496 / p496.length;
assert_true(meanSquaredZScore496 > 0);
var t497 = [1, 2, 3, 4, 5];
var h497 = { get(t, p) { return Reflect.get(t, p); } };
var p497 = new Proxy(t497, h497);
var sorted497 = [];
for (var i = 0; i < p497.length; i++) {
sorted497.push(p497[i]);
}
for (var i = 0; i < sorted497.length - 1; i++) {
for (var j = i + 1; j < sorted497.length; j++) {
if (sorted497[i] > sorted497[j]) {
var temp = sorted497[i];
sorted497[i] = sorted497[j];
sorted497[j] = temp;
}
}
}
var min497 = sorted497[0];
var max497 = sorted497[sorted497.length - 1];
var midRange497 = (min497 + max497) / 2;
assert_equal(midRange497, 3);
var t498 = [1, 2, 3, 4, 5];
var h498 = { get(t, p) { return Reflect.get(t, p); } };
var p498 = new Proxy(t498, h498);
var sum498 = 0;
for (var i = 0; i < p498.length; i++) {
sum498 += p498[i];
}
var mean498 = sum498 / p498.length;
var sumAbsDiff498 = 0;
for (var i = 0; i < p498.length; i++) {
for (var j = 0; j < p498.length; j++) {
sumAbsDiff498 += Math.abs(p498[i] - p498[j]);
}
}
var meanAbsDiff498 = sumAbsDiff498 / (p498.length * p498.length);
assert_true(meanAbsDiff498 > 0);
var t499 = [1, 2, 3, 4, 5];
var h499 = { get(t, p) { return Reflect.get(t, p); } };
var p499 = new Proxy(t499, h499);
var sum499 = 0;
for (var i = 0; i < p499.length; i++) {
sum499 += p499[i];
}
var mean499 = sum499 / p499.length;
var sumSquaredDiff499 = 0;
for (var i = 0; i < p499.length; i++) {
sumSquaredDiff499 += (p499[i] - mean499) * (p499[i] - mean499);
}
var variance499 = sumSquaredDiff499 / p499.length;
var stdDev499 = Math.sqrt(variance499);
var relStdDev499 = stdDev499 / mean499;
assert_true(relStdDev499 > 0);
var target500 = [1, 2, 3, 4, 5];
var handler500 = {
get(target, prop) {
if (prop === 'findLast') {
return function(predicate) {
return Array.prototype.findLast.call(target, predicate);
};
}
return Reflect.get(target, prop);
}
};
var proxy500 = new Proxy(target500, handler500);
assert_equal(proxy500.findLast(x => x < 4), 3);
assert_equal(proxy500.findLast(x => x > 10), undefined);
var target501 = [1, 2, 3, 4, 5];
var handler501 = {
get(target, prop) {
if (prop === 'findLastIndex') {
return function(predicate) {
return Array.prototype.findLastIndex.call(target, predicate);
};
}
return Reflect.get(target, prop);
}
};
var proxy501 = new Proxy(target501, handler501);
assert_equal(proxy501.findLastIndex(x => x < 4), 2);
assert_equal(proxy501.findLastIndex(x => x > 10), -1);
var target502 = [1, 2, 3, 4, 5];
var handler502 = {
get(target, prop) {
if (prop === 'toSpliced') {
return function(start, deleteCount, ...items) {
return Array.prototype.toSpliced.call(target, start, deleteCount, ...items);
};
}
return Reflect.get(target, prop);
}
};
var proxy502 = new Proxy(target502, handler502);
var result502 = proxy502.toSpliced(1, 2, 20, 30);
assert_equal(result502.length, 5);
assert_equal(result502[1], 20);
assert_equal(target502.length, 5);
var target503 = [1, 2, 3];
var handler503 = {
get(target, prop) {
if (prop === 'groupBy') {
return function(callback) {
return Array.prototype.groupBy.call(target, callback);
};
}
return Reflect.get(target, prop);
}
};
var proxy503 = new Proxy(target503, handler503);
var grouped503 = proxy503.groupBy(x => x % 2);
assert_true(grouped503[1].length === 2);
var target504 = [1, 2, 3, 4, 5];
var handler504 = {
get(target, prop) {
if (prop === 'groupByToMap') {
return function(callback) {
return Array.prototype.groupByToMap.call(target, callback);
};
}
return Reflect.get(target, prop);
}
};
var proxy504 = new Proxy(target504, handler504);
var groupedMap504 = proxy504.groupByToMap(x => x % 2);
assert_true(groupedMap504.get(1).length === 3);
var target505 = [1, 2, 3, 4, 5];
var handler505 = {
get(target, prop) {
if (prop === 'with') {
return function(index, value) {
return Array.prototype.with.call(target, index, value);
};
}
return Reflect.get(target, prop);
}
};
var proxy505 = new Proxy(target505, handler505);
var result505 = proxy505.with(0, 100);
assert_equal(result505[0], 100);
assert_equal(target505[0], 1);
var target506 = [1, 2, 3];
var handler506 = {
get(target, prop, receiver) {
if (typeof prop === 'symbol') {
return Reflect.get(target, prop, receiver);
}
const idx = parseInt(prop);
if (!isNaN(idx)) {
console.log(`Getting index ${idx}`);
}
return Reflect.get(target, prop, receiver);
},
set(target, prop, value, receiver) {
if (typeof prop === 'symbol') {
return Reflect.set(target, prop, value, receiver);
}
const idx = parseInt(prop);
if (!isNaN(idx)) {
console.log(`Setting index ${idx} to ${value}`);
}
return Reflect.set(target, prop, value, receiver);
}
};
var proxy506 = new Proxy(target506, handler506);
proxy506[0] = 10;
assert_equal(proxy506[0], 10);
var target507 = [1, 2, 3];
var handler507 = {
get(target, prop) {
if (prop === 'length') {
return target.length * 2;
}
return Reflect.get(target, prop);
}
};
var proxy507 = new Proxy(target507, handler507);
assert_equal(proxy507.length, 6);
var target508 = [1, 2, 3];
var handler508 = {
get(target, prop) {
if (prop === 'length') {
return target.length;
}
const idx = parseInt(prop);
if (!isNaN(idx) && idx >= 0 && idx < target.length) {
return target[idx] * 2;
}
return Reflect.get(target, prop);
}
};
var proxy508 = new Proxy(target508, handler508);
assert_equal(proxy508[0], 2);
assert_equal(proxy508[1], 4);
var target509 = [1, 2, 3];
var handler509 = {
get(target, prop) {
const value = Reflect.get(target, prop);
if (typeof value === 'function') {
return function(...args) {
console.log(`Calling ${prop} with args:`, args);
return value.apply(target, args);
};
}
return value;
}
};
var proxy509 = new Proxy(target509, handler509);
var result509 = proxy509.map(x => x * 2);
assert_equal(result509[0], 2);
var target510 = [1, 2, 3];
var getTrapCalled510 = false;
var handler510 = {
get(target, prop) {
getTrapCalled510 = true;
return Reflect.get(target, prop);
}
};
var proxy510 = new Proxy(target510, handler510);
var val510 = proxy510[0];
assert_true(getTrapCalled510);
var target511 = [1, 2, 3];
var setTrapCalled511 = false;
var handler511 = {
set(target, prop, value) {
setTrapCalled511 = true;
return Reflect.set(target, prop, value);
}
};
var proxy511 = new Proxy(target511, handler511);
proxy511[0] = 10;
assert_true(setTrapCalled511);
var target512 = [1, 2, 3];
var hasTrapCalled512 = false;
var handler512 = {
has(target, prop) {
hasTrapCalled512 = true;
return Reflect.has(target, prop);
}
};
var proxy512 = new Proxy(target512, handler512);
var exists512 = 0 in proxy512;
assert_true(hasTrapCalled512);
var target513 = [1, 2, 3];
var deleteTrapCalled513 = false;
var handler513 = {
deleteProperty(target, prop) {
deleteTrapCalled513 = true;
return Reflect.deleteProperty(target, prop);
}
};
var proxy513 = new Proxy(target513, handler513);
delete proxy513[0];
assert_true(deleteTrapCalled513);
var target514 = [1, 2, 3];
var definePropTrapCalled514 = false;
var handler514 = {
defineProperty(target, prop, descriptor) {
definePropTrapCalled514 = true;
return Reflect.defineProperty(target, prop, descriptor);
}
};
var proxy514 = new Proxy(target514, handler514);
Object.defineProperty(proxy514, 3, { value: 4 });
assert_true(definePropTrapCalled514);
var target515 = [1, 2, 3];
var ownKeysTrapCalled515 = false;
var handler515 = {
ownKeys(target) {
ownKeysTrapCalled515 = true;
return Reflect.ownKeys(target);
}
};
var proxy515 = new Proxy(target515, handler515);
Object.keys(proxy515);
assert_true(ownKeysTrapCalled515);
var target516 = [1, 2, 3];
var getProtoTrapCalled516 = false;
var handler516 = {
getPrototypeOf(target) {
getProtoTrapCalled516 = true;
return Reflect.getPrototypeOf(target);
}
};
var proxy516 = new Proxy(target516, handler516);
Object.getPrototypeOf(proxy516);
assert_true(getProtoTrapCalled516);
var target517 = [1, 2, 3];
var setProtoTrapCalled517 = false;
var handler517 = {
setPrototypeOf(target, proto) {
setProtoTrapCalled517 = true;
return Reflect.setPrototypeOf(target, proto);
}
};
var proxy517 = new Proxy(target517, handler517);
Object.setPrototypeOf(proxy517, {});
assert_true(setProtoTrapCalled517);
var target518 = [1, 2, 3];
var isExtensibleTrapCalled518 = false;
var handler518 = {
isExtensible(target) {
isExtensibleTrapCalled518 = true;
return Reflect.isExtensible(target);
}
};
var proxy518 = new Proxy(target518, handler518);
Object.isExtensible(proxy518);
assert_true(isExtensibleTrapCalled518);
var target519 = [1, 2, 3];
var preventExtensionsTrapCalled519 = false;
var handler519 = {
preventExtensions(target) {
preventExtensionsTrapCalled519 = true;
return Reflect.preventExtensions(target);
}
};
var proxy519 = new Proxy(target519, handler519);
Object.preventExtensions(proxy519);
assert_true(preventExtensionsTrapCalled519);
var target520 = [1, 2, 3];
var getOwnPropertyDescTrapCalled520 = false;
var handler520 = {
getOwnPropertyDescriptor(target, prop) {
getOwnPropertyDescTrapCalled520 = true;
return Reflect.getOwnPropertyDescriptor(target, prop);
}
};
var proxy520 = new Proxy(target520, handler520);
Object.getOwnPropertyDescriptor(proxy520, 0);
assert_true(getOwnPropertyDescTrapCalled520);
var handler1 = {
construct(target, args) {
return Reflect.construct(target, args);
}
};
var proxy1 = new Proxy(Array, handler1);
var arr1 = new proxy1(1, 2, 3);
assertable(arr1.length === 3);
var handler2 = {
construct(target, args) {
if (args.length === 1 && typeof args[0] === 'number') {
return Reflect.construct(target, args);
}
return Reflect.construct(target, args);
}
};
var proxy2 = new Proxy(Array, handler2);
var arr2 = new proxy2(5);
assertable(arr2.length === 5);
var handler3 = {
construct(target, args) {
console.log('Array called with:', args);
return Reflect.construct(target, args);
}
};
var proxy3 = new Proxy(Array, handler3);
var arr3 = new proxy3(1, 2, 3);
assertable(arr3.length === 3);
var handler4 = {
construct(target, args) {
const result = Reflect.construct(target, args);
result.customProp = 'custom';
return result;
}
};
var proxy4 = new Proxy(Array, handler4);
var arr4 = new proxy4(1, 2, 3);
assertable(arr4.customProp === 'custom');
var handler5 = {
construct(target, args) {
if (args.length === 0) {
return Reflect.construct(target, [10]);
}
return Reflect.construct(target, args);
}
};
var proxy5 = new Proxy(Array, handler5);
var arr5 = new proxy5();
assertable(arr5.length === 10);
var target530 = [1, 2, 3];
var handler530 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy530 = new Proxy(target530, handler530);
var arr530 = Array.from(proxy530);
assert_equal(arr530.length, 3);
assert_equal(arr530[0], 1);
var target531 = 'abc';
var handler531 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy531 = new Proxy(target531, handler531);
var arr531 = Array.from(proxy531);
assert_equal(arr531.length, 3);
assert_equal(arr531[0], 'a');
var target532 = [1, 2, 3];
var handler532 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy532 = new Proxy(target532, handler532);
var arr532 = Array.from(proxy532, x => x * 2);
assert_equal(arr532[0], 2);
var target533 = { 0: 'a', 1: 'b', 2: 'c', length: 3 };
var handler533 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy533 = new Proxy(target533, handler533);
var arr533 = Array.from(proxy533);
assert_equal(arr533.length, 3);
assert_equal(arr533[0], 'a');
var handler540 = {
construct(target, args) {
return Reflect.construct(target, args);
}
};
var proxy540 = new Proxy(Array, handler540);
var arr540 = proxy540.of(1, 2, 3);
assert_equal(arr540.length, 3);
assert_equal(arr540[0], 1);
var handler541 = {
construct(target, args) {
const result = Reflect.construct(target, args);
result.fromOf = true;
return result;
}
};
var proxy541 = new Proxy(Array, handler541);
var arr541 = proxy541.of(1, 2, 3);
assert_true(arr541.fromOf);
var target550 = [1, 2, 3];
var handler550 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy550 = new Proxy(target550, handler550);
assert_true(Array.isArray(proxy550));
var target551 = { length: 3 };
var handler551 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy551 = new Proxy(target551, handler551);
assert_true(!Array.isArray(proxy551));
var target560 = [1, 2, 3];
var handler560 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy560 = new Proxy(target560, handler560);
var result560 = [0].concat(proxy560);
assert_equal(result560.length, 4);
assert_equal(result560[0], 0);
assert_equal(result560[1], 1);
var target561 = [1, 2, 3];
target561[Symbol.isConcatSpreadable] = false;
var handler561 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy561 = new Proxy(target561, handler561);
var result561 = [0].concat(proxy561);
assert_equal(result561.length, 2);
var target562 = [1, 2, 3];
var handler562 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy562 = new Proxy(target562, handler562);
var result562 = proxy562.concat([4, 5]);
assert_equal(result562.length, 5);
assert_equal(result562[3], 4);
var target570 = [1, 2, 3, 4, 5];
var handler570 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy570 = new Proxy(target570, handler570);
var result570 = proxy570.copyWithin(0, 2, 4);
assert_equal(result570[0], 3);
assert_equal(result570[1], 4);
var target571 = [1, 2, 3, 4, 5];
var handler571 = {
get(target, prop) {
return Reflect.get(target, prop);
},
set(target, prop, value) {
return Reflect.set(target, prop, value);
}
};
var proxy571 = new Proxy(target571, handler571);
proxy571.copyWithin(0, 2);
assert_equal(proxy571[0], 3);
assert_equal(proxy571[2], 3);
var target580 = ['a', 'b', 'c'];
var handler580 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy580 = new Proxy(target580, handler580);
var entries580 = proxy580.entries();
var first580 = entries580.next().value;
assert_equal(first580[0], 0);
assert_equal(first580[1], 'a');
var target581 = ['a', 'b', 'c'];
var handler581 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy581 = new Proxy(target581, handler581);
var keys581 = proxy581.keys();
assert_equal(keys581.next().value, 0);
assert_equal(keys581.next().value, 1);
var target582 = ['a', 'b', 'c'];
var handler582 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy582 = new Proxy(target582, handler582);
var values582 = proxy582.values();
assert_equal(values582.next().value, 'a');
assert_equal(values582.next().value, 'b');
var target590 = [1, 2, 3, 4, 5];
var handler590 = {
get(target, prop) {
return Reflect.get(target, prop);
},
set(target, prop, value) {
return Reflect.set(target, prop, value);
}
};
var proxy590 = new Proxy(target590, handler590);
proxy590.fill(0, 1, 3);
assert_equal(proxy590[0], 1);
assert_equal(proxy590[1], 0);
assert_equal(proxy590[2], 0);
assert_equal(proxy590[3], 4);
var target591 = [1, 2, 3];
var handler591 = {
get(target, prop) {
return Reflect.get(target, prop);
},
set(target, prop, value) {
return Reflect.set(target, prop, value);
}
};
var proxy591 = new Proxy(target591, handler591);
proxy591.fill(5);
assert_equal(proxy591[0], 5);
assert_equal(proxy591[1], 5);
assert_equal(proxy591[2], 5);
var target600 = [1, 2, 3, 4, 5];
var handler600 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy600 = new Proxy(target600, handler600);
var filtered600 = proxy600.filter(x => x > 2);
assert_equal(filtered600.length, 3);
assert_equal(filtered600[0], 3);
var target601 = [1, 2, 3, 4, 5];
var handler601 = {
get(target, prop) {
if (prop === 'filter') {
return function(predicate) {
return target.filter(predicate).map(x => x * 2);
};
}
return Reflect.get(target, prop);
}
};
var proxy601 = new Proxy(target601, handler601);
var filtered601 = proxy601.filter(x => x > 2);
assert_equal(filtered601[0], 6);
var target610 = [1, 2, 3, 4, 5];
var handler610 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy610 = new Proxy(target610, handler610);
assert_equal(proxy610.find(x => x > 3), 4);
assert_equal(proxy610.findIndex(x => x > 3), 3);
var target611 = [1, 2, 3, 4, 5];
var handler611 = {
get(target, prop) {
if (prop === 'find') {
return function(predicate) {
const result = target.find(predicate);
return result ? result * 2 : undefined;
};
}
return Reflect.get(target, prop);
}
};
var proxy611 = new Proxy(target611, handler611);
assert_equal(proxy611.find(x => x > 3), 8);
var target620 = [1, [2, [3, [4]]]];
var handler620 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy620 = new Proxy(target620, handler620);
var flat620 = proxy620.flat(2);
assert_equal(flat620.length, 4);
assert_equal(flat620[0], 1);
assert_equal(flat620[1], 2);
var target621 = [1, 2, 3];
var handler621 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy621 = new Proxy(target621, handler621);
var flatMap621 = proxy621.flatMap(x => [x, x * 2]);
assert_equal(flatMap621.length, 6);
assert_equal(flatMap621[0], 1);
assert_equal(flatMap621[1], 2);
var target630 = [1, 2, 3];
var handler630 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy630 = new Proxy(target630, handler630);
var sum630 = 0;
proxy630.forEach(x => { sum630 += x; });
assert_equal(sum630, 6);
var target631 = [1, 2, 3];
var handler631 = {
get(target, prop) {
if (prop === 'forEach') {
return function(callback) {
let count = 0;
target.forEach((x, i, arr) => {
callback(x * 2, i, arr);
count++;
});
return count;
};
}
return Reflect.get(target, prop);
}
};
var proxy631 = new Proxy(target631, handler631);
var count631 = proxy631.forEach(x => {});
assert_equal(count631, 3);
var target640 = [1, 2, 3, 4, 5];
var handler640 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy640 = new Proxy(target640, handler640);
assert_true(proxy640.includes(3));
assert_equal(proxy640.indexOf(3), 2);
assert_equal(proxy640.lastIndexOf(3), 2);
var target641 = [1, 2, 3, 2, 1];
var handler641 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy641 = new Proxy(target641, handler641);
assert_equal(proxy641.indexOf(2), 1);
assert_equal(proxy641.lastIndexOf(2), 3);
var target650 = [1, 2, 3];
var handler650 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy650 = new Proxy(target650, handler650);
assert_equal(proxy650.join(), '1,2,3');
assert_equal(proxy650.join('-'), '1-2-3');
var target651 = ['a', 'b', 'c'];
var handler651 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy651 = new Proxy(target651, handler651);
assert_equal(proxy651.join(''), 'abc');
var target660 = [1, 2, 3];
var handler660 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy660 = new Proxy(target660, handler660);
var mapped660 = proxy660.map(x => x * 2);
assert_equal(mapped660.length, 3);
assert_equal(mapped660[0], 2);
var target661 = [1, 2, 3];
var handler661 = {
get(target, prop) {
if (prop === 'map') {
return function(callback) {
return target.map(callback).map(x => x + 1);
};
}
return Reflect.get(target, prop);
}
};
var proxy661 = new Proxy(target661, handler661);
var mapped661 = proxy661.map(x => x * 2);
assert_equal(mapped661[0], 3);
var target670 = [1, 2, 3];
var handler670 = {
get(target, prop) {
return Reflect.get(target, prop);
},
set(target, prop, value) {
return Reflect.set(target, prop, value);
}
};
var proxy670 = new Proxy(target670, handler670);
assert_equal(proxy670.pop(), 3);
assert_equal(proxy670.length, 2);
assert_equal(proxy670.push(4), 3);
assert_equal(proxy670[2], 4);
var target671 = [1, 2, 3];
var handler671 = {
get(target, prop) {
if (prop === 'push') {
return function(...args) {
const result = target.push(...args);
return result * 2;
};
}
return Reflect.get(target, prop);
}
};
var proxy671 = new Proxy(target671, handler671);
var result671 = proxy671.push(4);
assert_equal(result671, 8);
var target680 = [1, 2, 3, 4, 5];
var handler680 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy680 = new Proxy(target680, handler680);
assert_equal(proxy680.reduce((a, b) => a + b, 0), 15);
assert_equal(proxy680.reduceRight((a, b) => a - b, 0), -15);
var target681 = [1, 2, 3];
var handler681 = {
get(target, prop) {
if (prop === 'reduce') {
return function(callback, init) {
const result = target.reduce(callback, init);
return result * 2;
};
}
return Reflect.get(target, prop);
}
};
var proxy681 = new Proxy(target681, handler681);
assert_equal(proxy681.reduce((a, b) => a + b, 0), 12);
var target690 = [1, 2, 3, 4, 5];
var handler690 = {
get(target, prop) {
return Reflect.get(target, prop);
},
set(target, prop, value) {
return Reflect.set(target, prop, value);
}
};
var proxy690 = new Proxy(target690, handler690);
var reversed690 = proxy690.reverse();
assert_equal(reversed690[0], 5);
assert_equal(reversed690[4], 1);
var target700 = [1, 2, 3];
var handler700 = {
get(target, prop) {
return Reflect.get(target, prop);
},
set(target, prop, value) {
return Reflect.set(target, prop, value);
}
};
var proxy700 = new Proxy(target700, handler700);
assert_equal(proxy700.shift(), 1);
assert_equal(proxy700.length, 2);
assert_equal(proxy700.unshift(0), 3);
assert_equal(proxy700[0], 0);
var target710 = [1, 2, 3, 4, 5];
var handler710 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy710 = new Proxy(target710, handler710);
var sliced710 = proxy710.slice(1, 3);
assert_equal(sliced710.length, 2);
assert_equal(sliced710[0], 2);
var target720 = [1, 2, 3, 4, 5];
var handler720 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy720 = new Proxy(target720, handler720);
assert_true(proxy720.some(x => x > 3));
assert_true(proxy720.every(x => x > 0));
var target730 = [5, 2, 8, 1, 9];
var handler730 = {
get(target, prop) {
return Reflect.get(target, prop);
},
set(target, prop, value) {
return Reflect.set(target, prop, value);
}
};
var proxy730 = new Proxy(target730, handler730);
var sorted730 = proxy730.sort((a, b) => a - b);
assert_equal(sorted730[0], 1);
assert_equal(sorted730[4], 9);
var target740 = [1, 2, 3, 4, 5];
var handler740 = {
get(target, prop) {
return Reflect.get(target, prop);
},
set(target, prop, value) {
return Reflect.set(target, prop, value);
}
};
var proxy740 = new Proxy(target740, handler740);
var removed740 = proxy740.splice(1, 2, 20, 30);
assert_equal(removed740.length, 2);
assert_equal(proxy740[1], 20);
var target750 = [1, 2, 3];
var handler750 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy750 = new Proxy(target750, handler750);
assert_equal(proxy750.toString(), '1,2,3');
var target760 = [1, 2, 3, 4, 5];
var handler760 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy760 = new Proxy(target760, handler760);
assert_equal(proxy760.at(0), 1);
assert_equal(proxy760.at(-1), 5);
assert_equal(proxy760.at(10), undefined);
var target770 = [];
for (let i = 0; i < 1000; i++) {
target770[i] = i;
}
var handler770 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy770 = new Proxy(target770, handler770);
assert_equal(proxy770[999], 999);
var target771 = [];
for (let i = 0; i < 500; i++) {
target771[i] = i;
}
var handler771 = {
get(target, prop) {
if (prop === 'map') {
return function(callback) {
return target.map(callback);
};
}
return Reflect.get(target, prop);
}
};
var proxy771 = new Proxy(target771, handler771);
var mapped771 = proxy771.map(x => x * 2);
assert_equal(mapped771[499], 998);
var target772 = [];
for (let i = 0; i < 300; i++) {
target772[i] = i;
}
var handler772 = {
get(target, prop) {
if (prop === 'filter') {
return function(predicate) {
return target.filter(predicate);
};
}
return Reflect.get(target, prop);
}
};
var proxy772 = new Proxy(target772, handler772);
var filtered772 = proxy772.filter(x => x % 2 === 0);
assert_equal(filtered772.length, 150);
var target773 = [];
for (let i = 0; i < 200; i++) {
target773[i] = i + 1;
}
var handler773 = {
get(target, prop) {
if (prop === 'reduce') {
return function(callback, init) {
return target.reduce(callback, init);
};
}
return Reflect.get(target, prop);
}
};
var proxy773 = new Proxy(target773, handler773);
var sum773 = proxy773.reduce((a, b) => a + b, 0);
assert_equal(sum773, 20100);
var target774 = [];
for (let i = 0; i < 100; i++) {
target774[i] = i;
}
var handler774 = {
get(target, prop) {
if (prop === 'forEach') {
return function(callback) {
target.forEach(callback);
};
}
return Reflect.get(target, prop);
}
};
var proxy774 = new Proxy(target774, handler774);
var sum774 = 0;
proxy774.forEach(x => { sum774 += x; });
assert_equal(sum774, 4950);
var target780 = [1, 2, 3];
var handler780 = {
get(target, prop) {
if (prop === 'error') {
throw new Error('Custom error');
}
return Reflect.get(target, prop);
}
};
var proxy780 = new Proxy(target780, handler780);
var error780 = false;
try {
proxy780.error;
} catch (e) {
error780 = true;
}
assert_true(error780);
var target781 = [1, 2, 3];
var handler781 = {
set(target, prop, value) {
if (value < 0) {
throw new Error('Negative value not allowed');
}
return Reflect.set(target, prop, value);
}
};
var proxy781 = new Proxy(target781, handler781);
var error781 = false;
try {
proxy781[0] = -1;
} catch (e) {
error781 = true;
}
assert_true(error781);
var target790 = [1, 2, 3];
var sym790 = Symbol('test');
target790[sym790] = 'value';
var handler790 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy790 = new Proxy(target790, handler790);
assert_equal(proxy790[sym790], 'value');
var target791 = [1, 2, 3];
var handler791 = {
get(target, prop) {
if (prop === Symbol.iterator) {
return function() {
let index = 0;
return {
next() {
if (index < target.length) {
return { value: target[index++], done: false };
}
return { done: true };
}
};
};
}
return Reflect.get(target, prop);
}
};
var proxy791 = new Proxy(target791, handler791);
var arr791 = [...proxy791];
assert_equal(arr791.length, 3);
var target800 = [1, 2, 3];
var handler800 = {
get(target, prop) {
return Reflect.get(target, prop);
},
set(target, prop, value) {
throw new Error('Array is immutable');
},
deleteProperty(target, prop) {
throw new Error('Array is immutable');
}
};
var proxy800 = new Proxy(target800, handler800);
assert_equal(proxy800[0], 1);
var error800 = false;
try {
proxy800[0] = 10;
} catch (e) {
error800 = true;
}
assert_true(error800);
var target810 = [1, 2, 3];
var handler810 = {
get(target, prop) {
const value = Reflect.get(target, prop);
if (typeof value === 'number' && (value < 0 || value > 100)) {
throw new Error('Value out of range');
}
return value;
},
set(target, prop, value) {
if (typeof value === 'number' && (value < 0 || value > 100)) {
throw new Error('Value out of range');
}
return Reflect.set(target, prop, value);
}
};
var proxy810 = new Proxy(target810, handler810);
assert_equal(proxy810[0], 1);
proxy810[1] = 50;
assert_equal(proxy810[1], 50);
var error810 = false;
try {
proxy810[2] = 200;
} catch (e) {
error810 = true;
}
assert_true(error810);
var target820 = [1, 2, 3];
var handler820 = {
get(target, prop) {
console.log(`Getting ${prop}`);
return Reflect.get(target, prop);
},
set(target, prop, value) {
console.log(`Setting ${prop} to ${value}`);
return Reflect.set(target, prop, value);
}
};
var proxy820 = new Proxy(target820, handler820);
proxy820[0] = 10;
assert_equal(proxy820[0], 10);
var target830 = [1, 2, 3];
var cache830 = new Map();
var handler830 = {
get(target, prop) {
if (cache830.has(prop)) {
return cache830.get(prop);
}
const value = Reflect.get(target, prop);
cache830.set(prop, value);
return value;
}
};
var proxy830 = new Proxy(target830, handler830);
assert_equal(proxy830[0], 1);
assert_true(cache830.has('0'));
var target840 = { 0: 'a', 1: 'b', 2: 'c', length: 3 };
var handler840 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy840 = new Proxy(target840, handler840);
assert_equal(proxy840[0], 'a');
assert_equal(proxy840.length, 3);
var target850 = [1, , , 4, 5];
var handler850 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy850 = new Proxy(target850, handler850);
assert_equal(proxy850[0], 1);
assert_equal(proxy850[1], undefined);
assert_equal(proxy850[3], 4);
var target860 = [1, 'string', true, null, undefined, { key: 'value' }, [1, 2]];
var handler860 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy860 = new Proxy(target860, handler860);
assert_equal(proxy860[0], 1);
assert_equal(proxy860[1], 'string');
assert_true(proxy860[2]);
assert_true(proxy860[3] === null);
assert_true(proxy860[4] === undefined);
assert_equal(proxy860[5].key, 'value');
assert_equal(proxy860[6][0], 1);
var target870 = [{ id: 1 }, { id: 2 }, { id: 3 }];
var handler870 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy870 = new Proxy(target870, handler870);
assert_equal(proxy870[0].id, 1);
assert_equal(proxy870[1].id, 2);
var target871 = [{ id: 1 }, { id: 2 }, { id: 3 }];
var handler871 = {
get(target, prop) {
if (prop === 'findById') {
return function(id) {
return target.find(item => item.id === id);
};
}
return Reflect.get(target, prop);
}
};
var proxy871 = new Proxy(target871, handler871);
assert_equal(proxy871.findById(2).id, 2);
var target880 = [[1, 2], [3, 4], [5, 6]];
var handler880 = {
get(target, prop) {
return Reflect.get(target, prop);
}
};
var proxy880 = new Proxy(target880, handler880);
assert_equal(proxy880[0][0], 1);
assert_equal(proxy880[1][1], 4);
var target881 = [[1, 2], [3, 4], [5, 6]];
var handler881 = {
get(target, prop) {
const value = Reflect.get(target, prop);
if (Array.isArray(value)) {
return new Proxy(value, {
get(t, p) { return Reflect.get(t, p); }
});
}
return value;
}
};
var proxy881 = new Proxy(target881, handler881);
assert_equal(proxy881[0][0], 1);
var target890 = [1, 2, 3, 4, 5];
var handler890 = {
get(target, prop) {
const method = Reflect.get(target, prop);
if (typeof method === 'function') {
return function(...args) {
const result = Reflect.apply(method, target, args);
if (Array.isArray(result)) {
return new Proxy(result, handler890);
}
return result;
};
}
return method;
}
};
var proxy890 = new Proxy(target890, handler890);
var result890 = proxy890.filter(x => x > 2).map(x => x * 2).reduce((a, b) => a + b, 0);
assert_equal(result890, 24);
var target900 = [1, 2, 3, 4, 5];
var handler900 = {
get(target, prop) {
if (prop === 'sum') {
return target.reduce((a, b) => a + b, 0);
}
if (prop === 'average') {
return target.reduce((a, b) => a + b, 0) / target.length;
}
if (prop === 'min') {
return Math.min(...target);
}
if (prop === 'max') {
return Math.max(...target);
}
return Reflect.get(target, prop);
}
};
var proxy900 = new Proxy(target900, handler900);
assert_equal(proxy900.sum, 15);
assert_equal(proxy900.average, 3);
assert_equal(proxy900.min, 1);
assert_equal(proxy900.max, 5);
var target910 = [1, 2, 3, 4, 5];
var handler910 = {
get(target, prop) {
if (prop === 'first') {
return target[0];
}
if (prop === 'last') {
return target[target.length - 1];
}
if (prop === 'isEmpty') {
return target.length === 0;
}
return Reflect.get(target, prop);
}
};
var proxy910 = new Proxy(target910, handler910);
assert_equal(proxy910.first, 1);
assert_equal(proxy910.last, 5);
assert_true(!proxy910.isEmpty);
var target920 = [1, 2, 3];
var handler920 = {
get(target, prop) {
if (prop === 'doubled') {
return target.map(x => x * 2);
}
if (prop === 'tripled') {
return target.map(x => x * 3);
}
if (prop === 'squared') {
return target.map(x => x * x);
}
return Reflect.get(target, prop);
}
};
var proxy920 = new Proxy(target920, handler920);
assert_equal(proxy920.doubled[0], 2);
assert_equal(proxy920.tripled[1], 6);
assert_equal(proxy920.squared[2], 9);
var target930 = [1, 2, 3, 4, 5];
var handler930 = {
get(target, prop) {
if (prop === 'evens') {
return target.filter(x => x % 2 === 0);
}
if (prop === 'odds') {
return target.filter(x => x % 2 !== 0);
}
if (prop === 'greaterThan') {
return function(threshold) {
return target.filter(x => x > threshold);
};
}
return Reflect.get(target, prop);
}
};
var proxy930 = new Proxy(target930, handler930);
assert_equal(proxy930.evens.length, 2);
assert_equal(proxy930.odds.length, 3);
assert_equal(proxy930.greaterThan(3).length, 2);
var target940 = [1, 2, 3, 4, 5];
var handler940 = {
get(target, prop) {
if (prop === 'contains') {
return function(value) {
return target.includes(value);
};
}
if (prop === 'indexOf') {
return function(value) {
return target.indexOf(value);
};
}
return Reflect.get(target, prop);
}
};
var proxy940 = new Proxy(target940, handler940);
assert_true(proxy940.contains(3));
assert_true(!proxy940.contains(10));
assert_equal(proxy940.indexOf(4), 3);
var target950 = [5, 2, 8, 1, 9];
var handler950 = {
get(target, prop) {
if (prop === 'ascending') {
return [...target].sort((a, b) => a - b);
}
if (prop === 'descending') {
return [...target].sort((a, b) => b - a);
}
return Reflect.get(target, prop);
}
};
var proxy950 = new Proxy(target950, handler950);
assert_equal(proxy950.ascending[0], 1);
assert_equal(proxy950.descending[0], 9);
var target960 = [1, 2, 3];
var handler960 = {
get(target, prop) {
if (prop === 'without') {
return function(...values) {
return target.filter(x => !values.includes(x));
};
}
if (prop === 'unique') {
return [...new Set(target)];
}
return Reflect.get(target, prop);
}
};
var proxy960 = new Proxy(target960, handler960);
var without960 = proxy960.without(2);
assert_equal(without960.length, 2);
var target961 = [1, 2, 2, 3, 3, 3];
var handler961 = {
get(target, prop) {
if (prop === 'unique') {
return [...new Set(target)];
}
return Reflect.get(target, prop);
}
};
var proxy961 = new Proxy(target961, handler961);
assert_equal(proxy961.unique.length, 3);
var target970 = [1, 2, 3, 4, 5];
var handler970 = {
get(target, prop) {
if (prop === 'partition') {
return function(predicate) {
const truthy = [];
const falsy = [];
target.forEach(x => {
if (predicate(x)) {
truthy.push(x);
} else {
falsy.push(x);
}
});
return [truthy, falsy];
};
}
return Reflect.get(target, prop);
}
};
var proxy970 = new Proxy(target970, handler970);
var partition970 = proxy970.partition(x => x > 2);
assert_equal(partition970[0].length, 3);
assert_equal(partition970[1].length, 2);
var target980 = [1, 2, 3, 4, 5];
var handler980 = {
get(target, prop) {
if (prop === 'groupBy') {
return function(keyFn) {
const groups = {};
target.forEach(x => {
const key = keyFn(x);
if (!groups[key]) {
groups[key] = [];
}
groups[key].push(x);
});
return groups;
};
}
return Reflect.get(target, prop);
}
};
var proxy980 = new Proxy(target980, handler980);
var grouped980 = proxy980.groupBy(x => x % 2);
assert_equal(grouped980[0].length, 2);
assert_equal(grouped980[1].length, 3);
var target990 = [1, [2, [3, [4]]]];
var handler990 = {
get(target, prop) {
if (prop === 'flatten') {
return function(depth = Infinity) {
const result = [];
const flatten = (arr, d) => {
arr.forEach(x => {
if (Array.isArray(x) && d > 0) {
flatten(x, d - 1);
} else {
result.push(x);
}
});
};
flatten(target, depth);
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy990 = new Proxy(target990, handler990);
var flattened990 = proxy990.flatten(2);
assert_equal(flattened990.length, 4);
var target1000 = [1, 2, 3];
var handler1000 = {
get(target, prop) {
if (prop === 'zip') {
return function(...arrays) {
const result = [];
const maxLength = Math.max(target.length, ...arrays.map(a => a.length));
for (let i = 0; i < maxLength; i++) {
const tuple = [target[i]];
arrays.forEach(arr => tuple.push(arr[i]));
result.push(tuple);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1000 = new Proxy(target1000, handler1000);
var zipped1000 = proxy1000.zip([4, 5, 6], [7, 8, 9]);
assert_equal(zipped1000[0].length, 3);
assert_equal(zipped1000[0][0], 1);
assert_equal(zipped1000[0][1], 4);
var target1010 = [1, 2, 3, 4, 5, 6];
var handler1010 = {
get(target, prop) {
if (prop === 'chunk') {
return function(size) {
const result = [];
for (let i = 0; i < target.length; i += size) {
result.push(target.slice(i, i + size));
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1010 = new Proxy(target1010, handler1010);
var chunked1010 = proxy1010.chunk(2);
assert_equal(chunked1010.length, 3);
assert_equal(chunked1010[0].length, 2);
var target1020 = [1, 2, 3, 4, 5];
var handler1020 = {
get(target, prop) {
if (prop === 'sample') {
return function(count) {
const result = [];
const indices = new Set();
while (indices.size < count && indices.size < target.length) {
indices.add(Math.floor(Math.random() * target.length));
}
indices.forEach(i => result.push(target[i]));
return result;
};
}
if (prop === 'shuffle') {
return function() {
const result = [...target];
for (let i = result.length - 1; i > 0; i--) {
const j = Math.floor(Math.random() * (i + 1));
[result[i], result[j]] = [result[j], result[i]];
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1020 = new Proxy(target1020, handler1020);
var sampled1020 = proxy1020.sample(3);
assert_true(sampled1020.length <= 3);
var target1030 = [1, 2, 3];
var handler1030 = {
get(target, prop) {
if (prop === 'equals') {
return function(other) {
if (target.length !== other.length) {
return false;
}
return target.every((x, i) => x === other[i]);
};
}
return Reflect.get(target, prop);
}
};
var proxy1030 = new Proxy(target1030, handler1030);
assert_true(proxy1030.equals([1, 2, 3]));
assert_true(!proxy1030.equals([1, 2, 4]));
var target1040 = [1, 2, 3];
var handler1040 = {
get(target, prop) {
if (prop === 'intersection') {
return function(other) {
return target.filter(x => other.includes(x));
};
}
if (prop === 'union') {
return function(other) {
return [...new Set([...target, ...other])];
};
}
if (prop === 'difference') {
return function(other) {
return target.filter(x => !other.includes(x));
};
}
return Reflect.get(target, prop);
}
};
var proxy1040 = new Proxy(target1040, handler1040);
var intersection1040 = proxy1040.intersection([2, 3, 4]);
assert_equal(intersection1040.length, 2);
var union1040 = proxy1040.union([3, 4, 5]);
assert_equal(union1040.length, 5);
var difference1040 = proxy1040.difference([2, 3]);
assert_equal(difference1040.length, 1);
var target1050 = [1, 2, 3, 4, 5];
var handler1050 = {
get(target, prop) {
if (prop === 'accumulate') {
return function(fn = (a, b) => a + b) {
const result = [];
let acc = target[0];
result.push(acc);
for (let i = 1; i < target.length; i++) {
acc = fn(acc, target[i]);
result.push(acc);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1050 = new Proxy(target1050, handler1050);
var accumulated1050 = proxy1050.accumulate();
assert_equal(accumulated1050[0], 1);
assert_equal(accumulated1050[4], 15);
var target1060 = [1, 2, 3, 4, 5];
var handler1060 = {
get(target, prop) {
if (prop === 'window') {
return function(size) {
const result = [];
for (let i = 0; i <= target.length - size; i++) {
result.push(target.slice(i, i + size));
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1060 = new Proxy(target1060, handler1060);
var windowed1060 = proxy1060.window(3);
assert_equal(windowed1060.length, 3);
assert_equal(windowed1060[0].length, 3);
var target1070 = [1, 2, 3, 4, 5];
var handler1070 = {
get(target, prop) {
if (prop === 'rotateLeft') {
return function(n) {
const result = [...target];
for (let i = 0; i < n; i++) {
result.push(result.shift());
}
return result;
};
}
if (prop === 'rotateRight') {
return function(n) {
const result = [...target];
for (let i = 0; i < n; i++) {
result.unshift(result.pop());
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1070 = new Proxy(target1070, handler1070);
var rotated1070 = proxy1070.rotateLeft(2);
assert_equal(rotated1070[0], 3);
assert_equal(rotated1070[4], 2);
var target1080 = [1, 2, 3, 4, 5];
var handler1080 = {
get(target, prop) {
if (prop === 'reversed') {
return [...target].reverse();
}
return Reflect.get(target, prop);
}
};
var proxy1080 = new Proxy(target1080, handler1080);
assert_equal(proxy1080.reversed[0], 5);
assert_equal(proxy1080.reversed[4], 1);
var target1090 = [1, 2, 3];
var handler1090 = {
get(target, prop) {
if (prop === 'padLeft') {
return function(length, value) {
const result = [...target];
while (result.length < length) {
result.unshift(value);
}
return result;
};
}
if (prop === 'padRight') {
return function(length, value) {
const result = [...target];
while (result.length < length) {
result.push(value);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1090 = new Proxy(target1090, handler1090);
var padded1090 = proxy1090.padRight(5, 0);
assert_equal(padded1090.length, 5);
assert_equal(padded1090[3], 0);
var target1100 = [0, 0, 1, 2, 3, 0, 0];
var handler1100 = {
get(target, prop) {
if (prop === 'trim') {
return function(value) {
let start = 0;
let end = target.length;
while (start < end && target[start] === value) {
start++;
}
while (end > start && target[end - 1] === value) {
end--;
}
return target.slice(start, end);
};
}
return Reflect.get(target, prop);
}
};
var proxy1100 = new Proxy(target1100, handler1100);
var trimmed1100 = proxy1100.trim(0);
assert_equal(trimmed1100.length, 3);
assert_equal(trimmed1100[0], 1);
var target1110 = [1, 2, 3, 4, 5];
var handler1110 = {
get(target, prop) {
if (prop === 'range') {
return function(start, end) {
return target.slice(start, end);
};
}
return Reflect.get(target, prop);
}
};
var proxy1110 = new Proxy(target1110, handler1110);
var ranged1110 = proxy1110.range(1, 4);
assert_equal(ranged1110.length, 3);
assert_equal(ranged1110[0], 2);
var target1120 = [1, 2, 3];
var handler1120 = {
get(target,又prop) {
if (prop === 'insert') {
return function(index, ...values) {
const result = [...target];
result.splice(index, 0, ...values);
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1120 = new Proxy(target1120, handler1120);
var inserted1120 = proxy1120.insert(1, 10, 20);
assert_equal(inserted1120.length, 5);
assert_equal(inserted1120[1], 10);
var target1130 = [1, 2, 3, 4, 5];
var handler1130 = {
get(target, prop) {
if (prop === 'remove') {
return function(index, count = 1) {
const result = [...target];
result.splice(index, count);
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1130 = new Proxy(target1130, handler1130);
var removed1130 = proxy1130.remove(1, 2);
assert_equal(removed1130.length, 3);
assert_equal(removed1130[0], 1);
var target1140 = [1, 2, 3, 4, 5];
var handler1140 = {
get(target, prop) {
if (prop === 'replace') {
return function(oldValue, newValue) {
return target.map(x => x === oldValue ? newValue : x);
};
}
return Reflect.get(target, prop);
}
};
var proxy1140 = new Proxy(target1140, handler1140);
var replaced1140 = proxy1140.replace(3, 30);
assert_equal(replaced1140[2], 30);
var target1150 = [1, 2, 3, 4, 5];
var handler1150 = {
get(target, prop) {
if (prop === 'swap') {
return function(i, j) {
const result = [...target];
[result[i], result[j]] = [result[j], result[i]];
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1150 = new Proxy(target1150, handler1150);
var swapped1150 = proxy1150.swap(0, 4);
assert_equal(swapped1150[0], 5);
assert_equal(swapped1150[4], 1);
var target1160 = [1, 2, 2, 3, 3, 3];
var handler1160 = {
get(target, prop) {
if (prop === 'frequency') {
return function() {
const freq = {};
target.forEach(x => {
freq[x] = (freq[x] || 0) + 1;
});
return freq;
};
}
return Reflect.get(target, prop);
}
};
var proxy1160 = new Proxy(target1160, handler1160);
var freq1160 = proxy1160.frequency();
assert_equal(freq1160[1], 1);
assert_equal(freq1160[2], 2);
assert_equal(freq1160[3], 3);
var target1170 = [1, 2, 2, 3, 3, 3, 4];
var handler1170 = {
get(target, prop) {
if (prop === 'mode') {
return function() {
const freq = {};
target.forEach(x => {
freq[x] = (freq[x] || 0) + 1;
});
let maxCount = 0;
let mode = null;
for (const key in freq) {
if (freq[key] > maxCount) {
maxCount = freq[key];
mode = parseInt(key);
}
}
return mode;
};
}
return Reflect.get(target, prop);
}
};
var proxy1170 = new Proxy(target1170, handler1170);
assert_equal(proxy1170.mode(), 3);
var target1180 = [1, 2, 3, 4, 5];
var handler1180 = {
get(target, prop) {
if (prop === 'median') {
return function() {
const sorted = [...target].sort((a, b) => a - b);
const mid = Math.floor(sorted.length / 2);
if (sorted.length % 2 === 0) {
return (sorted[mid - 1] + sorted[mid]) / 2;
}
return sorted[mid];
};
}
return Reflect.get(target, prop);
}
};
var proxy1180 = new Proxy(target1180, handler1180);
assert_equal(proxy1180.median(), 3);
var target1190 = [1, 2, 3, 4, 5];
var handler1190 = {
get(target, prop) {
if (prop === 'variance') {
return function() {
const mean = target.reduce((a, b) => a + b, 0) / target.length;
return target.reduce((sum, x) => sum + (x - mean) ** 2, 0) / target.length;
};
}
if (prop === 'stdDev') {
return function() {
const mean = target.reduce((a, b) => a + b, 0) / target.length;
const variance = target.reduce((sum, x) => sum + (x - mean) ** 2, 0) / target.length;
return Math.sqrt(variance);
};
}
return Reflect.get(target, prop);
}
};
var proxy1190 = new Proxy(target1190, handler1190);
var variance1190 = proxy1190.variance();
assert_true(variance1190 > 0);
var target1200 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var handler1200 = {
get(target, prop) {
if (prop === 'percentile') {
return function(p) {
const sorted = [...target].sort((a, b) => a - b);
const index = (p / 100) * (sorted.length - 1);
const lower = Math.floor(index);
const upper = Math.ceil(index);
if (lower === upper) {
return sorted[lower];
}
return sorted[lower] + (index - lower) * (sorted[upper] - sorted[lower]);
};
}
return Reflect.get(target, prop);
}
};
var proxy1200 = new Proxy(target1200, handler1200);
assert_equal(proxy1200.percentile(50), 5.5);
var target1210 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var handler1210 = {
get(target, prop) {
if (prop === 'quartiles') {
return function() {
const sorted = [...target].sort((a, b) => a - b);
const q1 = sorted[Math.floor(sorted.length * 0.25)];
const q2 = sorted[Math.floor(sorted.length * 0.5)];
const q3 = sorted[Math.floor(sorted.length * 0.75)];
return [q1, q2, q3];
};
}
return Reflect.get(target, prop);
}
};
var proxy1210 = new Proxy(target1210, handler1210);
var quartiles1210 = proxy1210.quartiles();
assert_equal(quartiles1210.length, 3);
var target1220 = [1, 2, 3, 4, 5, 100];
var handler1220 = {
get(target, prop) {
if (prop === 'outliers') {
return function(threshold = 2) {
const mean = target.reduce((a, b) => a + b, 0) / target.length;
const stdDev = Math.sqrt(target.reduce((sum, x) => sum + (x - mean) ** 2, 0) / target.length);
return target.filter(x => Math.abs(x - mean) > threshold * stdDev);
};
}
return Reflect.get(target, prop);
}
};
var proxy1220 = new Proxy(target1220, handler1220);
var outliers1220 = proxy1220.outliers();
assert_true(outliers1220.length > 0);
var target1230 = [1, 2, 3, 4, 5];
var handler1230 = {
get(target, prop) {
if (prop === 'normalize') {
return function() {
const min = Math.min(...target);
const max = Math.max(...target);
return target.map(x => (x - min) / (max - min));
};
}
return Reflect.get(target, prop);
}
};
var proxy1230 = new Proxy(target1230, handler1230);
var normalized1230 = proxy1230.normalize();
assert_true(normalized1230[0] >= 0 && normalized1230[0] <= 1);
var target1240 = [1, 2, 3, 4, 5];
var handler1240 = {
get(target, prop) {
if (prop === 'standardize') {
return function() {
const mean = target.reduce((a, b) => a + b, 0) / target.length;
const stdDev = Math.sqrt(target.reduce((sum, x) => sum + (x - mean) ** 2, 0) / target.length);
return target.map(x => (x - mean) / stdDev);
};
}
return Reflect.get(target, prop);
}
};
var proxy1240 = new Proxy(target1240, handler1240);
var standardized1240 = proxy1240.standardize();
assert_true(standardized1240.length === 5);
var target1250 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var handler1250 = {
get(target, prop) {
if (prop === 'bin') {
return function(binCount) {
const min = Math.min(...target);
const max = Math.max(...target);
const binSize = (max - min) / binCount;
const bins = Array(binCount).fill().map(() => []);
target.forEach(x => {
const binIndex = Math.min(Math.floor((x - min) / binSize), binCount - 1);
bins[binIndex].push(x);
});
return bins;
};
}
return Reflect.get(target, prop);
}
};
var proxy1250 = new Proxy(target1250, handler1250);
var binned1250 = proxy1250.bin(3);
assert_equal(binned1250.length, 3);
var target1260 = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4];
var handler1260 = {
get(target, prop) {
if (prop === 'histogram') {
return function() {
const hist = {};
target.forEach(x => {
hist[x] = (hist[x] || 0) + 1;
});
return hist;
};
}
return Reflect.get(target, prop);
}
};
var proxy1260 = new Proxy(target1260, handler1260);
var histogram1260 = proxy1260.histogram();
assert_equal(histogram1260[1], 1);
assert_equal(histogram1260[4], 4);
var target1270 = [1, 2, 3, 4, 5];
var handler1270 = {
get(target, prop) {
if (prop === 'cumsum') {
return function() {
const result = [];
let sum = 0;
target.forEach(x => {
sum += x;
result.push(sum);
});
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1270 = new Proxy(target1270, handler1270);
var cumsum1270 = proxy1270.cumsum();
assert_equal(cumsum1270[0], 1);
assert_equal(cumsum1270[4], 15);
var target1280 = [1, 2, 3, 4, 5];
var handler1280 = {
get(target, prop) {
if (prop === 'cumprod') {
return function() {
const result = [];
let prod = 1;
target.forEach(x => {
prod *= x;
result.push(prod);
});
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1280 = new Proxy(target1280, handler1280);
var cumprod1280 = proxy1280.cumprod();
assert_equal(cumprod1280[0], 1);
assert_equal(cumprod1280[4], 120);
var target1290 = [1, 3, 6, 10, 15];
var handler1290 = {
get(target, prop) {
if (prop === 'diff') {
return function() {
const result = [];
for (let i = 1; i < target.length; i++) {
result.push(target[i] - target[i - 1]);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1290 = new Proxy(target1290, handler1290);
var diff1290 = proxy1290.diff();
assert_equal(diff1290[0], 2);
assert_equal(diff1290[3], 5);
var target1300 = [1, 2, 4, 8, 16];
var handler1300 = {
get(target, prop) {
if (prop === 'ratio') {
return function() {
const result = [];
for (let i = 1; i < target.length; i++) {
result.push(target[i] / target[i - 1]);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1300 = new Proxy(target1300, handler1300);
var ratio1300 = proxy1300.ratio();
assert_equal(ratio1300[0], 2);
assert_equal(ratio1300[3], 2);
var target1310 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var handler1310 = {
get(target, prop) {
if (prop === 'movingAverage') {
return function(windowSize) {
const result = [];
for (let i = windowSize - 1; i < target.length; i++) {
let sum = 0;
for (let j = i - windowSize + 1; j <= i; j++) {
sum += target[j];
}
result.push(sum / windowSize);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1310 = new Proxy(target1310, handler1310);
var ma1310 = proxy1310.movingAverage(3);
assert_equal(ma1310[0], 2);
assert_equal(ma1310[1], 3);
var target1320 = [1, 2, 3, 4, 5];
var handler1320 = {
get(target, prop) {
if (prop === 'expSmooth') {
return function(alpha) {
const result = [target[0]];
for (let i = 1; i < target.length; i++) {
result.push(alpha * target[i] + (1 - alpha) * result[i - 1]);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1320 = new Proxy(target1320, handler1320);
var smoothed1320 = proxy1320.expSmooth(0.5);
assert_equal(smoothed1320.length, 5);
var target1330 = [1, 2, 3, 4, 5];
var handler1330 = {
get(target, prop) {
if (prop === 'convolve') {
return function(kernel) {
const result = [];
for (let i = 0; i < target.length; i++) {
let sum = 0;
for (let j = 0; j < kernel.length; j++) {
const idx = i + j - Math.floor(kernel.length / 2);
if (idx >= 0 && idx < target.length) {
sum += target[idx] * kernel[j];
}
}
result.push(sum);
}
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1330 = new Proxy(target1330, handler1330);
var convolved1330 = proxy1330.convolve([0.5, 1, 0.5]);
assert_equal(convolved1330.length, 5);
var target1340 = [1, 2, 3, 4, 5];
var handler1340 = {
get(target, prop) {
if (prop === 'correlate') {
return function(other) {
const mean1 = target.reduce((a, b) => a + b, 0) / target.length;
const mean2 = other.reduce((a, b) => a + b, 0) / other.length;
let numerator = 0;
let denom1 = 0;
let denom2 = 0;
for (let i = 0; i < target.length; i++) {
const diff1 = target[i] - mean1;
const diff2 = other[i] - mean2;
numerator += diff1 * diff2;
denom1 += diff1 * diff1;
denom2 += diff2 * diff2;
}
return numerator / Math.sqrt(denom1 * denom2);
};
}
return Reflect.get(target, prop);
}
};
var proxy1340 = new Proxy(target1340, handler1340);
var corr1340 = proxy1340.correlate([2, 4, 6, 8, 10]);
assert_true(corr1340 > 0.9);
var target1350 = [1, 2, 3, 4, 5];
var handler1350 = {
get(target, prop) {
if (prop === 'covariance') {
return function(other) {
const mean1 = target.reduce((a, b) => a + b, 0) / target.length;
const mean2 = other.reduce((a, b) => a + b, 0) / other.length;
let sum = 0;
for (let i = 0; i < target.length; i++) {
sum += (target[i] - mean1) * (other[i] - mean2);
}
return sum / target.length;
};
}
return Reflect.get(target, prop);
}
};
var proxy1350 = new Proxy(target1350, handler1350);
var cov1350 = proxy1350.covariance([2, 4, 6, 8, 10]);
assert_true(cov1350 > 0);
var target1360 = [1, 2, 3];
var handler1360 = {
get(target, prop) {
if (prop === 'euclideanDistance') {
return function(other) {
let sum = 0;
for (let i = 0; i < target.length; i++) {
sum += (target[i] - other[i]) ** 2;
}
return Math.sqrt(sum);
};
}
if (prop === 'manhattanDistance') {
return function(other) {
let sum = 0;
for (let i = 0; i < target.length; i++) {
sum += Math.abs(target[i] - other[i]);
}
return sum;
};
}
return Reflect.get(target, prop);
}
};
var proxy1360 = new Proxy(target1360, handler1360);
var euclidean1360 = proxy1360.euclideanDistance([4, 5, 6]);
assert_true(euclidean1360 > 0);
var manhattan1360 = proxy1360.manhattanDistance([4, 5, 6]);
assert_equal(manhattan1360, 9);
var target1370 = [1, 2, 3];
var handler1370 = {
get(target, prop) {
if (prop === 'add') {
return function(other) {
return target.map((x, i) => x + other[i]);
};
}
if (prop === 'subtract') {
return function(other) {
return target.map((x, i) => x - other[i]);
};
}
if (prop === 'multiply') {
return function(scalar) {
return target.map(x => x * scalar);
};
}
if (prop === 'dot') {
return function(other) {
return target.reduce((sum, x, i) => sum + x * other[i], 0);
};
}
return Reflect.get(target, prop);
}
};
var proxy1370 = new Proxy(target1370, handler1370);
var added1370 = proxy1370.add([4, 5, 6]);
assert_equal(added1370[0], 5);
assert_equal(added1370[2], 9);
var dot1370 = proxy1370.dot([4, 5, 6]);
assert_equal(dot1370, 32);
var target1380 = [[1, 2], [3, 4]];
var handler1380 = {
get(target, prop) {
if (prop === 'transpose') {
return function() {
return target[0].map((_, i) => target.map(row => row[i]));
};
}
return Reflect.get(target, prop);
}
};
var proxy1380 = new Proxy(target1380, handler1380);
var transposed1380 = proxy1380.transpose();
assert_equal(transposed1380[0][0], 1);
assert_equal(transposed1380[0][1], 3);
var target1390 = [1, 2, 3, 4, 5];
var handler1390 = {
get(target, prop) {
if (prop === 'isSubset') {
return function(other) {
return target.every(x => other.includes(x));
};
}
if (prop === 'isSuperset') {
return function(other) {
return other.every(x => target.includes(x));
};
}
if (prop === 'isDisjoint') {
return function(other) {
return !target.some(x => other.includes(x));
};
}
return Reflect.get(target, prop);
}
};
var proxy1390 = new Proxy(target1390, handler1390);
assert_true(proxy1390.isSubset([1, 2, 3, 4, 5, 6]));
assert_true(proxy1390.isSuperset([2, 3]));
assert_true(!proxy1390.isDisjoint([3, 4]));
var target1400 = [1, 2];
var handler1400 = {
get(target, prop) {
if (prop === 'powerSet') {
return function() {
const result = [[]];
target.forEach(x => {
const length = result.length;
for (let i = 0; i < length; i++) {
result.push([...result[i], x]);
}
});
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1400 = new Proxy(target1400, handler1400);
var powerSet1400 = proxy1400.powerSet();
assert_equal(powerSet1400.length, 4);
var target1410 = [1, 2, 3];
var handler1410 = {
get(target, prop) {
if (prop === 'permutations') {
return function() {
const result = [];
const permute = (arr, start = 0) => {
if (start === arr.length) {
result.push([...arr]);
} else {
for (let i = start; i < arr.length; i++) {
[arr[start], arr[i]] = [arr[i], arr[start]];
permute(arr, start + 1);
[arr[start], arr[i]] = [arr[i], arr[start]];
}
}
};
permute([...target]);
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1410 = new Proxy(target1410, handler1410);
var perms1410 = proxy1410.permutations();
assert_equal(perms1410.length, 6);
var target1420 = [1, 2, 3, 4];
var handler1420 = {
get(target, prop) {
if (prop === 'combinations') {
return function(k) {
const result = [];
const combine = (start, combo) => {
if (combo.length === k) {
result.push([...combo]);
return;
}
for (let i = start; i < target.length; i++) {
combo.push(target[i]);
combine(i + 1, combo);
combo.pop();
}
};
combine(0, []);
return result;
};
}
return Reflect.get(target, prop);
}
};
var proxy1420 = new Proxy(target1420, handler1420);
var combos1420 = proxy1420.combinations(2);
assert_equal(combos1420.length, 6);
print('All tests completed successfully!');