@agoric/xsnap 0.14.3-u14.0 → 0.14.3-u16.0

package/moddable/xs/sources/xsArray.c

@@ -0,0 +1,2657 @@
+/*
+ * Copyright (c) 2016-2017  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ * 
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ * 
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ * 
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and  
+ * permission notice:  
+ *
+ *       Copyright (C) 2010-2016 Marvell International Ltd.
+ *       Copyright (C) 2002-2010 Kinoma, Inc.
+ *
+ *       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.
+ */
+
+#include "xsAll.h"
+
+#define mxArraySize(ARRAY) (((ARRAY)->value.array.address) ? (((txChunk*)(((txByte*)((ARRAY)->value.array.address)) - sizeof(txChunk)))->size) / sizeof(txSlot) : 0)
+
+static txIndex fxCheckArrayLength(txMachine* the, txSlot* slot);
+static txBoolean fxCallThisItem(txMachine* the, txSlot* function, txIndex index, txSlot* item);
+static txSlot* fxCheckArray(txMachine* the, txSlot* slot, txBoolean mutable);
+static txSlot* fxCheckArrayItems(txMachine* the, txSlot* array, txIndex from, txIndex to);
+static int fxCompareArrayItem(txMachine* the, txSlot* function, txSlot* array, txInteger i);
+static txSlot* fxCreateArray(txMachine* the, txFlag flag, txIndex length);
+static txSlot* fxCreateArraySpecies(txMachine* the, txNumber length);
+static void fxFindThisItem(txMachine* the, txSlot* function, txIndex index, txSlot* item);
+static txNumber fxGetArrayLength(txMachine* the, txSlot* reference);
+static txIndex fxGetArrayLimit(txMachine* the, txSlot* reference);
+static void fxMoveThisItem(txMachine* the, txNumber from, txNumber to);
+static void fxReduceThisItem(txMachine* the, txSlot* function, txIndex index);
+static txBoolean fxSetArrayLength(txMachine* the, txSlot* array, txIndex target);
+static void fx_Array_from_aux(txMachine* the, txSlot* function, txSlot* value, txIndex index);
+static txIndex fx_Array_prototype_flatAux(txMachine* the, txSlot* source, txIndex length, txIndex start, txIndex depth, txSlot* function);
+
+static txBoolean fxArrayDefineOwnProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* slot, txFlag mask);
+static txBoolean fxArrayDeleteProperty(txMachine* the, txSlot* instance, txID id, txIndex index);
+static txBoolean fxArrayGetOwnProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* slot);
+static txSlot* fxArrayGetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag);
+static txBoolean fxArrayHasProperty(txMachine* the, txSlot* instance, txID id, txIndex index);
+static void fxArrayOwnKeys(txMachine* the, txSlot* instance, txFlag flag, txSlot* keys);
+static txSlot* fxArraySetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag);
+
+const txBehavior ICACHE_FLASH_ATTR gxArrayBehavior = {
+	fxArrayGetProperty,
+	fxArraySetProperty,
+	fxOrdinaryCall,
+	fxOrdinaryConstruct,
+	fxArrayDefineOwnProperty,
+	fxArrayDeleteProperty,
+	fxArrayGetOwnProperty,
+	fxOrdinaryGetPropertyValue,
+	fxOrdinaryGetPrototype,
+	fxArrayHasProperty,
+	fxOrdinaryIsExtensible,
+	fxArrayOwnKeys,
+	fxOrdinaryPreventExtensions,
+	fxOrdinarySetPropertyValue,
+	fxOrdinarySetPrototype,
+};
+
+void fxBuildArray(txMachine* the)
+{
+	txSlot* instance;
+	txSlot* slot;
+	txSlot* property;
+	txSlot* unscopable;
+	
+	mxPush(mxObjectPrototype);
+	instance = fxNewArrayInstance(the);
+
+	fxNewHostFunction(the, mxCallback(fxArrayLengthGetter), 0, mxID(_length), XS_NO_ID);
+	property = mxFunctionInstanceHome(the->stack->value.reference);
+	property->value.home.object = instance;
+	fxNewHostFunction(the, mxCallback(fxArrayLengthSetter), 1, mxID(_length), XS_NO_ID);
+	property = mxFunctionInstanceHome(the->stack->value.reference);
+	property->value.home.object = instance;
+	mxPushUndefined();
+	the->stack->flag = XS_DONT_DELETE_FLAG;
+	the->stack->kind = XS_ACCESSOR_KIND;
+	the->stack->value.accessor.getter = (the->stack + 2)->value.reference;
+	the->stack->value.accessor.setter = (the->stack + 1)->value.reference;
+	mxPull(mxArrayLengthAccessor);
+	mxPop();
+	mxPop();
+
+	slot = fxLastProperty(the, instance);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_at), 1, mxID(_at), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_concat), 1, mxID(_concat), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_copyWithin), 2, mxID(_copyWithin), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_entries), 0, mxID(_entries), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_every), 1, mxID(_every), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_fill), 1, mxID(_fill), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_filter), 1, mxID(_filter), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_find), 1, mxID(_find), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_findIndex), 1, mxID(_findIndex), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_findLast), 1, mxID(_findLast), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_findLastIndex), 1, mxID(_findLastIndex), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_flat), 0, mxID(_flat), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_flatMap), 1, mxID(_flatMap), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_forEach), 1, mxID(_forEach), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_includes), 1, mxID(_includes), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_indexOf), 1, mxID(_indexOf), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_join), 1, mxID(_join), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_keys), 0, mxID(_keys), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_lastIndexOf), 1, mxID(_lastIndexOf), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_map), 1, mxID(_map), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_pop), 0, mxID(_pop), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_push), 1, mxID(_push), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_reduce), 1, mxID(_reduce), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_reduceRight), 1, mxID(_reduceRight), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_reverse), 0, mxID(_reverse), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_shift), 0, mxID(_shift), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_slice), 2, mxID(_slice), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_some), 1, mxID(_some), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_sort), 1, mxID(_sort), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_splice), 2, mxID(_splice), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_toLocaleString), 0, mxID(_toLocaleString), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_toString), 0, mxID(_toString), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_unshift), 1, mxID(_unshift), XS_DONT_ENUM_FLAG);
+	property = slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_prototype_values), 0, mxID(_values), XS_DONT_ENUM_FLAG);
+	mxPushSlot(property);
+	mxPull(mxArrayIteratorFunction);
+	slot = fxNextSlotProperty(the, slot, property, mxID(_Symbol_iterator), XS_DONT_ENUM_FLAG);
+	unscopable = fxLastProperty(the, fxNewInstance(the));
+	unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_copyWithin), XS_NO_FLAG);
+	unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_at), XS_NO_FLAG);
+	unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_entries), XS_NO_FLAG);
+	unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_fill), XS_NO_FLAG);
+	unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_find), XS_NO_FLAG);
+	unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_findIndex), XS_NO_FLAG);
+	unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_findLast), XS_NO_FLAG);
+	unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_findLastIndex), XS_NO_FLAG);
+	unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_flat), XS_NO_FLAG);
+	unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_flatMap), XS_NO_FLAG);
+	unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_includes), XS_NO_FLAG);
+	unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_keys), XS_NO_FLAG);
+	unscopable = fxNextBooleanProperty(the, unscopable, 1, mxID(_values), XS_NO_FLAG);
+	slot = fxNextSlotProperty(the, slot, the->stack++, mxID(_Symbol_unscopables), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
+	mxArrayPrototype = *the->stack;
+	slot = fxBuildHostConstructor(the, mxCallback(fx_Array), 1, mxID(_Array));
+	mxArrayConstructor = *the->stack;
+	slot = fxLastProperty(the, slot);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_from), 1, mxID(_from), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_isArray), 1, mxID(_isArray), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Array_of), 0, mxID(_of), XS_DONT_ENUM_FLAG);
+	slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_species_get), C_NULL, mxID(_Symbol_species), XS_DONT_ENUM_FLAG);
+	mxPop();
+
+	mxPush(mxIteratorPrototype);
+	slot = fxLastProperty(the, fxNewObjectInstance(the));
+	slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_ArrayIterator_prototype_next), 0, mxID(_next), XS_DONT_ENUM_FLAG);
+	slot = fxNextStringXProperty(the, slot, "Array Iterator", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
+	mxPull(mxArrayIteratorPrototype);
+}
+
+txNumber fxArgToIndex(txMachine* the, txInteger argi, txNumber index, txNumber length)
+{
+	if ((mxArgc > argi) && (mxArgv(argi)->kind != XS_UNDEFINED_KIND)) {
+		txNumber i = c_trunc(fxToNumber(the, mxArgv(argi)));
+		if (c_isnan(i) || (i == 0))
+			i = 0;
+		if (i < 0) {
+			i = length + i;
+			if (i < 0)
+				i = 0;
+		}
+		else if (i > length)
+			i = length;
+		index = i;
+	}
+	return index;
+}
+
+txNumber fxArgToLastIndex(txMachine* the, txInteger argi, txNumber index, txNumber length)
+{
+	if (mxArgc > argi) {
+		txNumber i = c_trunc(fxToNumber(the, mxArgv(argi)));
+		if (c_isnan(i) || (i == 0))
+			i = 0;
+		if (i < 0) {
+			i = length + i;
+			if (i < 0)
+				index = 0;
+			else
+				index = i + 1;
+		}
+		else if (i < length)
+			index = i + 1;
+	}
+	return index;
+}
+
+txNumber fxArgToRange(txMachine* the, txInteger argi, txNumber index, txNumber min, txNumber max)
+{
+	if ((mxArgc > argi) && (mxArgv(argi)->kind != XS_UNDEFINED_KIND)) {
+		txNumber i = c_trunc(fxToNumber(the, mxArgv(argi)));
+		if (c_isnan(i))
+			i = min;
+		if (i <= min)
+			i = min;
+		else if (i > max)
+			i = max;
+		index = i;
+	}
+	return index;
+}
+
+void fxCacheArray(txMachine* the, txSlot* instance)
+{
+	txSlot* array = instance->next;
+	txIndex length = array->value.array.length;
+	if (length) {
+		txSlot* address = (txSlot *)fxNewChunk(the, fxMultiplyChunkSizes(the, length, sizeof(txSlot)));
+		txSlot* srcSlot = array->next;
+		txSlot* dstSlot = address;
+		txIndex index = 0;
+		while (srcSlot) {
+			dstSlot->next = C_NULL;
+			*((txIndex*)dstSlot) = index;	
+			dstSlot->ID = XS_NO_ID;
+			dstSlot->flag = XS_NO_FLAG;
+			dstSlot->kind = srcSlot->kind;
+			dstSlot->value = srcSlot->value;
+			srcSlot = srcSlot->next;
+			dstSlot++;
+			index++;
+		}
+		array->value.array.address = address;
+		array->next = C_NULL;
+	}
+}
+
+txBoolean fxCallThisItem(txMachine* the, txSlot* function, txIndex index, txSlot* item)
+{
+	mxPushSlot(mxThis);
+	if (mxHasIndex(index)) {
+		/* THIS */
+		if (mxArgc > 1)
+			mxPushSlot(mxArgv(1));
+		else
+			mxPushUndefined();
+		/* FUNCTION */
+		mxPushSlot(function);
+		mxCall();
+		/* ARGUMENTS */
+		mxPushSlot(mxThis);
+		mxGetIndex(index);
+		if (item) {
+			item->kind = the->stack->kind;
+			item->value = the->stack->value;
+		}
+		mxPushUnsigned(index);
+		mxPushSlot(mxThis);
+		mxRunCount(3);
+		return 1;
+	}
+	return 0;
+}
+
+txSlot* fxCheckArray(txMachine* the, txSlot* slot, txBoolean mutable)
+{
+	txSlot* instance = fxToInstance(the, slot);
+	txSlot* array = instance->next;
+	if (array && (array->kind == XS_ARRAY_KIND) && (array->ID == XS_ARRAY_BEHAVIOR)) {
+		if (instance->ID) {
+			txSlot* alias = the->aliasArray[instance->ID];
+			if (alias)
+				array = alias->next;
+			else if (mutable) {
+				instance = fxAliasInstance(the, instance);
+				array = instance->next;
+			}
+		}
+		{
+			txSlot* address = array->value.array.address;
+			txIndex size = (address) ? (((txChunk*)(((txByte*)address) - sizeof(txChunk)))->size) / sizeof(txSlot) : 0;
+			txSlot* prototype = instance->value.instance.prototype;
+			if (array->value.array.length != size)
+				return C_NULL;
+			if (mutable && ((instance->flag & XS_DONT_PATCH_FLAG) || (array->flag & XS_DONT_SET_FLAG)))
+				return C_NULL;
+			while (prototype) {
+				txSlot* property = prototype->next;
+				while (property) {
+					if (property->flag & XS_INTERNAL_FLAG) {
+						if ((property->kind == XS_ARRAY_KIND) && (property->value.array.address != C_NULL)) 
+							return C_NULL;
+					}
+					else 
+						break;
+					property = property->next;
+				}
+				prototype = prototype->value.instance.prototype;
+			}				
+			return array;
+		}
+	}
+	return C_NULL;
+}
+
+txSlot* fxCheckArrayItems(txMachine* the, txSlot* array, txIndex from, txIndex to)
+{
+	txSlot* address = array->value.array.address;
+	txIndex length = array->value.array.length;
+	if (length < from)
+		return C_NULL;
+	if (length < to)
+		return C_NULL;
+	address += from;
+	while (from < to) {
+		if (address->flag)
+			return C_NULL;
+		if (address->kind == XS_ACCESSOR_KIND)
+			return C_NULL;
+		address++;
+		from++;
+	}
+	return array;
+}
+
+txIndex fxCheckArrayLength(txMachine* the, txSlot* slot)
+{
+	if (slot->kind == XS_INTEGER_KIND) {
+		if (slot->value.integer >= 0)
+			return (txIndex)slot->value.integer;
+	}
+	else if (slot->kind == XS_NUMBER_KIND) {
+		txIndex length = (txIndex)slot->value.number;
+		txNumber check = length;
+		if (slot->value.number == check)
+			return length;
+	}
+	else {
+		txUnsigned length;
+		txNumber check;
+		mxPushSlot(slot);
+		length = fxToUnsigned(the, the->stack);
+		mxPop();
+		mxPushSlot(slot);
+		check = fxToNumber(the, the->stack);
+		mxPop();
+		if (length == check)
+			return length;
+	}
+	mxRangeError("invalid length");
+	return 0;
+}
+
+int fxCompareArrayItem(txMachine* the, txSlot* function, txSlot* array, txInteger i)
+{
+	txSlot* address = array->value.array.address;
+	txSlot* a = address + i;
+	txSlot* b = the->stack;
+	txSlot* ai = a->next;
+	txSlot* bi = b->next;
+	int result;
+	
+	if (a->kind == XS_UNDEFINED_KIND)
+		result = (b->kind == XS_UNDEFINED_KIND) ? 0 : 1;
+	else if (b->kind == XS_UNDEFINED_KIND)
+		result = -1;
+	else {
+		if (function) {
+			/* THIS */
+			mxPushUndefined();
+			/* FUNCTION */
+			mxPushSlot(function);
+			mxCall();
+			/* ARGUMENTS */
+			mxPushSlot(a);
+			mxPushSlot(b);
+			mxRunCount(2);
+			if (the->stack->kind == XS_INTEGER_KIND)
+				result = the->stack->value.integer;
+			else {
+				txNumber number = fxToNumber(the, the->stack);
+				result = (number < 0) ? -1 :  (number > 0) ? 1 : 0;
+			}
+			mxPop();
+		}
+		else {
+			mxPushSlot(a);
+			mxPushSlot(b);
+			fxToString(the, the->stack + 1);
+			fxToString(the, the->stack);
+			result = fxUTF8Compare((the->stack + 1)->value.string, the->stack->value.string);
+			mxPop();
+			mxPop();
+			mxMeterSome(3);
+		}
+	}
+	if (result == 0)
+		result = (bi > ai) ? -1 : (bi < ai) ? 1 : 0;
+	return result;
+}
+
+void fxConstructArrayEntry(txMachine* the, txSlot* entry)
+{
+	txSlot* value = the->stack;
+	txSlot* key = the->stack + 1;
+	txSlot* instance;
+	txSlot* array;
+	txSlot* item;
+	mxPush(mxArrayPrototype);
+	instance = fxNewArrayInstance(the);
+	array = instance->next;
+	fxSetIndexSize(the, array, 2, XS_CHUNK);
+	item = array->value.array.address;
+	*((txIndex*)item) = 0;
+	item->ID = XS_NO_ID;
+	item->kind = key->kind;
+	item->value = key->value;
+	item++;
+	*((txIndex*)item) = 1;
+	item->ID = XS_NO_ID;
+	item->kind = value->kind;
+	item->value = value->value;
+	entry->kind = the->stack->kind;
+	entry->value = the->stack->value;
+	the->stack += 3;
+}
+
+txSlot* fxCreateArray(txMachine* the, txFlag flag, txIndex length)
+{
+    txBoolean resize = 1;
+	if (mxIsReference(mxThis) && mxIsConstructor(mxThis->value.reference)) {
+		mxPushSlot(mxThis);
+		if (the->stack->value.reference != mxArrayConstructor.value.reference)
+			resize = 0;
+	}
+	else
+		mxPush(mxArrayConstructor);
+	mxNew();
+	if (flag) {
+		mxPushUnsigned(length);
+		mxRunCount(1);
+	}
+	else
+		mxRunCount(0);
+	mxPullSlot(mxResult);
+	if (resize)
+		fxSetIndexSize(the, mxResult->value.reference->next, length, XS_CHUNK);
+	return fxCheckArray(the, mxResult, XS_MUTABLE);
+}
+
+txSlot* fxCreateArraySpecies(txMachine* the, txNumber length)
+{
+	txSlot* instance = fxToInstance(the, mxThis);
+	txFlag flag = 1;
+	if (fxIsArray(the, instance)) {
+		mxPushSlot(mxThis);
+		mxGetID(mxID(_constructor));
+		if (mxIsReference(the->stack)) {
+			mxGetID(mxID(_Symbol_species));
+			if (the->stack->kind == XS_NULL_KIND)
+				the->stack->kind = XS_UNDEFINED_KIND;
+		}
+	}
+	else
+		mxPushUndefined();
+    if (the->stack->kind == XS_UNDEFINED_KIND) {
+		*the->stack = mxArrayConstructor;
+        flag = 0;
+    }
+	else if (mxIsReference(the->stack) && mxIsConstructor(the->stack->value.reference)) {
+		if (the->stack->value.reference != mxArrayConstructor.value.reference)
+			flag = 0;
+	}
+	else
+		mxTypeError("invalid constructor");
+	mxNew();
+	mxPushNumber(length);
+	mxRunCount(1);
+	mxPullSlot(mxResult);
+	return (flag) ? mxResult->value.reference->next : C_NULL;
+}
+
+void fxFindThisItem(txMachine* the, txSlot* function, txIndex index, txSlot* item)
+{
+	/* THIS */
+	if (mxArgc > 1)
+		mxPushSlot(mxArgv(1));
+	else
+		mxPushUndefined();
+	/* FUNCTION */
+	mxPushSlot(function);
+	mxCall();
+	/* ARGUMENTS */
+	mxPushSlot(mxThis);
+	mxGetIndex(index);
+	if (item) {
+		item->kind = the->stack->kind;
+		item->value = the->stack->value;
+	}
+	mxPushUnsigned(index);
+	mxPushSlot(mxThis);
+	/* ARGC */
+	mxRunCount(3);
+}
+
+txNumber fxGetArrayLength(txMachine* the, txSlot* reference)
+{
+	txNumber length;
+	txSlot* instance = fxToInstance(the, reference);
+	mxPushReference(instance);
+	mxGetID(mxID(_length));
+	length = fxToLength(the, the->stack);
+	mxPop();
+	return length;
+}
+
+txIndex fxGetArrayLimit(txMachine* the, txSlot* reference)
+{
+	txNumber length;
+	txSlot* instance = fxToInstance(the, reference);
+	txSlot* array = instance->next;
+	if (array && (array->kind == XS_ARRAY_KIND) && (array->ID == XS_ARRAY_BEHAVIOR)) {
+		if (instance->ID) {
+			txSlot* alias = the->aliasArray[instance->ID];
+			if (alias)
+				array = alias->next;
+		}
+		return array->value.array.length;
+	}
+	if (array && (array->kind == XS_TYPED_ARRAY_KIND) && (array->ID == XS_TYPED_ARRAY_BEHAVIOR)) {
+		txSlot* view = array->next;
+		txSlot* buffer = view->next;
+		txSlot* data = buffer->value.reference->next;
+		if (data->value.arrayBuffer.address == C_NULL)
+			mxTypeError("detached buffer");
+		return fxGetDataViewSize(the, view, buffer) >> array->value.typedArray.dispatch->shift;
+	}
+	mxPushReference(instance);
+	mxGetID(mxID(_length));
+	length = fxToLength(the, the->stack);
+	mxPop();
+	if (length > 0xFFFFFFFF) { // @@ practical limit for iterations
+		txSlot* result = instance->next;
+		length = 0;
+		while (result && (result->flag & XS_INTERNAL_FLAG)) {
+			if (result->kind == XS_ARRAY_KIND) {
+				length = array->value.array.length;
+				break;
+			}
+			result = result->next;
+		}
+	}
+	return (txIndex)length;
+}
+
+void fxIndexArray(txMachine* the, txSlot* array) 
+{
+	txSlot* address = array->value.array.address;
+	if (address) {
+		txIndex size = (((txChunk*)(((txByte*)address) - sizeof(txChunk)))->size) / sizeof(txSlot);
+		txIndex index = 0;
+		while (index < size) {
+			*((txIndex*)address) = index;	
+			address->flag = XS_NO_FLAG;
+			address++;
+			index++;
+		}
+	}
+}
+
+txBoolean fxIsArray(txMachine* the, txSlot* instance) 
+{
+again:
+	if (instance) {
+		txSlot* internal = instance->next;
+		if (internal && (internal->flag & XS_INTERNAL_FLAG)) {
+			if ((internal->kind == XS_ARRAY_KIND) && (internal->ID == XS_ARRAY_BEHAVIOR))
+				return 1;
+			if (internal->kind == XS_PROXY_KIND) {
+				instance = internal->value.proxy.target;
+				if (instance)
+					goto again;
+				mxTypeError("revoked proxy");
+
+			}
+		}
+	}
+	return 0;
+}
+
+void fxMoveThisItem(txMachine* the, txNumber from, txNumber to)
+{
+	mxPushSlot(mxThis);
+	mxPushNumber(from);
+	if (mxHasAt()) {
+		mxPushSlot(mxThis);
+		mxPushNumber(from);
+		mxGetAt();
+		mxPushSlot(mxThis);
+		mxPushNumber(to);
+		mxSetAt();
+		mxPop();
+	}
+	else {
+		mxPushSlot(mxThis);
+		mxPushNumber(to);
+		mxDeleteAt();
+		mxPop();
+	}
+}
+
+txSlot* fxNewArrayInstance(txMachine* the)
+{
+	txSlot* instance;
+	txSlot* property;
+	instance = fxNewObjectInstance(the);
+	instance->flag |= XS_EXOTIC_FLAG;
+	property = instance->next = fxNewSlot(the);
+	property->flag = XS_INTERNAL_FLAG | XS_DONT_DELETE_FLAG | XS_DONT_ENUM_FLAG;
+	property->ID = XS_ARRAY_BEHAVIOR;
+	property->kind = XS_ARRAY_KIND;
+	property->value.array.length = 0;
+	property->value.array.address = C_NULL;
+	return instance;
+}
+
+void fxReduceThisItem(txMachine* the, txSlot* function, txIndex index)
+{
+	mxPushSlot(mxThis);
+	if (fxHasIndex(the, index)) {
+		/* THIS */
+		mxPushUndefined();
+		/* FUNCTION */
+		mxPushSlot(function);
+		mxCall();
+		/* ARGUMENTS */
+		mxPushSlot(mxResult);
+		mxPushSlot(mxThis);
+		mxGetIndex(index);
+		mxPushUnsigned(index);
+		mxPushSlot(mxThis);
+		mxRunCount(4);
+		mxPullSlot(mxResult);
+	}
+}
+
+txBoolean fxSetArrayLength(txMachine* the, txSlot* array, txIndex length)
+{
+	txSlot* address = array->value.array.address;
+	txSlot* chunk = address;
+	txBoolean success = 1;
+	if (address) {
+		txSize size = (((txChunk*)(((txByte*)chunk) - sizeof(txChunk)))->size) / sizeof(txSlot);
+		txSlot* result = address + size;
+		txSlot* limit = result;
+		txIndex at;
+		while (result > address) {
+			result--;
+			at = *((txIndex*)result);
+			if (length > at) {
+				result++;
+				break;
+			}
+			else if (result->flag & XS_DONT_DELETE_FLAG) {
+				result++;
+				length = at + 1;
+				success = 0;
+				break;
+			}
+		}
+		if (result < limit) {
+			if (result > address) {
+				size = mxPtrDiff(result - address);
+				chunk = (txSlot*)fxNewChunk(the, fxMultiplyChunkSizes(the, size, sizeof(txSlot)));
+				address = array->value.array.address;
+				c_memcpy(chunk, address, size * sizeof(txSlot));
+			}
+			else
+				chunk = C_NULL;
+		}	
+	}
+	array->value.array.length = length;
+	array->value.array.address = chunk;
+	return success;
+}
+
+void fxSortArrayItems(txMachine* the, txSlot* function, txSlot* array, txNumber LENGTH)
+{
+	txSlot* instance = C_NULL;
+ 	txIndex index;
+    txSlot* item;
+ 	txIndex length;
+ 	txIndex size;
+again:
+	if (!array) {
+		LENGTH = fxGetArrayLength(the, mxThis);
+		if (LENGTH > 0xFFFFFFFF)
+			mxRangeError("array overflow");
+		mxPush(mxArrayPrototype);
+		instance = fxNewArrayInstance(the);
+		array = instance->next;
+		item = array;
+        index = 0;
+		while (index < LENGTH) {
+			mxPushSlot(mxThis);
+			if (fxHasIndex(the, index)) {
+				item->next = fxNewSlot(the);
+				item = item->next;
+				array->value.array.length++;
+				mxPushSlot(mxThis);
+				mxGetIndex(index);
+				mxPullSlot(item);
+			}
+			index++;
+		}
+		fxCacheArray(the, instance);
+	}
+	length = array->value.array.length;
+	size = mxArraySize(array);
+	/* like GCC qsort */
+	#define CHECK \
+		if (size != mxArraySize(array)) { \
+			array = C_NULL; \
+			goto again; \
+		}
+	#define COMPARE(INDEX) \
+		fxCompareArrayItem(the, function, array, INDEX)
+	#define COPY \
+		to->next = from->next; \
+		to->ID = from->ID; \
+		to->kind = from->kind; \
+		to->value = from->value
+	#define MOVE(FROM,TO) \
+		from = array->value.array.address + (FROM); \
+		to = array->value.array.address + (TO); \
+		COPY
+	#define PUSH(INDEX) \
+		from = array->value.array.address + (INDEX); \
+		mxPushUndefined(); \
+		to = the->stack; \
+		COPY
+	#define PULL(INDEX) \
+		from = the->stack++; \
+		to = array->value.array.address + (INDEX); \
+		COPY
+	if (length > 0) {
+		txIndex i, j;
+		txSlot* from;
+		txSlot* to;
+		if (length > mxSortThreshold) {
+			txIndex lo = 0, hi = length - 1;
+			txSortPartition stack[mxSortPartitionCount];
+			txSortPartition *top = stack + 1;
+			while (stack < top) {
+				txIndex mid = lo + ((hi - lo) >> 1);
+				PUSH(mid);
+				if (COMPARE(lo) > 0) {
+					CHECK;
+					MOVE(lo, mid);
+					PULL(lo);
+					PUSH(mid);
+				}
+				else
+					CHECK;
+				if (COMPARE(hi) < 0) {
+					CHECK;
+					MOVE(hi, mid);
+					PULL(hi);
+					PUSH(mid);
+					if (COMPARE(lo) > 0) {
+						CHECK;
+						MOVE(lo, mid);
+						PULL(lo);
+						PUSH(mid);
+					}
+					else
+						CHECK;
+				}
+				else
+					CHECK;
+				i = lo + 1;
+				j = hi - 1;
+				do {
+					while ((COMPARE(i) < 0) && (i <= j)) { CHECK; i++; }
+                    CHECK;
+					while ((COMPARE(j) > 0) && (i <= j)) { CHECK; j--; }
+					CHECK;
+					if (i < j) {
+						PUSH(i);
+						MOVE(j, i);
+						PULL(j);
+						i++;
+						j--;
+					}
+					else if (i == j) {
+						i++;
+						j--;
+						break;
+					}
+				} while (i <= j);
+				if ((j - lo) <= mxSortThreshold) {
+					if ((hi - i) <= mxSortThreshold) {
+						top--;
+						lo = top->lo; 
+						hi = top->hi;
+					}
+					else {
+						lo = i;
+					}
+				}
+				else if ((hi - i) <= mxSortThreshold) {
+					hi = j;
+				}
+				else if ((j - lo) > (hi - i)) {
+					top->lo = lo;
+					top->hi = j; 
+					top++;
+					lo = i;
+				}
+				else {
+					top->lo = i;
+					top->hi = hi; 
+					top++;
+					hi = j;
+				}
+				mxPop();
+			}
+		}
+		for (i = 1; i < length; i++) {
+			PUSH(i);
+			for (j = i; (j > 0) && (COMPARE(j - 1) > 0); j--) {
+				CHECK;
+				MOVE(j - 1, j);
+			}
+            CHECK;
+			PULL(j);
+		}
+	}
+	if (instance) {
+		index = 0;
+		while (index < length) {
+			item = array->value.array.address + index;
+			mxPushSlot(item);
+			mxPushSlot(mxThis);
+			mxSetIndex(index);
+			mxPop();
+			index++;
+		}
+		while (index < LENGTH) {
+			mxPushSlot(mxThis);
+			mxDeleteIndex(index);
+			index++;
+		}
+		mxPop();
+	}
+	else
+		fxIndexArray(the, array);
+}
+
+txNumber fxToLength(txMachine* the, txSlot* slot)
+{
+again:
+	if (slot->kind == XS_INTEGER_KIND) {
+		txInteger length = slot->value.integer;
+		if (length < 0)
+			length = 0;
+		slot->value.number = (txNumber)length;
+		slot->kind = XS_NUMBER_KIND;
+		return (txNumber)length;
+	}
+	if (slot->kind == XS_NUMBER_KIND) {
+		txNumber length = slot->value.number;
+		if (c_isnan(length))
+			length = 0;
+		else if (length <= 0)
+			length = 0;
+		else if (length > C_MAX_SAFE_INTEGER)
+			length = C_MAX_SAFE_INTEGER;
+		else
+			length = c_trunc(length);
+		slot->value.number = length;
+		return length;
+	}
+	fxToNumber(the, slot);
+	goto again;
+}
+
+void fxArrayLengthGetter(txMachine* the)
+{
+	txSlot* instance = fxToInstance(the, mxThis);
+	txSlot* array;
+	while (instance) {
+		if (instance->flag & XS_EXOTIC_FLAG) {
+			array = instance->next;
+			if ((array->kind == XS_ARRAY_KIND) && (array->ID == XS_ARRAY_BEHAVIOR))
+				break;
+		}
+		instance = fxGetPrototype(the, instance);
+	}
+	if (!instance)
+		return;
+	if (instance->ID) {
+		txSlot* alias = the->aliasArray[instance->ID];
+		if (alias)
+			array = alias->next;
+	}
+	if (((txInteger)array->value.array.length) < 0) {
+		mxResult->value.number = array->value.array.length;
+		mxResult->kind = XS_NUMBER_KIND;
+	}
+	else {
+		mxResult->value.integer = (txInteger)array->value.array.length;
+		mxResult->kind = XS_INTEGER_KIND;
+	}
+}
+
+void fxArrayLengthSetter(txMachine* the)
+{
+	txSlot* instance = fxToInstance(the, mxThis);
+	txSlot* array;
+	txIndex length;
+	while (instance) {
+		if (instance->flag & XS_EXOTIC_FLAG) {
+			array = instance->next;
+			if (array->ID == XS_ARRAY_BEHAVIOR)
+				break;
+		}
+		instance = fxGetPrototype(the, instance);
+	}
+	if (!instance)
+		return;
+	if (instance->ID) {
+		txSlot* alias = the->aliasArray[instance->ID];
+		if (!alias)
+			alias = fxAliasInstance(the, instance);
+		array = alias->next;
+	}
+	length = fxCheckArrayLength(the, mxArgv(0));
+	if (array->flag & XS_DONT_SET_FLAG) {
+		if (the->frame->next->flag & XS_STRICT_FLAG)
+			mxTypeError("set length: not writable");
+		else
+			return;
+	}
+	fxSetArrayLength(the, array, length);
+    mxResult->value.number = array->value.array.length;
+    mxResult->kind = XS_NUMBER_KIND;
+}
+
+txBoolean fxArrayDefineOwnProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* descriptor, txFlag mask) 
+{
+	if (id == mxID(_length)) {
+		txSlot* array = instance->next;
+		txSlot slot;
+		txBoolean result = 1;
+        txIndex length = ((descriptor->kind != XS_UNINITIALIZED_KIND) && (descriptor->kind != XS_ACCESSOR_KIND)) ? fxCheckArrayLength(the, descriptor) : 0;
+        slot.flag = array->flag;
+		slot.ID = id;
+		slot.kind = XS_NUMBER_KIND;
+		slot.value.number = array->value.array.length;
+		if (!fxIsPropertyCompatible(the, &slot, descriptor, mask))
+			return 0;
+		if (instance->ID) {
+			txSlot* alias = the->aliasArray[instance->ID];
+			if (!alias) {
+				alias = fxAliasInstance(the, instance);
+				array = alias->next;
+			}
+		}
+		if (descriptor->kind != XS_UNINITIALIZED_KIND) {
+			if (array->value.array.length != length)
+				result = fxSetArrayLength(the, array, length);
+		}
+		if ((mask & XS_DONT_SET_FLAG) && (descriptor->flag & XS_DONT_SET_FLAG) && !(array->flag & XS_DONT_SET_FLAG))
+			array->flag |= XS_DONT_SET_FLAG;
+		return result;
+	}
+	return fxOrdinaryDefineOwnProperty(the, instance, id, index, descriptor, mask);
+}
+
+txBoolean fxArrayDeleteProperty(txMachine* the, txSlot* instance, txID id, txIndex index)
+{
+	if (id == mxID(_length))
+		return 0;
+	return fxOrdinaryDeleteProperty(the, instance, id, index);
+}
+
+txBoolean fxArrayGetOwnProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* descriptor)
+{
+	if (id == mxID(_length)) {
+		txSlot* array = instance->next;
+		descriptor->flag = array->flag;
+		descriptor->ID = id;
+		descriptor->kind = XS_NUMBER_KIND;
+		descriptor->value.number = array->value.array.length;
+		return 1;
+	}
+	return fxOrdinaryGetOwnProperty(the, instance, id, index, descriptor);
+}
+
+txSlot* fxArrayGetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag)
+{
+	if (id == mxID(_length))
+		return &mxArrayLengthAccessor;
+	return fxOrdinaryGetProperty(the, instance, id, index, flag);
+}
+
+txBoolean fxArrayHasProperty(txMachine* the, txSlot* instance, txID id, txIndex index) 
+{
+	if (id == mxID(_length))
+		return 1;
+	return fxOrdinaryHasProperty(the, instance, id, index);
+}
+
+void fxArrayOwnKeys(txMachine* the, txSlot* instance, txFlag flag, txSlot* keys)
+{
+	txSlot* property = instance->next;
+	keys = fxQueueIndexKeys(the, property, flag, keys);
+	if (flag & XS_EACH_NAME_FLAG)
+		keys = fxQueueKey(the, mxID(_length), 0, keys);
+	property = property->next;
+	fxQueueIDKeys(the, property, flag, keys);
+}
+
+txSlot* fxArraySetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag)
+{
+	if (id == mxID(_length)) {
+		txSlot* array = instance->next;
+		if (array->flag & XS_DONT_SET_FLAG)
+			return array;
+		return &mxArrayLengthAccessor;
+	}
+	return fxOrdinarySetProperty(the, instance, id, index, flag);
+}
+
+void fx_Array(txMachine* the)
+{
+	txSlot* instance;
+	txSlot* array;
+	txSlot* argument;
+	txIndex count = (txIndex)mxArgc;
+	txBoolean flag = 0;
+	txIndex index = 0;
+	txSlot* slot;
+	
+	if (mxIsUndefined(mxTarget))
+		mxPushSlot(mxFunction);
+	else
+		mxPushSlot(mxTarget);
+	fxGetPrototypeFromConstructor(the, &mxArrayPrototype);
+	instance = fxNewArrayInstance(the);
+	mxPullSlot(mxResult);
+	array = instance->next;	
+	
+	if (count == 1) {
+		argument = mxArgv(0);
+		if ((argument->kind == XS_INTEGER_KIND) || (argument->kind == XS_NUMBER_KIND)) {
+			count = fxCheckArrayLength(the, mxArgv(0));
+			flag = 1;
+		}
+	}
+	if (array) {
+		if (flag)
+			fxSetArrayLength(the, array, count);
+		else {
+			fxSetIndexSize(the, array, count, XS_CHUNK);
+			slot = array->value.array.address;
+			while (index < count) {
+				argument = mxArgv(index);
+				*((txIndex*)slot) = index;
+				slot->ID = XS_NO_ID;
+				slot->kind = argument->kind;
+				slot->value = argument->value;
+				slot++;
+				index++;
+			}
+		}
+	}
+	else {
+		mxPushNumber(count);
+		mxPushSlot(mxThis);
+		mxSetID(mxID(_length));
+		mxPop();
+		if (!flag) {
+			while (index < count) {
+				mxPushSlot(mxArgv(index));
+				mxPushSlot(mxThis);
+				mxDefineIndex(index, 0, XS_GET_ONLY);
+				mxPop();
+				index++;
+			}
+		}
+	}
+}
+
+void fx_Array_from(txMachine* the)
+{
+	txSlot* function = (mxArgc > 1) ? fxArgToCallback(the, 1) : C_NULL;
+	txIndex length = 0;
+	txSlot* iterator;
+	txSlot* next;
+	txSlot* value;
+	if (mxArgc > 0) {
+		mxPushSlot(mxArgv(0));
+		mxGetID(mxID(_Symbol_iterator));
+		if (mxIsUndefined(the->stack) || mxIsNull(the->stack)) {
+			txIndex index = 0;
+			mxPushSlot(mxArgv(0));
+			mxGetID(mxID(_length));
+			if (mxIsUndefined(the->stack))
+				length = 0;
+			else
+				length = fxCheckArrayLength(the, the->stack);
+			mxPop();
+			fxCreateArray(the, 1, length);
+			while (index < length) {
+				mxPushSlot(mxArgv(0));
+				mxGetIndex(index);
+				fx_Array_from_aux(the, function, the->stack, index);
+				mxPop();
+				index++;
+			}
+		}
+		else {
+			fxCreateArray(the, 0, 0);
+			mxTemporary(iterator);
+			mxTemporary(next);
+			fxGetIterator(the, mxArgv(0), iterator, next, 0);
+			mxTemporary(value);
+			length = 0;
+			while (fxIteratorNext(the, iterator, next, value)) {
+				mxTry(the) {
+					fx_Array_from_aux(the, function, value, length);
+					length++;
+				}
+				mxCatch(the) {
+					fxIteratorReturn(the, iterator);
+					fxJump(the);
+				}
+			}
+			mxPop();
+		}
+	}
+	else {
+		fxCreateArray(the, 1, length);
+	}
+	mxPushUnsigned(length);
+	mxPushSlot(mxResult);
+	mxSetID(mxID(_length));
+	mxPop();
+}
+
+void fx_Array_from_aux(txMachine* the, txSlot* function, txSlot* value, txIndex index)
+{
+	if (function) {
+		/* THIS */
+		if (mxArgc > 2)
+			mxPushSlot(mxArgv(2));
+		else
+			mxPushUndefined();
+		/* FUNCTION */
+		mxPushSlot(function);
+		mxCall();
+		/* ARGUMENTS */
+		mxPushSlot(value);
+		mxPushInteger(index);
+		mxRunCount(2);
+	}
+	else
+		mxPushSlot(value);
+	mxPushSlot(mxResult);
+	mxDefineIndex(index, 0, XS_GET_ONLY);
+	mxPop();
+}
+
+void fx_Array_isArray(txMachine* the)
+{
+	mxResult->kind = XS_BOOLEAN_KIND;
+	mxResult->value.boolean = (mxArgc > 0) ? fxIsArray(the, fxGetInstance(the, mxArgv(0))) : 0;
+}
+
+void fx_Array_of(txMachine* the)
+{
+	txIndex count = (txIndex)mxArgc, index = 0;
+	txSlot* array = fxCreateArray(the, 1, count);
+	if (array) {
+		txSlot* slot;
+		fxSetIndexSize(the, array, count, XS_CHUNK);
+		slot = array->value.array.address;
+		while (index < count) {
+			txSlot* argument = mxArgv(index);
+			*((txIndex*)slot) = index;
+			slot->ID = XS_NO_ID;
+			slot->kind = argument->kind;
+			slot->value = argument->value;
+			slot++;
+			mxMeterSome(4);
+			index++;
+		}
+		mxMeterSome(4);
+	}
+	else {
+		while (index < count) {
+			mxPushSlot(mxArgv(index));
+			mxPushSlot(mxResult);
+			mxDefineIndex(index, 0, XS_GET_ONLY);
+			mxPop();
+			index++;
+		}
+		mxPushInteger(count);
+		mxPushSlot(mxResult);
+		mxSetID(mxID(_length));
+		mxPop();
+	}
+}
+
+void fx_Array_prototype_at(txMachine* the)
+{
+	txSlot* array = fxCheckArray(the, mxThis, XS_IMMUTABLE);
+	txNumber length = (array) ? array->value.array.length : fxGetArrayLength(the, mxThis);
+	txNumber index = (mxArgc > 0) ? c_trunc(fxToNumber(the, mxArgv(0))) : C_NAN;
+	if (c_isnan(index) || (index == 0))
+		index = 0;
+	if (index < 0)
+		index = length + index;
+	if ((0 <= index) && (index < length)) {
+		mxPushSlot(mxThis);
+		mxPushNumber(index);
+		mxGetAt();
+		mxPullSlot(mxResult);
+	}
+}
+
+void fx_Array_prototype_concat(txMachine* the)
+{
+	txSlot* resultArray = fxCreateArraySpecies(the, 0);
+	txIndex resultLength = 0;
+	txInteger c = mxArgc;
+	txInteger i = -1;
+	if (resultArray) {
+		txSlot* list = fxNewInstance(the);
+		txSlot* slot = list;
+		txSlot* resultSlot;
+		txIndex holeCount = 0;
+		mxPushSlot(mxThis);
+		for (;;) {
+			txSlot* argument = the->stack;
+			txBoolean flag = 0;
+			if (mxIsReference(argument)) {
+				mxPushSlot(argument);
+				mxGetID(mxID(_Symbol_isConcatSpreadable));
+				if (mxIsUndefined(the->stack))
+					flag = fxIsArray(the, argument->value.reference);
+				else
+					flag = fxToBoolean(the, the->stack);
+				mxPop();
+			}
+			if (flag) {	
+				txIndex length, index;
+				mxPushSlot(argument);
+				mxGetID(mxID(_length));
+				length = (txIndex)fxToLength(the, the->stack);
+				mxPop();
+                if (resultLength + length < resultLength)
+                    mxTypeError("array overflow");
+				index = 0;
+				while (index < length) {
+					mxPushSlot(argument);
+					if (fxHasIndex(the, index)) {
+						mxPushSlot(argument);
+						mxGetIndex(index);
+						slot = fxNextSlotProperty(the, slot, the->stack, XS_NO_ID, XS_NO_FLAG);
+						mxMeterSome(2);
+						mxPop();
+					}
+					else {
+						slot = slot->next = fxNewSlot(the);
+						slot->kind = XS_UNINITIALIZED_KIND;
+						holeCount++;
+					}
+					index++;
+					resultLength++;
+				}
+			}
+			else {
+				slot = fxNextSlotProperty(the, slot, argument, XS_NO_ID, XS_NO_FLAG);
+				mxMeterSome(4);
+				resultLength++;
+				if (resultLength == 0)
+					mxTypeError("array overflow");
+			}
+			mxPop();
+			i++;
+			if (i == c)
+				break;
+			mxPushSlot(mxArgv(i));
+		}
+		fxSetIndexSize(the, resultArray, resultLength - holeCount, XS_CHUNK);
+		resultArray->value.array.length = resultLength;
+		resultSlot = resultArray->value.array.address;
+		slot = list->next;
+		resultLength = 0;
+		while (slot) {
+			if (slot->kind != XS_UNINITIALIZED_KIND) {
+				*((txIndex*)resultSlot) = resultLength;
+				resultSlot->ID = XS_NO_ID;
+				resultSlot->kind = slot->kind;
+				resultSlot->value = slot->value;
+				resultSlot++;
+			}
+			slot = slot->next;
+			resultLength++;
+		}
+		mxMeterSome(3);
+		mxPop();
+	}
+	else {
+		mxPushSlot(mxThis);
+		for (;;) {
+			txSlot* argument = the->stack;
+			txBoolean flag = 0;
+			if (mxIsReference(argument)) {
+				mxPushSlot(argument);
+				mxGetID(mxID(_Symbol_isConcatSpreadable));
+				if (mxIsUndefined(the->stack))
+					flag = fxIsArray(the, argument->value.reference);
+				else
+					flag = fxToBoolean(the, the->stack);
+				mxPop();
+			}
+			if (flag) {	
+				txIndex length, index;
+				mxPushSlot(argument);
+				mxGetID(mxID(_length));
+				length = (txIndex)fxToLength(the, the->stack);
+				mxPop();
+				index = 0;
+				while (index < length) {
+					mxPushSlot(argument);
+					if (fxHasIndex(the, index)) {
+						mxPushSlot(argument);
+						mxGetIndex(index);
+						mxPushSlot(mxResult);
+						mxDefineIndex(resultLength, 0, XS_GET_ONLY);
+						mxPop();
+					}
+					index++;
+					resultLength++;
+				}
+			}
+			else {
+				mxPushSlot(argument);
+				mxPushSlot(mxResult);
+				mxDefineIndex(resultLength, 0, XS_GET_ONLY);
+				mxPop();
+				resultLength++;
+			}
+			mxPop();
+			i++;
+			if (i == c)
+				break;
+			mxPushSlot(mxArgv(i));
+		}
+		mxPushInteger(resultLength);
+		mxPushSlot(mxResult);
+		mxSetID(mxID(_length));
+		mxPop();
+	}
+}
+
+void fx_Array_prototype_copyWithin(txMachine* the)
+{
+	txNumber length = fxGetArrayLength(the, mxThis);
+	txNumber to = fxArgToIndex(the, 0, 0, length);
+	txNumber from = fxArgToIndex(the, 1, 0, length);
+	txNumber final = fxArgToIndex(the, 2, length, length);
+	txNumber count = (final > from) ? final - from : 0;
+	txSlot* array = fxCheckArray(the, mxThis, XS_MUTABLE);
+	if (count > length - to)
+		count = length - to;
+	if (array) {
+		if (count > 0) {
+			if (from < to)
+				array = fxCheckArrayItems(the, array, (txIndex)from, (txIndex)(to + count));
+			else
+				array = fxCheckArrayItems(the, array, (txIndex)to, (txIndex)(from + count));
+		}
+	}
+	if (array) {
+		if (count > 0) {
+			c_memmove(array->value.array.address + (txIndex)to, array->value.array.address + (txIndex)from, (txIndex)count * sizeof(txSlot));
+			fxIndexArray(the, array);
+			mxMeterSome((txU4)count * 10);
+		}
+	}
+	else {
+		txNumber direction;
+		if ((from < to) && (to < from + count)) {
+			direction = -1;
+			from += count - 1;
+			to += count - 1;
+		}
+		else
+			direction = 1;
+		while (count > 0) {
+			fxMoveThisItem(the, from, to);
+			from += direction;
+			to += direction;
+			count--;
+		}	
+	}	
+	mxResult->kind = mxThis->kind;
+	mxResult->value = mxThis->value;
+}
+
+void fx_Array_prototype_entries(txMachine* the)
+{
+	txSlot* property;
+	fxToInstance(the, mxThis);
+	mxPush(mxArrayIteratorPrototype);
+	property = fxLastProperty(the, fxNewIteratorInstance(the, mxThis, mxID(_Array)));
+	property = fxNextIntegerProperty(the, property, 2, XS_NO_ID, XS_INTERNAL_FLAG);
+	mxPullSlot(mxResult);
+}
+
+void fx_Array_prototype_every(txMachine* the)
+{
+	txIndex length = fxGetArrayLimit(the, mxThis);
+	txIndex index = 0;
+	txSlot* function = fxArgToCallback(the, 0);
+	mxResult->kind = XS_BOOLEAN_KIND;
+	mxResult->value.boolean = 1;
+	while (index < length) {
+		if (fxCallThisItem(the, function, index, C_NULL)) {
+			mxResult->value.boolean = fxToBoolean(the, the->stack);
+			mxPop();
+			if (!mxResult->value.boolean)
+				break;
+		}
+		index++;
+	}
+}
+
+void fx_Array_prototype_fill(txMachine* the)
+{
+	txSlot* instance = fxToInstance(the, mxThis);
+	txSlot* array = instance->next;
+	txSlot* value;
+	if (mxArgc > 0)
+		mxPushSlot(mxArgv(0));
+	else
+		mxPushUndefined();
+	value = the->stack;
+	if (array && (array->kind == XS_ARRAY_KIND) && (array->ID == XS_ARRAY_BEHAVIOR)) {
+		txIndex length = array->value.array.length;
+		txIndex start = (txIndex)fxArgToIndex(the, 1, 0, length);
+		txIndex end = (txIndex)fxArgToIndex(the, 2, length, length);
+		txSlot* address;
+		txIndex size;
+		if ((start == 0) && (end == length)) {
+			fxSetIndexSize(the, array, length, XS_CHUNK);
+			fxIndexArray(the, array);
+		}
+		address = array->value.array.address;
+		size = (address) ? (((txChunk*)(((txByte*)address) - sizeof(txChunk)))->size) / sizeof(txSlot) : 0;
+		if (length == size) {
+			while (start < end) {
+				txSlot* slot = array->value.array.address + start;
+				if (slot->flag) {
+					mxPushSlot(value);
+					mxPushSlot(mxThis);
+					mxSetIndex(start);
+					mxPop();
+					mxMeterSome(1);
+				}
+				else {
+					slot->ID = XS_NO_ID;
+					slot->kind = value->kind;
+					slot->value = value->value;
+					mxMeterSome(5);
+				}
+				start++;
+			}
+			
+		}
+		else {
+			while (start < end) {
+				mxPushSlot(value);
+				mxPushSlot(mxThis);
+				mxSetIndex(start);
+				mxPop();
+				mxMeterSome(1);
+				start++;
+			}
+		}
+	}
+	else {
+		txNumber length = fxGetArrayLength(the, mxThis);
+		txNumber start = fxArgToIndex(the, 1, 0, length);
+		txNumber end = fxArgToIndex(the, 2, length, length);
+		txSlot* value = the->stack;
+		while (start < end) {
+			mxPushSlot(value);
+			mxPushSlot(mxThis);
+			mxPushNumber(start);
+			mxSetAt();
+			mxPop();
+			start++;
+		}
+	}
+	mxPop();
+	mxResult->kind = mxThis->kind;
+	mxResult->value = mxThis->value;
+}
+
+void fx_Array_prototype_filter(txMachine* the)
+{
+	txIndex length = fxGetArrayLimit(the, mxThis);
+	txIndex index = 0;
+	txSlot* function = fxArgToCallback(the, 0);
+	txSlot* resultArray = fxCreateArraySpecies(the, 0);
+	txIndex resultLength = 0;
+	txSlot* item;
+	mxPushUndefined();
+	item = the->stack;
+	if (resultArray) {
+		txSlot* list = fxNewInstance(the);
+		txSlot* slot = list;
+		txSlot* resultSlot;
+		while (index < length) {
+			if (fxCallThisItem(the, function, index, item)) {
+				if (fxToBoolean(the, the->stack)) {
+					slot = fxNextSlotProperty(the, slot, item, XS_NO_ID, XS_NO_FLAG);
+					mxMeterSome(4);
+					resultLength++;
+				}
+				mxPop();
+			}
+			index++;
+		}
+		fxSetIndexSize(the, resultArray, resultLength, XS_CHUNK);
+		resultSlot = resultArray->value.array.address;
+		slot = list->next;
+		index = 0;
+		while (slot) {
+			*((txIndex*)resultSlot) = index;
+			resultSlot->ID = XS_NO_ID;
+			resultSlot->kind = slot->kind;
+			resultSlot->value = slot->value;
+			resultSlot++;
+			slot = slot->next;
+			index++;
+		}
+		mxPop();
+		mxMeterSome(-1);
+	}
+	else {
+		while (index < length) {
+			if (fxCallThisItem(the, function, index, item)) {
+				if (fxToBoolean(the, the->stack)) {
+					mxPushSlot(item);
+					mxPushSlot(mxResult);
+					mxDefineIndex(resultLength, 0, XS_GET_ONLY);
+					mxPop();
+					resultLength++;
+				}
+				mxPop();
+			}
+			index++;
+		}
+	}
+	mxPop();
+}
+
+void fx_Array_prototype_find(txMachine* the)
+{
+	txIndex length = fxGetArrayLimit(the, mxThis);
+	txIndex index = 0;
+	txSlot* function = fxArgToCallback(the, 0);
+	txSlot* item;
+	mxPushUndefined();
+	item = the->stack;
+	while (index < length) {
+		fxFindThisItem(the, function, index, item);
+		if (fxToBoolean(the, the->stack++)) {
+			mxResult->kind = item->kind;
+			mxResult->value = item->value;
+			break;
+		}
+		index++;
+	}
+	mxPop();
+}
+
+void fx_Array_prototype_findIndex(txMachine* the)
+{
+	txIndex length = fxGetArrayLimit(the, mxThis);
+	txIndex index = 0;
+	txSlot* function = fxArgToCallback(the, 0);
+	fxInteger(the, mxResult, -1);
+	while (index < length) {
+		fxFindThisItem(the, function, index, C_NULL);
+		if (fxToBoolean(the, the->stack++)) {
+			fxUnsigned(the, mxResult, index);
+			break;
+		}
+		index++;
+	}
+}
+
+void fx_Array_prototype_findLast(txMachine* the)
+{
+	txIndex index = fxGetArrayLimit(the, mxThis);
+	txSlot* function = fxArgToCallback(the, 0);
+	txSlot* item;
+	mxPushUndefined();
+	item = the->stack;
+	while (index > 0) {
+		index--;
+		fxFindThisItem(the, function, index, item);
+		if (fxToBoolean(the, the->stack++)) {
+			mxResult->kind = item->kind;
+			mxResult->value = item->value;
+			break;
+		}
+	}
+	mxPop();
+}
+
+void fx_Array_prototype_findLastIndex(txMachine* the)
+{
+	txIndex index = fxGetArrayLimit(the, mxThis);
+	txSlot* function = fxArgToCallback(the, 0);
+	fxInteger(the, mxResult, -1);
+	while (index > 0) {
+		index--;
+		fxFindThisItem(the, function, index, C_NULL);
+		if (fxToBoolean(the, the->stack++)) {
+			fxUnsigned(the, mxResult, index);
+			break;
+		}
+	}
+}
+
+void fx_Array_prototype_flat(txMachine* the)
+{
+	txIndex length, depth = 1;
+	mxPushSlot(mxThis);
+	mxGetID(mxID(_length));
+	length = (txIndex)fxToLength(the, the->stack);
+	mxPop();
+	if ((mxArgc > 0) && !mxIsUndefined(mxArgv(0)))
+		depth = (txIndex)fxToLength(the, mxArgv(0));
+	fxCreateArraySpecies(the, 0);
+	fx_Array_prototype_flatAux(the, mxThis, length, 0, depth, C_NULL);
+}
+
+txIndex fx_Array_prototype_flatAux(txMachine* the, txSlot* source, txIndex length, txIndex start, txIndex depth, txSlot* function)
+{
+	txSlot* item;
+	txIndex index = 0;
+	while (index < length) {
+		mxPushSlot(source);
+		if (fxHasIndex(the, index)) {
+			if (function) {
+				/* THIS */
+				if (mxArgc > 1)
+					mxPushSlot(mxArgv(1));
+				else
+					mxPushUndefined();
+				/* FUNCTION */
+				mxPushSlot(function);
+				mxCall();
+				/* ARGUMENTS */
+				mxPushSlot(source);
+				mxGetIndex(index);
+				mxPushUnsigned(index);
+				mxPushSlot(mxThis);
+				mxRunCount(3);
+			}
+			else {
+				mxPushSlot(source);
+				mxGetIndex(index);
+			}
+			item = the->stack;
+			if ((depth > 0) && mxIsReference(item) && fxIsArray(the, fxToInstance(the, item))) {
+				txIndex itemLength;
+				mxPushSlot(item);
+				mxGetID(mxID(_length));
+				itemLength = (txIndex)fxToLength(the, the->stack);
+				mxPop();
+				start = fx_Array_prototype_flatAux(the, item, itemLength, start, depth - 1, C_NULL);
+			}
+			else {
+				mxPushSlot(mxResult);
+				mxDefineIndex(start, 0, XS_GET_ONLY);
+				start++;
+			}
+		}
+		index++;
+	}
+	return start;
+}
+
+void fx_Array_prototype_flatMap(txMachine* the)
+{
+	txIndex length = (txIndex)fxGetArrayLength(the, mxThis);
+	txSlot* function = fxArgToCallback(the, 0);
+	fxCreateArraySpecies(the, 0);
+	fx_Array_prototype_flatAux(the, mxThis, length, 0, 1, function);
+}
+
+void fx_Array_prototype_forEach(txMachine* the)
+{
+	txIndex length = fxGetArrayLimit(the, mxThis);
+	txIndex index = 0;
+	txSlot* function = fxArgToCallback(the, 0);
+	while (index < length) {
+		if (fxCallThisItem(the, function, index, C_NULL))
+			mxPop();
+		index++;
+	}
+}
+
+void fx_Array_prototype_includes(txMachine* the)
+{
+	txSlot* array = fxCheckArray(the, mxThis, XS_IMMUTABLE);
+	txSlot* argument;
+	if (mxArgc > 0)
+		mxPushSlot(mxArgv(0));
+	else
+		mxPushUndefined();
+	argument = the->stack;
+	fxBoolean(the, mxResult, 0);
+	if (array) {
+		txIndex length = array->value.array.length;
+		if (length) {
+			txIndex index = (txIndex)fxArgToIndex(the, 1, 0, length);
+			while (index < length) {
+				mxPushSlot(mxThis);
+				mxGetIndex(index);
+				if (fxIsSameValue(the, the->stack++, argument, 1)) {
+					mxResult->value.boolean = 1;
+					break;
+				}
+				index++;
+			}
+		}
+	}
+	else {
+		txNumber length = fxGetArrayLength(the, mxThis);
+		if (length) {
+			txNumber index = fxArgToIndex(the, 1, 0, length);
+			while (index < length) {
+				mxPushSlot(mxThis);
+				mxPushNumber(index);
+				mxGetAt();
+				if (fxIsSameValue(the, the->stack++, argument, 1)) {
+					mxResult->value.boolean = 1;
+					break;
+				}
+				index++;
+			}
+		}
+	}
+	mxPop();
+}
+
+void fx_Array_prototype_indexOf(txMachine* the)
+{
+	txSlot* array = fxCheckArray(the, mxThis, XS_IMMUTABLE);
+	txSlot* argument;
+	if (mxArgc > 0)
+		mxPushSlot(mxArgv(0));
+	else
+		mxPushUndefined();
+	argument = the->stack;
+	fxInteger(the, mxResult, -1);
+	if (array) {
+		txIndex length = array->value.array.length;
+		if (length) {
+			txIndex index = (txIndex)fxArgToIndex(the, 1, 0, length);
+			while (index < length) {
+				mxPushSlot(mxThis);
+				if (fxHasIndex(the, index)) {
+					mxPushSlot(mxThis);
+					mxGetIndex(index);
+					if (fxIsSameSlot(the, the->stack++, argument)) {
+						fxUnsigned(the, mxResult, index);
+						break;
+					}
+				}
+				index++;
+			}
+		}
+	}
+	else {
+		txNumber length = fxGetArrayLength(the, mxThis);
+		if (length) {
+			txNumber index = fxArgToIndex(the, 1, 0, length);
+			while (index < length) {
+				mxPushSlot(mxThis);
+				mxPushNumber(index);
+				if (mxHasAt()) {
+					mxPushSlot(mxThis);
+					mxPushNumber(index);
+					mxGetAt();
+					if (fxIsSameSlot(the, the->stack++, argument)) {
+						fxNumber(the, mxResult, index);
+						break;
+					}
+				}
+				index++;
+			}
+		}
+	}
+	mxPop();
+}
+
+void fx_Array_prototype_join(txMachine* the)
+{
+	txIndex length = fxGetArrayLimit(the, mxThis);
+	txIndex index = 0;
+	txString string;
+	txSlot* list = fxNewInstance(the);
+	txSlot* slot = list;
+	txBoolean comma = 0;
+	txInteger size = 0;
+	if ((mxArgc > 0) && (mxArgv(0)->kind != XS_UNDEFINED_KIND)) {
+		mxPushSlot(mxArgv(0));
+		string = fxToString(the, the->stack);
+		the->stack->kind += XS_KEY_KIND - XS_STRING_KIND;
+		the->stack->value.key.sum = mxStringLength(string);
+	}
+	else {
+		mxPushStringX(",");
+		the->stack->kind += XS_KEY_KIND - XS_STRING_KIND;
+		the->stack->value.key.sum = 1;
+	}
+	while (index < length) {
+		if (comma) {
+			slot = fxNextSlotProperty(the, slot, the->stack, XS_NO_ID, XS_NO_FLAG);
+			size = fxAddChunkSizes(the, size, slot->value.key.sum);
+		}
+		else
+			comma = 1;
+		mxPushSlot(mxThis);
+		mxGetIndex(index);
+		if ((the->stack->kind != XS_UNDEFINED_KIND) && (the->stack->kind != XS_NULL_KIND)) {
+			slot = fxNextSlotProperty(the, slot, the->stack, XS_NO_ID, XS_NO_FLAG);
+			string = fxToString(the, slot);
+			slot->kind += XS_KEY_KIND - XS_STRING_KIND;
+			slot->value.key.sum = mxStringLength(string);
+			size = fxAddChunkSizes(the, size, slot->value.key.sum);
+		}
+		mxPop();
+		index++;
+	}
+	mxPop();
+	string = mxResult->value.string = fxNewChunk(the, fxAddChunkSizes(the, size, 1));
+	slot = list->next;
+	while (slot) {
+		c_memcpy(string, slot->value.key.string, slot->value.key.sum);
+		string += slot->value.key.sum;
+		slot = slot->next;
+	}
+	*string = 0;
+	mxResult->kind = XS_STRING_KIND;
+	mxPop();
+}
+
+void fx_Array_prototype_keys(txMachine* the)
+{
+	txSlot* property;
+	fxToInstance(the, mxThis);
+	mxPush(mxArrayIteratorPrototype);
+	property = fxLastProperty(the, fxNewIteratorInstance(the, mxThis, mxID(_Array)));
+	property = fxNextIntegerProperty(the, property, 1, XS_NO_ID, XS_INTERNAL_FLAG);
+	mxPullSlot(mxResult);
+}
+
+void fx_Array_prototype_lastIndexOf(txMachine* the)
+{
+	txSlot* array = fxCheckArray(the, mxThis, XS_IMMUTABLE);
+	txSlot* argument;
+	if (mxArgc > 0)
+		mxPushSlot(mxArgv(0));
+	else
+		mxPushUndefined();
+	argument = the->stack;
+	fxInteger(the, mxResult, -1);
+	if (array) {
+		txIndex length = array->value.array.length;
+		if (length) {
+			txIndex index = (txIndex)fxArgToLastIndex(the, 1, length, length);
+			while (index > 0) {
+				index--;
+				mxPushSlot(mxThis);
+				if (fxHasIndex(the, index)) {
+					mxPushSlot(mxThis);
+					mxGetIndex(index);
+					if (fxIsSameSlot(the, the->stack++, argument)) {
+						fxUnsigned(the, mxResult, index);
+						break;
+					}
+				}
+			}
+		}
+	}
+	else {
+		txNumber length = fxGetArrayLength(the, mxThis);
+		if (length) {
+			txNumber index = fxArgToLastIndex(the, 1, length, length);
+			while (index > 0) {
+				index--;
+				mxPushSlot(mxThis);
+				mxPushNumber(index);
+				if (mxHasAt()) {
+					mxPushSlot(mxThis);
+					mxPushNumber(index);
+					mxGetAt();
+					if (fxIsSameSlot(the, the->stack++, argument)) {
+						fxNumber(the, mxResult, index);
+						break;
+					}
+				}
+			}
+		}
+	}
+	mxPop();
+}
+
+void fx_Array_prototype_map(txMachine* the)
+{
+	txNumber LENGTH = fxGetArrayLength(the, mxThis);
+	txSlot* function = fxArgToCallback(the, 0);
+	txSlot* resultArray = fxCreateArraySpecies(the, LENGTH);
+	txIndex length = (txIndex)LENGTH;
+	txIndex index = 0;
+	if (resultArray) {
+		txIndex resultLength = 0;
+		fxSetIndexSize(the, resultArray, length, XS_CHUNK);
+		while (index < length) {
+			if (fxCallThisItem(the, function, index, C_NULL)) {
+				txSlot* slot = resultArray->value.array.address + resultLength;
+				*((txIndex*)slot) = index;
+				slot->ID = XS_NO_ID;
+				slot->kind = the->stack->kind;
+				slot->value = the->stack->value;
+				resultLength++;
+				mxMeterSome(2);
+				mxPop();
+			}
+			index++;
+		}
+		if (resultLength < length) {
+			fxSetIndexSize(the, resultArray, resultLength, XS_CHUNK);
+			resultArray->value.array.length = length;
+		}
+	}
+	else {
+		while (index < length) {
+			if (fxCallThisItem(the, function, index, C_NULL)) {
+				mxPushSlot(mxResult);
+				mxDefineIndex(index, 0, XS_GET_ONLY);
+				mxPop();
+			}
+			index++;
+		}
+	}
+}
+
+void fx_Array_prototype_pop(txMachine* the)
+{
+	txSlot* array = fxCheckArray(the, mxThis, XS_MUTABLE);
+	if (array) {
+		txIndex length = array->value.array.length;
+		if (length > 0)
+			array = fxCheckArrayItems(the, array, length - 1, length);
+	}
+	if (array) {
+		txIndex length = array->value.array.length;
+		txSlot* address;
+		mxMeterSome(2);
+		if (length > 0) {
+			length--;
+			address = array->value.array.address + length;
+			mxResult->kind = address->kind;
+			mxResult->value = address->value;
+			fxSetIndexSize(the, array, length, XS_CHUNK);
+			mxMeterSome(8);
+		}
+		mxMeterSome(4);
+	}
+	else {
+		txNumber length = fxGetArrayLength(the, mxThis);
+		if (length > 0) {
+			length--;
+			mxPushSlot(mxThis);
+			mxPushNumber(length);
+			mxGetAt();
+			mxPullSlot(mxResult);
+			mxPushSlot(mxThis);
+			mxPushNumber(length);
+			mxDeleteAt();
+			mxPop();
+		}
+		mxPushNumber(length);
+		mxPushSlot(mxThis);
+		mxSetID(mxID(_length));
+		mxPop();
+	}
+}
+
+void fx_Array_prototype_push(txMachine* the)
+{
+	txIndex c = mxArgc, i = 0;
+	txSlot* array = fxCheckArray(the, mxThis, XS_MUTABLE);
+	if (array) {
+		txIndex length = array->value.array.length;
+		txSlot* address;
+		mxMeterSome(2);
+		if (length + c < length)
+			mxRangeError("array overflow");
+		fxSetIndexSize(the, array, length + c, XS_GROWABLE_CHUNK);
+		address = array->value.array.address + length;
+		while (i < c) {
+			txSlot* argument = mxArgv(i);
+			*((txIndex*)address) = length + i;
+			address->ID = XS_NO_ID;
+			address->kind = argument->kind;
+			address->value = argument->value;
+			address++;
+			mxMeterSome(5);
+			i++;
+		}
+		mxPushUnsigned(length + c);
+		mxMeterSome(2);
+	}
+	else {
+		txNumber length = fxGetArrayLength(the, mxThis);
+		if (length + c > C_MAX_SAFE_INTEGER)
+			mxTypeError("unsafe integer");
+		while (i < c) {
+			mxPushSlot(mxArgv(i));
+			mxPushSlot(mxThis);
+			mxPushNumber(length + i);
+			mxSetAt();
+			mxPop();
+			i++;
+		}
+		mxPushNumber(length + c);
+		mxPushSlot(mxThis);
+		mxSetID(mxID(_length));
+	}
+	mxPullSlot(mxResult);
+}
+
+void fx_Array_prototype_reduce(txMachine* the)
+{
+	txIndex length = fxGetArrayLimit(the, mxThis);
+	txIndex index = 0;
+	txSlot* function = fxArgToCallback(the, 0);
+	if (mxArgc > 1)
+		*mxResult = *mxArgv(1);
+	else {
+		txBoolean flag = 0;
+		while (!flag && (index < length)) {
+			mxPushSlot(mxThis);
+			if (fxHasIndex(the, index)) {
+				mxPushSlot(mxThis);
+				mxGetIndex(index);
+				mxPullSlot(mxResult);
+				flag = 1;
+			}
+			index++;
+		}
+		if (!flag)
+			mxTypeError("no initial value");
+	}
+	while (index < length) {
+		fxReduceThisItem(the, function, index);
+		index++;
+	}
+}
+
+void fx_Array_prototype_reduceRight(txMachine* the)
+{
+	txIndex length = fxGetArrayLimit(the, mxThis);
+	txIndex index = length;
+	txSlot* function = fxArgToCallback(the, 0);
+	if (mxArgc > 1)
+		*mxResult = *mxArgv(1);
+	else {
+		txBoolean flag = 0;
+		while (!flag && (index > 0)) {
+			index--;
+			mxPushSlot(mxThis);
+			if (fxHasIndex(the, index)) {
+				mxPushSlot(mxThis);
+				mxGetIndex(index);
+				mxPullSlot(mxResult);
+				flag = 1;
+			}
+		}
+		if (!flag)
+			mxTypeError("no initial value");
+	}
+	while (index > 0) {
+		index--;
+		fxReduceThisItem(the, function, index);
+	}
+}
+
+void fx_Array_prototype_reverse(txMachine* the)
+{
+	txSlot* lowerSlot;
+	txSlot* upperSlot;
+	txNumber length = fxGetArrayLength(the, mxThis);
+	txNumber middle = c_trunc(length / 2);
+	txNumber lower = 0;
+	while (lower != middle) {
+		txNumber upper = length - lower - 1;
+		mxPushSlot(mxThis);
+		mxPushNumber(lower);
+		if (mxHasAt()) {
+			mxPushSlot(mxThis);
+			mxPushNumber(lower);
+			mxGetAt();
+			lowerSlot = the->stack;
+		}
+		else
+			lowerSlot = C_NULL;
+		mxPushSlot(mxThis);
+		mxPushNumber(upper);
+		if (mxHasAt()) {
+			mxPushSlot(mxThis);
+			mxPushNumber(upper);
+			mxGetAt();
+			upperSlot = the->stack;
+		}
+		else
+			upperSlot = C_NULL;
+		if (upperSlot && lowerSlot) {
+			mxPushSlot(upperSlot);
+			mxPushSlot(mxThis);
+			mxPushNumber(lower);
+			mxSetAt();
+			mxPop();
+			mxPushSlot(lowerSlot);
+			mxPushSlot(mxThis);
+			mxPushNumber(upper);
+			mxSetAt();
+			mxPop();
+			mxPop();
+			mxPop();
+		}
+		else if (upperSlot) {
+			mxPushSlot(upperSlot);
+			mxPushSlot(mxThis);
+			mxPushNumber(lower);
+			mxSetAt();
+			mxPop();
+			mxPushSlot(mxThis);
+			mxPushNumber(upper);
+			mxDeleteAt();
+			mxPop();
+			mxPop();
+		}
+		else if (lowerSlot) {
+			mxPushSlot(mxThis);
+			mxPushNumber(lower);
+			mxDeleteAt();
+			mxPop();
+			mxPushSlot(lowerSlot);
+			mxPushSlot(mxThis);
+			mxPushNumber(upper);
+			mxSetAt();
+			mxPop();
+			mxPop();
+		}
+		lower++;
+	}
+	*mxResult = *mxThis;
+}
+
+void fx_Array_prototype_shift(txMachine* the)
+{
+	txSlot* array = fxCheckArray(the, mxThis, XS_MUTABLE);
+	if (array)
+		array = fxCheckArrayItems(the, array, 0, array->value.array.length);
+	if (array) {
+		txIndex length = array->value.array.length;
+		txSlot* address;
+		mxMeterSome(2);
+		if (length > 0) {
+			mxMeterSome(3);
+			address = array->value.array.address;
+			length--;
+			mxResult->kind = address->kind;
+			mxResult->value = address->value;
+			c_memmove(address, address + 1, length * sizeof(txSlot));
+			fxSetIndexSize(the, array, length, XS_CHUNK);
+			fxIndexArray(the, array);
+			mxMeterSome(length * 10);
+			mxMeterSome(3);
+		}
+		mxMeterSome(4);
+	}
+	else {
+		txNumber length = fxGetArrayLength(the, mxThis);
+		if (length > 0) {
+			txNumber index = 1;
+			mxPushSlot(mxThis);
+			mxGetIndex(0);
+			mxPullSlot(mxResult);
+			while (index < length) {
+				mxPushSlot(mxThis);
+				mxPushNumber(index);
+				if (mxHasAt()) {
+					mxPushSlot(mxThis);
+					mxPushNumber(index);
+					mxGetAt();
+					mxPushSlot(mxThis);
+					mxPushNumber(index - 1);
+					mxSetAt();
+					mxPop();
+				}
+				else {
+					mxPushSlot(mxThis);
+					mxPushNumber(index - 1);
+					mxDeleteAt();
+					mxPop();
+				}
+				index++;
+			}
+			length--;
+			mxPushSlot(mxThis);
+			mxDeleteIndex((txIndex)length);
+			mxPop();
+		}
+		mxPushNumber(length);
+		mxPushSlot(mxThis);
+		mxSetID(mxID(_length));
+		mxPop();
+	}
+}
+
+void fx_Array_prototype_slice(txMachine* the)
+{
+	txNumber LENGTH = fxGetArrayLength(the, mxThis);
+	txNumber START = fxArgToIndex(the, 0, 0, LENGTH);
+	txNumber END = fxArgToIndex(the, 1, LENGTH, LENGTH);
+	txNumber COUNT = (END > START) ? END - START : 0;
+	txSlot* resultArray = fxCreateArraySpecies(the, COUNT);
+	txSlot* array = C_NULL;
+	if (resultArray)
+		array = fxCheckArray(the, mxThis, XS_IMMUTABLE);
+	if (array)
+		array = fxCheckArrayItems(the, array, (txIndex)START, (txIndex)(START + COUNT));
+	if (array) {
+		txIndex start = (txIndex)START;
+		txIndex count = (txIndex)COUNT;
+		if (count) {
+			fxSetIndexSize(the, resultArray, count, XS_CHUNK);
+			c_memcpy(resultArray->value.array.address, array->value.array.address + start, count * sizeof(txSlot));
+			fxIndexArray(the, resultArray);
+			mxMeterSome(count * 10);
+		}
+		mxMeterSome(3);
+	}
+	else {
+		txNumber INDEX = 0;
+		while (START < END) {
+			mxPushSlot(mxThis);
+			mxPushNumber(START);
+			if (mxHasAt()) {
+				mxPushSlot(mxThis);
+				mxPushNumber(START);
+				mxGetAt();
+				mxPushSlot(mxResult);
+				mxPushNumber(INDEX);
+				mxDefineAt(0, XS_GET_ONLY);
+				mxPop();
+			}
+			INDEX++;
+			START++;
+		}
+		mxPushNumber(COUNT);
+		mxPushSlot(mxResult);
+		mxSetID(mxID(_length));
+	}
+}
+
+void fx_Array_prototype_some(txMachine* the)
+{
+	txIndex length = fxGetArrayLimit(the, mxThis);
+	txIndex index = 0;
+	txSlot* function = fxArgToCallback(the, 0);
+	mxResult->kind = XS_BOOLEAN_KIND;
+	mxResult->value.boolean = 0;
+	while (index < length) {
+		if (fxCallThisItem(the, function, index, C_NULL)) {
+			mxResult->value.boolean = fxToBoolean(the, the->stack);
+			mxPop();
+			if (mxResult->value.boolean)
+				break;
+		}
+		index++;
+	}
+}
+
+
+void fx_Array_prototype_sort(txMachine* the)
+{
+	txSlot* array = fxCheckArray(the, mxThis, XS_MUTABLE);
+	txSlot* function = C_NULL;
+	if (mxArgc > 0) {
+		txSlot* slot = mxArgv(0);
+		if (slot->kind != XS_UNDEFINED_KIND) {
+			if (fxIsCallable(the, slot))
+				function = slot;
+			else
+				mxTypeError("compare is no function");
+		}
+	}
+	if (function)
+		fxSortArrayItems(the, function, C_NULL, fxGetArrayLength(the, mxThis));
+	else {
+		if (array)
+			array = fxCheckArrayItems(the, array, 0, array->value.array.length);
+		fxSortArrayItems(the, function, array, fxGetArrayLength(the, mxThis));
+	}
+	mxResult->kind = mxThis->kind;
+	mxResult->value = mxThis->value;
+}
+
+void fx_Array_prototype_splice(txMachine* the)
+{
+	txIndex c = (txIndex)mxArgc;
+	txNumber LENGTH = fxGetArrayLength(the, mxThis);
+	txNumber START = fxArgToIndex(the, 0, 0, LENGTH);
+	txNumber INSERTIONS, DELETIONS;
+	txSlot* resultArray;
+	txSlot* array = C_NULL;
+	if (c == 0) {
+		INSERTIONS = 0;
+		DELETIONS = 0;
+	}
+	else if (c == 1) {
+		INSERTIONS = 0;
+		DELETIONS = LENGTH - START;
+	}
+	else {
+		INSERTIONS = c - 2;
+		DELETIONS = fxArgToRange(the, 1, 0, 0, LENGTH - START);
+	}
+	if (LENGTH + INSERTIONS - DELETIONS > C_MAX_SAFE_INTEGER)
+		mxTypeError("unsafe integer");
+	resultArray = fxCreateArraySpecies(the, DELETIONS);
+	if (resultArray)
+		array = fxCheckArray(the, mxThis, XS_MUTABLE);
+	if (array) {
+		if (INSERTIONS == DELETIONS)
+			array = fxCheckArrayItems(the, array, (txIndex)START, (txIndex)(START + DELETIONS));
+		else
+			array = fxCheckArrayItems(the, array, (txIndex)START, (txIndex)LENGTH);
+	}
+	if (array) {
+		txSlot* address;
+		txIndex length = (txIndex)LENGTH;
+		txIndex start = (txIndex)START;
+		txIndex insertions = (txIndex)INSERTIONS;
+		txIndex deletions = (txIndex)DELETIONS;
+		txIndex index;
+		if (LENGTH + INSERTIONS - DELETIONS > 0xFFFFFFFF)
+			mxTypeError("array overflow");
+		fxSetIndexSize(the, resultArray, deletions, XS_CHUNK);
+		c_memcpy(resultArray->value.array.address, array->value.array.address + start, deletions * sizeof(txSlot));
+		fxIndexArray(the, resultArray);
+		mxMeterSome(deletions * 10);
+		mxMeterSome(4);
+		if (insertions < deletions) {
+			c_memmove(array->value.array.address + start + insertions, array->value.array.address + start + deletions, (length - (start + deletions)) * sizeof(txSlot));
+			fxSetIndexSize(the, array, length - (deletions - insertions), XS_CHUNK);
+			mxMeterSome((length - (start + deletions)) * 10);
+			mxMeterSome((deletions - insertions) * 4);
+		}
+		else if (insertions > deletions) {
+			fxSetIndexSize(the, array, length + (insertions - deletions), XS_CHUNK);
+			c_memmove(array->value.array.address + start + insertions, array->value.array.address + start + deletions, (length - (start + deletions)) * sizeof(txSlot));
+			mxMeterSome((length - (start + deletions)) * 10);
+		}
+		address = array->value.array.address + start;
+		index = 2;
+		while (index < c) {
+			txSlot* argument = mxArgv(index);
+			address->ID = XS_NO_ID;
+			address->kind = argument->kind;
+			address->value = argument->value;
+			address++;
+			mxMeterSome(5);
+			index++;
+		}
+		fxIndexArray(the, array);
+		mxMeterSome(4);
+	}
+	else {	
+		txNumber INDEX = 0;
+		while (INDEX < DELETIONS) {
+			txNumber FROM = START + INDEX;
+			mxPushSlot(mxThis);
+			mxPushNumber(FROM);
+			if (mxHasAt()) {
+				mxPushSlot(mxThis);
+				mxPushNumber(FROM);
+				mxGetAt();
+				mxPushSlot(mxResult);
+				mxPushNumber(INDEX);
+				mxDefineAt(0, XS_GET_ONLY);
+				mxPop();
+			}
+			INDEX++;
+		}
+		mxPushNumber(DELETIONS);
+		mxPushSlot(mxResult);
+		mxSetID(mxID(_length));
+		mxPop();
+		if (INSERTIONS < DELETIONS) {
+			INDEX = START;
+			while (INDEX < (LENGTH - DELETIONS)) {
+				fxMoveThisItem(the, INDEX + DELETIONS, INDEX + INSERTIONS);
+				INDEX++;
+			}
+			INDEX = LENGTH;
+			while (INDEX > (LENGTH - DELETIONS + INSERTIONS)) {
+				mxPushSlot(mxThis);
+				mxPushNumber(INDEX - 1);
+				mxDeleteAt();
+				mxPop();
+				INDEX--;
+			}
+		}
+		else if (INSERTIONS > DELETIONS) {
+			INDEX = LENGTH - DELETIONS;
+			while (INDEX > START) {
+				fxMoveThisItem(the, INDEX + DELETIONS - 1, INDEX + INSERTIONS - 1);
+				INDEX--;
+			}
+		}
+		INDEX = 0;
+		while (INDEX < INSERTIONS) {
+			mxPushSlot(mxArgv(2 + (txInteger)INDEX));
+			mxPushSlot(mxThis);
+			mxPushNumber(START + INDEX);
+			mxSetAt();
+			mxPop();
+			INDEX++;
+		}
+		mxPushNumber(LENGTH - DELETIONS + INSERTIONS);
+		mxPushSlot(mxThis);
+		mxSetID(mxID(_length));
+		mxPop();
+	}
+}
+
+void fx_Array_prototype_toLocaleString(txMachine* the)
+{
+	txIndex length = fxGetArrayLimit(the, mxThis);
+	txIndex index = 0;
+	txString string;
+	txSlot* list = fxNewInstance(the);
+	txSlot* slot = list;
+	txBoolean comma = 0;
+	txInteger size = 0;
+    
+	mxPushStringX(",");
+	the->stack->kind += XS_KEY_KIND - XS_STRING_KIND;
+	the->stack->value.key.sum = 1;
+	while (index < length) {
+		if (comma) {
+			slot = fxNextSlotProperty(the, slot, the->stack, XS_NO_ID, XS_NO_FLAG);
+			size = fxAddChunkSizes(the, size, slot->value.key.sum);
+		}
+		else
+			comma = 1;
+		mxPushSlot(mxThis);
+		mxGetIndex(index);
+		if ((the->stack->kind != XS_UNDEFINED_KIND) && (the->stack->kind != XS_NULL_KIND)) {
+			mxDub();
+			mxGetID(mxID(_toLocaleString));
+			mxCall();
+			mxRunCount(0);
+			slot = fxNextSlotProperty(the, slot, the->stack, XS_NO_ID, XS_NO_FLAG);
+			string = fxToString(the, slot);
+			slot->kind += XS_KEY_KIND - XS_STRING_KIND;
+			slot->value.key.sum = mxStringLength(string);
+			size = fxAddChunkSizes(the, size, slot->value.key.sum);
+		}
+		mxPop();
+		index++;
+	}
+	string = mxResult->value.string = fxNewChunk(the, fxAddChunkSizes(the, size, 1));
+	slot = list->next;
+	while (slot) {
+		c_memcpy(string, slot->value.key.string, slot->value.key.sum);
+		string += slot->value.key.sum;
+		slot = slot->next;
+	}
+	*string = 0;
+	mxResult->kind = XS_STRING_KIND;
+	mxPop();
+}
+
+void fx_Array_prototype_toString(txMachine* the)
+{
+	mxPushSlot(mxThis);
+	mxDub();
+	mxGetID(mxID(_join));
+	if (fxIsCallable(the, the->stack)) {
+		mxCall();
+		mxRunCount(0);
+		mxPullSlot(mxResult);
+	}
+	else {
+		mxPop();
+		mxPop();
+		fx_Object_prototype_toString(the);
+	}
+}
+
+void fx_Array_prototype_unshift(txMachine* the)
+{
+	txIndex c = mxArgc, i;
+	txSlot* array = fxCheckArray(the, mxThis, XS_MUTABLE);
+	if (array)
+		array = fxCheckArrayItems(the, array, 0, array->value.array.length);
+	if (array) {
+		txSlot* address;
+		txIndex length = array->value.array.length;
+		if (length + c < length)
+			mxRangeError("array overflow");
+		if (c > 0) {
+			fxSetIndexSize(the, array, length + c, XS_GROWABLE_CHUNK);
+			address = array->value.array.address;
+			c_memmove(address + c, address, length * sizeof(txSlot));
+			mxMeterSome(length * 10);
+			i = 0;
+			while (i < c) {
+				txSlot* argument = mxArgv(i);
+				address->ID = XS_NO_ID;
+				address->kind = argument->kind;
+				address->value = argument->value;
+				address++;
+				mxMeterSome(4);
+				i++;
+			}
+			fxIndexArray(the, array);
+		}
+		mxPushUnsigned(length + c);
+		mxMeterSome(2);
+	}
+	else {
+		txNumber length = fxGetArrayLength(the, mxThis);
+		txNumber index = length;
+		if (c > 0) {
+			if (length + c > C_MAX_SAFE_INTEGER)
+				mxTypeError("unsafe integer");
+			while (index > 0) {
+				fxMoveThisItem(the, index - 1, index + c - 1);
+				index--;
+			}
+			i = 0;
+			while (i < c) {
+				mxPushSlot(mxArgv(i));
+				mxPushSlot(mxThis);
+				mxSetIndex(i);
+				mxPop();
+				i++;
+			}
+		}
+		mxPushNumber(length + c);
+		mxPushSlot(mxThis);
+		mxSetID(mxID(_length));
+	}
+	mxPullSlot(mxResult);
+}
+
+void fx_Array_prototype_values(txMachine* the)
+{
+	txSlot* property;
+	fxToInstance(the, mxThis);
+	mxPush(mxArrayIteratorPrototype);
+	property = fxLastProperty(the, fxNewIteratorInstance(the, mxThis, mxID(_Array)));
+	property = fxNextIntegerProperty(the, property, 0, XS_NO_ID, XS_INTERNAL_FLAG);
+	mxPullSlot(mxResult);
+}
+
+void fx_ArrayIterator_prototype_next(txMachine* the)
+{
+	txSlot* iterator = fxCheckIteratorInstance(the, mxThis, mxID(_Array));
+	txSlot* result = iterator->next;
+	txSlot* iterable = result->next;
+	txSlot* index = iterable->next;
+	txSlot* value = fxCheckIteratorResult(the, result);
+	txSlot* done = value->next;
+	if (!done->value.boolean) {
+		txInteger kind = index->next->value.integer;
+		txIndex length = fxGetArrayLimit(the, iterable);
+		txIndex i = (txIndex)index->value.integer;
+		if (i < length) {
+			switch(kind) {
+			case 0: 
+				mxPushSlot(iterable);
+				mxGetIndex(i);
+				mxPullSlot(value);
+				break;
+			case 1:
+				mxPushUnsigned(i);
+				mxPullSlot(value);
+				break;
+			case 2:
+				mxPushUnsigned(i);
+				mxPushSlot(iterable);
+				mxGetIndex(i);
+				fxConstructArrayEntry(the, value);
+				break;
+			}
+            index->value.integer = i + 1;
+		}
+		else {
+			value->kind = XS_UNDEFINED_KIND;
+			done->value.boolean = 1;
+		}
+	}
+	mxResult->kind = result->kind;
+	mxResult->value = result->value;
+}
+