More work on TypedArrays

46 files changed, 3031 insertions, 1062 deletions

diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp
index ea112f1..aef41ca 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp
@@ -9,6 +9,18 @@
 #include "dom/V8CDATASection.h"
 #include "dom/V8SCXMLEvent.h"
 
+#include "dom/V8ArrayBuffer.h"
+#include "dom/V8Int8Array.h"
+#include "dom/V8Uint8Array.h"
+#include "dom/V8Uint8ClampedArray.h"
+#include "dom/V8Int16Array.h"
+#include "dom/V8Uint16Array.h"
+#include "dom/V8Int32Array.h"
+#include "dom/V8Uint32Array.h"
+#include "dom/V8Float32Array.h"
+#include "dom/V8Float64Array.h"
+#include "dom/V8DataView.h"
+
 #include "uscxml/Message.h"
 #include <glog/logging.h>
 
@@ -86,6 +98,20 @@ boost::shared_ptr<DataModelImpl> V8DataModel::create(InterpreterImpl* interprete
 
 	context->Global()->Set(v8::String::New("document"), docObj);
 
+	// setup constructors
+	context->Global()->Set(v8::String::New("ArrayBuffer"), V8ArrayBuffer::getConstructor()->GetFunction());
+	context->Global()->Set(v8::String::New("Int8Array"), V8Int8Array::getConstructor()->GetFunction());
+	context->Global()->Set(v8::String::New("Uint8Array"), V8Uint8Array::getConstructor()->GetFunction());
+	context->Global()->Set(v8::String::New("Uint8ClampedArray"), V8Uint8ClampedArray::getConstructor()->GetFunction());
+	context->Global()->Set(v8::String::New("Int16Array"), V8Int16Array::getConstructor()->GetFunction());
+	context->Global()->Set(v8::String::New("Uint16Array"), V8Uint16Array::getConstructor()->GetFunction());
+	context->Global()->Set(v8::String::New("Int32Array"), V8Int32Array::getConstructor()->GetFunction());
+	context->Global()->Set(v8::String::New("Uint32Array"), V8Uint32Array::getConstructor()->GetFunction());
+	context->Global()->Set(v8::String::New("Float32Array"), V8Float32Array::getConstructor()->GetFunction());
+	context->Global()->Set(v8::String::New("Float64Array"), V8Float64Array::getConstructor()->GetFunction());
+	context->Global()->Set(v8::String::New("DataView"), V8DataView::getConstructor()->GetFunction());
+
+
 	context->Global()->SetAccessor(v8::String::New("_sessionid"),
 	                               V8DataModel::getAttribute,
 	                               V8DataModel::setWithException,
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ArrayBuffer.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ArrayBuffer.cpp
index d4146fe..ce51887 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ArrayBuffer.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ArrayBuffer.cpp
@@ -4,7 +4,37 @@ namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8ArrayBuffer::Tmpl;
+v8::Persistent<v8::FunctionTemplate> V8ArrayBuffer::Constr;
 
+v8::Handle<v8::Value> V8ArrayBuffer::constructor(const v8::Arguments& args) {
+	if (!args.IsConstructCall())
+		return v8::ThrowException(v8::String::New("Cannot call constructor as function"));
+
+	uscxml::ArrayBuffer* localInstance = NULL;
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+
+		unsigned long localLength = args[0]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::ArrayBuffer(localLength);
+
+	}
+	if (!localInstance) {
+		throw V8Exception("Parameter mismatch while calling constructor for ArrayBuffer");
+		return v8::Undefined();
+	}
+
+	v8::Handle<v8::Function> retCtor = V8ArrayBuffer::getTmpl()->GetFunction();
+	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+
+	struct V8ArrayBuffer::V8ArrayBufferPrivate* retPrivData = new V8ArrayBuffer::V8ArrayBufferPrivate();
+	retPrivData->nativeObj = localInstance;
+
+	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+
+	retObj.MakeWeak(0, V8ArrayBuffer::jsDestructor);
+	return retObj;
+}
 
 v8::Handle<v8::Value> V8ArrayBuffer::byteLengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
@@ -12,43 +42,69 @@ v8::Handle<v8::Value> V8ArrayBuffer::byteLengthAttrGetter(v8::Local<v8::String>
 
 	return v8::Integer::New(privData->nativeObj->getByteLength());
 }
+
 v8::Handle<v8::Value> V8ArrayBuffer::sliceCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in slice");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ArrayBufferPrivate* privData = V8DOM::toClassPtr<V8ArrayBufferPrivate >(self->GetInternalField(0));
-	long localBegin = args[0]->ToNumber()->Int32Value();
-	long localEnd = args[1]->ToNumber()->Int32Value();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsInt32() &&
+	           args[1]->IsInt32()) {
+		long localBegin = args[0]->ToNumber()->Int32Value();
+		long localEnd = args[1]->ToNumber()->Int32Value();
 
-	uscxml::ArrayBuffer* retVal = new uscxml::ArrayBuffer(privData->nativeObj->slice(localBegin, localEnd));
-	v8::Handle<v8::Function> retCtor = V8ArrayBuffer::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		uscxml::ArrayBuffer* retVal = new uscxml::ArrayBuffer(privData->nativeObj->slice(localBegin, localEnd));
+		v8::Handle<v8::Function> retCtor = V8ArrayBuffer::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8ArrayBuffer::V8ArrayBufferPrivate* retPrivData = new V8ArrayBuffer::V8ArrayBufferPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8ArrayBuffer::V8ArrayBufferPrivate* retPrivData = new V8ArrayBuffer::V8ArrayBufferPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8ArrayBuffer::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8ArrayBuffer::jsDestructor);
+		return retObj;
 
+	} else if (args.Length() == 1 &&
+	           args[0]->IsInt32()) {
+		long localBegin = args[0]->ToNumber()->Int32Value();
+
+		uscxml::ArrayBuffer* retVal = new uscxml::ArrayBuffer(privData->nativeObj->slice(localBegin));
+		v8::Handle<v8::Function> retCtor = V8ArrayBuffer::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+
+		struct V8ArrayBuffer::V8ArrayBufferPrivate* retPrivData = new V8ArrayBuffer::V8ArrayBufferPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
+
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+
+		retObj.MakeWeak(0, V8ArrayBuffer::jsDestructor);
+		return retObj;
+
+	}
+	throw V8Exception("Parameter mismatch while calling slice");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8ArrayBuffer::isViewCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in isView");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ArrayBufferPrivate* privData = V8DOM::toClassPtr<V8ArrayBufferPrivate >(self->GetInternalField(0));
-	void* localValue = v8::External::Unwrap(args[0]->ToObject()->GetInternalField(0));
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           true) {
+		void* localValue = v8::External::Unwrap(args[0]->ToObject()->GetInternalField(0));
 
-	bool retVal = privData->nativeObj->isView(localValue);
+		bool retVal = privData->nativeObj->isView(localValue);
 
-	return v8::Boolean::New(retVal);
+		return v8::Boolean::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling isView");
+	return v8::Undefined();
 }
-
 bool V8ArrayBuffer::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ArrayBuffer.h b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ArrayBuffer.h
index 3399575..d4229eb 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ArrayBuffer.h
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ArrayBuffer.h
@@ -45,6 +45,18 @@ public:
 	static v8::Handle<v8::Value> isViewCallback(const v8::Arguments&);
 
 	static v8::Handle<v8::Value> byteLengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+	static v8::Handle<v8::Value> indexedPropertyCustomGetter(uint32_t, const v8::AccessorInfo&);
+	static v8::Handle<v8::Value> indexedPropertyCustomSetter(uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo&);
+
+	static v8::Handle<v8::Value> constructor(const v8::Arguments&);
+	static v8::Persistent<v8::FunctionTemplate> Constr;
+	static v8::Handle<v8::FunctionTemplate> getConstructor() {
+		if (Constr.IsEmpty()) {
+			v8::Handle<v8::FunctionTemplate> constr = v8::FunctionTemplate::New(constructor);
+			Constr = v8::Persistent<v8::FunctionTemplate>::New(constr);
+		}
+		return Constr;
+	}
 
 	static v8::Persistent<v8::FunctionTemplate> Tmpl;
 	static v8::Handle<v8::FunctionTemplate> getTmpl() {
@@ -62,6 +74,7 @@ public:
 			instance->SetAccessor(v8::String::NewSymbol("byteLength"), V8ArrayBuffer::byteLengthAttrGetter, 0,
 			                      v8::External::New(0), static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None));
 
+			instance->SetIndexedPropertyHandler(V8ArrayBuffer::indexedPropertyCustomGetter, V8ArrayBuffer::indexedPropertyCustomSetter);
 			prototype->Set(v8::String::NewSymbol("slice"),
 			               v8::FunctionTemplate::New(V8ArrayBuffer::sliceCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("isView"),
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ArrayBufferView.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ArrayBufferView.cpp
index ff0b744..562b9f3 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ArrayBufferView.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ArrayBufferView.cpp
@@ -6,7 +6,6 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8ArrayBufferView::Tmpl;
 
-
 v8::Handle<v8::Value> V8ArrayBufferView::bufferAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8ArrayBufferViewPrivate* privData = V8DOM::toClassPtr<V8ArrayBufferViewPrivate >(self->GetInternalField(0));
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Attr.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Attr.cpp
index bee6042..efb9a75 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Attr.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Attr.cpp
@@ -7,7 +7,6 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Attr::Tmpl;
 
-
 v8::Handle<v8::Value> V8Attr::nameAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8AttrPrivate* privData = V8DOM::toClassPtr<V8AttrPrivate >(self->GetInternalField(0));
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8CDATASection.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8CDATASection.cpp
index a9e5ac9..a348cd5 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8CDATASection.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8CDATASection.cpp
@@ -5,7 +5,6 @@ namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8CDATASection::Tmpl;
-
 bool V8CDATASection::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8CharacterData.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8CharacterData.cpp
index 459cf96..673e6a8 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8CharacterData.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8CharacterData.cpp
@@ -6,7 +6,6 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8CharacterData::Tmpl;
 
-
 v8::Handle<v8::Value> V8CharacterData::dataAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8CharacterDataPrivate* privData = V8DOM::toClassPtr<V8CharacterDataPrivate >(self->GetInternalField(0));
@@ -27,76 +26,101 @@ v8::Handle<v8::Value> V8CharacterData::lengthAttrGetter(v8::Local<v8::String> pr
 
 	return v8::Integer::New(privData->nativeObj->getLength());
 }
+
 v8::Handle<v8::Value> V8CharacterData::substringDataCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in substringData");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8CharacterDataPrivate* privData = V8DOM::toClassPtr<V8CharacterDataPrivate >(self->GetInternalField(0));
-	unsigned long localOffset = args[0]->ToNumber()->Uint32Value();
-	unsigned long localCount = args[1]->ToNumber()->Uint32Value();
-
-	std::string retVal = privData->nativeObj->substringData(localOffset, localCount);
-
-	return v8::String::New(retVal.c_str());
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsUint32()) {
+		unsigned long localOffset = args[0]->ToNumber()->Uint32Value();
+		unsigned long localCount = args[1]->ToNumber()->Uint32Value();
+
+		std::string retVal = privData->nativeObj->substringData(localOffset, localCount);
+
+		return v8::String::New(retVal.c_str());
+	}
+	throw V8Exception("Parameter mismatch while calling substringData");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8CharacterData::appendDataCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in appendData");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8CharacterDataPrivate* privData = V8DOM::toClassPtr<V8CharacterDataPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localArg(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localArg(args[0]);
 
-	privData->nativeObj->appendData(*localArg);
+		privData->nativeObj->appendData(*localArg);
 
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling appendData");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8CharacterData::insertDataCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in insertData");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8CharacterDataPrivate* privData = V8DOM::toClassPtr<V8CharacterDataPrivate >(self->GetInternalField(0));
-	unsigned long localOffset = args[0]->ToNumber()->Uint32Value();
-	v8::String::AsciiValue localArg(args[1]);
-
-	privData->nativeObj->insertData(localOffset, *localArg);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsString()) {
+		unsigned long localOffset = args[0]->ToNumber()->Uint32Value();
+		v8::String::AsciiValue localArg(args[1]);
+
+		privData->nativeObj->insertData(localOffset, *localArg);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling insertData");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8CharacterData::deleteDataCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in deleteData");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8CharacterDataPrivate* privData = V8DOM::toClassPtr<V8CharacterDataPrivate >(self->GetInternalField(0));
-	unsigned long localOffset = args[0]->ToNumber()->Uint32Value();
-	unsigned long localCount = args[1]->ToNumber()->Uint32Value();
-
-	privData->nativeObj->deleteData(localOffset, localCount);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsUint32()) {
+		unsigned long localOffset = args[0]->ToNumber()->Uint32Value();
+		unsigned long localCount = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->deleteData(localOffset, localCount);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling deleteData");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8CharacterData::replaceDataCallback(const v8::Arguments& args) {
-	if (args.Length() < 3)
-		throw V8Exception("Wrong number of arguments in replaceData");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8CharacterDataPrivate* privData = V8DOM::toClassPtr<V8CharacterDataPrivate >(self->GetInternalField(0));
-	unsigned long localOffset = args[0]->ToNumber()->Uint32Value();
-	unsigned long localCount = args[1]->ToNumber()->Uint32Value();
-	v8::String::AsciiValue localArg(args[2]);
-
-	privData->nativeObj->replaceData(localOffset, localCount, *localArg);
-
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsUint32() &&
+	           args[2]->IsString()) {
+		unsigned long localOffset = args[0]->ToNumber()->Uint32Value();
+		unsigned long localCount = args[1]->ToNumber()->Uint32Value();
+		v8::String::AsciiValue localArg(args[2]);
+
+		privData->nativeObj->replaceData(localOffset, localCount, *localArg);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling replaceData");
 	return v8::Undefined();
 }
-
 bool V8CharacterData::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Comment.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Comment.cpp
index f754ea7..97cd948 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Comment.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Comment.cpp
@@ -5,7 +5,6 @@ namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Comment::Tmpl;
-
 bool V8Comment::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DOMImplementation.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DOMImplementation.cpp
index f7a7575..00fe645 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DOMImplementation.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DOMImplementation.cpp
@@ -8,71 +8,85 @@ namespace DOM {
 v8::Persistent<v8::FunctionTemplate> V8DOMImplementation::Tmpl;
 
 v8::Handle<v8::Value> V8DOMImplementation::hasFeatureCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in hasFeature");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DOMImplementationPrivate* privData = V8DOM::toClassPtr<V8DOMImplementationPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localFeature(args[0]);
-	v8::String::AsciiValue localVersion(args[1]);
-
-	bool retVal = privData->nativeObj->hasFeature(*localFeature, *localVersion);
-
-	return v8::Boolean::New(retVal);
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localFeature(args[0]);
+		v8::String::AsciiValue localVersion(args[1]);
+
+		bool retVal = privData->nativeObj->hasFeature(*localFeature, *localVersion);
+
+		return v8::Boolean::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling hasFeature");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DOMImplementation::createDocumentTypeCallback(const v8::Arguments& args) {
-	if (args.Length() < 3)
-		throw V8Exception("Wrong number of arguments in createDocumentType");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DOMImplementationPrivate* privData = V8DOM::toClassPtr<V8DOMImplementationPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localQualifiedName(args[0]);
-	v8::String::AsciiValue localPublicId(args[1]);
-	v8::String::AsciiValue localSystemId(args[2]);
-
-	Arabica::DOM::DocumentType<std::string>* retVal = new Arabica::DOM::DocumentType<std::string>(privData->nativeObj->createDocumentType(*localQualifiedName, *localPublicId, *localSystemId));
-	v8::Handle<v8::Function> retCtor = V8DocumentType::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
-
-	struct V8DocumentType::V8DocumentTypePrivate* retPrivData = new V8DocumentType::V8DocumentTypePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
-
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
-
-	retObj.MakeWeak(0, V8DocumentType::jsDestructor);
-	return retObj;
-
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString() &&
+	           args[2]->IsString()) {
+		v8::String::AsciiValue localQualifiedName(args[0]);
+		v8::String::AsciiValue localPublicId(args[1]);
+		v8::String::AsciiValue localSystemId(args[2]);
+
+		Arabica::DOM::DocumentType<std::string>* retVal = new Arabica::DOM::DocumentType<std::string>(privData->nativeObj->createDocumentType(*localQualifiedName, *localPublicId, *localSystemId));
+		v8::Handle<v8::Function> retCtor = V8DocumentType::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+
+		struct V8DocumentType::V8DocumentTypePrivate* retPrivData = new V8DocumentType::V8DocumentTypePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
+
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+
+		retObj.MakeWeak(0, V8DocumentType::jsDestructor);
+		return retObj;
+
+	}
+	throw V8Exception("Parameter mismatch while calling createDocumentType");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DOMImplementation::createDocumentCallback(const v8::Arguments& args) {
-	if (args.Length() < 3)
-		throw V8Exception("Wrong number of arguments in createDocument");
-	if (!(V8DocumentType::hasInstance(args[2])))
-		throw V8Exception("Parameter mismatch while calling createDocument");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DOMImplementationPrivate* privData = V8DOM::toClassPtr<V8DOMImplementationPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localNamespaceURI(args[0]);
-	v8::String::AsciiValue localQualifiedName(args[1]);
-	Arabica::DOM::DocumentType<std::string>* localDoctype = V8DOM::toClassPtr<V8DocumentType::V8DocumentTypePrivate >(args[2]->ToObject()->GetInternalField(0))->nativeObj;
-
-	Arabica::DOM::Document<std::string>* retVal = new Arabica::DOM::Document<std::string>(privData->nativeObj->createDocument(*localNamespaceURI, *localQualifiedName, *localDoctype));
-	v8::Handle<v8::Function> retCtor = V8Document::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
-
-	struct V8Document::V8DocumentPrivate* retPrivData = new V8Document::V8DocumentPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
-
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
-
-	retObj.MakeWeak(0, V8Document::jsDestructor);
-	return retObj;
-
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString() &&
+	           args[2]->IsObject() && V8DocumentType::hasInstance(args[2])) {
+		v8::String::AsciiValue localNamespaceURI(args[0]);
+		v8::String::AsciiValue localQualifiedName(args[1]);
+		Arabica::DOM::DocumentType<std::string>* localDoctype = V8DOM::toClassPtr<V8DocumentType::V8DocumentTypePrivate >(args[2]->ToObject()->GetInternalField(0))->nativeObj;
+
+		Arabica::DOM::Document<std::string>* retVal = new Arabica::DOM::Document<std::string>(privData->nativeObj->createDocument(*localNamespaceURI, *localQualifiedName, *localDoctype));
+		v8::Handle<v8::Function> retCtor = V8Document::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+
+		struct V8Document::V8DocumentPrivate* retPrivData = new V8Document::V8DocumentPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
+
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+
+		retObj.MakeWeak(0, V8Document::jsDestructor);
+		return retObj;
+
+	}
+	throw V8Exception("Parameter mismatch while calling createDocument");
+	return v8::Undefined();
 }
-
 bool V8DOMImplementation::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DataView.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DataView.cpp
index 4a756ee..4611595 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DataView.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DataView.cpp
@@ -1,238 +1,468 @@
+#include "V8ArrayBuffer.h"
+#include "V8ArrayBufferView.h"
 #include "V8DataView.h"
 
 namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8DataView::Tmpl;
+v8::Persistent<v8::FunctionTemplate> V8DataView::Constr;
+
+v8::Handle<v8::Value> V8DataView::constructor(const v8::Arguments& args) {
+	if (!args.IsConstructCall())
+		return v8::ThrowException(v8::String::New("Cannot call constructor as function"));
+
+	uscxml::DataView* localInstance = NULL;
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32() &&
+	           args[2]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		unsigned long localByteLength = args[2]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::DataView(localBuffer, localByteOffset, localByteLength);
+
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::DataView(localBuffer, localByteOffset);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0])) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::DataView(localBuffer);
+
+	}
+	if (!localInstance) {
+		throw V8Exception("Parameter mismatch while calling constructor for DataView");
+		return v8::Undefined();
+	}
+
+	v8::Handle<v8::Function> retCtor = V8DataView::getTmpl()->GetFunction();
+	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+
+	struct V8DataView::V8DataViewPrivate* retPrivData = new V8DataView::V8DataViewPrivate();
+	retPrivData->nativeObj = localInstance;
+
+	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+
+	retObj.MakeWeak(0, V8DataView::jsDestructor);
+	return retObj;
+}
 
 v8::Handle<v8::Value> V8DataView::getInt8Callback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in getInt8");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
 
-	char retVal = privData->nativeObj->getInt8(localByteOffset);
+		char retVal = privData->nativeObj->getInt8(localByteOffset);
 
-	return v8::Number::New(retVal);
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling getInt8");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::getUint8Callback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in getUint8");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
 
-	char retVal = privData->nativeObj->getUint8(localByteOffset);
+		unsigned char retVal = privData->nativeObj->getUint8(localByteOffset);
 
-	return v8::Number::New(retVal);
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling getUint8");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::getInt16Callback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in getInt16");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
-	bool localLittleEndian = args[1]->ToBoolean()->BooleanValue();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsBoolean()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		bool localLittleEndian = args[1]->ToBoolean()->BooleanValue();
+
+		short retVal = privData->nativeObj->getInt16(localByteOffset, localLittleEndian);
 
-	short retVal = privData->nativeObj->getInt16(localByteOffset, localLittleEndian);
+		return v8::Number::New(retVal);
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
 
-	return v8::Number::New(retVal);
+		short retVal = privData->nativeObj->getInt16(localByteOffset);
+
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling getInt16");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::getUint16Callback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in getUint16");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
-	bool localLittleEndian = args[1]->ToBoolean()->BooleanValue();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsBoolean()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		bool localLittleEndian = args[1]->ToBoolean()->BooleanValue();
+
+		unsigned short retVal = privData->nativeObj->getUint16(localByteOffset, localLittleEndian);
 
-	unsigned short retVal = privData->nativeObj->getUint16(localByteOffset, localLittleEndian);
+		return v8::Number::New(retVal);
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
 
-	return v8::Number::New(retVal);
+		unsigned short retVal = privData->nativeObj->getUint16(localByteOffset);
+
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling getUint16");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::getInt32Callback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in getInt32");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
-	bool localLittleEndian = args[1]->ToBoolean()->BooleanValue();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsBoolean()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		bool localLittleEndian = args[1]->ToBoolean()->BooleanValue();
+
+		long retVal = privData->nativeObj->getInt32(localByteOffset, localLittleEndian);
 
-	long retVal = privData->nativeObj->getInt32(localByteOffset, localLittleEndian);
+		return v8::Number::New(retVal);
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
 
-	return v8::Number::New(retVal);
+		long retVal = privData->nativeObj->getInt32(localByteOffset);
+
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling getInt32");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::getUint32Callback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in getUint32");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
-	bool localLittleEndian = args[1]->ToBoolean()->BooleanValue();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsBoolean()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		bool localLittleEndian = args[1]->ToBoolean()->BooleanValue();
+
+		unsigned long retVal = privData->nativeObj->getUint32(localByteOffset, localLittleEndian);
 
-	unsigned long retVal = privData->nativeObj->getUint32(localByteOffset, localLittleEndian);
+		return v8::Number::New(retVal);
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
 
-	return v8::Number::New(retVal);
+		unsigned long retVal = privData->nativeObj->getUint32(localByteOffset);
+
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling getUint32");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::getFloat32Callback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in getFloat32");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
-	bool localLittleEndian = args[1]->ToBoolean()->BooleanValue();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsBoolean()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		bool localLittleEndian = args[1]->ToBoolean()->BooleanValue();
+
+		float retVal = privData->nativeObj->getFloat32(localByteOffset, localLittleEndian);
+
+		return v8::Number::New(retVal);
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
 
-	float retVal = privData->nativeObj->getFloat32(localByteOffset, localLittleEndian);
+		float retVal = privData->nativeObj->getFloat32(localByteOffset);
 
-	return v8::Number::New(retVal);
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling getFloat32");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::getFloat64Callback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in getFloat64");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
-	bool localLittleEndian = args[1]->ToBoolean()->BooleanValue();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsBoolean()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		bool localLittleEndian = args[1]->ToBoolean()->BooleanValue();
+
+		double retVal = privData->nativeObj->getFloat64(localByteOffset, localLittleEndian);
+
+		return v8::Number::New(retVal);
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
 
-	double retVal = privData->nativeObj->getFloat64(localByteOffset, localLittleEndian);
+		double retVal = privData->nativeObj->getFloat64(localByteOffset);
 
-	return v8::Number::New(retVal);
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling getFloat64");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::setInt8Callback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in setInt8");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
-	char localValue = args[1]->ToNumber()->Int32Value();
-
-	privData->nativeObj->setInt8(localByteOffset, localValue);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsInt32()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		char localValue = args[1]->ToNumber()->Int32Value();
+
+		privData->nativeObj->setInt8(localByteOffset, localValue);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling setInt8");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::setUint8Callback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in setUint8");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
-	unsigned char localValue = args[1]->ToNumber()->Uint32Value();
-
-	privData->nativeObj->setUint8(localByteOffset, localValue);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsUint32()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		unsigned char localValue = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->setUint8(localByteOffset, localValue);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling setUint8");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::setInt16Callback(const v8::Arguments& args) {
-	if (args.Length() < 3)
-		throw V8Exception("Wrong number of arguments in setInt16");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
-	short localValue = args[1]->ToNumber()->Int32Value();
-	bool localLittleEndian = args[2]->ToBoolean()->BooleanValue();
-
-	privData->nativeObj->setInt16(localByteOffset, localValue, localLittleEndian);
-
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsInt32() &&
+	           args[2]->IsBoolean()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		short localValue = args[1]->ToNumber()->Int32Value();
+		bool localLittleEndian = args[2]->ToBoolean()->BooleanValue();
+
+		privData->nativeObj->setInt16(localByteOffset, localValue, localLittleEndian);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsInt32()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		short localValue = args[1]->ToNumber()->Int32Value();
+
+		privData->nativeObj->setInt16(localByteOffset, localValue);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling setInt16");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::setUint16Callback(const v8::Arguments& args) {
-	if (args.Length() < 3)
-		throw V8Exception("Wrong number of arguments in setUint16");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
-	unsigned short localValue = args[1]->ToNumber()->Uint32Value();
-	bool localLittleEndian = args[2]->ToBoolean()->BooleanValue();
-
-	privData->nativeObj->setUint16(localByteOffset, localValue, localLittleEndian);
-
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsUint32() &&
+	           args[2]->IsBoolean()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		unsigned short localValue = args[1]->ToNumber()->Uint32Value();
+		bool localLittleEndian = args[2]->ToBoolean()->BooleanValue();
+
+		privData->nativeObj->setUint16(localByteOffset, localValue, localLittleEndian);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsUint32()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		unsigned short localValue = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->setUint16(localByteOffset, localValue);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling setUint16");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::setInt32Callback(const v8::Arguments& args) {
-	if (args.Length() < 3)
-		throw V8Exception("Wrong number of arguments in setInt32");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
-	long localValue = args[1]->ToNumber()->Int32Value();
-	bool localLittleEndian = args[2]->ToBoolean()->BooleanValue();
-
-	privData->nativeObj->setInt32(localByteOffset, localValue, localLittleEndian);
-
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsInt32() &&
+	           args[2]->IsBoolean()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		long localValue = args[1]->ToNumber()->Int32Value();
+		bool localLittleEndian = args[2]->ToBoolean()->BooleanValue();
+
+		privData->nativeObj->setInt32(localByteOffset, localValue, localLittleEndian);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsInt32()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		long localValue = args[1]->ToNumber()->Int32Value();
+
+		privData->nativeObj->setInt32(localByteOffset, localValue);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling setInt32");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::setUint32Callback(const v8::Arguments& args) {
-	if (args.Length() < 3)
-		throw V8Exception("Wrong number of arguments in setUint32");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
-	unsigned long localValue = args[1]->ToNumber()->Uint32Value();
-	bool localLittleEndian = args[2]->ToBoolean()->BooleanValue();
-
-	privData->nativeObj->setUint32(localByteOffset, localValue, localLittleEndian);
-
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsUint32() &&
+	           args[2]->IsBoolean()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		unsigned long localValue = args[1]->ToNumber()->Uint32Value();
+		bool localLittleEndian = args[2]->ToBoolean()->BooleanValue();
+
+		privData->nativeObj->setUint32(localByteOffset, localValue, localLittleEndian);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsUint32()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		unsigned long localValue = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->setUint32(localByteOffset, localValue);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling setUint32");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::setFloat32Callback(const v8::Arguments& args) {
-	if (args.Length() < 3)
-		throw V8Exception("Wrong number of arguments in setFloat32");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
-	float localValue = args[1]->ToNumber()->Value();
-	bool localLittleEndian = args[2]->ToBoolean()->BooleanValue();
-
-	privData->nativeObj->setFloat32(localByteOffset, localValue, localLittleEndian);
-
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsNumber() &&
+	           args[2]->IsBoolean()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		float localValue = args[1]->ToNumber()->Value();
+		bool localLittleEndian = args[2]->ToBoolean()->BooleanValue();
+
+		privData->nativeObj->setFloat32(localByteOffset, localValue, localLittleEndian);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsNumber()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		float localValue = args[1]->ToNumber()->Value();
+
+		privData->nativeObj->setFloat32(localByteOffset, localValue);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling setFloat32");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8DataView::setFloat64Callback(const v8::Arguments& args) {
-	if (args.Length() < 3)
-		throw V8Exception("Wrong number of arguments in setFloat64");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DataViewPrivate* privData = V8DOM::toClassPtr<V8DataViewPrivate >(self->GetInternalField(0));
-	unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
-	double localValue = args[1]->ToNumber()->Value();
-	bool localLittleEndian = args[2]->ToBoolean()->BooleanValue();
-
-	privData->nativeObj->setFloat64(localByteOffset, localValue, localLittleEndian);
-
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsNumber() &&
+	           args[2]->IsBoolean()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		double localValue = args[1]->ToNumber()->Value();
+		bool localLittleEndian = args[2]->ToBoolean()->BooleanValue();
+
+		privData->nativeObj->setFloat64(localByteOffset, localValue, localLittleEndian);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsNumber()) {
+		unsigned long localByteOffset = args[0]->ToNumber()->Uint32Value();
+		double localValue = args[1]->ToNumber()->Value();
+
+		privData->nativeObj->setFloat64(localByteOffset, localValue);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling setFloat64");
 	return v8::Undefined();
 }
-
 bool V8DataView::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DataView.h b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DataView.h
index 476ff87..e2d2351 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DataView.h
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DataView.h
@@ -24,6 +24,7 @@
 #include <string>
 #include "../../TypedArray.h"
 #include "DOM/Node.hpp"
+#include "V8ArrayBufferView.h"
 #include "string"
 #include "uscxml/plugins/datamodel/ecmascript/v8/V8DOM.h"
 #include <v8.h>
@@ -59,6 +60,16 @@ public:
 	static v8::Handle<v8::Value> setFloat64Callback(const v8::Arguments&);
 
 
+	static v8::Handle<v8::Value> constructor(const v8::Arguments&);
+	static v8::Persistent<v8::FunctionTemplate> Constr;
+	static v8::Handle<v8::FunctionTemplate> getConstructor() {
+		if (Constr.IsEmpty()) {
+			v8::Handle<v8::FunctionTemplate> constr = v8::FunctionTemplate::New(constructor);
+			Constr = v8::Persistent<v8::FunctionTemplate>::New(constr);
+		}
+		return Constr;
+	}
+
 	static v8::Persistent<v8::FunctionTemplate> Tmpl;
 	static v8::Handle<v8::FunctionTemplate> getTmpl() {
 		if (Tmpl.IsEmpty()) {
@@ -107,6 +118,7 @@ public:
 			               v8::FunctionTemplate::New(V8DataView::setFloat64Callback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 
 
+			tmpl->Inherit(V8ArrayBufferView::getTmpl());
 			Tmpl = v8::Persistent<v8::FunctionTemplate>::New(tmpl);
 		}
 		return Tmpl;
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Document.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Document.cpp
index 06191ea..c45039c 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Document.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Document.cpp
@@ -17,7 +17,6 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Document::Tmpl;
 
-
 v8::Handle<v8::Value> V8Document::doctypeAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
@@ -77,332 +76,392 @@ v8::Handle<v8::Value> V8Document::documentElementAttrGetter(v8::Local<v8::String
 	return arbaicaRetObj;
 
 }
+
 v8::Handle<v8::Value> V8Document::createElementCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in createElement");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localTagName(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localTagName(args[0]);
 
-	Arabica::DOM::Element<std::string>* retVal = new Arabica::DOM::Element<std::string>(privData->nativeObj->createElement(*localTagName));
-	v8::Handle<v8::Function> retCtor = V8Element::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Element<std::string>* retVal = new Arabica::DOM::Element<std::string>(privData->nativeObj->createElement(*localTagName));
+		v8::Handle<v8::Function> retCtor = V8Element::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Element::V8ElementPrivate* retPrivData = new V8Element::V8ElementPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Element::V8ElementPrivate* retPrivData = new V8Element::V8ElementPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Element::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Element::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling createElement");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Document::createDocumentFragmentCallback(const v8::Arguments& args) {
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
+	if (false) {
+	} else if (args.Length() == 0) {
 
-	Arabica::DOM::DocumentFragment<std::string>* retVal = new Arabica::DOM::DocumentFragment<std::string>(privData->nativeObj->createDocumentFragment());
-	v8::Handle<v8::Function> retCtor = V8DocumentFragment::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::DocumentFragment<std::string>* retVal = new Arabica::DOM::DocumentFragment<std::string>(privData->nativeObj->createDocumentFragment());
+		v8::Handle<v8::Function> retCtor = V8DocumentFragment::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8DocumentFragment::V8DocumentFragmentPrivate* retPrivData = new V8DocumentFragment::V8DocumentFragmentPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8DocumentFragment::V8DocumentFragmentPrivate* retPrivData = new V8DocumentFragment::V8DocumentFragmentPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8DocumentFragment::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8DocumentFragment::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling createDocumentFragment");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Document::createTextNodeCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in createTextNode");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localData(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localData(args[0]);
 
-	Arabica::DOM::Text<std::string>* retVal = new Arabica::DOM::Text<std::string>(privData->nativeObj->createTextNode(*localData));
-	v8::Handle<v8::Function> retCtor = V8Text::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Text<std::string>* retVal = new Arabica::DOM::Text<std::string>(privData->nativeObj->createTextNode(*localData));
+		v8::Handle<v8::Function> retCtor = V8Text::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Text::V8TextPrivate* retPrivData = new V8Text::V8TextPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Text::V8TextPrivate* retPrivData = new V8Text::V8TextPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Text::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Text::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling createTextNode");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Document::createCommentCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in createComment");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localData(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localData(args[0]);
 
-	Arabica::DOM::Comment<std::string>* retVal = new Arabica::DOM::Comment<std::string>(privData->nativeObj->createComment(*localData));
-	v8::Handle<v8::Function> retCtor = V8Comment::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Comment<std::string>* retVal = new Arabica::DOM::Comment<std::string>(privData->nativeObj->createComment(*localData));
+		v8::Handle<v8::Function> retCtor = V8Comment::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Comment::V8CommentPrivate* retPrivData = new V8Comment::V8CommentPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Comment::V8CommentPrivate* retPrivData = new V8Comment::V8CommentPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Comment::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Comment::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling createComment");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Document::createCDATASectionCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in createCDATASection");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localData(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localData(args[0]);
 
-	Arabica::DOM::CDATASection<std::string>* retVal = new Arabica::DOM::CDATASection<std::string>(privData->nativeObj->createCDATASection(*localData));
-	v8::Handle<v8::Function> retCtor = V8CDATASection::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::CDATASection<std::string>* retVal = new Arabica::DOM::CDATASection<std::string>(privData->nativeObj->createCDATASection(*localData));
+		v8::Handle<v8::Function> retCtor = V8CDATASection::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8CDATASection::V8CDATASectionPrivate* retPrivData = new V8CDATASection::V8CDATASectionPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8CDATASection::V8CDATASectionPrivate* retPrivData = new V8CDATASection::V8CDATASectionPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8CDATASection::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8CDATASection::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling createCDATASection");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Document::createProcessingInstructionCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in createProcessingInstruction");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localTarget(args[0]);
-	v8::String::AsciiValue localData(args[1]);
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localTarget(args[0]);
+		v8::String::AsciiValue localData(args[1]);
 
-	Arabica::DOM::ProcessingInstruction<std::string>* retVal = new Arabica::DOM::ProcessingInstruction<std::string>(privData->nativeObj->createProcessingInstruction(*localTarget, *localData));
-	v8::Handle<v8::Function> retCtor = V8ProcessingInstruction::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::ProcessingInstruction<std::string>* retVal = new Arabica::DOM::ProcessingInstruction<std::string>(privData->nativeObj->createProcessingInstruction(*localTarget, *localData));
+		v8::Handle<v8::Function> retCtor = V8ProcessingInstruction::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8ProcessingInstruction::V8ProcessingInstructionPrivate* retPrivData = new V8ProcessingInstruction::V8ProcessingInstructionPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8ProcessingInstruction::V8ProcessingInstructionPrivate* retPrivData = new V8ProcessingInstruction::V8ProcessingInstructionPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8ProcessingInstruction::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8ProcessingInstruction::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling createProcessingInstruction");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Document::createAttributeCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in createAttribute");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localName(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localName(args[0]);
 
-	Arabica::DOM::Attr<std::string>* retVal = new Arabica::DOM::Attr<std::string>(privData->nativeObj->createAttribute(*localName));
-	v8::Handle<v8::Function> retCtor = V8Attr::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Attr<std::string>* retVal = new Arabica::DOM::Attr<std::string>(privData->nativeObj->createAttribute(*localName));
+		v8::Handle<v8::Function> retCtor = V8Attr::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Attr::V8AttrPrivate* retPrivData = new V8Attr::V8AttrPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Attr::V8AttrPrivate* retPrivData = new V8Attr::V8AttrPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Attr::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Attr::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling createAttribute");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Document::createEntityReferenceCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in createEntityReference");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localName(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localName(args[0]);
 
-	Arabica::DOM::EntityReference<std::string>* retVal = new Arabica::DOM::EntityReference<std::string>(privData->nativeObj->createEntityReference(*localName));
-	v8::Handle<v8::Function> retCtor = V8EntityReference::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::EntityReference<std::string>* retVal = new Arabica::DOM::EntityReference<std::string>(privData->nativeObj->createEntityReference(*localName));
+		v8::Handle<v8::Function> retCtor = V8EntityReference::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8EntityReference::V8EntityReferencePrivate* retPrivData = new V8EntityReference::V8EntityReferencePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8EntityReference::V8EntityReferencePrivate* retPrivData = new V8EntityReference::V8EntityReferencePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8EntityReference::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8EntityReference::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling createEntityReference");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Document::getElementsByTagNameCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in getElementsByTagName");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localTagname(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localTagname(args[0]);
 
-	Arabica::DOM::NodeList<std::string>* retVal = new Arabica::DOM::NodeList<std::string>(privData->nativeObj->getElementsByTagName(*localTagname));
-	v8::Handle<v8::Function> retCtor = V8NodeList::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::NodeList<std::string>* retVal = new Arabica::DOM::NodeList<std::string>(privData->nativeObj->getElementsByTagName(*localTagname));
+		v8::Handle<v8::Function> retCtor = V8NodeList::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8NodeList::V8NodeListPrivate* retPrivData = new V8NodeList::V8NodeListPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8NodeList::V8NodeListPrivate* retPrivData = new V8NodeList::V8NodeListPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8NodeList::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8NodeList::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling getElementsByTagName");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Document::importNodeCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in importNode");
-	if (!(V8Node::hasInstance(args[0])))
-		throw V8Exception("Parameter mismatch while calling importNode");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
-	Arabica::DOM::Node<std::string>* localImportedNode = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
-	bool localDeep = args[1]->ToBoolean()->BooleanValue();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8Node::hasInstance(args[0]) &&
+	           args[1]->IsBoolean()) {
+		Arabica::DOM::Node<std::string>* localImportedNode = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		bool localDeep = args[1]->ToBoolean()->BooleanValue();
 
-	Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->importNode(*localImportedNode, localDeep));
-	v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->importNode(*localImportedNode, localDeep));
+		v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Node::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Node::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling importNode");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Document::createElementNSCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in createElementNS");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localNamespaceURI(args[0]);
-	v8::String::AsciiValue localQualifiedName(args[1]);
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localNamespaceURI(args[0]);
+		v8::String::AsciiValue localQualifiedName(args[1]);
 
-	Arabica::DOM::Element<std::string>* retVal = new Arabica::DOM::Element<std::string>(privData->nativeObj->createElementNS(*localNamespaceURI, *localQualifiedName));
-	v8::Handle<v8::Function> retCtor = V8Element::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Element<std::string>* retVal = new Arabica::DOM::Element<std::string>(privData->nativeObj->createElementNS(*localNamespaceURI, *localQualifiedName));
+		v8::Handle<v8::Function> retCtor = V8Element::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Element::V8ElementPrivate* retPrivData = new V8Element::V8ElementPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Element::V8ElementPrivate* retPrivData = new V8Element::V8ElementPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Element::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Element::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling createElementNS");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Document::createAttributeNSCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in createAttributeNS");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localNamespaceURI(args[0]);
-	v8::String::AsciiValue localQualifiedName(args[1]);
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localNamespaceURI(args[0]);
+		v8::String::AsciiValue localQualifiedName(args[1]);
 
-	Arabica::DOM::Attr<std::string>* retVal = new Arabica::DOM::Attr<std::string>(privData->nativeObj->createAttributeNS(*localNamespaceURI, *localQualifiedName));
-	v8::Handle<v8::Function> retCtor = V8Attr::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Attr<std::string>* retVal = new Arabica::DOM::Attr<std::string>(privData->nativeObj->createAttributeNS(*localNamespaceURI, *localQualifiedName));
+		v8::Handle<v8::Function> retCtor = V8Attr::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Attr::V8AttrPrivate* retPrivData = new V8Attr::V8AttrPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Attr::V8AttrPrivate* retPrivData = new V8Attr::V8AttrPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Attr::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Attr::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling createAttributeNS");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Document::getElementsByTagNameNSCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in getElementsByTagNameNS");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localNamespaceURI(args[0]);
-	v8::String::AsciiValue localLocalName(args[1]);
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localNamespaceURI(args[0]);
+		v8::String::AsciiValue localLocalName(args[1]);
 
-	Arabica::DOM::NodeList<std::string>* retVal = new Arabica::DOM::NodeList<std::string>(privData->nativeObj->getElementsByTagNameNS(*localNamespaceURI, *localLocalName));
-	v8::Handle<v8::Function> retCtor = V8NodeList::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::NodeList<std::string>* retVal = new Arabica::DOM::NodeList<std::string>(privData->nativeObj->getElementsByTagNameNS(*localNamespaceURI, *localLocalName));
+		v8::Handle<v8::Function> retCtor = V8NodeList::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8NodeList::V8NodeListPrivate* retPrivData = new V8NodeList::V8NodeListPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8NodeList::V8NodeListPrivate* retPrivData = new V8NodeList::V8NodeListPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8NodeList::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8NodeList::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling getElementsByTagNameNS");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Document::getElementByIdCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in getElementById");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localElementId(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localElementId(args[0]);
 
-	Arabica::DOM::Element<std::string>* retVal = new Arabica::DOM::Element<std::string>(privData->nativeObj->getElementById(*localElementId));
-	v8::Handle<v8::Function> retCtor = V8Element::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Element<std::string>* retVal = new Arabica::DOM::Element<std::string>(privData->nativeObj->getElementById(*localElementId));
+		v8::Handle<v8::Function> retCtor = V8Element::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Element::V8ElementPrivate* retPrivData = new V8Element::V8ElementPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Element::V8ElementPrivate* retPrivData = new V8Element::V8ElementPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Element::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Element::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling getElementById");
+	return v8::Undefined();
 }
-
 bool V8Document::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DocumentFragment.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DocumentFragment.cpp
index 1403574..fa655ae 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DocumentFragment.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DocumentFragment.cpp
@@ -5,7 +5,6 @@ namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8DocumentFragment::Tmpl;
-
 bool V8DocumentFragment::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DocumentType.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DocumentType.cpp
index 6b9a7b0..3b60da4 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DocumentType.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8DocumentType.cpp
@@ -7,7 +7,6 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8DocumentType::Tmpl;
 
-
 v8::Handle<v8::Value> V8DocumentType::nameAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8DocumentTypePrivate* privData = V8DOM::toClassPtr<V8DocumentTypePrivate >(self->GetInternalField(0));
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Element.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Element.cpp
index 680dd5e..87ea5be 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Element.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Element.cpp
@@ -8,292 +8,353 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Element::Tmpl;
 
-
 v8::Handle<v8::Value> V8Element::tagNameAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
 
 	return v8::String::New(privData->nativeObj->getTagName().c_str());
 }
+
 v8::Handle<v8::Value> V8Element::getAttributeCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in getAttribute");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localName(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localName(args[0]);
 
-	std::string retVal = privData->nativeObj->getAttribute(*localName);
+		std::string retVal = privData->nativeObj->getAttribute(*localName);
 
-	return v8::String::New(retVal.c_str());
+		return v8::String::New(retVal.c_str());
+	}
+	throw V8Exception("Parameter mismatch while calling getAttribute");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Element::setAttributeCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in setAttribute");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localName(args[0]);
-	v8::String::AsciiValue localValue(args[1]);
-
-	privData->nativeObj->setAttribute(*localName, *localValue);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localName(args[0]);
+		v8::String::AsciiValue localValue(args[1]);
+
+		privData->nativeObj->setAttribute(*localName, *localValue);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling setAttribute");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Element::removeAttributeCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in removeAttribute");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localName(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localName(args[0]);
 
-	privData->nativeObj->removeAttribute(*localName);
+		privData->nativeObj->removeAttribute(*localName);
 
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling removeAttribute");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Element::getAttributeNodeCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in getAttributeNode");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localName(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localName(args[0]);
 
-	Arabica::DOM::Attr<std::string>* retVal = new Arabica::DOM::Attr<std::string>(privData->nativeObj->getAttributeNode(*localName));
-	v8::Handle<v8::Function> retCtor = V8Attr::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Attr<std::string>* retVal = new Arabica::DOM::Attr<std::string>(privData->nativeObj->getAttributeNode(*localName));
+		v8::Handle<v8::Function> retCtor = V8Attr::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Attr::V8AttrPrivate* retPrivData = new V8Attr::V8AttrPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Attr::V8AttrPrivate* retPrivData = new V8Attr::V8AttrPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Attr::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Attr::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling getAttributeNode");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Element::setAttributeNodeCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in setAttributeNode");
-	if (!(V8Attr::hasInstance(args[0])))
-		throw V8Exception("Parameter mismatch while calling setAttributeNode");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	Arabica::DOM::Attr<std::string>* localNewAttr = V8DOM::toClassPtr<V8Attr::V8AttrPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Attr::hasInstance(args[0])) {
+		Arabica::DOM::Attr<std::string>* localNewAttr = V8DOM::toClassPtr<V8Attr::V8AttrPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
 
-	Arabica::DOM::Attr<std::string>* retVal = new Arabica::DOM::Attr<std::string>(privData->nativeObj->setAttributeNode(*localNewAttr));
-	v8::Handle<v8::Function> retCtor = V8Attr::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Attr<std::string>* retVal = new Arabica::DOM::Attr<std::string>(privData->nativeObj->setAttributeNode(*localNewAttr));
+		v8::Handle<v8::Function> retCtor = V8Attr::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Attr::V8AttrPrivate* retPrivData = new V8Attr::V8AttrPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Attr::V8AttrPrivate* retPrivData = new V8Attr::V8AttrPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Attr::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Attr::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling setAttributeNode");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Element::removeAttributeNodeCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in removeAttributeNode");
-	if (!(V8Attr::hasInstance(args[0])))
-		throw V8Exception("Parameter mismatch while calling removeAttributeNode");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	Arabica::DOM::Attr<std::string>* localOldAttr = V8DOM::toClassPtr<V8Attr::V8AttrPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Attr::hasInstance(args[0])) {
+		Arabica::DOM::Attr<std::string>* localOldAttr = V8DOM::toClassPtr<V8Attr::V8AttrPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
 
-	Arabica::DOM::Attr<std::string>* retVal = new Arabica::DOM::Attr<std::string>(privData->nativeObj->removeAttributeNode(*localOldAttr));
-	v8::Handle<v8::Function> retCtor = V8Attr::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Attr<std::string>* retVal = new Arabica::DOM::Attr<std::string>(privData->nativeObj->removeAttributeNode(*localOldAttr));
+		v8::Handle<v8::Function> retCtor = V8Attr::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Attr::V8AttrPrivate* retPrivData = new V8Attr::V8AttrPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Attr::V8AttrPrivate* retPrivData = new V8Attr::V8AttrPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Attr::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Attr::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling removeAttributeNode");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Element::getElementsByTagNameCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in getElementsByTagName");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localName(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localName(args[0]);
 
-	Arabica::DOM::NodeList<std::string>* retVal = new Arabica::DOM::NodeList<std::string>(privData->nativeObj->getElementsByTagName(*localName));
-	v8::Handle<v8::Function> retCtor = V8NodeList::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::NodeList<std::string>* retVal = new Arabica::DOM::NodeList<std::string>(privData->nativeObj->getElementsByTagName(*localName));
+		v8::Handle<v8::Function> retCtor = V8NodeList::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8NodeList::V8NodeListPrivate* retPrivData = new V8NodeList::V8NodeListPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8NodeList::V8NodeListPrivate* retPrivData = new V8NodeList::V8NodeListPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8NodeList::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8NodeList::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling getElementsByTagName");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Element::getAttributeNSCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in getAttributeNS");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localNamespaceURI(args[0]);
-	v8::String::AsciiValue localLocalName(args[1]);
-
-	std::string retVal = privData->nativeObj->getAttributeNS(*localNamespaceURI, *localLocalName);
-
-	return v8::String::New(retVal.c_str());
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localNamespaceURI(args[0]);
+		v8::String::AsciiValue localLocalName(args[1]);
+
+		std::string retVal = privData->nativeObj->getAttributeNS(*localNamespaceURI, *localLocalName);
+
+		return v8::String::New(retVal.c_str());
+	}
+	throw V8Exception("Parameter mismatch while calling getAttributeNS");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Element::setAttributeNSCallback(const v8::Arguments& args) {
-	if (args.Length() < 3)
-		throw V8Exception("Wrong number of arguments in setAttributeNS");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localNamespaceURI(args[0]);
-	v8::String::AsciiValue localQualifiedName(args[1]);
-	v8::String::AsciiValue localValue(args[2]);
-
-	privData->nativeObj->setAttributeNS(*localNamespaceURI, *localQualifiedName, *localValue);
-
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString() &&
+	           args[2]->IsString()) {
+		v8::String::AsciiValue localNamespaceURI(args[0]);
+		v8::String::AsciiValue localQualifiedName(args[1]);
+		v8::String::AsciiValue localValue(args[2]);
+
+		privData->nativeObj->setAttributeNS(*localNamespaceURI, *localQualifiedName, *localValue);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling setAttributeNS");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Element::removeAttributeNSCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in removeAttributeNS");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localNamespaceURI(args[0]);
-	v8::String::AsciiValue localLocalName(args[1]);
-
-	privData->nativeObj->removeAttributeNS(*localNamespaceURI, *localLocalName);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localNamespaceURI(args[0]);
+		v8::String::AsciiValue localLocalName(args[1]);
+
+		privData->nativeObj->removeAttributeNS(*localNamespaceURI, *localLocalName);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling removeAttributeNS");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Element::getAttributeNodeNSCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in getAttributeNodeNS");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localNamespaceURI(args[0]);
-	v8::String::AsciiValue localLocalName(args[1]);
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localNamespaceURI(args[0]);
+		v8::String::AsciiValue localLocalName(args[1]);
 
-	Arabica::DOM::Attr<std::string>* retVal = new Arabica::DOM::Attr<std::string>(privData->nativeObj->getAttributeNodeNS(*localNamespaceURI, *localLocalName));
-	v8::Handle<v8::Function> retCtor = V8Attr::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Attr<std::string>* retVal = new Arabica::DOM::Attr<std::string>(privData->nativeObj->getAttributeNodeNS(*localNamespaceURI, *localLocalName));
+		v8::Handle<v8::Function> retCtor = V8Attr::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Attr::V8AttrPrivate* retPrivData = new V8Attr::V8AttrPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Attr::V8AttrPrivate* retPrivData = new V8Attr::V8AttrPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Attr::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Attr::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling getAttributeNodeNS");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Element::setAttributeNodeNSCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in setAttributeNodeNS");
-	if (!(V8Attr::hasInstance(args[0])))
-		throw V8Exception("Parameter mismatch while calling setAttributeNodeNS");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	Arabica::DOM::Attr<std::string>* localNewAttr = V8DOM::toClassPtr<V8Attr::V8AttrPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Attr::hasInstance(args[0])) {
+		Arabica::DOM::Attr<std::string>* localNewAttr = V8DOM::toClassPtr<V8Attr::V8AttrPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
 
-	Arabica::DOM::Attr<std::string>* retVal = new Arabica::DOM::Attr<std::string>(privData->nativeObj->setAttributeNodeNS(*localNewAttr));
-	v8::Handle<v8::Function> retCtor = V8Attr::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Attr<std::string>* retVal = new Arabica::DOM::Attr<std::string>(privData->nativeObj->setAttributeNodeNS(*localNewAttr));
+		v8::Handle<v8::Function> retCtor = V8Attr::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Attr::V8AttrPrivate* retPrivData = new V8Attr::V8AttrPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Attr::V8AttrPrivate* retPrivData = new V8Attr::V8AttrPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Attr::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Attr::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling setAttributeNodeNS");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Element::getElementsByTagNameNSCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in getElementsByTagNameNS");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localNamespaceURI(args[0]);
-	v8::String::AsciiValue localLocalName(args[1]);
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localNamespaceURI(args[0]);
+		v8::String::AsciiValue localLocalName(args[1]);
 
-	Arabica::DOM::NodeList<std::string>* retVal = new Arabica::DOM::NodeList<std::string>(privData->nativeObj->getElementsByTagNameNS(*localNamespaceURI, *localLocalName));
-	v8::Handle<v8::Function> retCtor = V8NodeList::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::NodeList<std::string>* retVal = new Arabica::DOM::NodeList<std::string>(privData->nativeObj->getElementsByTagNameNS(*localNamespaceURI, *localLocalName));
+		v8::Handle<v8::Function> retCtor = V8NodeList::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8NodeList::V8NodeListPrivate* retPrivData = new V8NodeList::V8NodeListPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8NodeList::V8NodeListPrivate* retPrivData = new V8NodeList::V8NodeListPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8NodeList::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8NodeList::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling getElementsByTagNameNS");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Element::hasAttributeCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in hasAttribute");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localName(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localName(args[0]);
 
-	bool retVal = privData->nativeObj->hasAttribute(*localName);
+		bool retVal = privData->nativeObj->hasAttribute(*localName);
 
-	return v8::Boolean::New(retVal);
+		return v8::Boolean::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling hasAttribute");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Element::hasAttributeNSCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in hasAttributeNS");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8ElementPrivate* privData = V8DOM::toClassPtr<V8ElementPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localNamespaceURI(args[0]);
-	v8::String::AsciiValue localLocalName(args[1]);
-
-	bool retVal = privData->nativeObj->hasAttributeNS(*localNamespaceURI, *localLocalName);
-
-	return v8::Boolean::New(retVal);
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localNamespaceURI(args[0]);
+		v8::String::AsciiValue localLocalName(args[1]);
+
+		bool retVal = privData->nativeObj->hasAttributeNS(*localNamespaceURI, *localLocalName);
+
+		return v8::Boolean::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling hasAttributeNS");
+	return v8::Undefined();
 }
-
 bool V8Element::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Entity.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Entity.cpp
index f3ce21d..2cb07ae 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Entity.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Entity.cpp
@@ -6,7 +6,6 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Entity::Tmpl;
 
-
 v8::Handle<v8::Value> V8Entity::publicIdAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8EntityPrivate* privData = V8DOM::toClassPtr<V8EntityPrivate >(self->GetInternalField(0));
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8EntityReference.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8EntityReference.cpp
index 197fadd..228ac79 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8EntityReference.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8EntityReference.cpp
@@ -5,7 +5,6 @@ namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8EntityReference::Tmpl;
-
 bool V8EntityReference::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float32Array.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float32Array.cpp
index 6d3fa47..1fe74e6 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float32Array.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float32Array.cpp
@@ -1,10 +1,82 @@
+#include "V8ArrayBuffer.h"
+#include "V8ArrayBufferView.h"
 #include "V8Float32Array.h"
 
 namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Float32Array::Tmpl;
+v8::Persistent<v8::FunctionTemplate> V8Float32Array::Constr;
 
+v8::Handle<v8::Value> V8Float32Array::constructor(const v8::Arguments& args) {
+	if (!args.IsConstructCall())
+		return v8::ThrowException(v8::String::New("Cannot call constructor as function"));
+
+	uscxml::Float32Array* localInstance = NULL;
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32() &&
+	           args[2]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		unsigned long localLength = args[2]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Float32Array(localBuffer, localByteOffset, localLength);
+
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Float32Array(localBuffer, localByteOffset);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Float32Array::hasInstance(args[0])) {
+
+		uscxml::Float32Array* localArray = V8DOM::toClassPtr<V8Float32Array::V8Float32ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Float32Array(localArray);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0])) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Float32Array(localBuffer);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+
+		unsigned long localLength = args[0]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Float32Array(localLength);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+
+		std::vector<float> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToNumber()->Value());
+		}
+		localInstance = new uscxml::Float32Array(localArray);
+
+	}
+	if (!localInstance) {
+		throw V8Exception("Parameter mismatch while calling constructor for Float32Array");
+		return v8::Undefined();
+	}
+
+	v8::Handle<v8::Function> retCtor = V8Float32Array::getTmpl()->GetFunction();
+	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+
+	struct V8Float32Array::V8Float32ArrayPrivate* retPrivData = new V8Float32Array::V8Float32ArrayPrivate();
+	retPrivData->nativeObj = localInstance;
+
+	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+
+	retObj.MakeWeak(0, V8Float32Array::jsDestructor);
+	return retObj;
+}
 
 v8::Handle<v8::Value> V8Float32Array::lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
@@ -12,57 +84,111 @@ v8::Handle<v8::Value> V8Float32Array::lengthAttrGetter(v8::Local<v8::String> pro
 
 	return v8::Integer::New(privData->nativeObj->getLength());
 }
+
 v8::Handle<v8::Value> V8Float32Array::getCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in get");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Float32ArrayPrivate* privData = V8DOM::toClassPtr<V8Float32ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
 
-	float retVal = privData->nativeObj->get(localIndex);
+		float retVal = privData->nativeObj->get(localIndex);
 
-	return v8::Number::New(retVal);
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling get");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Float32Array::setCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in set");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Float32ArrayPrivate* privData = V8DOM::toClassPtr<V8Float32ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
-	float localValue = args[1]->ToNumber()->Value();
-
-	privData->nativeObj->set(localIndex, localValue);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8Float32Array::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+		uscxml::Float32Array* localArray = V8DOM::toClassPtr<V8Float32Array::V8Float32ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsNumber()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+		float localValue = args[1]->ToNumber()->Value();
+
+		privData->nativeObj->set(localIndex, localValue);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsArray() &&
+	           args[1]->IsUint32()) {
+		std::vector<float> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToNumber()->Value());
+		}
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Float32Array::hasInstance(args[0])) {
+		uscxml::Float32Array* localArray = V8DOM::toClassPtr<V8Float32Array::V8Float32ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+		std::vector<float> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToNumber()->Value());
+		}
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling set");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Float32Array::subarrayCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in subarray");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Float32ArrayPrivate* privData = V8DOM::toClassPtr<V8Float32ArrayPrivate >(self->GetInternalField(0));
-	long localStart = args[0]->ToNumber()->Int32Value();
-	long localEnd = args[1]->ToNumber()->Int32Value();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsInt32() &&
+	           args[1]->IsInt32()) {
+		long localStart = args[0]->ToNumber()->Int32Value();
+		long localEnd = args[1]->ToNumber()->Int32Value();
 
-	uscxml::Float32Array* retVal = new uscxml::Float32Array(privData->nativeObj->subarray(localStart, localEnd));
-	v8::Handle<v8::Function> retCtor = V8Float32Array::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		uscxml::Float32Array* retVal = new uscxml::Float32Array(privData->nativeObj->subarray(localStart, localEnd));
+		v8::Handle<v8::Function> retCtor = V8Float32Array::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Float32Array::V8Float32ArrayPrivate* retPrivData = new V8Float32Array::V8Float32ArrayPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Float32Array::V8Float32ArrayPrivate* retPrivData = new V8Float32Array::V8Float32ArrayPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Float32Array::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Float32Array::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling subarray");
+	return v8::Undefined();
 }
-
 bool V8Float32Array::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float32Array.h b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float32Array.h
index ffb5fa7..0eec20f 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float32Array.h
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float32Array.h
@@ -24,6 +24,7 @@
 #include <string>
 #include "../../TypedArray.h"
 #include "DOM/Node.hpp"
+#include "V8ArrayBufferView.h"
 #include "string"
 #include "uscxml/plugins/datamodel/ecmascript/v8/V8DOM.h"
 #include <v8.h>
@@ -46,6 +47,18 @@ public:
 	static v8::Handle<v8::Value> subarrayCallback(const v8::Arguments&);
 
 	static v8::Handle<v8::Value> lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+	static v8::Handle<v8::Value> indexedPropertyCustomGetter(uint32_t, const v8::AccessorInfo&);
+	static v8::Handle<v8::Value> indexedPropertyCustomSetter(uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo&);
+
+	static v8::Handle<v8::Value> constructor(const v8::Arguments&);
+	static v8::Persistent<v8::FunctionTemplate> Constr;
+	static v8::Handle<v8::FunctionTemplate> getConstructor() {
+		if (Constr.IsEmpty()) {
+			v8::Handle<v8::FunctionTemplate> constr = v8::FunctionTemplate::New(constructor);
+			Constr = v8::Persistent<v8::FunctionTemplate>::New(constr);
+		}
+		return Constr;
+	}
 
 	static v8::Persistent<v8::FunctionTemplate> Tmpl;
 	static v8::Handle<v8::FunctionTemplate> getTmpl() {
@@ -63,20 +76,18 @@ public:
 			instance->SetAccessor(v8::String::NewSymbol("length"), V8Float32Array::lengthAttrGetter, 0,
 			                      v8::External::New(0), static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None));
 
+			instance->SetIndexedPropertyHandler(V8Float32Array::indexedPropertyCustomGetter, V8Float32Array::indexedPropertyCustomSetter);
 			prototype->Set(v8::String::NewSymbol("get"),
 			               v8::FunctionTemplate::New(V8Float32Array::getCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("set"),
 			               v8::FunctionTemplate::New(V8Float32Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Float32Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Float32Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("subarray"),
 			               v8::FunctionTemplate::New(V8Float32Array::subarrayCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 
 			tmpl->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(4), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 			prototype->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(4), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 
+			tmpl->Inherit(V8ArrayBufferView::getTmpl());
 			Tmpl = v8::Persistent<v8::FunctionTemplate>::New(tmpl);
 		}
 		return Tmpl;
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float64Array.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float64Array.cpp
index 3dc69d0..92d468d 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float64Array.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float64Array.cpp
@@ -1,10 +1,82 @@
+#include "V8ArrayBuffer.h"
+#include "V8ArrayBufferView.h"
 #include "V8Float64Array.h"
 
 namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Float64Array::Tmpl;
+v8::Persistent<v8::FunctionTemplate> V8Float64Array::Constr;
 
+v8::Handle<v8::Value> V8Float64Array::constructor(const v8::Arguments& args) {
+	if (!args.IsConstructCall())
+		return v8::ThrowException(v8::String::New("Cannot call constructor as function"));
+
+	uscxml::Float64Array* localInstance = NULL;
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32() &&
+	           args[2]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		unsigned long localLength = args[2]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Float64Array(localBuffer, localByteOffset, localLength);
+
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Float64Array(localBuffer, localByteOffset);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Float64Array::hasInstance(args[0])) {
+
+		uscxml::Float64Array* localArray = V8DOM::toClassPtr<V8Float64Array::V8Float64ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Float64Array(localArray);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0])) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Float64Array(localBuffer);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+
+		unsigned long localLength = args[0]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Float64Array(localLength);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+
+		std::vector<double> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToNumber()->Value());
+		}
+		localInstance = new uscxml::Float64Array(localArray);
+
+	}
+	if (!localInstance) {
+		throw V8Exception("Parameter mismatch while calling constructor for Float64Array");
+		return v8::Undefined();
+	}
+
+	v8::Handle<v8::Function> retCtor = V8Float64Array::getTmpl()->GetFunction();
+	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+
+	struct V8Float64Array::V8Float64ArrayPrivate* retPrivData = new V8Float64Array::V8Float64ArrayPrivate();
+	retPrivData->nativeObj = localInstance;
+
+	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+
+	retObj.MakeWeak(0, V8Float64Array::jsDestructor);
+	return retObj;
+}
 
 v8::Handle<v8::Value> V8Float64Array::lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
@@ -12,57 +84,111 @@ v8::Handle<v8::Value> V8Float64Array::lengthAttrGetter(v8::Local<v8::String> pro
 
 	return v8::Integer::New(privData->nativeObj->getLength());
 }
+
 v8::Handle<v8::Value> V8Float64Array::getCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in get");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Float64ArrayPrivate* privData = V8DOM::toClassPtr<V8Float64ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
 
-	double retVal = privData->nativeObj->get(localIndex);
+		double retVal = privData->nativeObj->get(localIndex);
 
-	return v8::Number::New(retVal);
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling get");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Float64Array::setCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in set");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Float64ArrayPrivate* privData = V8DOM::toClassPtr<V8Float64ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
-	double localValue = args[1]->ToNumber()->Value();
-
-	privData->nativeObj->set(localIndex, localValue);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8Float64Array::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+		uscxml::Float64Array* localArray = V8DOM::toClassPtr<V8Float64Array::V8Float64ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsNumber()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+		double localValue = args[1]->ToNumber()->Value();
+
+		privData->nativeObj->set(localIndex, localValue);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsArray() &&
+	           args[1]->IsUint32()) {
+		std::vector<double> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToNumber()->Value());
+		}
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Float64Array::hasInstance(args[0])) {
+		uscxml::Float64Array* localArray = V8DOM::toClassPtr<V8Float64Array::V8Float64ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+		std::vector<double> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToNumber()->Value());
+		}
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling set");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Float64Array::subarrayCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in subarray");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Float64ArrayPrivate* privData = V8DOM::toClassPtr<V8Float64ArrayPrivate >(self->GetInternalField(0));
-	long localStart = args[0]->ToNumber()->Int32Value();
-	long localEnd = args[1]->ToNumber()->Int32Value();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsInt32() &&
+	           args[1]->IsInt32()) {
+		long localStart = args[0]->ToNumber()->Int32Value();
+		long localEnd = args[1]->ToNumber()->Int32Value();
 
-	uscxml::Float64Array* retVal = new uscxml::Float64Array(privData->nativeObj->subarray(localStart, localEnd));
-	v8::Handle<v8::Function> retCtor = V8Float64Array::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		uscxml::Float64Array* retVal = new uscxml::Float64Array(privData->nativeObj->subarray(localStart, localEnd));
+		v8::Handle<v8::Function> retCtor = V8Float64Array::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Float64Array::V8Float64ArrayPrivate* retPrivData = new V8Float64Array::V8Float64ArrayPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Float64Array::V8Float64ArrayPrivate* retPrivData = new V8Float64Array::V8Float64ArrayPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Float64Array::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Float64Array::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling subarray");
+	return v8::Undefined();
 }
-
 bool V8Float64Array::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float64Array.h b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float64Array.h
index 8537a09..bd7755e 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float64Array.h
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Float64Array.h
@@ -24,6 +24,7 @@
 #include <string>
 #include "../../TypedArray.h"
 #include "DOM/Node.hpp"
+#include "V8ArrayBufferView.h"
 #include "string"
 #include "uscxml/plugins/datamodel/ecmascript/v8/V8DOM.h"
 #include <v8.h>
@@ -46,6 +47,18 @@ public:
 	static v8::Handle<v8::Value> subarrayCallback(const v8::Arguments&);
 
 	static v8::Handle<v8::Value> lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+	static v8::Handle<v8::Value> indexedPropertyCustomGetter(uint32_t, const v8::AccessorInfo&);
+	static v8::Handle<v8::Value> indexedPropertyCustomSetter(uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo&);
+
+	static v8::Handle<v8::Value> constructor(const v8::Arguments&);
+	static v8::Persistent<v8::FunctionTemplate> Constr;
+	static v8::Handle<v8::FunctionTemplate> getConstructor() {
+		if (Constr.IsEmpty()) {
+			v8::Handle<v8::FunctionTemplate> constr = v8::FunctionTemplate::New(constructor);
+			Constr = v8::Persistent<v8::FunctionTemplate>::New(constr);
+		}
+		return Constr;
+	}
 
 	static v8::Persistent<v8::FunctionTemplate> Tmpl;
 	static v8::Handle<v8::FunctionTemplate> getTmpl() {
@@ -63,20 +76,18 @@ public:
 			instance->SetAccessor(v8::String::NewSymbol("length"), V8Float64Array::lengthAttrGetter, 0,
 			                      v8::External::New(0), static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None));
 
+			instance->SetIndexedPropertyHandler(V8Float64Array::indexedPropertyCustomGetter, V8Float64Array::indexedPropertyCustomSetter);
 			prototype->Set(v8::String::NewSymbol("get"),
 			               v8::FunctionTemplate::New(V8Float64Array::getCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("set"),
 			               v8::FunctionTemplate::New(V8Float64Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Float64Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Float64Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("subarray"),
 			               v8::FunctionTemplate::New(V8Float64Array::subarrayCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 
 			tmpl->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(8), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 			prototype->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(8), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 
+			tmpl->Inherit(V8ArrayBufferView::getTmpl());
 			Tmpl = v8::Persistent<v8::FunctionTemplate>::New(tmpl);
 		}
 		return Tmpl;
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int16Array.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int16Array.cpp
index ba268da..d8f63f2 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int16Array.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int16Array.cpp
@@ -1,10 +1,82 @@
+#include "V8ArrayBuffer.h"
+#include "V8ArrayBufferView.h"
 #include "V8Int16Array.h"
 
 namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Int16Array::Tmpl;
+v8::Persistent<v8::FunctionTemplate> V8Int16Array::Constr;
 
+v8::Handle<v8::Value> V8Int16Array::constructor(const v8::Arguments& args) {
+	if (!args.IsConstructCall())
+		return v8::ThrowException(v8::String::New("Cannot call constructor as function"));
+
+	uscxml::Int16Array* localInstance = NULL;
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32() &&
+	           args[2]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		unsigned long localLength = args[2]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Int16Array(localBuffer, localByteOffset, localLength);
+
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Int16Array(localBuffer, localByteOffset);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Int16Array::hasInstance(args[0])) {
+
+		uscxml::Int16Array* localArray = V8DOM::toClassPtr<V8Int16Array::V8Int16ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Int16Array(localArray);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0])) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Int16Array(localBuffer);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+
+		unsigned long localLength = args[0]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Int16Array(localLength);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+
+		std::vector<short> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToInt32()->Value());
+		}
+		localInstance = new uscxml::Int16Array(localArray);
+
+	}
+	if (!localInstance) {
+		throw V8Exception("Parameter mismatch while calling constructor for Int16Array");
+		return v8::Undefined();
+	}
+
+	v8::Handle<v8::Function> retCtor = V8Int16Array::getTmpl()->GetFunction();
+	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+
+	struct V8Int16Array::V8Int16ArrayPrivate* retPrivData = new V8Int16Array::V8Int16ArrayPrivate();
+	retPrivData->nativeObj = localInstance;
+
+	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+
+	retObj.MakeWeak(0, V8Int16Array::jsDestructor);
+	return retObj;
+}
 
 v8::Handle<v8::Value> V8Int16Array::lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
@@ -12,57 +84,111 @@ v8::Handle<v8::Value> V8Int16Array::lengthAttrGetter(v8::Local<v8::String> prope
 
 	return v8::Integer::New(privData->nativeObj->getLength());
 }
+
 v8::Handle<v8::Value> V8Int16Array::getCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in get");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Int16ArrayPrivate* privData = V8DOM::toClassPtr<V8Int16ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
 
-	short retVal = privData->nativeObj->get(localIndex);
+		short retVal = privData->nativeObj->get(localIndex);
 
-	return v8::Number::New(retVal);
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling get");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Int16Array::setCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in set");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Int16ArrayPrivate* privData = V8DOM::toClassPtr<V8Int16ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
-	short localValue = args[1]->ToNumber()->Int32Value();
-
-	privData->nativeObj->set(localIndex, localValue);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8Int16Array::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+		uscxml::Int16Array* localArray = V8DOM::toClassPtr<V8Int16Array::V8Int16ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsInt32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+		short localValue = args[1]->ToNumber()->Int32Value();
+
+		privData->nativeObj->set(localIndex, localValue);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsArray() &&
+	           args[1]->IsUint32()) {
+		std::vector<short> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToInt32()->Value());
+		}
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Int16Array::hasInstance(args[0])) {
+		uscxml::Int16Array* localArray = V8DOM::toClassPtr<V8Int16Array::V8Int16ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+		std::vector<short> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToInt32()->Value());
+		}
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling set");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Int16Array::subarrayCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in subarray");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Int16ArrayPrivate* privData = V8DOM::toClassPtr<V8Int16ArrayPrivate >(self->GetInternalField(0));
-	long localStart = args[0]->ToNumber()->Int32Value();
-	long localEnd = args[1]->ToNumber()->Int32Value();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsInt32() &&
+	           args[1]->IsInt32()) {
+		long localStart = args[0]->ToNumber()->Int32Value();
+		long localEnd = args[1]->ToNumber()->Int32Value();
 
-	uscxml::Int16Array* retVal = new uscxml::Int16Array(privData->nativeObj->subarray(localStart, localEnd));
-	v8::Handle<v8::Function> retCtor = V8Int16Array::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		uscxml::Int16Array* retVal = new uscxml::Int16Array(privData->nativeObj->subarray(localStart, localEnd));
+		v8::Handle<v8::Function> retCtor = V8Int16Array::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Int16Array::V8Int16ArrayPrivate* retPrivData = new V8Int16Array::V8Int16ArrayPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Int16Array::V8Int16ArrayPrivate* retPrivData = new V8Int16Array::V8Int16ArrayPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Int16Array::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Int16Array::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling subarray");
+	return v8::Undefined();
 }
-
 bool V8Int16Array::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int16Array.h b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int16Array.h
index e221cdd..ea5cc21 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int16Array.h
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int16Array.h
@@ -24,6 +24,7 @@
 #include <string>
 #include "../../TypedArray.h"
 #include "DOM/Node.hpp"
+#include "V8ArrayBufferView.h"
 #include "string"
 #include "uscxml/plugins/datamodel/ecmascript/v8/V8DOM.h"
 #include <v8.h>
@@ -46,6 +47,18 @@ public:
 	static v8::Handle<v8::Value> subarrayCallback(const v8::Arguments&);
 
 	static v8::Handle<v8::Value> lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+	static v8::Handle<v8::Value> indexedPropertyCustomGetter(uint32_t, const v8::AccessorInfo&);
+	static v8::Handle<v8::Value> indexedPropertyCustomSetter(uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo&);
+
+	static v8::Handle<v8::Value> constructor(const v8::Arguments&);
+	static v8::Persistent<v8::FunctionTemplate> Constr;
+	static v8::Handle<v8::FunctionTemplate> getConstructor() {
+		if (Constr.IsEmpty()) {
+			v8::Handle<v8::FunctionTemplate> constr = v8::FunctionTemplate::New(constructor);
+			Constr = v8::Persistent<v8::FunctionTemplate>::New(constr);
+		}
+		return Constr;
+	}
 
 	static v8::Persistent<v8::FunctionTemplate> Tmpl;
 	static v8::Handle<v8::FunctionTemplate> getTmpl() {
@@ -63,20 +76,18 @@ public:
 			instance->SetAccessor(v8::String::NewSymbol("length"), V8Int16Array::lengthAttrGetter, 0,
 			                      v8::External::New(0), static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None));
 
+			instance->SetIndexedPropertyHandler(V8Int16Array::indexedPropertyCustomGetter, V8Int16Array::indexedPropertyCustomSetter);
 			prototype->Set(v8::String::NewSymbol("get"),
 			               v8::FunctionTemplate::New(V8Int16Array::getCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("set"),
 			               v8::FunctionTemplate::New(V8Int16Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Int16Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Int16Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("subarray"),
 			               v8::FunctionTemplate::New(V8Int16Array::subarrayCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 
 			tmpl->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(2), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 			prototype->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(2), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 
+			tmpl->Inherit(V8ArrayBufferView::getTmpl());
 			Tmpl = v8::Persistent<v8::FunctionTemplate>::New(tmpl);
 		}
 		return Tmpl;
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int32Array.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int32Array.cpp
index 5d00d46..5c2d130 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int32Array.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int32Array.cpp
@@ -1,10 +1,82 @@
+#include "V8ArrayBuffer.h"
+#include "V8ArrayBufferView.h"
 #include "V8Int32Array.h"
 
 namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Int32Array::Tmpl;
+v8::Persistent<v8::FunctionTemplate> V8Int32Array::Constr;
 
+v8::Handle<v8::Value> V8Int32Array::constructor(const v8::Arguments& args) {
+	if (!args.IsConstructCall())
+		return v8::ThrowException(v8::String::New("Cannot call constructor as function"));
+
+	uscxml::Int32Array* localInstance = NULL;
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32() &&
+	           args[2]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		unsigned long localLength = args[2]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Int32Array(localBuffer, localByteOffset, localLength);
+
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Int32Array(localBuffer, localByteOffset);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Int32Array::hasInstance(args[0])) {
+
+		uscxml::Int32Array* localArray = V8DOM::toClassPtr<V8Int32Array::V8Int32ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Int32Array(localArray);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0])) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Int32Array(localBuffer);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+
+		unsigned long localLength = args[0]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Int32Array(localLength);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+
+		std::vector<long> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToInteger()->Value());
+		}
+		localInstance = new uscxml::Int32Array(localArray);
+
+	}
+	if (!localInstance) {
+		throw V8Exception("Parameter mismatch while calling constructor for Int32Array");
+		return v8::Undefined();
+	}
+
+	v8::Handle<v8::Function> retCtor = V8Int32Array::getTmpl()->GetFunction();
+	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+
+	struct V8Int32Array::V8Int32ArrayPrivate* retPrivData = new V8Int32Array::V8Int32ArrayPrivate();
+	retPrivData->nativeObj = localInstance;
+
+	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+
+	retObj.MakeWeak(0, V8Int32Array::jsDestructor);
+	return retObj;
+}
 
 v8::Handle<v8::Value> V8Int32Array::lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
@@ -12,57 +84,111 @@ v8::Handle<v8::Value> V8Int32Array::lengthAttrGetter(v8::Local<v8::String> prope
 
 	return v8::Integer::New(privData->nativeObj->getLength());
 }
+
 v8::Handle<v8::Value> V8Int32Array::getCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in get");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Int32ArrayPrivate* privData = V8DOM::toClassPtr<V8Int32ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
 
-	long retVal = privData->nativeObj->get(localIndex);
+		long retVal = privData->nativeObj->get(localIndex);
 
-	return v8::Number::New(retVal);
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling get");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Int32Array::setCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in set");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Int32ArrayPrivate* privData = V8DOM::toClassPtr<V8Int32ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
-	long localValue = args[1]->ToNumber()->Int32Value();
-
-	privData->nativeObj->set(localIndex, localValue);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8Int32Array::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+		uscxml::Int32Array* localArray = V8DOM::toClassPtr<V8Int32Array::V8Int32ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsInt32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+		long localValue = args[1]->ToNumber()->Int32Value();
+
+		privData->nativeObj->set(localIndex, localValue);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsArray() &&
+	           args[1]->IsUint32()) {
+		std::vector<long> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToInteger()->Value());
+		}
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Int32Array::hasInstance(args[0])) {
+		uscxml::Int32Array* localArray = V8DOM::toClassPtr<V8Int32Array::V8Int32ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+		std::vector<long> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToInteger()->Value());
+		}
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling set");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Int32Array::subarrayCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in subarray");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Int32ArrayPrivate* privData = V8DOM::toClassPtr<V8Int32ArrayPrivate >(self->GetInternalField(0));
-	long localStart = args[0]->ToNumber()->Int32Value();
-	long localEnd = args[1]->ToNumber()->Int32Value();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsInt32() &&
+	           args[1]->IsInt32()) {
+		long localStart = args[0]->ToNumber()->Int32Value();
+		long localEnd = args[1]->ToNumber()->Int32Value();
 
-	uscxml::Int32Array* retVal = new uscxml::Int32Array(privData->nativeObj->subarray(localStart, localEnd));
-	v8::Handle<v8::Function> retCtor = V8Int32Array::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		uscxml::Int32Array* retVal = new uscxml::Int32Array(privData->nativeObj->subarray(localStart, localEnd));
+		v8::Handle<v8::Function> retCtor = V8Int32Array::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Int32Array::V8Int32ArrayPrivate* retPrivData = new V8Int32Array::V8Int32ArrayPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Int32Array::V8Int32ArrayPrivate* retPrivData = new V8Int32Array::V8Int32ArrayPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Int32Array::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Int32Array::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling subarray");
+	return v8::Undefined();
 }
-
 bool V8Int32Array::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int32Array.h b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int32Array.h
index 892b666..d3c5b71 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int32Array.h
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int32Array.h
@@ -24,6 +24,7 @@
 #include <string>
 #include "../../TypedArray.h"
 #include "DOM/Node.hpp"
+#include "V8ArrayBufferView.h"
 #include "string"
 #include "uscxml/plugins/datamodel/ecmascript/v8/V8DOM.h"
 #include <v8.h>
@@ -46,6 +47,18 @@ public:
 	static v8::Handle<v8::Value> subarrayCallback(const v8::Arguments&);
 
 	static v8::Handle<v8::Value> lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+	static v8::Handle<v8::Value> indexedPropertyCustomGetter(uint32_t, const v8::AccessorInfo&);
+	static v8::Handle<v8::Value> indexedPropertyCustomSetter(uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo&);
+
+	static v8::Handle<v8::Value> constructor(const v8::Arguments&);
+	static v8::Persistent<v8::FunctionTemplate> Constr;
+	static v8::Handle<v8::FunctionTemplate> getConstructor() {
+		if (Constr.IsEmpty()) {
+			v8::Handle<v8::FunctionTemplate> constr = v8::FunctionTemplate::New(constructor);
+			Constr = v8::Persistent<v8::FunctionTemplate>::New(constr);
+		}
+		return Constr;
+	}
 
 	static v8::Persistent<v8::FunctionTemplate> Tmpl;
 	static v8::Handle<v8::FunctionTemplate> getTmpl() {
@@ -63,20 +76,18 @@ public:
 			instance->SetAccessor(v8::String::NewSymbol("length"), V8Int32Array::lengthAttrGetter, 0,
 			                      v8::External::New(0), static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None));
 
+			instance->SetIndexedPropertyHandler(V8Int32Array::indexedPropertyCustomGetter, V8Int32Array::indexedPropertyCustomSetter);
 			prototype->Set(v8::String::NewSymbol("get"),
 			               v8::FunctionTemplate::New(V8Int32Array::getCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("set"),
 			               v8::FunctionTemplate::New(V8Int32Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Int32Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Int32Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("subarray"),
 			               v8::FunctionTemplate::New(V8Int32Array::subarrayCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 
 			tmpl->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(4), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 			prototype->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(4), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 
+			tmpl->Inherit(V8ArrayBufferView::getTmpl());
 			Tmpl = v8::Persistent<v8::FunctionTemplate>::New(tmpl);
 		}
 		return Tmpl;
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int8Array.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int8Array.cpp
index fd64a8c..d78be76 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int8Array.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int8Array.cpp
@@ -1,10 +1,82 @@
+#include "V8ArrayBuffer.h"
+#include "V8ArrayBufferView.h"
 #include "V8Int8Array.h"
 
 namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Int8Array::Tmpl;
+v8::Persistent<v8::FunctionTemplate> V8Int8Array::Constr;
 
+v8::Handle<v8::Value> V8Int8Array::constructor(const v8::Arguments& args) {
+	if (!args.IsConstructCall())
+		return v8::ThrowException(v8::String::New("Cannot call constructor as function"));
+
+	uscxml::Int8Array* localInstance = NULL;
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32() &&
+	           args[2]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		unsigned long localLength = args[2]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Int8Array(localBuffer, localByteOffset, localLength);
+
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Int8Array(localBuffer, localByteOffset);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Int8Array::hasInstance(args[0])) {
+
+		uscxml::Int8Array* localArray = V8DOM::toClassPtr<V8Int8Array::V8Int8ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Int8Array(localArray);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0])) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Int8Array(localBuffer);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+
+		unsigned long localLength = args[0]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Int8Array(localLength);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+
+		std::vector<char> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToInt32()->Value());
+		}
+		localInstance = new uscxml::Int8Array(localArray);
+
+	}
+	if (!localInstance) {
+		throw V8Exception("Parameter mismatch while calling constructor for Int8Array");
+		return v8::Undefined();
+	}
+
+	v8::Handle<v8::Function> retCtor = V8Int8Array::getTmpl()->GetFunction();
+	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+
+	struct V8Int8Array::V8Int8ArrayPrivate* retPrivData = new V8Int8Array::V8Int8ArrayPrivate();
+	retPrivData->nativeObj = localInstance;
+
+	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+
+	retObj.MakeWeak(0, V8Int8Array::jsDestructor);
+	return retObj;
+}
 
 v8::Handle<v8::Value> V8Int8Array::lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
@@ -12,57 +84,111 @@ v8::Handle<v8::Value> V8Int8Array::lengthAttrGetter(v8::Local<v8::String> proper
 
 	return v8::Integer::New(privData->nativeObj->getLength());
 }
+
 v8::Handle<v8::Value> V8Int8Array::getCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in get");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Int8ArrayPrivate* privData = V8DOM::toClassPtr<V8Int8ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
 
-	char retVal = privData->nativeObj->get(localIndex);
+		char retVal = privData->nativeObj->get(localIndex);
 
-	return v8::Number::New(retVal);
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling get");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Int8Array::setCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in set");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Int8ArrayPrivate* privData = V8DOM::toClassPtr<V8Int8ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
-	char localValue = args[1]->ToNumber()->Int32Value();
-
-	privData->nativeObj->set(localIndex, localValue);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8Int8Array::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+		uscxml::Int8Array* localArray = V8DOM::toClassPtr<V8Int8Array::V8Int8ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsInt32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+		char localValue = args[1]->ToNumber()->Int32Value();
+
+		privData->nativeObj->set(localIndex, localValue);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsArray() &&
+	           args[1]->IsUint32()) {
+		std::vector<char> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToInt32()->Value());
+		}
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Int8Array::hasInstance(args[0])) {
+		uscxml::Int8Array* localArray = V8DOM::toClassPtr<V8Int8Array::V8Int8ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+		std::vector<char> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToInt32()->Value());
+		}
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling set");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Int8Array::subarrayCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in subarray");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Int8ArrayPrivate* privData = V8DOM::toClassPtr<V8Int8ArrayPrivate >(self->GetInternalField(0));
-	long localStart = args[0]->ToNumber()->Int32Value();
-	long localEnd = args[1]->ToNumber()->Int32Value();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsInt32() &&
+	           args[1]->IsInt32()) {
+		long localStart = args[0]->ToNumber()->Int32Value();
+		long localEnd = args[1]->ToNumber()->Int32Value();
 
-	uscxml::Int8Array* retVal = new uscxml::Int8Array(privData->nativeObj->subarray(localStart, localEnd));
-	v8::Handle<v8::Function> retCtor = V8Int8Array::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		uscxml::Int8Array* retVal = new uscxml::Int8Array(privData->nativeObj->subarray(localStart, localEnd));
+		v8::Handle<v8::Function> retCtor = V8Int8Array::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Int8Array::V8Int8ArrayPrivate* retPrivData = new V8Int8Array::V8Int8ArrayPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Int8Array::V8Int8ArrayPrivate* retPrivData = new V8Int8Array::V8Int8ArrayPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Int8Array::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Int8Array::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling subarray");
+	return v8::Undefined();
 }
-
 bool V8Int8Array::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int8Array.h b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int8Array.h
index bcfcc3c..2802c5f 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int8Array.h
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Int8Array.h
@@ -24,6 +24,7 @@
 #include <string>
 #include "../../TypedArray.h"
 #include "DOM/Node.hpp"
+#include "V8ArrayBufferView.h"
 #include "string"
 #include "uscxml/plugins/datamodel/ecmascript/v8/V8DOM.h"
 #include <v8.h>
@@ -46,6 +47,18 @@ public:
 	static v8::Handle<v8::Value> subarrayCallback(const v8::Arguments&);
 
 	static v8::Handle<v8::Value> lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+	static v8::Handle<v8::Value> indexedPropertyCustomGetter(uint32_t, const v8::AccessorInfo&);
+	static v8::Handle<v8::Value> indexedPropertyCustomSetter(uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo&);
+
+	static v8::Handle<v8::Value> constructor(const v8::Arguments&);
+	static v8::Persistent<v8::FunctionTemplate> Constr;
+	static v8::Handle<v8::FunctionTemplate> getConstructor() {
+		if (Constr.IsEmpty()) {
+			v8::Handle<v8::FunctionTemplate> constr = v8::FunctionTemplate::New(constructor);
+			Constr = v8::Persistent<v8::FunctionTemplate>::New(constr);
+		}
+		return Constr;
+	}
 
 	static v8::Persistent<v8::FunctionTemplate> Tmpl;
 	static v8::Handle<v8::FunctionTemplate> getTmpl() {
@@ -63,20 +76,18 @@ public:
 			instance->SetAccessor(v8::String::NewSymbol("length"), V8Int8Array::lengthAttrGetter, 0,
 			                      v8::External::New(0), static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None));
 
+			instance->SetIndexedPropertyHandler(V8Int8Array::indexedPropertyCustomGetter, V8Int8Array::indexedPropertyCustomSetter);
 			prototype->Set(v8::String::NewSymbol("get"),
 			               v8::FunctionTemplate::New(V8Int8Array::getCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("set"),
 			               v8::FunctionTemplate::New(V8Int8Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Int8Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Int8Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("subarray"),
 			               v8::FunctionTemplate::New(V8Int8Array::subarrayCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 
 			tmpl->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(1), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 			prototype->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(1), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 
+			tmpl->Inherit(V8ArrayBufferView::getTmpl());
 			Tmpl = v8::Persistent<v8::FunctionTemplate>::New(tmpl);
 		}
 		return Tmpl;
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8NamedNodeMap.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8NamedNodeMap.cpp
index 037d651..a405fd0 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8NamedNodeMap.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8NamedNodeMap.cpp
@@ -6,180 +6,205 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8NamedNodeMap::Tmpl;
 
-
 v8::Handle<v8::Value> V8NamedNodeMap::lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8NamedNodeMapPrivate* privData = V8DOM::toClassPtr<V8NamedNodeMapPrivate >(self->GetInternalField(0));
 
 	return v8::Integer::New(privData->nativeObj->getLength());
 }
+
 v8::Handle<v8::Value> V8NamedNodeMap::getNamedItemCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in getNamedItem");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NamedNodeMapPrivate* privData = V8DOM::toClassPtr<V8NamedNodeMapPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localName(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localName(args[0]);
 
-	Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->getNamedItem(*localName));
-	v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->getNamedItem(*localName));
+		v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Node::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Node::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling getNamedItem");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8NamedNodeMap::setNamedItemCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in setNamedItem");
-	if (!(V8Node::hasInstance(args[0])))
-		throw V8Exception("Parameter mismatch while calling setNamedItem");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NamedNodeMapPrivate* privData = V8DOM::toClassPtr<V8NamedNodeMapPrivate >(self->GetInternalField(0));
-	Arabica::DOM::Node<std::string>* localArg = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Node::hasInstance(args[0])) {
+		Arabica::DOM::Node<std::string>* localArg = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
 
-	Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->setNamedItem(*localArg));
-	v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->setNamedItem(*localArg));
+		v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Node::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Node::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling setNamedItem");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8NamedNodeMap::removeNamedItemCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in removeNamedItem");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NamedNodeMapPrivate* privData = V8DOM::toClassPtr<V8NamedNodeMapPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localName(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localName(args[0]);
 
-	Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->removeNamedItem(*localName));
-	v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->removeNamedItem(*localName));
+		v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Node::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Node::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling removeNamedItem");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8NamedNodeMap::itemCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in item");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NamedNodeMapPrivate* privData = V8DOM::toClassPtr<V8NamedNodeMapPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
 
-	Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->item(localIndex));
-	v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->item(localIndex));
+		v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Node::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Node::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling item");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8NamedNodeMap::getNamedItemNSCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in getNamedItemNS");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NamedNodeMapPrivate* privData = V8DOM::toClassPtr<V8NamedNodeMapPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localNamespaceURI(args[0]);
-	v8::String::AsciiValue localLocalName(args[1]);
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localNamespaceURI(args[0]);
+		v8::String::AsciiValue localLocalName(args[1]);
 
-	Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->getNamedItemNS(*localNamespaceURI, *localLocalName));
-	v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->getNamedItemNS(*localNamespaceURI, *localLocalName));
+		v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Node::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Node::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling getNamedItemNS");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8NamedNodeMap::setNamedItemNSCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in setNamedItemNS");
-	if (!(V8Node::hasInstance(args[0])))
-		throw V8Exception("Parameter mismatch while calling setNamedItemNS");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NamedNodeMapPrivate* privData = V8DOM::toClassPtr<V8NamedNodeMapPrivate >(self->GetInternalField(0));
-	Arabica::DOM::Node<std::string>* localArg = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Node::hasInstance(args[0])) {
+		Arabica::DOM::Node<std::string>* localArg = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
 
-	Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->setNamedItemNS(*localArg));
-	v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->setNamedItemNS(*localArg));
+		v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Node::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Node::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling setNamedItemNS");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8NamedNodeMap::removeNamedItemNSCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in removeNamedItemNS");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NamedNodeMapPrivate* privData = V8DOM::toClassPtr<V8NamedNodeMapPrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localNamespaceURI(args[0]);
-	v8::String::AsciiValue localLocalName(args[1]);
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localNamespaceURI(args[0]);
+		v8::String::AsciiValue localLocalName(args[1]);
 
-	Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->removeNamedItemNS(*localNamespaceURI, *localLocalName));
-	v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->removeNamedItemNS(*localNamespaceURI, *localLocalName));
+		v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Node::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Node::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling removeNamedItemNS");
+	return v8::Undefined();
 }
-
 bool V8NamedNodeMap::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Node.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Node.cpp
index c5b1b83..9d0cd62 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Node.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Node.cpp
@@ -7,7 +7,6 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Node::Tmpl;
 
-
 v8::Handle<v8::Value> V8Node::nodeNameAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8NodePrivate* privData = V8DOM::toClassPtr<V8NodePrivate >(self->GetInternalField(0));
@@ -203,175 +202,209 @@ v8::Handle<v8::Value> V8Node::localNameAttrGetter(v8::Local<v8::String> property
 
 	return v8::String::New(privData->nativeObj->getLocalName().c_str());
 }
+
 v8::Handle<v8::Value> V8Node::insertBeforeCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in insertBefore");
-	if (!((V8Node::hasInstance(args[0])) && (V8Node::hasInstance(args[1]))))
-		throw V8Exception("Parameter mismatch while calling insertBefore");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NodePrivate* privData = V8DOM::toClassPtr<V8NodePrivate >(self->GetInternalField(0));
-	Arabica::DOM::Node<std::string>* localNewChild = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
-	Arabica::DOM::Node<std::string>* localRefChild = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[1]->ToObject()->GetInternalField(0))->nativeObj;
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8Node::hasInstance(args[0]) &&
+	           args[1]->IsObject() && V8Node::hasInstance(args[1])) {
+		Arabica::DOM::Node<std::string>* localNewChild = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		Arabica::DOM::Node<std::string>* localRefChild = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[1]->ToObject()->GetInternalField(0))->nativeObj;
 
-	Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->insertBefore(*localNewChild, *localRefChild));
-	v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->insertBefore(*localNewChild, *localRefChild));
+		v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Node::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Node::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling insertBefore");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Node::replaceChildCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in replaceChild");
-	if (!((V8Node::hasInstance(args[0])) && (V8Node::hasInstance(args[1]))))
-		throw V8Exception("Parameter mismatch while calling replaceChild");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NodePrivate* privData = V8DOM::toClassPtr<V8NodePrivate >(self->GetInternalField(0));
-	Arabica::DOM::Node<std::string>* localNewChild = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
-	Arabica::DOM::Node<std::string>* localOldChild = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[1]->ToObject()->GetInternalField(0))->nativeObj;
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8Node::hasInstance(args[0]) &&
+	           args[1]->IsObject() && V8Node::hasInstance(args[1])) {
+		Arabica::DOM::Node<std::string>* localNewChild = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		Arabica::DOM::Node<std::string>* localOldChild = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[1]->ToObject()->GetInternalField(0))->nativeObj;
 
-	Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->replaceChild(*localNewChild, *localOldChild));
-	v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->replaceChild(*localNewChild, *localOldChild));
+		v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Node::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Node::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling replaceChild");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Node::removeChildCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in removeChild");
-	if (!(V8Node::hasInstance(args[0])))
-		throw V8Exception("Parameter mismatch while calling removeChild");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NodePrivate* privData = V8DOM::toClassPtr<V8NodePrivate >(self->GetInternalField(0));
-	Arabica::DOM::Node<std::string>* localOldChild = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Node::hasInstance(args[0])) {
+		Arabica::DOM::Node<std::string>* localOldChild = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
 
-	Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->removeChild(*localOldChild));
-	v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->removeChild(*localOldChild));
+		v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Node::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Node::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling removeChild");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Node::appendChildCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in appendChild");
-	if (!(V8Node::hasInstance(args[0])))
-		throw V8Exception("Parameter mismatch while calling appendChild");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NodePrivate* privData = V8DOM::toClassPtr<V8NodePrivate >(self->GetInternalField(0));
-	Arabica::DOM::Node<std::string>* localNewChild = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Node::hasInstance(args[0])) {
+		Arabica::DOM::Node<std::string>* localNewChild = V8DOM::toClassPtr<V8Node::V8NodePrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
 
-	Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->appendChild(*localNewChild));
-	v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->appendChild(*localNewChild));
+		v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Node::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Node::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling appendChild");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Node::hasChildNodesCallback(const v8::Arguments& args) {
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NodePrivate* privData = V8DOM::toClassPtr<V8NodePrivate >(self->GetInternalField(0));
+	if (false) {
+	} else if (args.Length() == 0) {
 
-	bool retVal = privData->nativeObj->hasChildNodes();
+		bool retVal = privData->nativeObj->hasChildNodes();
 
-	return v8::Boolean::New(retVal);
+		return v8::Boolean::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling hasChildNodes");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Node::cloneNodeCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in cloneNode");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NodePrivate* privData = V8DOM::toClassPtr<V8NodePrivate >(self->GetInternalField(0));
-	bool localDeep = args[0]->ToBoolean()->BooleanValue();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsBoolean()) {
+		bool localDeep = args[0]->ToBoolean()->BooleanValue();
 
-	Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->cloneNode(localDeep));
-	v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->cloneNode(localDeep));
+		v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Node::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Node::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling cloneNode");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Node::normalizeCallback(const v8::Arguments& args) {
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NodePrivate* privData = V8DOM::toClassPtr<V8NodePrivate >(self->GetInternalField(0));
+	if (false) {
+	} else if (args.Length() == 0) {
 
-	privData->nativeObj->normalize();
+		privData->nativeObj->normalize();
 
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling normalize");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Node::isSupportedCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in isSupported");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NodePrivate* privData = V8DOM::toClassPtr<V8NodePrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localFeature(args[0]);
-	v8::String::AsciiValue localVersion(args[1]);
-
-	bool retVal = privData->nativeObj->isSupported(*localFeature, *localVersion);
-
-	return v8::Boolean::New(retVal);
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localFeature(args[0]);
+		v8::String::AsciiValue localVersion(args[1]);
+
+		bool retVal = privData->nativeObj->isSupported(*localFeature, *localVersion);
+
+		return v8::Boolean::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling isSupported");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Node::hasAttributesCallback(const v8::Arguments& args) {
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NodePrivate* privData = V8DOM::toClassPtr<V8NodePrivate >(self->GetInternalField(0));
+	if (false) {
+	} else if (args.Length() == 0) {
 
-	bool retVal = privData->nativeObj->hasAttributes();
+		bool retVal = privData->nativeObj->hasAttributes();
 
-	return v8::Boolean::New(retVal);
+		return v8::Boolean::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling hasAttributes");
+	return v8::Undefined();
 }
-
 bool V8Node::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8NodeList.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8NodeList.cpp
index bee706e..4f37d14 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8NodeList.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8NodeList.cpp
@@ -6,36 +6,39 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8NodeList::Tmpl;
 
-
 v8::Handle<v8::Value> V8NodeList::lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8NodeListPrivate* privData = V8DOM::toClassPtr<V8NodeListPrivate >(self->GetInternalField(0));
 
 	return v8::Integer::New(privData->nativeObj->getLength());
 }
+
 v8::Handle<v8::Value> V8NodeList::itemCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in item");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NodeListPrivate* privData = V8DOM::toClassPtr<V8NodeListPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
 
-	Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->item(localIndex));
-	v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Node<std::string>* retVal = new Arabica::DOM::Node<std::string>(privData->nativeObj->item(localIndex));
+		v8::Handle<v8::Function> retCtor = V8Node::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Node::V8NodePrivate* retPrivData = new V8Node::V8NodePrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Node::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Node::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling item");
+	return v8::Undefined();
 }
-
 bool V8NodeList::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8NodeSet.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8NodeSet.cpp
index fade729..4580ef4 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8NodeSet.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8NodeSet.cpp
@@ -5,7 +5,6 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8NodeSet::Tmpl;
 
-
 v8::Handle<v8::Value> V8NodeSet::sizeAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8NodeSetPrivate* privData = V8DOM::toClassPtr<V8NodeSetPrivate >(self->GetInternalField(0));
@@ -19,16 +18,21 @@ v8::Handle<v8::Value> V8NodeSet::emptyAttrGetter(v8::Local<v8::String> property,
 
 	return v8::Boolean::New(privData->nativeObj->empty());
 }
+
 v8::Handle<v8::Value> V8NodeSet::toDocumentOrderCallback(const v8::Arguments& args) {
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8NodeSetPrivate* privData = V8DOM::toClassPtr<V8NodeSetPrivate >(self->GetInternalField(0));
+	if (false) {
+	} else if (args.Length() == 0) {
 
-	privData->nativeObj->to_document_order();
+		privData->nativeObj->to_document_order();
 
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling toDocumentOrder");
 	return v8::Undefined();
 }
-
 bool V8NodeSet::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Notation.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Notation.cpp
index 129563d..6a53ba6 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Notation.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Notation.cpp
@@ -6,7 +6,6 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Notation::Tmpl;
 
-
 v8::Handle<v8::Value> V8Notation::publicIdAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8NotationPrivate* privData = V8DOM::toClassPtr<V8NotationPrivate >(self->GetInternalField(0));
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ProcessingInstruction.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ProcessingInstruction.cpp
index c6d2b28..1b819d8 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ProcessingInstruction.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8ProcessingInstruction.cpp
@@ -6,7 +6,6 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8ProcessingInstruction::Tmpl;
 
-
 v8::Handle<v8::Value> V8ProcessingInstruction::targetAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8ProcessingInstructionPrivate* privData = V8DOM::toClassPtr<V8ProcessingInstructionPrivate >(self->GetInternalField(0));
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8SCXMLEvent.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8SCXMLEvent.cpp
index 9679d74..0f750ee 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8SCXMLEvent.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8SCXMLEvent.cpp
@@ -6,7 +6,6 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8SCXMLEvent::Tmpl;
 
-
 v8::Handle<v8::Value> V8SCXMLEvent::nameAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8SCXMLEventPrivate* privData = V8DOM::toClassPtr<V8SCXMLEventPrivate >(self->GetInternalField(0));
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Storage.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Storage.cpp
index d9ab828..7cd90f9 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Storage.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Storage.cpp
@@ -5,63 +5,80 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Storage::Tmpl;
 
-
 v8::Handle<v8::Value> V8Storage::lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8StoragePrivate* privData = V8DOM::toClassPtr<V8StoragePrivate >(self->GetInternalField(0));
 
 	return v8::Integer::New(privData->nativeObj->getLength());
 }
+
 v8::Handle<v8::Value> V8Storage::keyCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in key");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8StoragePrivate* privData = V8DOM::toClassPtr<V8StoragePrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
 
-	std::string retVal = privData->nativeObj->key(localIndex);
+		std::string retVal = privData->nativeObj->key(localIndex);
 
-	return v8::String::New(retVal.c_str());
+		return v8::String::New(retVal.c_str());
+	}
+	throw V8Exception("Parameter mismatch while calling key");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Storage::getItemCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in getItem");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8StoragePrivate* privData = V8DOM::toClassPtr<V8StoragePrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localKey(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localKey(args[0]);
 
-	std::string retVal = privData->nativeObj->getItem(*localKey);
+		std::string retVal = privData->nativeObj->getItem(*localKey);
 
-	return v8::String::New(retVal.c_str());
+		return v8::String::New(retVal.c_str());
+	}
+	throw V8Exception("Parameter mismatch while calling getItem");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Storage::setItemCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in setItem");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8StoragePrivate* privData = V8DOM::toClassPtr<V8StoragePrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localKey(args[0]);
-	v8::String::AsciiValue localValue(args[1]);
-
-	privData->nativeObj->setItem(*localKey, *localValue);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsString() &&
+	           args[1]->IsString()) {
+		v8::String::AsciiValue localKey(args[0]);
+		v8::String::AsciiValue localValue(args[1]);
+
+		privData->nativeObj->setItem(*localKey, *localValue);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling setItem");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Storage::removeItemCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in removeItem");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8StoragePrivate* privData = V8DOM::toClassPtr<V8StoragePrivate >(self->GetInternalField(0));
-	v8::String::AsciiValue localKey(args[0]);
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsString()) {
+		v8::String::AsciiValue localKey(args[0]);
 
-	privData->nativeObj->removeItem(*localKey);
+		privData->nativeObj->removeItem(*localKey);
 
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling removeItem");
 	return v8::Undefined();
 }
 
@@ -69,12 +86,16 @@ v8::Handle<v8::Value> V8Storage::clearCallback(const v8::Arguments& args) {
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8StoragePrivate* privData = V8DOM::toClassPtr<V8StoragePrivate >(self->GetInternalField(0));
+	if (false) {
+	} else if (args.Length() == 0) {
 
-	privData->nativeObj->clear();
+		privData->nativeObj->clear();
 
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling clear");
 	return v8::Undefined();
 }
-
 bool V8Storage::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Text.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Text.cpp
index 42b298a..c37970f 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Text.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Text.cpp
@@ -7,28 +7,31 @@ namespace DOM {
 v8::Persistent<v8::FunctionTemplate> V8Text::Tmpl;
 
 v8::Handle<v8::Value> V8Text::splitTextCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in splitText");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8TextPrivate* privData = V8DOM::toClassPtr<V8TextPrivate >(self->GetInternalField(0));
-	unsigned long localOffset = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localOffset = args[0]->ToNumber()->Uint32Value();
 
-	Arabica::DOM::Text<std::string>* retVal = new Arabica::DOM::Text<std::string>(privData->nativeObj->splitText(localOffset));
-	v8::Handle<v8::Function> retCtor = V8Text::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::DOM::Text<std::string>* retVal = new Arabica::DOM::Text<std::string>(privData->nativeObj->splitText(localOffset));
+		v8::Handle<v8::Function> retCtor = V8Text::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Text::V8TextPrivate* retPrivData = new V8Text::V8TextPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Text::V8TextPrivate* retPrivData = new V8Text::V8TextPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Text::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Text::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling splitText");
+	return v8::Undefined();
 }
-
 bool V8Text::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8TypedArrayCustom.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8TypedArrayCustom.cpp
new file mode 100644
index 0000000..118eb46
--- /dev/null
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8TypedArrayCustom.cpp
@@ -0,0 +1,144 @@
+#include "../../TypedArray.h"
+#include "V8ArrayBuffer.h"
+#include "V8Int8Array.h"
+#include "V8Uint8Array.h"
+#include "V8Uint8ClampedArray.h"
+#include "V8Int16Array.h"
+#include "V8Uint16Array.h"
+#include "V8Int32Array.h"
+#include "V8Uint32Array.h"
+#include "V8Float32Array.h"
+#include "V8Float64Array.h"
+#include "V8DataView.h"
+
+#define V8_TYPED_ARRAY_GET_PRIVATE(type) \
+v8::Local<v8::Object> self = info.Holder(); \
+uscxml::type* array = V8DOM::toClassPtr<V8##type##Private >(self->GetInternalField(0))->nativeObj; \
+if (index > array->getLength()) \
+	return v8::Undefined();
+
+
+namespace Arabica {
+namespace DOM {
+
+v8::Handle<v8::Value> V8Int8Array::indexedPropertyCustomSetter(unsigned int index, v8::Local<v8::Value> value, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Int8Array);
+	array->set(index, value->ToInt32()->Value());
+	return value;
+}
+
+v8::Handle<v8::Value> V8Int16Array::indexedPropertyCustomSetter(unsigned int index, v8::Local<v8::Value> value, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Int16Array);
+	array->set(index, value->ToInt32()->Value());
+	return value;
+}
+
+v8::Handle<v8::Value> V8Int32Array::indexedPropertyCustomSetter(unsigned int index, v8::Local<v8::Value> value, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Int32Array);
+	array->set(index, value->ToInt32()->Value());
+	return value;
+}
+
+v8::Handle<v8::Value> V8Uint8Array::indexedPropertyCustomSetter(unsigned int index, v8::Local<v8::Value> value, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Uint8Array);
+	array->set(index, value->ToUint32()->Value());
+	return value;
+}
+
+v8::Handle<v8::Value> V8Uint16Array::indexedPropertyCustomSetter(unsigned int index, v8::Local<v8::Value> value, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Uint16Array);
+	array->set(index, value->ToUint32()->Value());
+	return value;
+}
+
+v8::Handle<v8::Value> V8Uint32Array::indexedPropertyCustomSetter(unsigned int index, v8::Local<v8::Value> value, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Uint32Array);
+	array->set(index, value->ToUint32()->Value());
+	return value;
+}
+
+v8::Handle<v8::Value> V8Float32Array::indexedPropertyCustomSetter(unsigned int index, v8::Local<v8::Value> value, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Float32Array);
+	array->set(index, value->ToNumber()->Value());
+	return value;
+}
+
+v8::Handle<v8::Value> V8Float64Array::indexedPropertyCustomSetter(unsigned int index, v8::Local<v8::Value> value, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Float64Array);
+	array->set(index, value->ToNumber()->Value());
+	return value;
+}
+
+v8::Handle<v8::Value> V8Uint8ClampedArray::indexedPropertyCustomSetter(unsigned int index, v8::Local<v8::Value> value, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Uint8ClampedArray);
+	array->set(index, value->ToUint32()->Value() & 0xff);
+	return value;
+}
+
+v8::Handle<v8::Value> V8ArrayBuffer::indexedPropertyCustomSetter(unsigned int index, v8::Local<v8::Value> value, const v8::AccessorInfo &info) {
+	v8::Local<v8::Object> self = info.Holder();
+	uscxml::ArrayBuffer* array = V8DOM::toClassPtr<V8ArrayBufferPrivate >(self->GetInternalField(0))->nativeObj;
+	if (index > array->getByteLength())
+		return v8::Undefined();
+	array->_buffer->_data[index] = value->ToInt32()->Value() & 0xff;
+	return value;
+
+}
+
+// ----------------
+
+v8::Handle<v8::Value> V8Int8Array::indexedPropertyCustomGetter(unsigned int index, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Int8Array);
+	return v8::Int32::New(array->get(index));
+}
+
+v8::Handle<v8::Value> V8Int16Array::indexedPropertyCustomGetter(unsigned int index, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Int16Array);
+	return v8::Int32::New(array->get(index));
+}
+
+v8::Handle<v8::Value> V8Int32Array::indexedPropertyCustomGetter(unsigned int index, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Int32Array);
+	return v8::Int32::New(array->get(index));
+}
+
+v8::Handle<v8::Value> V8Uint8Array::indexedPropertyCustomGetter(unsigned int index, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Uint8Array);
+	return v8::Uint32::New(array->get(index));
+}
+
+v8::Handle<v8::Value> V8Uint16Array::indexedPropertyCustomGetter(unsigned int index, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Uint16Array);
+	return v8::Uint32::New(array->get(index));
+}
+
+v8::Handle<v8::Value> V8Uint32Array::indexedPropertyCustomGetter(unsigned int index, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Uint32Array);
+	return v8::Uint32::New(array->get(index));
+}
+
+v8::Handle<v8::Value> V8Float32Array::indexedPropertyCustomGetter(unsigned int index, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Float32Array);
+	return v8::Number::New(array->get(index));
+}
+
+v8::Handle<v8::Value> V8Float64Array::indexedPropertyCustomGetter(unsigned int index, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Float64Array);
+	return v8::Number::New(array->get(index));
+}
+
+v8::Handle<v8::Value> V8Uint8ClampedArray::indexedPropertyCustomGetter(unsigned int index, const v8::AccessorInfo &info) {
+	V8_TYPED_ARRAY_GET_PRIVATE(Uint8ClampedArray);
+	return v8::Uint32::New(array->get(index));
+}
+
+v8::Handle<v8::Value> V8ArrayBuffer::indexedPropertyCustomGetter(unsigned int index, const v8::AccessorInfo &info) {
+	v8::Local<v8::Object> self = info.Holder();
+	uscxml::ArrayBuffer* array = V8DOM::toClassPtr<V8ArrayBufferPrivate >(self->GetInternalField(0))->nativeObj;
+	if (index > array->getByteLength())
+		return v8::Undefined();
+	return v8::Int32::New(array->_buffer->_data[index]);
+}
+
+}
+}
\ No newline at end of file
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint16Array.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint16Array.cpp
index c1d94d7..4c84081 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint16Array.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint16Array.cpp
@@ -1,10 +1,82 @@
+#include "V8ArrayBuffer.h"
+#include "V8ArrayBufferView.h"
 #include "V8Uint16Array.h"
 
 namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Uint16Array::Tmpl;
+v8::Persistent<v8::FunctionTemplate> V8Uint16Array::Constr;
 
+v8::Handle<v8::Value> V8Uint16Array::constructor(const v8::Arguments& args) {
+	if (!args.IsConstructCall())
+		return v8::ThrowException(v8::String::New("Cannot call constructor as function"));
+
+	uscxml::Uint16Array* localInstance = NULL;
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32() &&
+	           args[2]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		unsigned long localLength = args[2]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Uint16Array(localBuffer, localByteOffset, localLength);
+
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Uint16Array(localBuffer, localByteOffset);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Uint16Array::hasInstance(args[0])) {
+
+		uscxml::Uint16Array* localArray = V8DOM::toClassPtr<V8Uint16Array::V8Uint16ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Uint16Array(localArray);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0])) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Uint16Array(localBuffer);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+
+		unsigned long localLength = args[0]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Uint16Array(localLength);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+
+		std::vector<unsigned short> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToUint32()->Value());
+		}
+		localInstance = new uscxml::Uint16Array(localArray);
+
+	}
+	if (!localInstance) {
+		throw V8Exception("Parameter mismatch while calling constructor for Uint16Array");
+		return v8::Undefined();
+	}
+
+	v8::Handle<v8::Function> retCtor = V8Uint16Array::getTmpl()->GetFunction();
+	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+
+	struct V8Uint16Array::V8Uint16ArrayPrivate* retPrivData = new V8Uint16Array::V8Uint16ArrayPrivate();
+	retPrivData->nativeObj = localInstance;
+
+	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+
+	retObj.MakeWeak(0, V8Uint16Array::jsDestructor);
+	return retObj;
+}
 
 v8::Handle<v8::Value> V8Uint16Array::lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
@@ -12,57 +84,111 @@ v8::Handle<v8::Value> V8Uint16Array::lengthAttrGetter(v8::Local<v8::String> prop
 
 	return v8::Integer::New(privData->nativeObj->getLength());
 }
+
 v8::Handle<v8::Value> V8Uint16Array::getCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in get");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Uint16ArrayPrivate* privData = V8DOM::toClassPtr<V8Uint16ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
 
-	unsigned short retVal = privData->nativeObj->get(localIndex);
+		unsigned short retVal = privData->nativeObj->get(localIndex);
 
-	return v8::Number::New(retVal);
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling get");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Uint16Array::setCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in set");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Uint16ArrayPrivate* privData = V8DOM::toClassPtr<V8Uint16ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
-	unsigned short localValue = args[1]->ToNumber()->Uint32Value();
-
-	privData->nativeObj->set(localIndex, localValue);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8Uint16Array::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+		uscxml::Uint16Array* localArray = V8DOM::toClassPtr<V8Uint16Array::V8Uint16ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+		unsigned short localValue = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localIndex, localValue);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsArray() &&
+	           args[1]->IsUint32()) {
+		std::vector<unsigned short> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToUint32()->Value());
+		}
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Uint16Array::hasInstance(args[0])) {
+		uscxml::Uint16Array* localArray = V8DOM::toClassPtr<V8Uint16Array::V8Uint16ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+		std::vector<unsigned short> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToUint32()->Value());
+		}
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling set");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Uint16Array::subarrayCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in subarray");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Uint16ArrayPrivate* privData = V8DOM::toClassPtr<V8Uint16ArrayPrivate >(self->GetInternalField(0));
-	long localStart = args[0]->ToNumber()->Int32Value();
-	long localEnd = args[1]->ToNumber()->Int32Value();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsInt32() &&
+	           args[1]->IsInt32()) {
+		long localStart = args[0]->ToNumber()->Int32Value();
+		long localEnd = args[1]->ToNumber()->Int32Value();
 
-	uscxml::Uint16Array* retVal = new uscxml::Uint16Array(privData->nativeObj->subarray(localStart, localEnd));
-	v8::Handle<v8::Function> retCtor = V8Uint16Array::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		uscxml::Uint16Array* retVal = new uscxml::Uint16Array(privData->nativeObj->subarray(localStart, localEnd));
+		v8::Handle<v8::Function> retCtor = V8Uint16Array::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Uint16Array::V8Uint16ArrayPrivate* retPrivData = new V8Uint16Array::V8Uint16ArrayPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Uint16Array::V8Uint16ArrayPrivate* retPrivData = new V8Uint16Array::V8Uint16ArrayPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Uint16Array::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Uint16Array::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling subarray");
+	return v8::Undefined();
 }
-
 bool V8Uint16Array::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint16Array.h b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint16Array.h
index e4d237d..ca9a40a 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint16Array.h
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint16Array.h
@@ -24,6 +24,7 @@
 #include <string>
 #include "../../TypedArray.h"
 #include "DOM/Node.hpp"
+#include "V8ArrayBufferView.h"
 #include "string"
 #include "uscxml/plugins/datamodel/ecmascript/v8/V8DOM.h"
 #include <v8.h>
@@ -46,6 +47,18 @@ public:
 	static v8::Handle<v8::Value> subarrayCallback(const v8::Arguments&);
 
 	static v8::Handle<v8::Value> lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+	static v8::Handle<v8::Value> indexedPropertyCustomGetter(uint32_t, const v8::AccessorInfo&);
+	static v8::Handle<v8::Value> indexedPropertyCustomSetter(uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo&);
+
+	static v8::Handle<v8::Value> constructor(const v8::Arguments&);
+	static v8::Persistent<v8::FunctionTemplate> Constr;
+	static v8::Handle<v8::FunctionTemplate> getConstructor() {
+		if (Constr.IsEmpty()) {
+			v8::Handle<v8::FunctionTemplate> constr = v8::FunctionTemplate::New(constructor);
+			Constr = v8::Persistent<v8::FunctionTemplate>::New(constr);
+		}
+		return Constr;
+	}
 
 	static v8::Persistent<v8::FunctionTemplate> Tmpl;
 	static v8::Handle<v8::FunctionTemplate> getTmpl() {
@@ -63,20 +76,18 @@ public:
 			instance->SetAccessor(v8::String::NewSymbol("length"), V8Uint16Array::lengthAttrGetter, 0,
 			                      v8::External::New(0), static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None));
 
+			instance->SetIndexedPropertyHandler(V8Uint16Array::indexedPropertyCustomGetter, V8Uint16Array::indexedPropertyCustomSetter);
 			prototype->Set(v8::String::NewSymbol("get"),
 			               v8::FunctionTemplate::New(V8Uint16Array::getCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("set"),
 			               v8::FunctionTemplate::New(V8Uint16Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Uint16Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Uint16Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("subarray"),
 			               v8::FunctionTemplate::New(V8Uint16Array::subarrayCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 
 			tmpl->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(2), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 			prototype->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(2), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 
+			tmpl->Inherit(V8ArrayBufferView::getTmpl());
 			Tmpl = v8::Persistent<v8::FunctionTemplate>::New(tmpl);
 		}
 		return Tmpl;
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint32Array.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint32Array.cpp
index 54b05aa..da3fdc2 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint32Array.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint32Array.cpp
@@ -1,10 +1,82 @@
+#include "V8ArrayBuffer.h"
+#include "V8ArrayBufferView.h"
 #include "V8Uint32Array.h"
 
 namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Uint32Array::Tmpl;
+v8::Persistent<v8::FunctionTemplate> V8Uint32Array::Constr;
 
+v8::Handle<v8::Value> V8Uint32Array::constructor(const v8::Arguments& args) {
+	if (!args.IsConstructCall())
+		return v8::ThrowException(v8::String::New("Cannot call constructor as function"));
+
+	uscxml::Uint32Array* localInstance = NULL;
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32() &&
+	           args[2]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		unsigned long localLength = args[2]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Uint32Array(localBuffer, localByteOffset, localLength);
+
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Uint32Array(localBuffer, localByteOffset);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Uint32Array::hasInstance(args[0])) {
+
+		uscxml::Uint32Array* localArray = V8DOM::toClassPtr<V8Uint32Array::V8Uint32ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Uint32Array(localArray);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0])) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Uint32Array(localBuffer);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+
+		unsigned long localLength = args[0]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Uint32Array(localLength);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+
+		std::vector<unsigned long> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToUint32()->Value());
+		}
+		localInstance = new uscxml::Uint32Array(localArray);
+
+	}
+	if (!localInstance) {
+		throw V8Exception("Parameter mismatch while calling constructor for Uint32Array");
+		return v8::Undefined();
+	}
+
+	v8::Handle<v8::Function> retCtor = V8Uint32Array::getTmpl()->GetFunction();
+	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+
+	struct V8Uint32Array::V8Uint32ArrayPrivate* retPrivData = new V8Uint32Array::V8Uint32ArrayPrivate();
+	retPrivData->nativeObj = localInstance;
+
+	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+
+	retObj.MakeWeak(0, V8Uint32Array::jsDestructor);
+	return retObj;
+}
 
 v8::Handle<v8::Value> V8Uint32Array::lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
@@ -12,57 +84,111 @@ v8::Handle<v8::Value> V8Uint32Array::lengthAttrGetter(v8::Local<v8::String> prop
 
 	return v8::Integer::New(privData->nativeObj->getLength());
 }
+
 v8::Handle<v8::Value> V8Uint32Array::getCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in get");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Uint32ArrayPrivate* privData = V8DOM::toClassPtr<V8Uint32ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
 
-	unsigned long retVal = privData->nativeObj->get(localIndex);
+		unsigned long retVal = privData->nativeObj->get(localIndex);
 
-	return v8::Number::New(retVal);
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling get");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Uint32Array::setCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in set");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Uint32ArrayPrivate* privData = V8DOM::toClassPtr<V8Uint32ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
-	unsigned long localValue = args[1]->ToNumber()->Uint32Value();
-
-	privData->nativeObj->set(localIndex, localValue);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8Uint32Array::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+		uscxml::Uint32Array* localArray = V8DOM::toClassPtr<V8Uint32Array::V8Uint32ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+		unsigned long localValue = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localIndex, localValue);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsArray() &&
+	           args[1]->IsUint32()) {
+		std::vector<unsigned long> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToUint32()->Value());
+		}
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Uint32Array::hasInstance(args[0])) {
+		uscxml::Uint32Array* localArray = V8DOM::toClassPtr<V8Uint32Array::V8Uint32ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+		std::vector<unsigned long> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToUint32()->Value());
+		}
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling set");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Uint32Array::subarrayCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in subarray");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Uint32ArrayPrivate* privData = V8DOM::toClassPtr<V8Uint32ArrayPrivate >(self->GetInternalField(0));
-	long localStart = args[0]->ToNumber()->Int32Value();
-	long localEnd = args[1]->ToNumber()->Int32Value();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsInt32() &&
+	           args[1]->IsInt32()) {
+		long localStart = args[0]->ToNumber()->Int32Value();
+		long localEnd = args[1]->ToNumber()->Int32Value();
 
-	uscxml::Uint32Array* retVal = new uscxml::Uint32Array(privData->nativeObj->subarray(localStart, localEnd));
-	v8::Handle<v8::Function> retCtor = V8Uint32Array::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		uscxml::Uint32Array* retVal = new uscxml::Uint32Array(privData->nativeObj->subarray(localStart, localEnd));
+		v8::Handle<v8::Function> retCtor = V8Uint32Array::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Uint32Array::V8Uint32ArrayPrivate* retPrivData = new V8Uint32Array::V8Uint32ArrayPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Uint32Array::V8Uint32ArrayPrivate* retPrivData = new V8Uint32Array::V8Uint32ArrayPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Uint32Array::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Uint32Array::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling subarray");
+	return v8::Undefined();
 }
-
 bool V8Uint32Array::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint32Array.h b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint32Array.h
index 09098aa..a119719 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint32Array.h
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint32Array.h
@@ -24,6 +24,7 @@
 #include <string>
 #include "../../TypedArray.h"
 #include "DOM/Node.hpp"
+#include "V8ArrayBufferView.h"
 #include "string"
 #include "uscxml/plugins/datamodel/ecmascript/v8/V8DOM.h"
 #include <v8.h>
@@ -46,6 +47,18 @@ public:
 	static v8::Handle<v8::Value> subarrayCallback(const v8::Arguments&);
 
 	static v8::Handle<v8::Value> lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+	static v8::Handle<v8::Value> indexedPropertyCustomGetter(uint32_t, const v8::AccessorInfo&);
+	static v8::Handle<v8::Value> indexedPropertyCustomSetter(uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo&);
+
+	static v8::Handle<v8::Value> constructor(const v8::Arguments&);
+	static v8::Persistent<v8::FunctionTemplate> Constr;
+	static v8::Handle<v8::FunctionTemplate> getConstructor() {
+		if (Constr.IsEmpty()) {
+			v8::Handle<v8::FunctionTemplate> constr = v8::FunctionTemplate::New(constructor);
+			Constr = v8::Persistent<v8::FunctionTemplate>::New(constr);
+		}
+		return Constr;
+	}
 
 	static v8::Persistent<v8::FunctionTemplate> Tmpl;
 	static v8::Handle<v8::FunctionTemplate> getTmpl() {
@@ -63,20 +76,18 @@ public:
 			instance->SetAccessor(v8::String::NewSymbol("length"), V8Uint32Array::lengthAttrGetter, 0,
 			                      v8::External::New(0), static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None));
 
+			instance->SetIndexedPropertyHandler(V8Uint32Array::indexedPropertyCustomGetter, V8Uint32Array::indexedPropertyCustomSetter);
 			prototype->Set(v8::String::NewSymbol("get"),
 			               v8::FunctionTemplate::New(V8Uint32Array::getCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("set"),
 			               v8::FunctionTemplate::New(V8Uint32Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Uint32Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Uint32Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("subarray"),
 			               v8::FunctionTemplate::New(V8Uint32Array::subarrayCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 
 			tmpl->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(4), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 			prototype->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(4), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 
+			tmpl->Inherit(V8ArrayBufferView::getTmpl());
 			Tmpl = v8::Persistent<v8::FunctionTemplate>::New(tmpl);
 		}
 		return Tmpl;
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8Array.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8Array.cpp
index cc13bf0..b2eafe5 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8Array.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8Array.cpp
@@ -1,10 +1,82 @@
+#include "V8ArrayBuffer.h"
+#include "V8ArrayBufferView.h"
 #include "V8Uint8Array.h"
 
 namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Uint8Array::Tmpl;
+v8::Persistent<v8::FunctionTemplate> V8Uint8Array::Constr;
 
+v8::Handle<v8::Value> V8Uint8Array::constructor(const v8::Arguments& args) {
+	if (!args.IsConstructCall())
+		return v8::ThrowException(v8::String::New("Cannot call constructor as function"));
+
+	uscxml::Uint8Array* localInstance = NULL;
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32() &&
+	           args[2]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		unsigned long localLength = args[2]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Uint8Array(localBuffer, localByteOffset, localLength);
+
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Uint8Array(localBuffer, localByteOffset);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Uint8Array::hasInstance(args[0])) {
+
+		uscxml::Uint8Array* localArray = V8DOM::toClassPtr<V8Uint8Array::V8Uint8ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Uint8Array(localArray);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0])) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Uint8Array(localBuffer);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+
+		unsigned long localLength = args[0]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Uint8Array(localLength);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+
+		std::vector<unsigned char> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToUint32()->Value());
+		}
+		localInstance = new uscxml::Uint8Array(localArray);
+
+	}
+	if (!localInstance) {
+		throw V8Exception("Parameter mismatch while calling constructor for Uint8Array");
+		return v8::Undefined();
+	}
+
+	v8::Handle<v8::Function> retCtor = V8Uint8Array::getTmpl()->GetFunction();
+	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+
+	struct V8Uint8Array::V8Uint8ArrayPrivate* retPrivData = new V8Uint8Array::V8Uint8ArrayPrivate();
+	retPrivData->nativeObj = localInstance;
+
+	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+
+	retObj.MakeWeak(0, V8Uint8Array::jsDestructor);
+	return retObj;
+}
 
 v8::Handle<v8::Value> V8Uint8Array::lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
@@ -12,57 +84,111 @@ v8::Handle<v8::Value> V8Uint8Array::lengthAttrGetter(v8::Local<v8::String> prope
 
 	return v8::Integer::New(privData->nativeObj->getLength());
 }
+
 v8::Handle<v8::Value> V8Uint8Array::getCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in get");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Uint8ArrayPrivate* privData = V8DOM::toClassPtr<V8Uint8ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
 
-	char retVal = privData->nativeObj->get(localIndex);
+		unsigned char retVal = privData->nativeObj->get(localIndex);
 
-	return v8::Number::New(retVal);
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling get");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Uint8Array::setCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in set");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Uint8ArrayPrivate* privData = V8DOM::toClassPtr<V8Uint8ArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
-	unsigned char localValue = args[1]->ToNumber()->Uint32Value();
-
-	privData->nativeObj->set(localIndex, localValue);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8Uint8Array::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+		uscxml::Uint8Array* localArray = V8DOM::toClassPtr<V8Uint8Array::V8Uint8ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+		unsigned char localValue = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localIndex, localValue);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsArray() &&
+	           args[1]->IsUint32()) {
+		std::vector<unsigned char> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToUint32()->Value());
+		}
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Uint8Array::hasInstance(args[0])) {
+		uscxml::Uint8Array* localArray = V8DOM::toClassPtr<V8Uint8Array::V8Uint8ArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+		std::vector<unsigned char> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToUint32()->Value());
+		}
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling set");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Uint8Array::subarrayCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in subarray");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Uint8ArrayPrivate* privData = V8DOM::toClassPtr<V8Uint8ArrayPrivate >(self->GetInternalField(0));
-	long localStart = args[0]->ToNumber()->Int32Value();
-	long localEnd = args[1]->ToNumber()->Int32Value();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsInt32() &&
+	           args[1]->IsInt32()) {
+		long localStart = args[0]->ToNumber()->Int32Value();
+		long localEnd = args[1]->ToNumber()->Int32Value();
 
-	uscxml::Uint8Array* retVal = new uscxml::Uint8Array(privData->nativeObj->subarray(localStart, localEnd));
-	v8::Handle<v8::Function> retCtor = V8Uint8Array::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		uscxml::Uint8Array* retVal = new uscxml::Uint8Array(privData->nativeObj->subarray(localStart, localEnd));
+		v8::Handle<v8::Function> retCtor = V8Uint8Array::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Uint8Array::V8Uint8ArrayPrivate* retPrivData = new V8Uint8Array::V8Uint8ArrayPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Uint8Array::V8Uint8ArrayPrivate* retPrivData = new V8Uint8Array::V8Uint8ArrayPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Uint8Array::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Uint8Array::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling subarray");
+	return v8::Undefined();
 }
-
 bool V8Uint8Array::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8Array.h b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8Array.h
index e59d8a6..e32007f 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8Array.h
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8Array.h
@@ -24,6 +24,7 @@
 #include <string>
 #include "../../TypedArray.h"
 #include "DOM/Node.hpp"
+#include "V8ArrayBufferView.h"
 #include "string"
 #include "uscxml/plugins/datamodel/ecmascript/v8/V8DOM.h"
 #include <v8.h>
@@ -46,6 +47,18 @@ public:
 	static v8::Handle<v8::Value> subarrayCallback(const v8::Arguments&);
 
 	static v8::Handle<v8::Value> lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+	static v8::Handle<v8::Value> indexedPropertyCustomGetter(uint32_t, const v8::AccessorInfo&);
+	static v8::Handle<v8::Value> indexedPropertyCustomSetter(uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo&);
+
+	static v8::Handle<v8::Value> constructor(const v8::Arguments&);
+	static v8::Persistent<v8::FunctionTemplate> Constr;
+	static v8::Handle<v8::FunctionTemplate> getConstructor() {
+		if (Constr.IsEmpty()) {
+			v8::Handle<v8::FunctionTemplate> constr = v8::FunctionTemplate::New(constructor);
+			Constr = v8::Persistent<v8::FunctionTemplate>::New(constr);
+		}
+		return Constr;
+	}
 
 	static v8::Persistent<v8::FunctionTemplate> Tmpl;
 	static v8::Handle<v8::FunctionTemplate> getTmpl() {
@@ -63,20 +76,18 @@ public:
 			instance->SetAccessor(v8::String::NewSymbol("length"), V8Uint8Array::lengthAttrGetter, 0,
 			                      v8::External::New(0), static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None));
 
+			instance->SetIndexedPropertyHandler(V8Uint8Array::indexedPropertyCustomGetter, V8Uint8Array::indexedPropertyCustomSetter);
 			prototype->Set(v8::String::NewSymbol("get"),
 			               v8::FunctionTemplate::New(V8Uint8Array::getCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("set"),
 			               v8::FunctionTemplate::New(V8Uint8Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Uint8Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Uint8Array::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("subarray"),
 			               v8::FunctionTemplate::New(V8Uint8Array::subarrayCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 
 			tmpl->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(1), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 			prototype->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(1), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 
+			tmpl->Inherit(V8ArrayBufferView::getTmpl());
 			Tmpl = v8::Persistent<v8::FunctionTemplate>::New(tmpl);
 		}
 		return Tmpl;
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8ClampedArray.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8ClampedArray.cpp
index 64c8d95..206b755 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8ClampedArray.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8ClampedArray.cpp
@@ -1,10 +1,82 @@
+#include "V8ArrayBuffer.h"
+#include "V8ArrayBufferView.h"
 #include "V8Uint8ClampedArray.h"
 
 namespace Arabica {
 namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8Uint8ClampedArray::Tmpl;
+v8::Persistent<v8::FunctionTemplate> V8Uint8ClampedArray::Constr;
 
+v8::Handle<v8::Value> V8Uint8ClampedArray::constructor(const v8::Arguments& args) {
+	if (!args.IsConstructCall())
+		return v8::ThrowException(v8::String::New("Cannot call constructor as function"));
+
+	uscxml::Uint8ClampedArray* localInstance = NULL;
+	if (false) {
+	} else if (args.Length() == 3 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32() &&
+	           args[2]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		unsigned long localLength = args[2]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Uint8ClampedArray(localBuffer, localByteOffset, localLength);
+
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localByteOffset = args[1]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Uint8ClampedArray(localBuffer, localByteOffset);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Uint8ClampedArray::hasInstance(args[0])) {
+
+		uscxml::Uint8ClampedArray* localArray = V8DOM::toClassPtr<V8Uint8ClampedArray::V8Uint8ClampedArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Uint8ClampedArray(localArray);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8ArrayBuffer::hasInstance(args[0])) {
+
+		uscxml::ArrayBuffer* localBuffer = V8DOM::toClassPtr<V8ArrayBuffer::V8ArrayBufferPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		localInstance = new uscxml::Uint8ClampedArray(localBuffer);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+
+		unsigned long localLength = args[0]->ToNumber()->Uint32Value();
+		localInstance = new uscxml::Uint8ClampedArray(localLength);
+
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+
+		std::vector<unsigned char> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToUint32()->Value());
+		}
+		localInstance = new uscxml::Uint8ClampedArray(localArray);
+
+	}
+	if (!localInstance) {
+		throw V8Exception("Parameter mismatch while calling constructor for Uint8ClampedArray");
+		return v8::Undefined();
+	}
+
+	v8::Handle<v8::Function> retCtor = V8Uint8ClampedArray::getTmpl()->GetFunction();
+	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+
+	struct V8Uint8ClampedArray::V8Uint8ClampedArrayPrivate* retPrivData = new V8Uint8ClampedArray::V8Uint8ClampedArrayPrivate();
+	retPrivData->nativeObj = localInstance;
+
+	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+
+	retObj.MakeWeak(0, V8Uint8ClampedArray::jsDestructor);
+	return retObj;
+}
 
 v8::Handle<v8::Value> V8Uint8ClampedArray::lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
@@ -12,57 +84,111 @@ v8::Handle<v8::Value> V8Uint8ClampedArray::lengthAttrGetter(v8::Local<v8::String
 
 	return v8::Integer::New(privData->nativeObj->getLength());
 }
+
 v8::Handle<v8::Value> V8Uint8ClampedArray::getCallback(const v8::Arguments& args) {
-	if (args.Length() < 1)
-		throw V8Exception("Wrong number of arguments in get");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Uint8ClampedArrayPrivate* privData = V8DOM::toClassPtr<V8Uint8ClampedArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+	if (false) {
+	} else if (args.Length() == 1 &&
+	           args[0]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
 
-	char retVal = privData->nativeObj->get(localIndex);
+		unsigned char retVal = privData->nativeObj->get(localIndex);
 
-	return v8::Number::New(retVal);
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling get");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Uint8ClampedArray::setCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in set");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Uint8ClampedArrayPrivate* privData = V8DOM::toClassPtr<V8Uint8ClampedArrayPrivate >(self->GetInternalField(0));
-	unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
-	unsigned char localValue = args[1]->ToNumber()->Uint32Value();
-
-	privData->nativeObj->set(localIndex, localValue);
-
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsObject() && V8Uint8ClampedArray::hasInstance(args[0]) &&
+	           args[1]->IsUint32()) {
+		uscxml::Uint8ClampedArray* localArray = V8DOM::toClassPtr<V8Uint8ClampedArray::V8Uint8ClampedArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsUint32() &&
+	           args[1]->IsUint32()) {
+		unsigned long localIndex = args[0]->ToNumber()->Uint32Value();
+		unsigned char localValue = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localIndex, localValue);
+
+		return v8::Undefined();
+	} else if (args.Length() == 2 &&
+	           args[0]->IsArray() &&
+	           args[1]->IsUint32()) {
+		std::vector<unsigned char> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToUint32()->Value());
+		}
+		unsigned long localOffset = args[1]->ToNumber()->Uint32Value();
+
+		privData->nativeObj->set(localArray, localOffset);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsObject() && V8Uint8ClampedArray::hasInstance(args[0])) {
+		uscxml::Uint8ClampedArray* localArray = V8DOM::toClassPtr<V8Uint8ClampedArray::V8Uint8ClampedArrayPrivate >(args[0]->ToObject()->GetInternalField(0))->nativeObj;
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	} else if (args.Length() == 1 &&
+	           args[0]->IsArray()) {
+		std::vector<unsigned char> localArray;
+		v8::Handle<v8::Array> localArrayArray(v8::Array::Cast(*args[0]));
+		for (int i = 0; i < localArrayArray->Length(); i++) {
+			localArray.push_back(localArrayArray->Get(i)->ToUint32()->Value());
+		}
+
+		privData->nativeObj->set(localArray);
+
+		return v8::Undefined();
+	}
+	throw V8Exception("Parameter mismatch while calling set");
 	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8Uint8ClampedArray::subarrayCallback(const v8::Arguments& args) {
-	if (args.Length() < 2)
-		throw V8Exception("Wrong number of arguments in subarray");
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8Uint8ClampedArrayPrivate* privData = V8DOM::toClassPtr<V8Uint8ClampedArrayPrivate >(self->GetInternalField(0));
-	long localStart = args[0]->ToNumber()->Int32Value();
-	long localEnd = args[1]->ToNumber()->Int32Value();
+	if (false) {
+	} else if (args.Length() == 2 &&
+	           args[0]->IsInt32() &&
+	           args[1]->IsInt32()) {
+		long localStart = args[0]->ToNumber()->Int32Value();
+		long localEnd = args[1]->ToNumber()->Int32Value();
 
-	uscxml::Uint8ClampedArray* retVal = new uscxml::Uint8ClampedArray(privData->nativeObj->subarray(localStart, localEnd));
-	v8::Handle<v8::Function> retCtor = V8Uint8ClampedArray::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		uscxml::Uint8ClampedArray* retVal = new uscxml::Uint8ClampedArray(privData->nativeObj->subarray(localStart, localEnd));
+		v8::Handle<v8::Function> retCtor = V8Uint8ClampedArray::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8Uint8ClampedArray::V8Uint8ClampedArrayPrivate* retPrivData = new V8Uint8ClampedArray::V8Uint8ClampedArrayPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8Uint8ClampedArray::V8Uint8ClampedArrayPrivate* retPrivData = new V8Uint8ClampedArray::V8Uint8ClampedArrayPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8Uint8ClampedArray::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8Uint8ClampedArray::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling subarray");
+	return v8::Undefined();
 }
-
 bool V8Uint8ClampedArray::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8ClampedArray.h b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8ClampedArray.h
index 37f9482..8e130f4 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8ClampedArray.h
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8Uint8ClampedArray.h
@@ -24,6 +24,7 @@
 #include <string>
 #include "../../TypedArray.h"
 #include "DOM/Node.hpp"
+#include "V8ArrayBufferView.h"
 #include "string"
 #include "uscxml/plugins/datamodel/ecmascript/v8/V8DOM.h"
 #include <v8.h>
@@ -46,6 +47,18 @@ public:
 	static v8::Handle<v8::Value> subarrayCallback(const v8::Arguments&);
 
 	static v8::Handle<v8::Value> lengthAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+	static v8::Handle<v8::Value> indexedPropertyCustomGetter(uint32_t, const v8::AccessorInfo&);
+	static v8::Handle<v8::Value> indexedPropertyCustomSetter(uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo&);
+
+	static v8::Handle<v8::Value> constructor(const v8::Arguments&);
+	static v8::Persistent<v8::FunctionTemplate> Constr;
+	static v8::Handle<v8::FunctionTemplate> getConstructor() {
+		if (Constr.IsEmpty()) {
+			v8::Handle<v8::FunctionTemplate> constr = v8::FunctionTemplate::New(constructor);
+			Constr = v8::Persistent<v8::FunctionTemplate>::New(constr);
+		}
+		return Constr;
+	}
 
 	static v8::Persistent<v8::FunctionTemplate> Tmpl;
 	static v8::Handle<v8::FunctionTemplate> getTmpl() {
@@ -63,20 +76,18 @@ public:
 			instance->SetAccessor(v8::String::NewSymbol("length"), V8Uint8ClampedArray::lengthAttrGetter, 0,
 			                      v8::External::New(0), static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None));
 
+			instance->SetIndexedPropertyHandler(V8Uint8ClampedArray::indexedPropertyCustomGetter, V8Uint8ClampedArray::indexedPropertyCustomSetter);
 			prototype->Set(v8::String::NewSymbol("get"),
 			               v8::FunctionTemplate::New(V8Uint8ClampedArray::getCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("set"),
 			               v8::FunctionTemplate::New(V8Uint8ClampedArray::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Uint8ClampedArray::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
-			prototype->Set(v8::String::NewSymbol("set"),
-			               v8::FunctionTemplate::New(V8Uint8ClampedArray::setCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 			prototype->Set(v8::String::NewSymbol("subarray"),
 			               v8::FunctionTemplate::New(V8Uint8ClampedArray::subarrayCallback, v8::Undefined()), static_cast<v8::PropertyAttribute>(v8::DontDelete));
 
 			tmpl->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(1), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 			prototype->Set(v8::String::NewSymbol("BYTES_PER_ELEMENT"), v8::Integer::New(1), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 
+			tmpl->Inherit(V8ArrayBufferView::getTmpl());
 			Tmpl = v8::Persistent<v8::FunctionTemplate>::New(tmpl);
 		}
 		return Tmpl;
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8XPathResult.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8XPathResult.cpp
index 968e53d..265bcfe 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8XPathResult.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/dom/V8XPathResult.cpp
@@ -6,7 +6,6 @@ namespace DOM {
 
 v8::Persistent<v8::FunctionTemplate> V8XPathResult::Tmpl;
 
-
 v8::Handle<v8::Value> V8XPathResult::numberValueAttrGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
 	v8::Local<v8::Object> self = info.Holder();
 	struct V8XPathResultPrivate* privData = V8DOM::toClassPtr<V8XPathResultPrivate >(self->GetInternalField(0));
@@ -27,56 +26,76 @@ v8::Handle<v8::Value> V8XPathResult::booleanValueAttrGetter(v8::Local<v8::String
 
 	return v8::Boolean::New(privData->nativeObj->asBool());
 }
+
 v8::Handle<v8::Value> V8XPathResult::asNodeSetCallback(const v8::Arguments& args) {
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8XPathResultPrivate* privData = V8DOM::toClassPtr<V8XPathResultPrivate >(self->GetInternalField(0));
+	if (false) {
+	} else if (args.Length() == 0) {
 
-	Arabica::XPath::NodeSet<std::string>* retVal = new Arabica::XPath::NodeSet<std::string>(privData->nativeObj->asNodeSet());
-	v8::Handle<v8::Function> retCtor = V8NodeSet::getTmpl()->GetFunction();
-	v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
+		Arabica::XPath::NodeSet<std::string>* retVal = new Arabica::XPath::NodeSet<std::string>(privData->nativeObj->asNodeSet());
+		v8::Handle<v8::Function> retCtor = V8NodeSet::getTmpl()->GetFunction();
+		v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance());
 
-	struct V8NodeSet::V8NodeSetPrivate* retPrivData = new V8NodeSet::V8NodeSetPrivate();
-	retPrivData->dom = privData->dom;
-	retPrivData->nativeObj = retVal;
+		struct V8NodeSet::V8NodeSetPrivate* retPrivData = new V8NodeSet::V8NodeSetPrivate();
+		retPrivData->dom = privData->dom;
+		retPrivData->nativeObj = retVal;
 
-	retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
+		retObj->SetInternalField(0, V8DOM::toExternal(retPrivData));
 
-	retObj.MakeWeak(0, V8NodeSet::jsDestructor);
-	return retObj;
+		retObj.MakeWeak(0, V8NodeSet::jsDestructor);
+		return retObj;
 
+	}
+	throw V8Exception("Parameter mismatch while calling asNodeSet");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8XPathResult::asBoolCallback(const v8::Arguments& args) {
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8XPathResultPrivate* privData = V8DOM::toClassPtr<V8XPathResultPrivate >(self->GetInternalField(0));
+	if (false) {
+	} else if (args.Length() == 0) {
 
-	bool retVal = privData->nativeObj->asBool();
+		bool retVal = privData->nativeObj->asBool();
 
-	return v8::Boolean::New(retVal);
+		return v8::Boolean::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling asBool");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8XPathResult::asStringCallback(const v8::Arguments& args) {
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8XPathResultPrivate* privData = V8DOM::toClassPtr<V8XPathResultPrivate >(self->GetInternalField(0));
+	if (false) {
+	} else if (args.Length() == 0) {
 
-	std::string retVal = privData->nativeObj->asString();
+		std::string retVal = privData->nativeObj->asString();
 
-	return v8::String::New(retVal.c_str());
+		return v8::String::New(retVal.c_str());
+	}
+	throw V8Exception("Parameter mismatch while calling asString");
+	return v8::Undefined();
 }
 
 v8::Handle<v8::Value> V8XPathResult::asNumberCallback(const v8::Arguments& args) {
 
 	v8::Local<v8::Object> self = args.Holder();
 	struct V8XPathResultPrivate* privData = V8DOM::toClassPtr<V8XPathResultPrivate >(self->GetInternalField(0));
+	if (false) {
+	} else if (args.Length() == 0) {
 
-	double retVal = privData->nativeObj->asNumber();
+		double retVal = privData->nativeObj->asNumber();
 
-	return v8::Number::New(retVal);
+		return v8::Number::New(retVal);
+	}
+	throw V8Exception("Parameter mismatch while calling asNumber");
+	return v8::Undefined();
 }
-
 bool V8XPathResult::hasInstance(v8::Handle<v8::Value> value) {
 	return getTmpl()->HasInstance(value);
 }