diff --git a/demo-shell-ng2/app/polyfills.ts b/demo-shell-ng2/app/polyfills.ts
index c279c6f18f..d5be0fad92 100644
--- a/demo-shell-ng2/app/polyfills.ts
+++ b/demo-shell-ng2/app/polyfills.ts
@@ -2,8 +2,6 @@ import 'core-js/es6';
 import 'core-js/es7/reflect';
 
 // IE 8-11
-require('script!element.scrollintoviewifneeded-polyfill/index.js');
-
 require('zone.js/dist/zone');
 
 if (process.env.ENV === 'production') {
diff --git a/demo-shell-ng2/app/vendor.ts b/demo-shell-ng2/app/vendor.ts
index 038e3284c7..4bb3c9218f 100644
--- a/demo-shell-ng2/app/vendor.ts
+++ b/demo-shell-ng2/app/vendor.ts
@@ -10,45 +10,32 @@ import '@angular/router';
 import 'rxjs';
 
 //Alfresco
-import 'ng2-alfresco-core'
-import 'ng2-alfresco-datatable'
-import 'ng2-activiti-diagrams'
-import 'ng2-activiti-analytics'
-import 'ng2-activiti-form'
-import 'ng2-activiti-processlist'
-import 'ng2-activiti-tasklist'
-import 'ng2-alfresco-documentlist'
-import 'ng2-alfresco-login'
-import 'ng2-alfresco-search'
-import 'ng2-alfresco-tag'
-import 'ng2-alfresco-upload'
-import 'ng2-alfresco-viewer'
-import 'ng2-alfresco-webscript'
-import 'ng2-alfresco-userinfo'
-
-// Other vendors for example jQuery, Lodash or Bootstrap
-// You can import js, ts, css, sass, ...
-
-// Google Material Design Lite
-import '../public/css/material.orange-blue.min.css';
-import 'material-design-lite/material.min';
-import 'material-design-icons/iconfont/material-icons.css';
-
-// Flags
-import 'flag-icon-css/css/flag-icon.min.css';
+import 'ng2-alfresco-core';
+import 'ng2-alfresco-datatable';
+import 'ng2-activiti-diagrams';
+import 'ng2-activiti-analytics';
+import 'ng2-activiti-form';
+import 'ng2-activiti-processlist';
+import 'ng2-activiti-tasklist';
+import 'ng2-alfresco-documentlist';
+import 'ng2-alfresco-login';
+import 'ng2-alfresco-search';
+import 'ng2-alfresco-tag';
+import 'ng2-alfresco-upload';
+import 'ng2-alfresco-viewer';
+import 'ng2-alfresco-webscript';
+import 'ng2-alfresco-userinfo';
 
 // Polyfill(s) for dialogs
 import 'dialog-polyfill/dialog-polyfill';
 import 'dialog-polyfill/dialog-polyfill.css';
 
-// app content
-import '../public/css/app.css';
-import '../public/css/muli-font.css';
+// Flags
+import 'flag-icon-css/css/flag-icon.min.css';
 
 import 'ng2-activiti-form/stencils/runtime.ng1';
 import 'ng2-activiti-form/stencils/runtime.adf';
 
-require('script!../public/js/Polyline.js');
 import 'chart.js';
 require('script!raphael/raphael.min.js');
 
diff --git a/demo-shell-ng2/config/webpack.common.js b/demo-shell-ng2/config/webpack.common.js
index d2d3be3135..513f6e09f7 100644
--- a/demo-shell-ng2/config/webpack.common.js
+++ b/demo-shell-ng2/config/webpack.common.js
@@ -111,7 +111,110 @@ module.exports = {
         }),
 
         new CopyWebpackPlugin([
-            { from: 'versions.json' }
+            {
+                from: 'versions.json'
+            },{
+                context: 'node_modules',
+                from: 'element.scrollintoviewifneeded-polyfill/index.js',
+                to: 'js/element.scrollintoviewifneeded-polyfill.js',
+                flatten: true
+            },{
+                context: 'node_modules',
+                from: 'classlist-polyfill/src/index.js',
+                to: 'js/classlist-polyfill.js',
+                flatten: true
+            }, {
+                context: 'node_modules',
+                from: 'intl/dist/Intl.min.js',
+                to: 'js/Intl.min.js',
+                flatten: true
+            }, {
+                context: 'node_modules',
+                from: 'web-animations-js/web-animations.min.js',
+                to: 'js/web-animations.min.js',
+                flatten: true
+            }, {
+                context: 'node_modules',
+                from: 'core-js/client/shim.min.js',
+                to: 'js/shim.min.js',
+                flatten: true
+            }, {
+                context: 'node_modules',
+                from:  'es6-shim/es6-shim.min.js',
+                to: 'js/es6-shim.min.js',
+                flatten: true
+            }, {
+                context: 'node_modules',
+                from:  'es5-shim/es5-shim.min.js',
+                to: 'js/es5-shim.min.js',
+                flatten: true
+            }, {
+                context: 'node_modules',
+                from:  'systemjs/dist/system-polyfills.js',
+                to: 'js/system-polyfills.js',
+                flatten: true
+            }, {
+                context: 'node_modules',
+                from:  'material-design-lite/material.min.js',
+                to: 'js/material.min.js',
+                flatten: true
+            }, {
+                context: 'node_modules',
+                from:  'material-design-lite/material.min.js',
+                to: 'js/material.min.js',
+                flatten: true
+            }, {
+                context: 'public',
+                from: 'css/app.css',
+                to: 'css/app.css',
+                flatten: true
+            },  {
+                context: 'public',
+                from: 'css/material.orange-blue.min.css',
+                to: 'css/material.orange-blue.min.css',
+                flatten: true
+            },  {
+                context: 'node_modules',
+                from: 'material-design-icons/iconfont/',
+                to: 'css/iconfont/',
+                flatten: true
+            },  {
+                context: 'node_modules',
+                from: 'flag-icon-css/css/flag-icon.min.css',
+                to: 'css/flag-icon.min.css',
+                flatten: true
+            }, {
+                context: 'public',
+                from: 'fonts',
+                to: 'css',
+                flatten: true
+            }, {
+                context: 'public',
+                from: 'js/typedarray.js',
+                to: 'js/typedarray.js',
+                flatten: true
+            }, {
+                context: 'public',
+                from: 'js/Blob.js',
+                to: 'js/Blob.js',
+                flatten: true
+            }, {
+                context: 'public',
+                from: 'js/formdata.js',
+                to: 'js/formdata.js',
+                flatten: true
+            }, {
+                context: 'public',
+                from: 'js/promisePolyfill.js',
+                to: 'js/promisePolyfill.js',
+                flatten: true
+            }, {
+                context: 'public',
+                from: 'css/muli-font.css',
+                to: 'css/muli-font.css',
+                flatten: true
+            }
+
         ]),
 
         new webpack.optimize.CommonsChunkPlugin({
diff --git a/demo-shell-ng2/index.html b/demo-shell-ng2/index.html
index 984baef300..cc047ded14 100644
--- a/demo-shell-ng2/index.html
+++ b/demo-shell-ng2/index.html
@@ -5,15 +5,36 @@
     <title>Demo Application - Angular 2</title>
     <meta name="viewport" content="width=device-width, initial-scale=1">
 
+    <link href="css/app.css" rel="stylesheet">
     <link rel="icon" type="image/png" href="favicon-96x96.png" sizes="96x96">
-    <link href="https://fonts.googleapis.com/css?family=Roboto:regular,bold,italic,thin,light,bolditalic,black,medium&amp;lang=en" rel="stylesheet" type="text/css">
 
     <!-- 1. Load libraries -->
     <!-- Polyfill(s) for Safari (pre-10.x) -->
-    <script src="https://cdn.polyfill.io/v2/polyfill.min.js?features=Intl.~locale.en"></script>
+    <!--[if lt IE 7]>
+    <script src="js/dialog-polyfill.js"></script>
+
+    <script src=js/shim.min.js></script>
+    <script src=//cdnjs.cloudflare.com/ajax/libs/dom4/1.8.3/dom4.js></script>
+    <script src=js/element.scrollintoviewifneeded-polyfill.js></script>
+    <script src=js/classlist-polyfill.js></script>
+    <script src=js/Intl.min.js></script>
+    <script src=js/web-animations.min.js></script>
+    <script src=js/typedarray.js></script>
+    <script src=js/Blob.js></script>
+    <script src=js/formdata.js></script>
+    <script src=https://npmcdn.com/angular2/es6/dev/src/testing/shims_for_IE.js></script>
+    <script src=js/es6-shim.min.js></script>
+    <script src=js/es5-shim.min.js></script>
+    <script src=js/system-polyfills.js></script>
+    <![endif]-->
+    <link href=css/flag-icon.min.css rel="stylesheet" type="text/css/">
+    <link href=css/muli-font.csss rel="stylesheet" type="text/css/">
+
+    <!-- Google Material Design Lite -->
+    <link href="css/material.orange-blue.min.css" rel="stylesheet">
+    <script src="js/material.min.js"></script>
+    <link href="css/iconfont/material-icons.css" rel="stylesheet">
 
-    <!-- Polyfill(s) for older browsers -->
-    <script src="//cdnjs.cloudflare.com/ajax/libs/dom4/1.8.3/dom4.js"></script>
 
     <style>
         .main_header_adf .mdl-layout__drawer-button {
@@ -24,13 +45,14 @@
 </head>
 <!-- 3. Display the application -->
 <body>
-    <alfresco-app>
-        <div id="loader-container" class="loader-container">
-            <div class="loader-item">
-                <div id="loader-spin" class="mdl-progress mdl-js-progress mdl-progress__indeterminate"></div>
-                <div id="loader-text" class="loader-text">Loading Demo Shell..</div>
-            </div >
-        </div>
-    </alfresco-app>
+<alfresco-app>
+    <div id="loader-container" class="loader-container">
+        <div class="loader-item">
+            <div id="loader-spin" class="mdl-progress mdl-js-progress mdl-progress__indeterminate"></div>
+            <div id="loader-text" class="loader-text">Loading Demo Shell..</div>
+        </div >
+    </div>
+</alfresco-app>
 </body>
 </html>
+
diff --git a/demo-shell-ng2/package.json b/demo-shell-ng2/package.json
index 149c1503d5..3d2e1015dc 100644
--- a/demo-shell-ng2/package.json
+++ b/demo-shell-ng2/package.json
@@ -10,7 +10,7 @@
     "clean-build": "rimraf 'app/{,**/}**.js' 'app/{,**/}**.js.map' 'app/{,**/}**.d.ts'",
     "test": "karma start",
     "build": "npm run server-versions && rimraf dist && webpack --config config/webpack.prod.js --progress --profile --bail",
-    "server-versions" : "rimraf versions.json && npm list --depth=0 --json=true --prod=true > versions.json  || true",
+    "server-versions": "rimraf versions.json && npm list --depth=0 --json=true --prod=true > versions.json  || true",
     "aws": "node app.js",
     "tslint": "tslint -c tslint.json *.ts && tslint -c tslint.json 'app/{,**/}**.ts'",
     "licensecheck": "license-check"
@@ -63,8 +63,8 @@
     "systemjs": "0.19.40",
     "core-js": "^2.4.1",
     "reflect-metadata": "^0.1.8",
-    "rxjs": "5.0.0-beta.12",
-    "zone.js": "^0.6.26",
+    "rxjs": "5.0.1",
+    "zone.js": "^0.7.2",
     "material-design-icons": "2.2.3",
     "material-design-lite": "1.2.1",
     "ng2-translate": "2.5.0",
@@ -98,8 +98,10 @@
     "@types/node": "^6.0.45",
     "angular2-template-loader": "^0.6.0",
     "awesome-typescript-loader": "^2.2.4",
+    "classlist-polyfill": "^1.0.3",
     "copy-webpack-plugin": "^4.0.1",
     "css-loader": "^0.23.1",
+    "es6-shim": "^0.35.2",
     "extract-text-webpack-plugin": "^1.0.1",
     "file-loader": "^0.8.5",
     "glob": "^7.1.1",
@@ -124,13 +126,10 @@
     "style-loader": "^0.13.1",
     "tslint": "3.15.1",
     "typescript": "2.0.3",
+    "web-animations-js": "^2.2.2",
     "webpack": "^1.13.0",
     "webpack-dev-server": "^1.14.1",
     "webpack-merge": "^0.14.0",
-    "source-map-loader": "^0.1.5",
-    "script-loader": "^0.7.0",
-    "copy-webpack-plugin": "^4.0.1",
-    "glob": "^7.1.1",
     "wsrv": "^0.1.6"
   },
   "license-check-config": {
diff --git a/demo-shell-ng2/public/fonts/material-icons.woff2 b/demo-shell-ng2/public/fonts/material-icons.woff2
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/demo-shell-ng2/public/js/Blob.js b/demo-shell-ng2/public/js/Blob.js
new file mode 100644
index 0000000000..bd41a44806
--- /dev/null
+++ b/demo-shell-ng2/public/js/Blob.js
@@ -0,0 +1,211 @@
+/* Blob.js
+ * A Blob implementation.
+ * 2014-07-24
+ *
+ * By Eli Grey, http://eligrey.com
+ * By Devin Samarin, https://github.com/dsamarin
+ * License: MIT
+ *   See https://github.com/eligrey/Blob.js/blob/master/LICENSE.md
+ */
+
+/*global self, unescape */
+/*jslint bitwise: true, regexp: true, confusion: true, es5: true, vars: true, white: true,
+ plusplus: true */
+
+/*! @source http://purl.eligrey.com/github/Blob.js/blob/master/Blob.js */
+
+(function (view) {
+    "use strict";
+
+    view.URL = view.URL || view.webkitURL;
+
+    if (view.Blob && view.URL) {
+        try {
+            new Blob;
+            return;
+        } catch (e) {}
+    }
+
+    // Internally we use a BlobBuilder implementation to base Blob off of
+    // in order to support older browsers that only have BlobBuilder
+    var BlobBuilder = view.BlobBuilder || view.WebKitBlobBuilder || view.MozBlobBuilder || (function(view) {
+            var
+                get_class = function(object) {
+                    return Object.prototype.toString.call(object).match(/^\[object\s(.*)\]$/)[1];
+                }
+                , FakeBlobBuilder = function BlobBuilder() {
+                    this.data = [];
+                }
+                , FakeBlob = function Blob(data, type, encoding) {
+                    this.data = data;
+                    this.size = data.length;
+                    this.type = type;
+                    this.encoding = encoding;
+                }
+                , FBB_proto = FakeBlobBuilder.prototype
+                , FB_proto = FakeBlob.prototype
+                , FileReaderSync = view.FileReaderSync
+                , FileException = function(type) {
+                    this.code = this[this.name = type];
+                }
+                , file_ex_codes = (
+                    "NOT_FOUND_ERR SECURITY_ERR ABORT_ERR NOT_READABLE_ERR ENCODING_ERR "
+                    + "NO_MODIFICATION_ALLOWED_ERR INVALID_STATE_ERR SYNTAX_ERR"
+                ).split(" ")
+                , file_ex_code = file_ex_codes.length
+                , real_URL = view.URL || view.webkitURL || view
+                , real_create_object_URL = real_URL.createObjectURL
+                , real_revoke_object_URL = real_URL.revokeObjectURL
+                , URL = real_URL
+                , btoa = view.btoa
+                , atob = view.atob
+
+                , ArrayBuffer = view.ArrayBuffer
+                , Uint8Array = view.Uint8Array
+
+                , origin = /^[\w-]+:\/*\[?[\w\.:-]+\]?(?::[0-9]+)?/
+                ;
+            FakeBlob.fake = FB_proto.fake = true;
+            while (file_ex_code--) {
+                FileException.prototype[file_ex_codes[file_ex_code]] = file_ex_code + 1;
+            }
+            // Polyfill URL
+            if (!real_URL.createObjectURL) {
+                URL = view.URL = function(uri) {
+                    var
+                        uri_info = document.createElementNS("http://www.w3.org/1999/xhtml", "a")
+                        , uri_origin
+                        ;
+                    uri_info.href = uri;
+                    if (!("origin" in uri_info)) {
+                        if (uri_info.protocol.toLowerCase() === "data:") {
+                            uri_info.origin = null;
+                        } else {
+                            uri_origin = uri.match(origin);
+                            uri_info.origin = uri_origin && uri_origin[1];
+                        }
+                    }
+                    return uri_info;
+                };
+            }
+            URL.createObjectURL = function(blob) {
+                var
+                    type = blob.type
+                    , data_URI_header
+                    ;
+                if (type === null) {
+                    type = "application/octet-stream";
+                }
+                if (blob instanceof FakeBlob) {
+                    data_URI_header = "data:" + type;
+                    if (blob.encoding === "base64") {
+                        return data_URI_header + ";base64," + blob.data;
+                    } else if (blob.encoding === "URI") {
+                        return data_URI_header + "," + decodeURIComponent(blob.data);
+                    } if (btoa) {
+                        return data_URI_header + ";base64," + btoa(blob.data);
+                    } else {
+                        return data_URI_header + "," + encodeURIComponent(blob.data);
+                    }
+                } else if (real_create_object_URL) {
+                    return real_create_object_URL.call(real_URL, blob);
+                }
+            };
+            URL.revokeObjectURL = function(object_URL) {
+                if (object_URL.substring(0, 5) !== "data:" && real_revoke_object_URL) {
+                    real_revoke_object_URL.call(real_URL, object_URL);
+                }
+            };
+            FBB_proto.append = function(data/*, endings*/) {
+                var bb = this.data;
+                // decode data to a binary string
+                if (Uint8Array && (data instanceof ArrayBuffer || data instanceof Uint8Array)) {
+                    var
+                        str = ""
+                        , buf = new Uint8Array(data)
+                        , i = 0
+                        , buf_len = buf.length
+                        ;
+                    for (; i < buf_len; i++) {
+                        str += String.fromCharCode(buf[i]);
+                    }
+                    bb.push(str);
+                } else if (get_class(data) === "Blob" || get_class(data) === "File") {
+                    if (FileReaderSync) {
+                        var fr = new FileReaderSync;
+                        bb.push(fr.readAsBinaryString(data));
+                    } else {
+                        // async FileReader won't work as BlobBuilder is sync
+                        throw new FileException("NOT_READABLE_ERR");
+                    }
+                } else if (data instanceof FakeBlob) {
+                    if (data.encoding === "base64" && atob) {
+                        bb.push(atob(data.data));
+                    } else if (data.encoding === "URI") {
+                        bb.push(decodeURIComponent(data.data));
+                    } else if (data.encoding === "raw") {
+                        bb.push(data.data);
+                    }
+                } else {
+                    if (typeof data !== "string") {
+                        data += ""; // convert unsupported types to strings
+                    }
+                    // decode UTF-16 to binary string
+                    bb.push(unescape(encodeURIComponent(data)));
+                }
+            };
+            FBB_proto.getBlob = function(type) {
+                if (!arguments.length) {
+                    type = null;
+                }
+                return new FakeBlob(this.data.join(""), type, "raw");
+            };
+            FBB_proto.toString = function() {
+                return "[object BlobBuilder]";
+            };
+            FB_proto.slice = function(start, end, type) {
+                var args = arguments.length;
+                if (args < 3) {
+                    type = null;
+                }
+                return new FakeBlob(
+                    this.data.slice(start, args > 1 ? end : this.data.length)
+                    , type
+                    , this.encoding
+                );
+            };
+            FB_proto.toString = function() {
+                return "[object Blob]";
+            };
+            FB_proto.close = function() {
+                this.size = 0;
+                delete this.data;
+            };
+            return FakeBlobBuilder;
+        }(view));
+
+    view.Blob = function(blobParts, options) {
+        var type = options ? (options.type || "") : "";
+        var builder = new BlobBuilder();
+        if (blobParts) {
+            for (var i = 0, len = blobParts.length; i < len; i++) {
+                if (Uint8Array && blobParts[i] instanceof Uint8Array) {
+                    builder.append(blobParts[i].buffer);
+                }
+                else {
+                    builder.append(blobParts[i]);
+                }
+            }
+        }
+        var blob = builder.getBlob(type);
+        if (!blob.slice && blob.webkitSlice) {
+            blob.slice = blob.webkitSlice;
+        }
+        return blob;
+    };
+
+    var getPrototypeOf = Object.getPrototypeOf || function(object) {
+            return object.__proto__;
+        };
+    view.Blob.prototype = getPrototypeOf(new view.Blob());
+}(typeof self !== "undefined" && self || typeof window !== "undefined" && window || this.content || this));
diff --git a/demo-shell-ng2/public/js/Polyline.js b/demo-shell-ng2/public/js/Polyline.js
deleted file mode 100644
index 9983929cf1..0000000000
--- a/demo-shell-ng2/public/js/Polyline.js
+++ /dev/null
@@ -1,372 +0,0 @@
-/**
- * Class to generate polyline
- *
- * @author Dmitry Farafonov
- */
- 
-var ANCHOR_TYPE= {
-	main: "main",
-	middle: "middle",
-	first: "first",
-	last: "last"
-};
-
-function Anchor(uuid, type, x, y) {
-	this.uuid = uuid; 
-	this.x = x;
-	this.y = y;
-	this.type = (type == ANCHOR_TYPE.middle) ? ANCHOR_TYPE.middle : ANCHOR_TYPE.main;
-};
-Anchor.prototype = {
-	uuid: null,
-	x: 0,
-	y: 0,
-	type: ANCHOR_TYPE.main,
-	isFirst: false,
-	isLast: false,
-	ndex: 0,
-	typeIndex: 0
-};
-
-function Polyline(uuid, points, strokeWidth, paper) {
-	/* Array on coordinates:
-	 * points: [{x: 410, y: 110}, 1
-	 *			{x: 570, y: 110}, 1 2
-	 *			{x: 620, y: 240},   2 3
-	 *			{x: 750, y: 270},     3 4
-	 *			{x: 650, y: 370}];      4
-	 */
-	this.points = points;
-	
-	/*
-	 * path for graph
-	 * [["M", x1, y1], ["L", x2, y2], ["C", ax, ay, bx, by, x3, y3], ["L", x3, y3]]
-	 */
-	this.path = [];
-	
-	this.anchors = [];
-	
-	if (strokeWidth) this.strokeWidth = strokeWidth;
-	
-	this.paper = paper;
-	
-	this.closePath = false;
-	
-	this.init();
-};
-
-Polyline.prototype = {
-	id: null,
-	points: [],
-	path: [],
-	anchors: [],
-	strokeWidth: 1,
-	radius: 1,
-	showDetails: false,
-	paper: null,
-	element: null,
-	isDefaultConditionAvailable: false,
-	closePath: false,
-	
-	init: function(points){
-		var linesCount = this.getLinesCount();
-		if (linesCount < 1)
-			return;
-			
-		this.normalizeCoordinates();
-		
-		// create anchors
-		
-		this.pushAnchor(ANCHOR_TYPE.first, this.getLine(0).x1, this.getLine(0).y1);
-		
-		for (var i = 1; i < linesCount; i++)
-		{
-			var line1 = this.getLine(i-1);
-			this.pushAnchor(ANCHOR_TYPE.main,  line1.x2, line1.y2);
-		}
-		
-		this.pushAnchor(ANCHOR_TYPE.last, this.getLine(linesCount-1).x2, this.getLine(linesCount-1).y2);
-		
-		this.rebuildPath();
-	},
-	
-	normalizeCoordinates: function(){
-		for(var i=0; i < this.points.length; i++){
-			this.points[i].x = parseFloat(this.points[i].x);
-			this.points[i].y = parseFloat(this.points[i].y);
-		}
-	},
-	
-	getLinesCount: function(){
-		return this.points.length-1;
-	},
-	_getLine: function(i){
-	    if (this.points.length > i && this.points[i]) {
-	        return {x1: this.points[i].x, y1: this.points[i].y, x2: this.points[i+1].x, y2: this.points[i+1].y};
-	    } else {
-	        return undefined;
-	    }
-	},
-	getLine: function(i){
-		var line = this._getLine(i);
-		if (line != undefined) {
-		    line.angle = this.getLineAngle(i);
-		}
-		return line;
-	},
-	getLineAngle: function(i){
-		var line = this._getLine(i);
-		return Math.atan2(line.y2 - line.y1, line.x2 - line.x1);
-	},
-	getLineLengthX: function(i){
-		var line = this.getLine(i);
-		return (line.x2 - line.x1);
-	},
-	getLineLengthY: function(i){
-		var line = this.getLine(i);
-		return (line.y2 - line.y1);
-	},
-	getLineLength: function(i){
-		return Math.sqrt(Math.pow(this.getLineLengthX(i), 2) + Math.pow(this.getLineLengthY(i), 2));
-	},
-	
-	getAnchors: function(){
-		return this.anchors;
-	},
-	getAnchorsCount: function(type){
-		if (!type)
-			return this.anchors.length;
-		else {
-			var count = 0;
-			for(var i=0; i < this.getAnchorsCount(); i++){
-				var anchor = this.anchors[i];
-				if (anchor.getType() == type) {
-					count++;
-				}
-			}
-			return count;
-		}
-	},
-	
-	pushAnchor: function(type, x, y, index){
-		if (type == ANCHOR_TYPE.first) {
-			index = 0;
-			typeIndex = 0;
-		} else if (type == ANCHOR_TYPE.last) {
-			index = this.getAnchorsCount();
-			typeIndex = 0;
-		} else if (!index) {
-			index = this.anchors.length;
-		} else {
-			for(var i=0; i < this.getAnchorsCount(); i++){
-				var anchor = this.anchors[i];
-				if (anchor.index > index) {
-					anchor.index++;
-					anchor.typeIndex++;
-				}
-			}
-		}
-		
-		var anchor = new Anchor(this.id, ANCHOR_TYPE.main, x, y, index, typeIndex);
-		
-		this.anchors.push(anchor);
-	},
-	
-	getAnchor: function(position){
-		return this.anchors[position];
-	},
-	
-	getAnchorByType: function(type, position){
-		if (type == ANCHOR_TYPE.first)
-			return this.anchors[0];
-		if (type == ANCHOR_TYPE.last)
-			return this.anchors[this.getAnchorsCount()-1];
-		
-		for(var i=0; i < this.getAnchorsCount(); i++){
-			var anchor = this.anchors[i];
-			if (anchor.type == type) {
-				if( position == anchor.position)
-					return anchor;
-			}
-		}
-		return null;
-	},
-	
-	addNewPoint: function(position, x, y){
-		// 
-		for(var i = 0; i < this.getLinesCount(); i++){
-			var line = this.getLine(i);
-			if (x > line.x1 && x < line.x2 && y > line.y1 && y < line.y2) {
-				this.points.splice(i+1,0,{x: x, y: y});
-				break;
-			}
-		}
-		
-		this.rebuildPath();
-	},
-	
-	rebuildPath: function(){
-		var path = [];
-		
-		for(var i = 0; i < this.getAnchorsCount(); i++){
-			var anchor = this.getAnchor(i);
-			
-			var pathType = "";
-			if (i == 0)
-				pathType = "M";
-			else 
-				pathType = "L";
-			
-			// TODO: save previous points and calculate new path just if points are updated, and then save currents values as previous
-			
-			var targetX = anchor.x, targetY = anchor.y;
-			if (i>0 && i < this.getAnchorsCount()-1) {
-				// get new x,y
-				var cx = anchor.x, cy = anchor.y;
-				
-				// pivot point of prev line
-				var AO = this.getLineLength(i-1);
-				if (AO < this.radius) {
-					AO = this.radius;
-				}
-				
-				this.isDefaultConditionAvailable = (this.isDefaultConditionAvailable || (i == 1 && AO > 10));
-				
-				var ED = this.getLineLengthY(i-1) * this.radius / AO;
-				var OD = this.getLineLengthX(i-1) * this.radius / AO;
-					targetX = anchor.x - OD;
-					targetY = anchor.y - ED;
-				
-				if (AO < 2*this.radius && i>1) {
-					targetX = anchor.x - this.getLineLengthX(i-1)/2;
-					targetY = anchor.y - this.getLineLengthY(i-1)/2;;
-				}
-					
-				// pivot point of next line
-				var AO = this.getLineLength(i);
-				if (AO < this.radius) {
-					AO = this.radius;
-				}
-				var ED = this.getLineLengthY(i) * this.radius / AO;
-				var OD = this.getLineLengthX(i) * this.radius / AO;
-					var nextSrcX = anchor.x + OD;
-					var nextSrcY = anchor.y + ED;
-					
-				if (AO < 2*this.radius && i<this.getAnchorsCount()-2) {
-					nextSrcX = anchor.x + this.getLineLengthX(i)/2;
-					nextSrcY = anchor.y + this.getLineLengthY(i)/2;;
-				}
-					
-				
-				var dx0 = (cx - targetX) / 3,
-					dy0 = (cy - targetY) / 3,
-					ax = cx - dx0,
-					ay = cy - dy0,
-					
-					dx1 = (cx - nextSrcX) / 3,
-					dy1 = (cy - nextSrcY) / 3,
-					bx = cx - dx1,
-					by = cy - dy1,
-					
-					zx=nextSrcX, zy=nextSrcY;
-					
-			} else if (i==1 && this.getAnchorsCount() == 2){
-				var AO = this.getLineLength(i-1);
-				if (AO < this.radius) {
-					AO = this.radius;
-				}
-				this.isDefaultConditionAvailable = (this.isDefaultConditionAvailable || (i == 1 && AO > 10));
-			}
-
-			// anti smoothing
-			if (this.strokeWidth%2 == 1) {
-				targetX += 0.5;
-				targetY += 0.5;
-			}
-			
-			path.push([pathType, targetX, targetY]);
-			
-			if (i>0 && i < this.getAnchorsCount()-1) {
-				path.push(["C", ax, ay, bx, by, zx, zy]);
-			}
-		}
-		
-		if (this.closePath) 
-		{
-			path.push(["Z"]);
-		}
-		
-		this.path = path;
-	},
-	
-	transform: function(transformation)
-	{
-		this.element.transform(transformation);
-	},
-	attr: function(attrs)
-	{
-		// TODO: foreach and set each
-		this.element.attr(attrs);
-	}
-};
-
-function Polygone(points, strokeWidth) {
-	/* Array on coordinates:
-	 * points: [{x: 410, y: 110}, 1
-	 *			{x: 570, y: 110}, 1 2
-	 *			{x: 620, y: 240},   2 3
-	 *			{x: 750, y: 270},     3 4
-	 *			{x: 650, y: 370}];      4
-	 */
-	this.points = points;
-	
-	/*
-	 * path for graph
-	 * [["M", x1, y1], ["L", x2, y2], ["C", ax, ay, bx, by, x3, y3], ["L", x3, y3]]
-	 */
-	this.path = [];
-	
-	this.anchors = [];
-	
-	if (strokeWidth) this.strokeWidth = strokeWidth;
-	
-	this.closePath = true;
-	this.init();
-};
-
-
-/*
- * Poligone is inherited from Poliline: draws closedPath of polyline
- */
-
-var Foo = function () { };
-Foo.prototype = Polyline.prototype;
-
-Polygone.prototype = new Foo();
-
-Polygone.prototype.rebuildPath = function(){
-	var path = [];
-	for(var i = 0; i < this.getAnchorsCount(); i++){
-		var anchor = this.getAnchor(i);
-		
-		var pathType = "";
-		if (i == 0)
-			pathType = "M";
-		else 
-			pathType = "L";
-		
-		var targetX = anchor.x, targetY = anchor.y;
-		
-		// anti smoothing
-		if (this.strokeWidth%2 == 1) {
-			targetX += 0.5;
-			targetY += 0.5;
-		}
-		
-		path.push([pathType, targetX, targetY]);	
-	}
-	if (this.closePath)
-		path.push(["Z"]);
-	
-	this.path = path;
-};
\ No newline at end of file
diff --git a/demo-shell-ng2/public/js/formdata.js b/demo-shell-ng2/public/js/formdata.js
new file mode 100644
index 0000000000..4eabc4815b
--- /dev/null
+++ b/demo-shell-ng2/public/js/formdata.js
@@ -0,0 +1,37 @@
+/**
+ * Emulate FormData for some browsers
+ * MIT License
+ * (c) 2010 François de Metz
+ */
+(function(w) {
+    if (w.FormData)
+        return;
+    function FormData() {
+        this.fake = true;
+        this.boundary = "--------FormData" + Math.random();
+        this._fields = [];
+    }
+    FormData.prototype.append = function(key, value) {
+        this._fields.push([key, value]);
+    }
+    FormData.prototype.toString = function() {
+        var boundary = this.boundary;
+        var body = "";
+        this._fields.forEach(function(field) {
+            body += "--" + boundary + "\r\n";
+            // file upload
+            if (field[1].name) {
+                var file = field[1];
+                body += "Content-Disposition: form-data; name=\""+ field[0] +"\"; filename=\""+ file.name +"\"\r\n";
+                body += "Content-Type: "+ file.type +"\r\n\r\n";
+                body += file.getAsBinary() + "\r\n";
+            } else {
+                body += "Content-Disposition: form-data; name=\""+ field[0] +"\";\r\n\r\n";
+                body += field[1] + "\r\n";
+            }
+        });
+        body += "--" + boundary +"--";
+        return body;
+    }
+    w.FormData = FormData;
+})(window);
diff --git a/demo-shell-ng2/public/js/promisePolyfill.js b/demo-shell-ng2/public/js/promisePolyfill.js
new file mode 100644
index 0000000000..ef7bf2e267
--- /dev/null
+++ b/demo-shell-ng2/public/js/promisePolyfill.js
@@ -0,0 +1,3 @@
+/* Disable minification (remove `.min` from URL path) for more info */
+
+(function(undefined) {if (!('Symbol' in this && 'iterator' in this.Symbol && !!Array.prototype[Symbol.iterator] && !!Array.prototype.values && (Array.prototype[Symbol.iterator] === Array.prototype.values))) {Object.defineProperty(Array.prototype,"values",{value:Array.prototype[Symbol.iterator],enumerable:!1,writable:!1});}if (!('contains' in String.prototype)) {String.prototype.contains=String.prototype.includes;}var ArrayIterator=function(){var e=function(){var e=function(){return this.length=0,this},t=function(e){if("function"!=typeof e)throw new TypeError(e+" is not a function");return e},_=function(e,n){return this instanceof _?(Object.defineProperties(this,{__list__:{writable:!0,value:e},__context__:{writable:!0,value:n},__nextIndex__:{writable:!0,value:0}}),void(n&&(t(n.on),n.on("_add",this._onAdd.bind(this)),n.on("_delete",this._onDelete.bind(this)),n.on("_clear",this._onClear.bind(this))))):new _(e,n)};return Object.defineProperties(_.prototype,Object.assign({constructor:{value:_,configurable:!0,enumerable:!1,writable:!0},_next:{value:function(){var e;if(this.__list__)return this.__redo__&&(e=this.__redo__.shift(),void 0!==e)?e:this.__nextIndex__<this.__list__.length?this.__nextIndex__++:void this._unBind()},configurable:!0,enumerable:!1,writable:!0},next:{value:function(){return this._createResult(this._next())},configurable:!0,enumerable:!1,writable:!0},_createResult:{value:function(e){return void 0===e?{done:!0,value:void 0}:{done:!1,value:this._resolve(e)}},configurable:!0,enumerable:!1,writable:!0},_resolve:{value:function(e){return this.__list__[e]},configurable:!0,enumerable:!1,writable:!0},_unBind:{value:function(){this.__list__=null,delete this.__redo__,this.__context__&&(this.__context__.off("_add",this._onAdd.bind(this)),this.__context__.off("_delete",this._onDelete.bind(this)),this.__context__.off("_clear",this._onClear.bind(this)),this.__context__=null)},configurable:!0,enumerable:!1,writable:!0},toString:{value:function(){return"[object Iterator]"},configurable:!0,enumerable:!1,writable:!0}},{_onAdd:{value:function(e){if(!(e>=this.__nextIndex__)){if(++this.__nextIndex__,!this.__redo__)return void Object.defineProperty(this,"__redo__",{value:[e],configurable:!0,enumerable:!1,writable:!1});this.__redo__.forEach(function(t,_){t>=e&&(this.__redo__[_]=++t)},this),this.__redo__.push(e)}},configurable:!0,enumerable:!1,writable:!0},_onDelete:{value:function(e){var t;e>=this.__nextIndex__||(--this.__nextIndex__,this.__redo__&&(t=this.__redo__.indexOf(e),t!==-1&&this.__redo__.splice(t,1),this.__redo__.forEach(function(t,_){t>e&&(this.__redo__[_]=--t)},this)))},configurable:!0,enumerable:!1,writable:!0},_onClear:{value:function(){this.__redo__&&e.call(this.__redo__),this.__nextIndex__=0},configurable:!0,enumerable:!1,writable:!0}})),Object.defineProperty(_.prototype,Symbol.iterator,{value:function(){return this},configurable:!0,enumerable:!1,writable:!0}),Object.defineProperty(_.prototype,Symbol.toStringTag,{value:"Iterator",configurable:!1,enumerable:!1,writable:!1}),_}(),t=function(_,n){return this instanceof t?(e.call(this,_),n=n?String.prototype.contains.call(n,"key+value")?"key+value":String.prototype.contains.call(n,"key")?"key":"value":"value",void Object.defineProperty(this,"__kind__",{value:n,configurable:!1,enumerable:!1,writable:!1})):new t(_,n)};return Object.setPrototypeOf&&Object.setPrototypeOf(t,e.prototype),t.prototype=Object.create(e.prototype,{constructor:{value:t,configurable:!0,enumerable:!1,writable:!0},_resolve:{value:function(e){return"value"===this.__kind__?this.__list__[e]:"key+value"===this.__kind__?[e,this.__list__[e]]:e},configurable:!0,enumerable:!1,writable:!0},toString:{value:function(){return"[object Array Iterator]"},configurable:!0,enumerable:!1,writable:!0}}),t}();}).call('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof global && global || {});
diff --git a/demo-shell-ng2/public/js/typedarray.js b/demo-shell-ng2/public/js/typedarray.js
new file mode 100644
index 0000000000..3d9fafd437
--- /dev/null
+++ b/demo-shell-ng2/public/js/typedarray.js
@@ -0,0 +1,1048 @@
+/*
+ Copyright (c) 2010, Linden Research, Inc.
+ Copyright (c) 2014, Joshua Bell
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ $/LicenseInfo$
+ */
+
+// Original can be found at:
+//   https://bitbucket.org/lindenlab/llsd
+// Modifications by Joshua Bell inexorabletash@gmail.com
+//   https://github.com/inexorabletash/polyfill
+
+// ES3/ES5 implementation of the Krhonos Typed Array Specification
+//   Ref: http://www.khronos.org/registry/typedarray/specs/latest/
+//   Date: 2011-02-01
+//
+// Variations:
+//  * Allows typed_array.get/set() as alias for subscripts (typed_array[])
+//  * Gradually migrating structure from Khronos spec to ES2015 spec
+//
+// Caveats:
+//  * Beyond 10000 or so entries, polyfilled array accessors (ta[0],
+//    etc) become memory-prohibitive, so array creation will fail. Set
+//    self.TYPED_ARRAY_POLYFILL_NO_ARRAY_ACCESSORS=true to disable
+//    creation of accessors. Your code will need to use the
+//    non-standard get()/set() instead, and will need to add those to
+//    native arrays for interop.
+(function(global) {
+    'use strict';
+    var undefined = (void 0); // Paranoia
+
+    // Beyond this value, index getters/setters (i.e. array[0], array[1]) are so slow to
+    // create, and consume so much memory, that the browser appears frozen.
+    var MAX_ARRAY_LENGTH = 1e5;
+
+    // Approximations of internal ECMAScript conversion functions
+    function Type(v) {
+        switch(typeof v) {
+            case 'undefined': return 'undefined';
+            case 'boolean': return 'boolean';
+            case 'number': return 'number';
+            case 'string': return 'string';
+            default: return v === null ? 'null' : 'object';
+        }
+    }
+
+    // Class returns internal [[Class]] property, used to avoid cross-frame instanceof issues:
+    function Class(v) { return Object.prototype.toString.call(v).replace(/^\[object *|\]$/g, ''); }
+    function IsCallable(o) { return typeof o === 'function'; }
+    function ToObject(v) {
+        if (v === null || v === undefined) throw TypeError();
+        return Object(v);
+    }
+    function ToInt32(v) { return v >> 0; }
+    function ToUint32(v) { return v >>> 0; }
+
+    // Snapshot intrinsics
+    var LN2 = Math.LN2,
+        abs = Math.abs,
+        floor = Math.floor,
+        log = Math.log,
+        max = Math.max,
+        min = Math.min,
+        pow = Math.pow,
+        round = Math.round;
+
+    // emulate ES5 getter/setter API using legacy APIs
+    // http://blogs.msdn.com/b/ie/archive/2010/09/07/transitioning-existing-code-to-the-es5-getter-setter-apis.aspx
+    // (second clause tests for Object.defineProperty() in IE<9 that only supports extending DOM prototypes, but
+    // note that IE<9 does not support __defineGetter__ or __defineSetter__ so it just renders the method harmless)
+
+    (function() {
+        var orig = Object.defineProperty;
+        var dom_only = !(function(){try{return Object.defineProperty({},'x',{});}catch(_){return false;}}());
+
+        if (!orig || dom_only) {
+            Object.defineProperty = function (o, prop, desc) {
+                // In IE8 try built-in implementation for defining properties on DOM prototypes.
+                if (orig)
+                    try { return orig(o, prop, desc); } catch (_) {}
+                if (o !== Object(o))
+                    throw TypeError('Object.defineProperty called on non-object');
+                if (Object.prototype.__defineGetter__ && ('get' in desc))
+                    Object.prototype.__defineGetter__.call(o, prop, desc.get);
+                if (Object.prototype.__defineSetter__ && ('set' in desc))
+                    Object.prototype.__defineSetter__.call(o, prop, desc.set);
+                if ('value' in desc)
+                    o[prop] = desc.value;
+                return o;
+            };
+        }
+    }());
+
+    // ES5: Make obj[index] an alias for obj._getter(index)/obj._setter(index, value)
+    // for index in 0 ... obj.length
+    function makeArrayAccessors(obj) {
+        if ('TYPED_ARRAY_POLYFILL_NO_ARRAY_ACCESSORS' in global)
+            return;
+
+        if (obj.length > MAX_ARRAY_LENGTH) throw RangeError('Array too large for polyfill');
+
+        function makeArrayAccessor(index) {
+            Object.defineProperty(obj, index, {
+                'get': function() { return obj._getter(index); },
+                'set': function(v) { obj._setter(index, v); },
+                enumerable: true,
+                configurable: false
+            });
+        }
+
+        var i;
+        for (i = 0; i < obj.length; i += 1) {
+            makeArrayAccessor(i);
+        }
+    }
+
+    // Internal conversion functions:
+    //    pack<Type>()   - take a number (interpreted as Type), output a byte array
+    //    unpack<Type>() - take a byte array, output a Type-like number
+
+    function as_signed(value, bits) { var s = 32 - bits; return (value << s) >> s; }
+    function as_unsigned(value, bits) { var s = 32 - bits; return (value << s) >>> s; }
+
+    function packI8(n) { return [n & 0xff]; }
+    function unpackI8(bytes) { return as_signed(bytes[0], 8); }
+
+    function packU8(n) { return [n & 0xff]; }
+    function unpackU8(bytes) { return as_unsigned(bytes[0], 8); }
+
+    function packU8Clamped(n) { n = round(Number(n)); return [n < 0 ? 0 : n > 0xff ? 0xff : n & 0xff]; }
+
+    function packI16(n) { return [n & 0xff, (n >> 8) & 0xff]; }
+    function unpackI16(bytes) { return as_signed(bytes[1] << 8 | bytes[0], 16); }
+
+    function packU16(n) { return [n & 0xff, (n >> 8) & 0xff]; }
+    function unpackU16(bytes) { return as_unsigned(bytes[1] << 8 | bytes[0], 16); }
+
+    function packI32(n) { return [n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (n >> 24) & 0xff]; }
+    function unpackI32(bytes) { return as_signed(bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0], 32); }
+
+    function packU32(n) { return [n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (n >> 24) & 0xff]; }
+    function unpackU32(bytes) { return as_unsigned(bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0], 32); }
+
+    function packIEEE754(v, ebits, fbits) {
+
+        var bias = (1 << (ebits - 1)) - 1;
+
+        function roundToEven(n) {
+            var w = floor(n), f = n - w;
+            if (f < 0.5)
+                return w;
+            if (f > 0.5)
+                return w + 1;
+            return w % 2 ? w + 1 : w;
+        }
+
+        // Compute sign, exponent, fraction
+        var s, e, f;
+        if (v !== v) {
+            // NaN
+            // http://dev.w3.org/2006/webapi/WebIDL/#es-type-mapping
+            e = (1 << ebits) - 1; f = pow(2, fbits - 1); s = 0;
+        } else if (v === Infinity || v === -Infinity) {
+            e = (1 << ebits) - 1; f = 0; s = (v < 0) ? 1 : 0;
+        } else if (v === 0) {
+            e = 0; f = 0; s = (1 / v === -Infinity) ? 1 : 0;
+        } else {
+            s = v < 0;
+            v = abs(v);
+
+            if (v >= pow(2, 1 - bias)) {
+                // Normalized
+                e = min(floor(log(v) / LN2), 1023);
+                var significand = v / pow(2, e);
+                if (significand < 1) {
+                    e -= 1;
+                    significand *= 2;
+                }
+                if (significand >= 2) {
+                    e += 1;
+                    significand /= 2;
+                }
+                var d = pow(2, fbits);
+                f = roundToEven(significand * d) - d;
+                e += bias;
+                if (f / d >= 1) {
+                    e += 1;
+                    f = 0;
+                }
+                if (e > 2 * bias) {
+                    // Overflow
+                    e = (1 << ebits) - 1;
+                    f = 0;
+                }
+            } else {
+                // Denormalized
+                e = 0;
+                f = roundToEven(v / pow(2, 1 - bias - fbits));
+            }
+        }
+
+        // Pack sign, exponent, fraction
+        var bits = [], i;
+        for (i = fbits; i; i -= 1) { bits.push(f % 2 ? 1 : 0); f = floor(f / 2); }
+        for (i = ebits; i; i -= 1) { bits.push(e % 2 ? 1 : 0); e = floor(e / 2); }
+        bits.push(s ? 1 : 0);
+        bits.reverse();
+        var str = bits.join('');
+
+        // Bits to bytes
+        var bytes = [];
+        while (str.length) {
+            bytes.unshift(parseInt(str.substring(0, 8), 2));
+            str = str.substring(8);
+        }
+        return bytes;
+    }
+
+    function unpackIEEE754(bytes, ebits, fbits) {
+        // Bytes to bits
+        var bits = [], i, j, b, str,
+            bias, s, e, f;
+
+        for (i = 0; i < bytes.length; ++i) {
+            b = bytes[i];
+            for (j = 8; j; j -= 1) {
+                bits.push(b % 2 ? 1 : 0); b = b >> 1;
+            }
+        }
+        bits.reverse();
+        str = bits.join('');
+
+        // Unpack sign, exponent, fraction
+        bias = (1 << (ebits - 1)) - 1;
+        s = parseInt(str.substring(0, 1), 2) ? -1 : 1;
+        e = parseInt(str.substring(1, 1 + ebits), 2);
+        f = parseInt(str.substring(1 + ebits), 2);
+
+        // Produce number
+        if (e === (1 << ebits) - 1) {
+            return f !== 0 ? NaN : s * Infinity;
+        } else if (e > 0) {
+            // Normalized
+            return s * pow(2, e - bias) * (1 + f / pow(2, fbits));
+        } else if (f !== 0) {
+            // Denormalized
+            return s * pow(2, -(bias - 1)) * (f / pow(2, fbits));
+        } else {
+            return s < 0 ? -0 : 0;
+        }
+    }
+
+    function unpackF64(b) { return unpackIEEE754(b, 11, 52); }
+    function packF64(v) { return packIEEE754(v, 11, 52); }
+    function unpackF32(b) { return unpackIEEE754(b, 8, 23); }
+    function packF32(v) { return packIEEE754(v, 8, 23); }
+
+    //
+    // 3 The ArrayBuffer Type
+    //
+
+    (function() {
+
+        function ArrayBuffer(length) {
+            length = ToInt32(length);
+            if (length < 0) throw RangeError('ArrayBuffer size is not a small enough positive integer.');
+            Object.defineProperty(this, 'byteLength', {value: length});
+            Object.defineProperty(this, '_bytes', {value: Array(length)});
+
+            for (var i = 0; i < length; i += 1)
+                this._bytes[i] = 0;
+        }
+
+        global.ArrayBuffer = global.ArrayBuffer || ArrayBuffer;
+
+        //
+        // 5 The Typed Array View Types
+        //
+
+        function $TypedArray$() {
+
+            // %TypedArray% ( length )
+            if (!arguments.length || typeof arguments[0] !== 'object') {
+                return (function(length) {
+                    length = ToInt32(length);
+                    if (length < 0) throw RangeError('length is not a small enough positive integer.');
+                    Object.defineProperty(this, 'length', {value: length});
+                    Object.defineProperty(this, 'byteLength', {value: length * this.BYTES_PER_ELEMENT});
+                    Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(this.byteLength)});
+                    Object.defineProperty(this, 'byteOffset', {value: 0});
+
+                }).apply(this, arguments);
+            }
+
+            // %TypedArray% ( typedArray )
+            if (arguments.length >= 1 &&
+                Type(arguments[0]) === 'object' &&
+                arguments[0] instanceof $TypedArray$) {
+                return (function(typedArray){
+                    if (this.constructor !== typedArray.constructor) throw TypeError();
+
+                    var byteLength = typedArray.length * this.BYTES_PER_ELEMENT;
+                    Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(byteLength)});
+                    Object.defineProperty(this, 'byteLength', {value: byteLength});
+                    Object.defineProperty(this, 'byteOffset', {value: 0});
+                    Object.defineProperty(this, 'length', {value: typedArray.length});
+
+                    for (var i = 0; i < this.length; i += 1)
+                        this._setter(i, typedArray._getter(i));
+
+                }).apply(this, arguments);
+            }
+
+            // %TypedArray% ( array )
+            if (arguments.length >= 1 &&
+                Type(arguments[0]) === 'object' &&
+                !(arguments[0] instanceof $TypedArray$) &&
+                !(arguments[0] instanceof ArrayBuffer || Class(arguments[0]) === 'ArrayBuffer')) {
+                return (function(array) {
+
+                    var byteLength = array.length * this.BYTES_PER_ELEMENT;
+                    Object.defineProperty(this, 'buffer', {value: new ArrayBuffer(byteLength)});
+                    Object.defineProperty(this, 'byteLength', {value: byteLength});
+                    Object.defineProperty(this, 'byteOffset', {value: 0});
+                    Object.defineProperty(this, 'length', {value: array.length});
+
+                    for (var i = 0; i < this.length; i += 1) {
+                        var s = array[i];
+                        this._setter(i, Number(s));
+                    }
+                }).apply(this, arguments);
+            }
+
+            // %TypedArray% ( buffer, byteOffset=0, length=undefined )
+            if (arguments.length >= 1 &&
+                Type(arguments[0]) === 'object' &&
+                (arguments[0] instanceof ArrayBuffer || Class(arguments[0]) === 'ArrayBuffer')) {
+                return (function(buffer, byteOffset, length) {
+
+                    byteOffset = ToUint32(byteOffset);
+                    if (byteOffset > buffer.byteLength)
+                        throw RangeError('byteOffset out of range');
+
+                    // The given byteOffset must be a multiple of the element
+                    // size of the specific type, otherwise an exception is raised.
+                    if (byteOffset % this.BYTES_PER_ELEMENT)
+                        throw RangeError('buffer length minus the byteOffset is not a multiple of the element size.');
+
+                    if (length === undefined) {
+                        var byteLength = buffer.byteLength - byteOffset;
+                        if (byteLength % this.BYTES_PER_ELEMENT)
+                            throw RangeError('length of buffer minus byteOffset not a multiple of the element size');
+                        length = byteLength / this.BYTES_PER_ELEMENT;
+
+                    } else {
+                        length = ToUint32(length);
+                        byteLength = length * this.BYTES_PER_ELEMENT;
+                    }
+
+                    if ((byteOffset + byteLength) > buffer.byteLength)
+                        throw RangeError('byteOffset and length reference an area beyond the end of the buffer');
+
+                    Object.defineProperty(this, 'buffer', {value: buffer});
+                    Object.defineProperty(this, 'byteLength', {value: byteLength});
+                    Object.defineProperty(this, 'byteOffset', {value: byteOffset});
+                    Object.defineProperty(this, 'length', {value: length});
+
+                }).apply(this, arguments);
+            }
+
+            // %TypedArray% ( all other argument combinations )
+            throw TypeError();
+        }
+
+        // Properties of the %TypedArray Instrinsic Object
+
+        // %TypedArray%.from ( source , mapfn=undefined, thisArg=undefined )
+        Object.defineProperty($TypedArray$, 'from', {value: function(iterable) {
+            return new this(iterable);
+        }});
+
+        // %TypedArray%.of ( ...items )
+        Object.defineProperty($TypedArray$, 'of', {value: function(/*...items*/) {
+            return new this(arguments);
+        }});
+
+        // %TypedArray%.prototype
+        var $TypedArrayPrototype$ = {};
+        $TypedArray$.prototype = $TypedArrayPrototype$;
+
+        // WebIDL: getter type (unsigned long index);
+        Object.defineProperty($TypedArray$.prototype, '_getter', {value: function(index) {
+            if (arguments.length < 1) throw SyntaxError('Not enough arguments');
+
+            index = ToUint32(index);
+            if (index >= this.length)
+                return undefined;
+
+            var bytes = [], i, o;
+            for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT;
+                 i < this.BYTES_PER_ELEMENT;
+                 i += 1, o += 1) {
+                bytes.push(this.buffer._bytes[o]);
+            }
+            return this._unpack(bytes);
+        }});
+
+        // NONSTANDARD: convenience alias for getter: type get(unsigned long index);
+        Object.defineProperty($TypedArray$.prototype, 'get', {value: $TypedArray$.prototype._getter});
+
+        // WebIDL: setter void (unsigned long index, type value);
+        Object.defineProperty($TypedArray$.prototype, '_setter', {value: function(index, value) {
+            if (arguments.length < 2) throw SyntaxError('Not enough arguments');
+
+            index = ToUint32(index);
+            if (index >= this.length)
+                return;
+
+            var bytes = this._pack(value), i, o;
+            for (i = 0, o = this.byteOffset + index * this.BYTES_PER_ELEMENT;
+                 i < this.BYTES_PER_ELEMENT;
+                 i += 1, o += 1) {
+                this.buffer._bytes[o] = bytes[i];
+            }
+        }});
+
+        // get %TypedArray%.prototype.buffer
+        // get %TypedArray%.prototype.byteLength
+        // get %TypedArray%.prototype.byteOffset
+        // -- applied directly to the object in the constructor
+
+        // %TypedArray%.prototype.constructor
+        Object.defineProperty($TypedArray$.prototype, 'constructor', {value: $TypedArray$});
+
+        // %TypedArray%.prototype.copyWithin (target, start, end = this.length )
+        Object.defineProperty($TypedArray$.prototype, 'copyWithin', {value: function(target, start) {
+            var end = arguments[2];
+
+            var o = ToObject(this);
+            var lenVal = o.length;
+            var len = ToUint32(lenVal);
+            len = max(len, 0);
+            var relativeTarget = ToInt32(target);
+            var to;
+            if (relativeTarget < 0)
+                to = max(len + relativeTarget, 0);
+            else
+                to = min(relativeTarget, len);
+            var relativeStart = ToInt32(start);
+            var from;
+            if (relativeStart < 0)
+                from = max(len + relativeStart, 0);
+            else
+                from = min(relativeStart, len);
+            var relativeEnd;
+            if (end === undefined)
+                relativeEnd = len;
+            else
+                relativeEnd = ToInt32(end);
+            var final;
+            if (relativeEnd < 0)
+                final = max(len + relativeEnd, 0);
+            else
+                final = min(relativeEnd, len);
+            var count = min(final - from, len - to);
+            var direction;
+            if (from < to && to < from + count) {
+                direction = -1;
+                from = from + count - 1;
+                to = to + count - 1;
+            } else {
+                direction = 1;
+            }
+            while (count > 0) {
+                o._setter(to, o._getter(from));
+                from = from + direction;
+                to = to + direction;
+                count = count - 1;
+            }
+            return o;
+        }});
+
+        // %TypedArray%.prototype.entries ( )
+        // -- defined in es6.js to shim browsers w/ native TypedArrays
+
+        // %TypedArray%.prototype.every ( callbackfn, thisArg = undefined )
+        Object.defineProperty($TypedArray$.prototype, 'every', {value: function(callbackfn) {
+            if (this === undefined || this === null) throw TypeError();
+            var t = Object(this);
+            var len = ToUint32(t.length);
+            if (!IsCallable(callbackfn)) throw TypeError();
+            var thisArg = arguments[1];
+            for (var i = 0; i < len; i++) {
+                if (!callbackfn.call(thisArg, t._getter(i), i, t))
+                    return false;
+            }
+            return true;
+        }});
+
+        // %TypedArray%.prototype.fill (value, start = 0, end = this.length )
+        Object.defineProperty($TypedArray$.prototype, 'fill', {value: function(value) {
+            var start = arguments[1],
+                end = arguments[2];
+
+            var o = ToObject(this);
+            var lenVal = o.length;
+            var len = ToUint32(lenVal);
+            len = max(len, 0);
+            var relativeStart = ToInt32(start);
+            var k;
+            if (relativeStart < 0)
+                k = max((len + relativeStart), 0);
+            else
+                k = min(relativeStart, len);
+            var relativeEnd;
+            if (end === undefined)
+                relativeEnd = len;
+            else
+                relativeEnd = ToInt32(end);
+            var final;
+            if (relativeEnd < 0)
+                final = max((len + relativeEnd), 0);
+            else
+                final = min(relativeEnd, len);
+            while (k < final) {
+                o._setter(k, value);
+                k += 1;
+            }
+            return o;
+        }});
+
+        // %TypedArray%.prototype.filter ( callbackfn, thisArg = undefined )
+        Object.defineProperty($TypedArray$.prototype, 'filter', {value: function(callbackfn) {
+            if (this === undefined || this === null) throw TypeError();
+            var t = Object(this);
+            var len = ToUint32(t.length);
+            if (!IsCallable(callbackfn)) throw TypeError();
+            var res = [];
+            var thisp = arguments[1];
+            for (var i = 0; i < len; i++) {
+                var val = t._getter(i); // in case fun mutates this
+                if (callbackfn.call(thisp, val, i, t))
+                    res.push(val);
+            }
+            return new this.constructor(res);
+        }});
+
+        // %TypedArray%.prototype.find (predicate, thisArg = undefined)
+        Object.defineProperty($TypedArray$.prototype, 'find', {value: function(predicate) {
+            var o = ToObject(this);
+            var lenValue = o.length;
+            var len = ToUint32(lenValue);
+            if (!IsCallable(predicate)) throw TypeError();
+            var t = arguments.length > 1 ? arguments[1] : undefined;
+            var k = 0;
+            while (k < len) {
+                var kValue = o._getter(k);
+                var testResult = predicate.call(t, kValue, k, o);
+                if (Boolean(testResult))
+                    return kValue;
+                ++k;
+            }
+            return undefined;
+        }});
+
+        // %TypedArray%.prototype.findIndex ( predicate, thisArg = undefined )
+        Object.defineProperty($TypedArray$.prototype, 'findIndex', {value: function(predicate) {
+            var o = ToObject(this);
+            var lenValue = o.length;
+            var len = ToUint32(lenValue);
+            if (!IsCallable(predicate)) throw TypeError();
+            var t = arguments.length > 1 ? arguments[1] : undefined;
+            var k = 0;
+            while (k < len) {
+                var kValue = o._getter(k);
+                var testResult = predicate.call(t, kValue, k, o);
+                if (Boolean(testResult))
+                    return k;
+                ++k;
+            }
+            return -1;
+        }});
+
+        // %TypedArray%.prototype.forEach ( callbackfn, thisArg = undefined )
+        Object.defineProperty($TypedArray$.prototype, 'forEach', {value: function(callbackfn) {
+            if (this === undefined || this === null) throw TypeError();
+            var t = Object(this);
+            var len = ToUint32(t.length);
+            if (!IsCallable(callbackfn)) throw TypeError();
+            var thisp = arguments[1];
+            for (var i = 0; i < len; i++)
+                callbackfn.call(thisp, t._getter(i), i, t);
+        }});
+
+        // %TypedArray%.prototype.indexOf (searchElement, fromIndex = 0 )
+        Object.defineProperty($TypedArray$.prototype, 'indexOf', {value: function(searchElement) {
+            if (this === undefined || this === null) throw TypeError();
+            var t = Object(this);
+            var len = ToUint32(t.length);
+            if (len === 0) return -1;
+            var n = 0;
+            if (arguments.length > 0) {
+                n = Number(arguments[1]);
+                if (n !== n) {
+                    n = 0;
+                } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) {
+                    n = (n > 0 || -1) * floor(abs(n));
+                }
+            }
+            if (n >= len) return -1;
+            var k = n >= 0 ? n : max(len - abs(n), 0);
+            for (; k < len; k++) {
+                if (t._getter(k) === searchElement) {
+                    return k;
+                }
+            }
+            return -1;
+        }});
+
+        // %TypedArray%.prototype.join ( separator )
+        Object.defineProperty($TypedArray$.prototype, 'join', {value: function(separator) {
+            if (this === undefined || this === null) throw TypeError();
+            var t = Object(this);
+            var len = ToUint32(t.length);
+            var tmp = Array(len);
+            for (var i = 0; i < len; ++i)
+                tmp[i] = t._getter(i);
+            return tmp.join(separator === undefined ? ',' : separator); // Hack for IE7
+        }});
+
+        // %TypedArray%.prototype.keys ( )
+        // -- defined in es6.js to shim browsers w/ native TypedArrays
+
+        // %TypedArray%.prototype.lastIndexOf ( searchElement, fromIndex = this.length-1 )
+        Object.defineProperty($TypedArray$.prototype, 'lastIndexOf', {value: function(searchElement) {
+            if (this === undefined || this === null) throw TypeError();
+            var t = Object(this);
+            var len = ToUint32(t.length);
+            if (len === 0) return -1;
+            var n = len;
+            if (arguments.length > 1) {
+                n = Number(arguments[1]);
+                if (n !== n) {
+                    n = 0;
+                } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) {
+                    n = (n > 0 || -1) * floor(abs(n));
+                }
+            }
+            var k = n >= 0 ? min(n, len - 1) : len - abs(n);
+            for (; k >= 0; k--) {
+                if (t._getter(k) === searchElement)
+                    return k;
+            }
+            return -1;
+        }});
+
+        // get %TypedArray%.prototype.length
+        // -- applied directly to the object in the constructor
+
+        // %TypedArray%.prototype.map ( callbackfn, thisArg = undefined )
+        Object.defineProperty($TypedArray$.prototype, 'map', {value: function(callbackfn) {
+            if (this === undefined || this === null) throw TypeError();
+            var t = Object(this);
+            var len = ToUint32(t.length);
+            if (!IsCallable(callbackfn)) throw TypeError();
+            var res = []; res.length = len;
+            var thisp = arguments[1];
+            for (var i = 0; i < len; i++)
+                res[i] = callbackfn.call(thisp, t._getter(i), i, t);
+            return new this.constructor(res);
+        }});
+
+        // %TypedArray%.prototype.reduce ( callbackfn [, initialValue] )
+        Object.defineProperty($TypedArray$.prototype, 'reduce', {value: function(callbackfn) {
+            if (this === undefined || this === null) throw TypeError();
+            var t = Object(this);
+            var len = ToUint32(t.length);
+            if (!IsCallable(callbackfn)) throw TypeError();
+            // no value to return if no initial value and an empty array
+            if (len === 0 && arguments.length === 1) throw TypeError();
+            var k = 0;
+            var accumulator;
+            if (arguments.length >= 2) {
+                accumulator = arguments[1];
+            } else {
+                accumulator = t._getter(k++);
+            }
+            while (k < len) {
+                accumulator = callbackfn.call(undefined, accumulator, t._getter(k), k, t);
+                k++;
+            }
+            return accumulator;
+        }});
+
+        // %TypedArray%.prototype.reduceRight ( callbackfn [, initialValue] )
+        Object.defineProperty($TypedArray$.prototype, 'reduceRight', {value: function(callbackfn) {
+            if (this === undefined || this === null) throw TypeError();
+            var t = Object(this);
+            var len = ToUint32(t.length);
+            if (!IsCallable(callbackfn)) throw TypeError();
+            // no value to return if no initial value, empty array
+            if (len === 0 && arguments.length === 1) throw TypeError();
+            var k = len - 1;
+            var accumulator;
+            if (arguments.length >= 2) {
+                accumulator = arguments[1];
+            } else {
+                accumulator = t._getter(k--);
+            }
+            while (k >= 0) {
+                accumulator = callbackfn.call(undefined, accumulator, t._getter(k), k, t);
+                k--;
+            }
+            return accumulator;
+        }});
+
+        // %TypedArray%.prototype.reverse ( )
+        Object.defineProperty($TypedArray$.prototype, 'reverse', {value: function() {
+            if (this === undefined || this === null) throw TypeError();
+            var t = Object(this);
+            var len = ToUint32(t.length);
+            var half = floor(len / 2);
+            for (var i = 0, j = len - 1; i < half; ++i, --j) {
+                var tmp = t._getter(i);
+                t._setter(i, t._getter(j));
+                t._setter(j, tmp);
+            }
+            return t;
+        }});
+
+        // %TypedArray%.prototype.set(array, offset = 0 )
+        // %TypedArray%.prototype.set(typedArray, offset = 0 )
+        // WebIDL: void set(TypedArray array, optional unsigned long offset);
+        // WebIDL: void set(sequence<type> array, optional unsigned long offset);
+        Object.defineProperty($TypedArray$.prototype, 'set', {value: function(index, value) {
+            if (arguments.length < 1) throw SyntaxError('Not enough arguments');
+            var array, sequence, offset, len,
+                i, s, d,
+                byteOffset, byteLength, tmp;
+
+            if (typeof arguments[0] === 'object' && arguments[0].constructor === this.constructor) {
+                // void set(TypedArray array, optional unsigned long offset);
+                array = arguments[0];
+                offset = ToUint32(arguments[1]);
+
+                if (offset + array.length > this.length) {
+                    throw RangeError('Offset plus length of array is out of range');
+                }
+
+                byteOffset = this.byteOffset + offset * this.BYTES_PER_ELEMENT;
+                byteLength = array.length * this.BYTES_PER_ELEMENT;
+
+                if (array.buffer === this.buffer) {
+                    tmp = [];
+                    for (i = 0, s = array.byteOffset; i < byteLength; i += 1, s += 1) {
+                        tmp[i] = array.buffer._bytes[s];
+                    }
+                    for (i = 0, d = byteOffset; i < byteLength; i += 1, d += 1) {
+                        this.buffer._bytes[d] = tmp[i];
+                    }
+                } else {
+                    for (i = 0, s = array.byteOffset, d = byteOffset;
+                         i < byteLength; i += 1, s += 1, d += 1) {
+                        this.buffer._bytes[d] = array.buffer._bytes[s];
+                    }
+                }
+            } else if (typeof arguments[0] === 'object' && typeof arguments[0].length !== 'undefined') {
+                // void set(sequence<type> array, optional unsigned long offset);
+                sequence = arguments[0];
+                len = ToUint32(sequence.length);
+                offset = ToUint32(arguments[1]);
+
+                if (offset + len > this.length) {
+                    throw RangeError('Offset plus length of array is out of range');
+                }
+
+                for (i = 0; i < len; i += 1) {
+                    s = sequence[i];
+                    this._setter(offset + i, Number(s));
+                }
+            } else {
+                throw TypeError('Unexpected argument type(s)');
+            }
+        }});
+
+        // %TypedArray%.prototype.slice ( start, end )
+        Object.defineProperty($TypedArray$.prototype, 'slice', {value: function(start, end) {
+            var o = ToObject(this);
+            var lenVal = o.length;
+            var len = ToUint32(lenVal);
+            var relativeStart = ToInt32(start);
+            var k = (relativeStart < 0) ? max(len + relativeStart, 0) : min(relativeStart, len);
+            var relativeEnd = (end === undefined) ? len : ToInt32(end);
+            var final = (relativeEnd < 0) ? max(len + relativeEnd, 0) : min(relativeEnd, len);
+            var count = final - k;
+            var c = o.constructor;
+            var a = new c(count);
+            var n = 0;
+            while (k < final) {
+                var kValue = o._getter(k);
+                a._setter(n, kValue);
+                ++k;
+                ++n;
+            }
+            return a;
+        }});
+
+        // %TypedArray%.prototype.some ( callbackfn, thisArg = undefined )
+        Object.defineProperty($TypedArray$.prototype, 'some', {value: function(callbackfn) {
+            if (this === undefined || this === null) throw TypeError();
+            var t = Object(this);
+            var len = ToUint32(t.length);
+            if (!IsCallable(callbackfn)) throw TypeError();
+            var thisp = arguments[1];
+            for (var i = 0; i < len; i++) {
+                if (callbackfn.call(thisp, t._getter(i), i, t)) {
+                    return true;
+                }
+            }
+            return false;
+        }});
+
+        // %TypedArray%.prototype.sort ( comparefn )
+        Object.defineProperty($TypedArray$.prototype, 'sort', {value: function(comparefn) {
+            if (this === undefined || this === null) throw TypeError();
+            var t = Object(this);
+            var len = ToUint32(t.length);
+            var tmp = Array(len);
+            for (var i = 0; i < len; ++i)
+                tmp[i] = t._getter(i);
+            if (comparefn) tmp.sort(comparefn); else tmp.sort(); // Hack for IE8/9
+            for (i = 0; i < len; ++i)
+                t._setter(i, tmp[i]);
+            return t;
+        }});
+
+        // %TypedArray%.prototype.subarray(begin = 0, end = this.length )
+        // WebIDL: TypedArray subarray(long begin, optional long end);
+        Object.defineProperty($TypedArray$.prototype, 'subarray', {value: function(start, end) {
+            function clamp(v, min, max) { return v < min ? min : v > max ? max : v; }
+
+            start = ToInt32(start);
+            end = ToInt32(end);
+
+            if (arguments.length < 1) { start = 0; }
+            if (arguments.length < 2) { end = this.length; }
+
+            if (start < 0) { start = this.length + start; }
+            if (end < 0) { end = this.length + end; }
+
+            start = clamp(start, 0, this.length);
+            end = clamp(end, 0, this.length);
+
+            var len = end - start;
+            if (len < 0) {
+                len = 0;
+            }
+
+            return new this.constructor(
+                this.buffer, this.byteOffset + start * this.BYTES_PER_ELEMENT, len);
+        }});
+
+        // %TypedArray%.prototype.toLocaleString ( )
+        // %TypedArray%.prototype.toString ( )
+        // %TypedArray%.prototype.values ( )
+        // %TypedArray%.prototype [ @@iterator ] ( )
+        // get %TypedArray%.prototype [ @@toStringTag ]
+        // -- defined in es6.js to shim browsers w/ native TypedArrays
+
+        function makeTypedArray(elementSize, pack, unpack) {
+            // Each TypedArray type requires a distinct constructor instance with
+            // identical logic, which this produces.
+            var TypedArray = function() {
+                Object.defineProperty(this, 'constructor', {value: TypedArray});
+                $TypedArray$.apply(this, arguments);
+                makeArrayAccessors(this);
+            };
+            if ('__proto__' in TypedArray) {
+                TypedArray.__proto__ = $TypedArray$;
+            } else {
+                TypedArray.from = $TypedArray$.from;
+                TypedArray.of = $TypedArray$.of;
+            }
+
+            TypedArray.BYTES_PER_ELEMENT = elementSize;
+
+            var TypedArrayPrototype = function() {};
+            TypedArrayPrototype.prototype = $TypedArrayPrototype$;
+
+            TypedArray.prototype = new TypedArrayPrototype();
+
+            Object.defineProperty(TypedArray.prototype, 'BYTES_PER_ELEMENT', {value: elementSize});
+            Object.defineProperty(TypedArray.prototype, '_pack', {value: pack});
+            Object.defineProperty(TypedArray.prototype, '_unpack', {value: unpack});
+
+            return TypedArray;
+        }
+
+        var Int8Array = makeTypedArray(1, packI8, unpackI8);
+        var Uint8Array = makeTypedArray(1, packU8, unpackU8);
+        var Uint8ClampedArray = makeTypedArray(1, packU8Clamped, unpackU8);
+        var Int16Array = makeTypedArray(2, packI16, unpackI16);
+        var Uint16Array = makeTypedArray(2, packU16, unpackU16);
+        var Int32Array = makeTypedArray(4, packI32, unpackI32);
+        var Uint32Array = makeTypedArray(4, packU32, unpackU32);
+        var Float32Array = makeTypedArray(4, packF32, unpackF32);
+        var Float64Array = makeTypedArray(8, packF64, unpackF64);
+
+        global.Int8Array = global.Int8Array || Int8Array;
+        global.Uint8Array = global.Uint8Array || Uint8Array;
+        global.Uint8ClampedArray = global.Uint8ClampedArray || Uint8ClampedArray;
+        global.Int16Array = global.Int16Array || Int16Array;
+        global.Uint16Array = global.Uint16Array || Uint16Array;
+        global.Int32Array = global.Int32Array || Int32Array;
+        global.Uint32Array = global.Uint32Array || Uint32Array;
+        global.Float32Array = global.Float32Array || Float32Array;
+        global.Float64Array = global.Float64Array || Float64Array;
+    }());
+
+    //
+    // 6 The DataView View Type
+    //
+
+    (function() {
+        function r(array, index) {
+            return IsCallable(array.get) ? array.get(index) : array[index];
+        }
+
+        var IS_BIG_ENDIAN = (function() {
+            var u16array = new Uint16Array([0x1234]),
+                u8array = new Uint8Array(u16array.buffer);
+            return r(u8array, 0) === 0x12;
+        }());
+
+        // DataView(buffer, byteOffset=0, byteLength=undefined)
+        // WebIDL: Constructor(ArrayBuffer buffer,
+        //                     optional unsigned long byteOffset,
+        //                     optional unsigned long byteLength)
+        function DataView(buffer, byteOffset, byteLength) {
+            if (!(buffer instanceof ArrayBuffer || Class(buffer) === 'ArrayBuffer')) throw TypeError();
+
+            byteOffset = ToUint32(byteOffset);
+            if (byteOffset > buffer.byteLength)
+                throw RangeError('byteOffset out of range');
+
+            if (byteLength === undefined)
+                byteLength = buffer.byteLength - byteOffset;
+            else
+                byteLength = ToUint32(byteLength);
+
+            if ((byteOffset + byteLength) > buffer.byteLength)
+                throw RangeError('byteOffset and length reference an area beyond the end of the buffer');
+
+            Object.defineProperty(this, 'buffer', {value: buffer});
+            Object.defineProperty(this, 'byteLength', {value: byteLength});
+            Object.defineProperty(this, 'byteOffset', {value: byteOffset});
+        };
+
+        // get DataView.prototype.buffer
+        // get DataView.prototype.byteLength
+        // get DataView.prototype.byteOffset
+        // -- applied directly to instances by the constructor
+
+        function makeGetter(arrayType) {
+            return function GetViewValue(byteOffset, littleEndian) {
+                byteOffset = ToUint32(byteOffset);
+
+                if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength)
+                    throw RangeError('Array index out of range');
+
+                byteOffset += this.byteOffset;
+
+                var uint8Array = new Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT),
+                    bytes = [];
+                for (var i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1)
+                    bytes.push(r(uint8Array, i));
+
+                if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN))
+                    bytes.reverse();
+
+                return r(new arrayType(new Uint8Array(bytes).buffer), 0);
+            };
+        }
+
+        Object.defineProperty(DataView.prototype, 'getUint8', {value: makeGetter(Uint8Array)});
+        Object.defineProperty(DataView.prototype, 'getInt8', {value: makeGetter(Int8Array)});
+        Object.defineProperty(DataView.prototype, 'getUint16', {value: makeGetter(Uint16Array)});
+        Object.defineProperty(DataView.prototype, 'getInt16', {value: makeGetter(Int16Array)});
+        Object.defineProperty(DataView.prototype, 'getUint32', {value: makeGetter(Uint32Array)});
+        Object.defineProperty(DataView.prototype, 'getInt32', {value: makeGetter(Int32Array)});
+        Object.defineProperty(DataView.prototype, 'getFloat32', {value: makeGetter(Float32Array)});
+        Object.defineProperty(DataView.prototype, 'getFloat64', {value: makeGetter(Float64Array)});
+
+        function makeSetter(arrayType) {
+            return function SetViewValue(byteOffset, value, littleEndian) {
+                byteOffset = ToUint32(byteOffset);
+                if (byteOffset + arrayType.BYTES_PER_ELEMENT > this.byteLength)
+                    throw RangeError('Array index out of range');
+
+                // Get bytes
+                var typeArray = new arrayType([value]),
+                    byteArray = new Uint8Array(typeArray.buffer),
+                    bytes = [], i, byteView;
+
+                for (i = 0; i < arrayType.BYTES_PER_ELEMENT; i += 1)
+                    bytes.push(r(byteArray, i));
+
+                // Flip if necessary
+                if (Boolean(littleEndian) === Boolean(IS_BIG_ENDIAN))
+                    bytes.reverse();
+
+                // Write them
+                byteView = new Uint8Array(this.buffer, byteOffset, arrayType.BYTES_PER_ELEMENT);
+                byteView.set(bytes);
+            };
+        }
+
+        Object.defineProperty(DataView.prototype, 'setUint8', {value: makeSetter(Uint8Array)});
+        Object.defineProperty(DataView.prototype, 'setInt8', {value: makeSetter(Int8Array)});
+        Object.defineProperty(DataView.prototype, 'setUint16', {value: makeSetter(Uint16Array)});
+        Object.defineProperty(DataView.prototype, 'setInt16', {value: makeSetter(Int16Array)});
+        Object.defineProperty(DataView.prototype, 'setUint32', {value: makeSetter(Uint32Array)});
+        Object.defineProperty(DataView.prototype, 'setInt32', {value: makeSetter(Int32Array)});
+        Object.defineProperty(DataView.prototype, 'setFloat32', {value: makeSetter(Float32Array)});
+        Object.defineProperty(DataView.prototype, 'setFloat64', {value: makeSetter(Float64Array)});
+
+        global.DataView = global.DataView || DataView;
+
+    }());
+
+}(self));
diff --git a/ng2-components/ng2-alfresco-userinfo/src/components/user-info.component.css b/ng2-components/ng2-alfresco-userinfo/src/components/user-info.component.css
index 7c0864e56a..9ccf104ae2 100644
--- a/ng2-components/ng2-alfresco-userinfo/src/components/user-info.component.css
+++ b/ng2-components/ng2-alfresco-userinfo/src/components/user-info.component.css
@@ -20,11 +20,14 @@
     padding: 0px 0;
 }
 
-.user-profile-list-mdl{
-    max-height: 450px;
-    min-width: 450px;
-    overflow: auto;
-    padding:0px;
+@media only screen
+and (min-device-width: 480px) {
+    .user-profile-list-mdl{
+        max-height: 450px;
+        min-width: 450px;
+        overflow: auto;
+        padding:0px;
+    }
 }
 
 .header-profile{