two.js, pts.js and tone.js drivers

public/drivers/model/pts.js

@@ -0,0 +1,380 @@
+/*
+The MIT License (MIT)
+Copyright (c) 2014-2020 Nikolai Suslov and the Krestianstvo.org project contributors. (https://github.com/NikolaySuslov/livecodingspace/blob/master/LICENSE.md)
+
+*/
+
+// VWF & PtsJS model driver
+
+import { Fabric } from '/core/vwf/fabric.js';
+
+class PTSModel extends Fabric {
+
+    constructor(module) {
+
+        console.log("PTSModel constructor");
+        super(module, "Model");
+    }
+
+    factory() {
+        let _self_ = this;
+
+        return this.load( this.module, 
+            {
+
+                // == Module Definition ====================================================================
+        
+                // -- pipeline -----------------------------------------------------------------------------
+        
+                // pipeline: [ log ], // vwf <=> log <=> scene
+        
+                // -- initialize ---------------------------------------------------------------------------
+        
+                initialize: function() {
+                    
+                    var self = this;
+        
+                   this.state = {
+                        nodes: {},
+                        scenes: {},
+                        prototypes: {},
+                        createLocalNode: function (nodeID, childID, childExtendsID, childImplementsIDs,
+                            childSource, childType, childIndex, childName, callback) {
+                            return {
+                                "parentID": nodeID,
+                                "ID": childID,
+                                "extendsID": childExtendsID,
+                                "implementsIDs": childImplementsIDs,
+                                "source": childSource,
+                                "type": childType,
+                                "name": childName,
+                                "prototypes": undefined
+                            };
+                        },
+                        isNodeComponent: function (prototypes) {
+                            var found = false;
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length && !found; i++) {
+                                    found = (prototypes[i] === "proxy/pts/node.vwf");
+                                }
+                            }
+                            return found;
+                        },
+                        isClass: function (prototypes, classID) {
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length; i++) {
+                                    if (prototypes[i] === classID) {
+                                        //console.info( "prototypes[ i ]: " + prototypes[ i ] );
+                                        return true;
+                                    }
+                                }
+                            }
+                            return false;
+                        },
+                        isPTDefinition: function (prototypes) {
+                            var found = false;
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length && !found; i++) {
+                                    found = (prototypes[i] == "proxy/pts/pt.vwf");
+                                }
+                            }
+                            return found;
+                        },
+                        
+                        createObject: function (node, config) {
+
+                            var protos = node.prototypes;
+                            var obj = undefined;
+    
+                            if (this.isClass(protos, "proxy/pts/scene.vwf")) {
+
+                                let el = document.createElement("space");
+                                el.setAttribute("id", "space");
+                                el.style.height = "600px";
+                                el.style.width = "800px";
+                                document.querySelector("body").appendChild(el);
+                                Pts.namespace( window );
+                                obj = new CanvasSpace("#space").setup(
+                                    { bgcolor: "#99eeff", retina: true, resize: false });
+                               
+                                obj.nodeName = "space";  
+                                obj.nodeID = node.ID; 
+                                this.scenes[node.ID] = node;
+                                node.form = obj.getForm();
+                                
+                            }
+
+                            // if (this.isClass(protos, "proxy/pts/player.vwf")) {
+                            //     toneObj = new Tone.PolySynth(Tone.MembraneSynth);
+
+                            // }
+
+                            if(this.isPTDefinition(protos)) {
+                                obj = new Pt(2);
+                                obj.nodeName = "pt";  
+                                obj.nodeID = node.ID; 
+                                
+                            }
+
+                            return obj
+                            },
+                            addNodeToHierarchy: function (node) {
+
+                                if (node.obj) {
+                                    
+                                    if (node.obj.nodeName !== "space") {
+                                        node.scene = this.scenes[self.kernel.application()];
+                                    }
+        
+                                }
+        
+                            }
+                    };
+        
+                    this.state.kernel = this.kernel.kernel.kernel;
+        
+                    //this.Tone = Tone;
+                    //this.state.kernel = this.kernel.kernel.kernel;
+                    
+                },
+                // == Model API ============================================================================
+        
+                // -- creatingNode -------------------------------------------------------------------------
+        
+                creatingNode: function( nodeID, childID, childExtendsID, childImplementsIDs,
+                    childSource, childType, childIndex, childName, callback /* ( ready ) */ ) {
+        
+                    // If the parent nodeID is 0, this node is attached directly to the root and is therefore either 
+                    // the scene or a prototype.  In either of those cases, save the uri of the new node
+                    var childURI = (nodeID === 0 ? childIndex : undefined);
+                    var appID = this.kernel.application();
+        
+                    // If the node being created is a prototype, construct it and add it to the array of prototypes,
+                    // and then return
+                    var prototypeID = _self_.utility.ifPrototypeGetId(appID, this.state.prototypes, nodeID, childID);
+                    if (prototypeID !== undefined) {
+        
+                        this.state.prototypes[prototypeID] = {
+                            parentID: nodeID,
+                            ID: childID,
+                            extendsID: childExtendsID,
+                            implementsID: childImplementsIDs,
+                            source: childSource,
+                            type: childType,
+                            name: childName
+                        };
+                        return;
+                    }
+        
+                    var protos = _self_.getPrototypes(this.kernel, childExtendsID);
+                    //var kernel = this.kernel.kernel.kernel;
+                    var node;
+        
+                    if (this.state.isNodeComponent(protos)) {
+        
+                        // Create the local copy of the node properties
+                        if (this.state.nodes[childID] === undefined) {
+                            this.state.nodes[childID] = this.state.createLocalNode(nodeID, childID, childExtendsID, childImplementsIDs,
+                                childSource, childType, childIndex, childName, callback);
+                        }
+        
+                        node = this.state.nodes[childID];
+                        node.prototypes = protos;
+        
+                        node.obj = this.state.createObject(node);
+                        this.state.addNodeToHierarchy(node);
+
+                        //let aframeDriver = vwf.views["/drivers/view/aframe"];
+                      
+                        
+                        //notifyDriverOfPrototypeAndBehaviorProps();
+                    }
+                },
+        
+                 // -- initializingNode -------------------------------------------------------------------------
+        
+                //   initializingNode: function( nodeID, childID, childExtendsID, childImplementsIDs,
+                //     childSource, childType, childIndex, childName ) {
+        
+                // },
+        
+                // -- deletingNode -------------------------------------------------------------------------
+        
+                deletingNode: function( nodeID ) {
+
+                    if (nodeID) {
+                        var childNode = this.state.nodes[nodeID];
+                        if (!childNode) return;
+    
+    
+                        if (childNode !== undefined) {
+    
+                            if (childNode.children) {
+    
+                                for (var i = 0; i < childNode.children.length; i++) {
+                                    this.deletingNode(childNode.children[i]);
+                                }
+                            }
+    
+                            if (childNode.obj !== undefined) {
+                                // removes and destroys object
+
+                                let space = childNode.scene.obj;
+                                let player = Object.values(space.players).filter(el=> el.myID == nodeID)[0];
+                                space.remove(player.animateID);
+                                childNode.obj = undefined;
+                            }
+    
+                            delete this.state.nodes[nodeID];
+                        }
+    
+                    }
+
+
+                },
+        
+                 // -- initializingProperty -----------------------------------------------------------------
+        
+                initializingProperty: function( nodeID, propertyName, propertyValue ) {
+        
+                     var value = undefined;
+                    var node = this.state.nodes[nodeID];
+                    if (node !== undefined) {
+                        value = this.settingProperty(nodeID, propertyName, propertyValue);
+                    }
+                    return value;
+                
+            },
+        
+                // -- creatingProperty ---------------------------------------------------------------------
+        
+                creatingProperty: function (nodeID, propertyName, propertyValue) {
+                    return this.initializingProperty(nodeID, propertyName, propertyValue);
+                },
+        
+        
+                // -- settingProperty ----------------------------------------------------------------------
+        
+                settingProperty: function( nodeID, propertyName, propertyValue ) {
+        
+                    let self = this;
+                    let node = this.state.nodes[nodeID];
+                    var value = undefined;
+
+                    if (node && node.obj && _self_.utility.validObject(propertyValue)) {
+
+                        let object = node.obj;
+
+                        // if (self.state.isComponentNodeDefinition(node.prototypes)) {
+
+
+                        //     value = propertyValue;
+                        //     switch (propertyName) {
+
+                        //         default:
+                        //             value = undefined;
+                        //             break;
+                        //     }
+
+                        // }
+
+
+                        if (value === undefined && self.state.isPTDefinition(node.prototypes)) {
+                            
+                            value = propertyValue;
+
+                            switch (propertyName) {
+
+
+                                case "x":
+
+                                    object.x = propertyValue
+
+                                    break;
+
+                                case "y":
+                                        object.y = propertyValue
+
+    
+                                        break;
+
+                                default:
+                                    value = undefined;
+                                    break;
+                            }
+                        }
+                    }
+        
+                     return value;
+        
+                },
+        
+                // -- gettingProperty ----------------------------------------------------------------------
+        
+                gettingProperty: function( nodeID, propertyName, propertyValue ) {
+        
+                    let self = this;
+                    let node = this.state.nodes[nodeID];
+                    let value = undefined;
+                    if (node && node.obj) {
+
+                        let object = node.obj;
+
+                        // if (self.state.isComponentNodeDefinition(node.prototypes)) {
+                        //     switch (propertyName) {
+                        //     }
+                        // }
+
+                        if (value === undefined && self.state.isPTDefinition(node.prototypes)) {
+
+                            switch (propertyName) {
+
+                                case "x":
+                                    value = object.x
+                                    break;
+
+                                case "y":
+                                        value = object.y
+                                        break;
+                            }
+                        }
+
+        
+                    }
+
+                     if ( value !== undefined ) {
+                        propertyValue = value;
+                    }
+        
+                    return value;
+        
+                     
+                }
+
+
+
+
+        
+            } );
+
+        }
+
+
+    getPrototypes(kernel, extendsID) {
+        var prototypes = [];
+        var id = extendsID;
+    
+        while (id !== undefined) {
+            prototypes.push(id);
+            id = kernel.prototype(id);
+        }
+        return prototypes;
+    }
+    
+
+    }
+
+    export {
+        PTSModel as default
+      }
+    

public/drivers/model/tone.js

@@ -19,22 +19,22 @@ class ToneModel extends Fabric {
     factory() {
         let _self_ = this;
 
-        return this.load( this.module, 
+        return this.load(this.module,
             {
 
                 // == Module Definition ====================================================================
-        
+
                 // -- pipeline -----------------------------------------------------------------------------
-        
+
                 // pipeline: [ log ], // vwf <=> log <=> scene
-        
+
                 // -- initialize ---------------------------------------------------------------------------
-        
-                initialize: function() {
-                    
+
+                initialize: function () {
+
                     var self = this;
-        
-                   this.state = {
+
+                    this.state = {
                         nodes: {},
                         scenes: {},
                         prototypes: {},
@@ -71,6 +71,24 @@ class ToneModel extends Fabric {
                             }
                             return false;
                         },
+                        isTransportDefinition: function (prototypes) {
+                            var found = false;
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length && !found; i++) {
+                                    found = (prototypes[i] == "proxy/tonejs/transport.vwf");
+                                }
+                            }
+                            return found;
+                        },
+                        isPlayerDefinition: function (prototypes) {
+                            var found = false;
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length && !found; i++) {
+                                    found = (prototypes[i] == "proxy/tonejs/player.vwf");
+                                }
+                            }
+                            return found;
+                        },
                         isSynthDefinition: function (prototypes) {
                             var found = false;
                             if (prototypes) {
@@ -102,7 +120,17 @@ class ToneModel extends Fabric {
 
                             var protos = node.prototypes;
                             var toneObj = undefined;
-    
+
+                            if (this.isToneClass(protos, "proxy/tonejs/transport.vwf")) {
+                                // global transport for now
+                                toneObj = Tone.Transport;
+                            }
+
+                            if (this.isToneClass(protos, "proxy/tonejs/player.vwf")) {
+                                toneObj = new Tone.Player(); //GrainPlayer
+                                toneObj.autostart = false;
+                            }
+
                             if (this.isToneClass(protos, "proxy/tonejs/synth.vwf")) {
                                 toneObj = new Tone.PolySynth(Tone.synth);
                             }
@@ -126,32 +154,32 @@ class ToneModel extends Fabric {
 
 
                             return toneObj
-                            }
+                        }
                     };
-        
+
                     this.state.kernel = this.kernel.kernel.kernel;
-        
+
                     //this.Tone = Tone;
                     //this.state.kernel = this.kernel.kernel.kernel;
-                    
+
                 },
                 // == Model API ============================================================================
-        
+
                 // -- creatingNode -------------------------------------------------------------------------
-        
-                creatingNode: function( nodeID, childID, childExtendsID, childImplementsIDs,
-                    childSource, childType, childIndex, childName, callback /* ( ready ) */ ) {
-        
+
+                creatingNode: function (nodeID, childID, childExtendsID, childImplementsIDs,
+                    childSource, childType, childIndex, childName, callback /* ( ready ) */) {
+
                     // If the parent nodeID is 0, this node is attached directly to the root and is therefore either 
                     // the scene or a prototype.  In either of those cases, save the uri of the new node
                     var childURI = (nodeID === 0 ? childIndex : undefined);
                     var appID = this.kernel.application();
-        
+
                     // If the node being created is a prototype, construct it and add it to the array of prototypes,
                     // and then return
                     var prototypeID = _self_.utility.ifPrototypeGetId(appID, this.state.prototypes, nodeID, childID);
                     if (prototypeID !== undefined) {
-        
+
                         this.state.prototypes[prototypeID] = {
                             parentID: nodeID,
                             ID: childID,
@@ -163,28 +191,28 @@ class ToneModel extends Fabric {
                         };
                         return;
                     }
-        
+
                     var protos = _self_.getPrototypes(this.kernel, childExtendsID);
                     //var kernel = this.kernel.kernel.kernel;
                     var node;
-        
+
                     if (this.state.isToneNodeComponent(protos)) {
-        
+
                         // Create the local copy of the node properties
                         if (this.state.nodes[childID] === undefined) {
                             this.state.nodes[childID] = this.state.createLocalNode(nodeID, childID, childExtendsID, childImplementsIDs,
                                 childSource, childType, childIndex, childName, callback);
                         }
-        
+
                         node = this.state.nodes[childID];
                         node.prototypes = protos;
-        
+
                         //this.state.createToneObject(node);
 
                         let aframeDriver = vwf.views["/drivers/view/aframe"];
-                        if(aframeDriver){
+                        if (aframeDriver) {
                             let parentNode = aframeDriver.state.nodes[nodeID];
-                            if(parentNode.aframeObj){
+                            if (parentNode.aframeObj) {
                                 let sceneEl = aframeDriver.state.nodes[nodeID].scene.sceneEl;
                                 if (!sceneEl.audioListener) {
                                     sceneEl.audioListener = new THREE.AudioListener();
@@ -193,56 +221,68 @@ class ToneModel extends Fabric {
                                     //     evt.detail.cameraEl.getObject3D('camera').add(sceneEl.audioListener);
                                     // });
                                 }
-                                node.sound = new THREE.PositionalAudio( sceneEl.audioListener );
+                                node.sound = new THREE.PositionalAudio(sceneEl.audioListener);
                                 Tone.setContext(node.sound.context);
                                 //node.sound.context.resume();
                                 node.toneObj = this.state.createToneObject(node);
-                                node.sound.setNodeSource(node.toneObj);
-                                parentNode.aframeObj.object3D.add(node.sound);
-                                
-                            } 
+
+                                if (!this.state.isTransportDefinition(node.prototypes)) {
+                                    node.sound.setNodeSource(node.toneObj);
+                                    parentNode.aframeObj.object3D.add(node.sound);
+                                }
+
+                            }
+                        } else {
+
+                            node.toneObj = this.state.createToneObject(node);
+
+                            if (!this.state.isTransportDefinition(node.prototypes)) {
+                                node.toneObj.toDestination();
+                            }
+
+                            //node.sound.setNodeSource(node.toneObj);
                         }
                         //addNodeToHierarchy(node);
                         //notifyDriverOfPrototypeAndBehaviorProps();
                     }
                 },
-        
-                 // -- initializingNode -------------------------------------------------------------------------
-        
+
+                // -- initializingNode -------------------------------------------------------------------------
+
                 //   initializingNode: function( nodeID, childID, childExtendsID, childImplementsIDs,
                 //     childSource, childType, childIndex, childName ) {
-        
+
                 // },
-        
+
                 // -- deletingNode -------------------------------------------------------------------------
-        
+
                 //deletingNode: function( nodeID ) {
                 //},
-        
-                 // -- initializingProperty -----------------------------------------------------------------
-        
-                initializingProperty: function( nodeID, propertyName, propertyValue ) {
-        
-                     var value = undefined;
+
+                // -- initializingProperty -----------------------------------------------------------------
+
+                initializingProperty: function (nodeID, propertyName, propertyValue) {
+
+                    var value = undefined;
                     var node = this.state.nodes[nodeID];
                     if (node !== undefined) {
                         value = this.settingProperty(nodeID, propertyName, propertyValue);
                     }
                     return value;
-                
-            },
-        
+
+                },
+
                 // -- creatingProperty ---------------------------------------------------------------------
-        
+
                 creatingProperty: function (nodeID, propertyName, propertyValue) {
                     return this.initializingProperty(nodeID, propertyName, propertyValue);
                 },
-        
-        
+
+
                 // -- settingProperty ----------------------------------------------------------------------
-        
-                settingProperty: function( nodeID, propertyName, propertyValue ) {
-        
+
+                settingProperty: function (nodeID, propertyName, propertyValue) {
+
                     let self = this;
                     let node = this.state.nodes[nodeID];
                     var value = undefined;
@@ -265,6 +305,132 @@ class ToneModel extends Fabric {
                         // }
 
 
+                        if (value === undefined && self.state.isTransportDefinition(node.prototypes)) {
+
+                            value = propertyValue;
+
+                            switch (propertyName) {
+
+
+                                case "bpm":
+
+                                    toneObject.bpm.value = propertyValue
+                                    toneObject.initbpm = propertyValue
+                                    break;
+
+                                // case "state":
+
+                                //     toneObject.state = propertyValue
+
+                                //     break;
+
+                                case "position":
+
+                                    toneObject.position = propertyValue
+
+                                    break;
+
+                                case "loop":
+                                    toneObject.loop = propertyValue
+                                    break;
+
+                                case "loopStart":
+
+                                    if (typeof propertyValue == "string") {
+                                        propertyValue = Tone.Time(propertyValue).toSeconds();
+                                    }
+
+                                    toneObject.loopStart = propertyValue
+                                    break;
+
+                                case "loopEnd":
+
+                                    if (typeof propertyValue == "string") {
+                                        propertyValue = Tone.Time(propertyValue).toSeconds();
+                                    }
+
+                                    toneObject.loopEnd = propertyValue
+                                    break;
+
+                                case "duration":
+                                    if (typeof propertyValue == "string") {
+                                        propertyValue = Tone.Time(propertyValue).toSeconds();
+                                    }
+
+                                    toneObject.duration = propertyValue
+                                    break;
+
+                                default:
+                                    value = undefined;
+                                    break;
+                            }
+                        }
+
+                        if (value === undefined && self.state.isPlayerDefinition(node.prototypes)) {
+
+                            value = propertyValue;
+
+                            switch (propertyName) {
+
+
+                                // case "url":
+
+                                //     toneObject.load(propertyValue)
+                                //     break;
+
+                                // case "state":
+
+                                //     toneObject.state = propertyValue
+
+                                //     break;
+
+                                case "startTime":
+
+                                    toneObject.startTime = propertyValue
+
+                                    break;
+
+                                case "volume":
+
+                                    toneObject.volume.value = propertyValue
+
+                                    break;
+
+
+                                case "mute":
+
+                                    toneObject.mute = propertyValue
+
+                                    break;
+
+                                case "autostart":
+
+                                    toneObject.autostart = propertyValue
+
+                                    break;
+
+                                case "loop":
+                                    toneObject.loop = propertyValue
+                                    break;
+
+                                case "loopStart":
+                                    toneObject.loopStart = propertyValue
+                                    break;
+
+                                case "loopEnd":
+                                    toneObject.loopEnd = propertyValue
+                                    break;
+
+                                // case "duration":
+                                //     toneObject.duration = propertyValue
+                                //     break;
+
+                                default:
+                                    value = undefined;
+                                    break;
+                            }
+                        }
+
                         if (value === undefined && self.state.isSynthDefinition(node.prototypes)) {
 
                             value = propertyValue;
@@ -274,7 +440,7 @@ class ToneModel extends Fabric {
 
                                 case "type":
 
-                                    toneObject.set({oscillator:{type: propertyValue}})
+                                    toneObject.set({ oscillator: { type: propertyValue } })
                                     //"sine"; "square"; "triangle"; "sawtooth";
 
                                     break;
@@ -284,16 +450,18 @@ class ToneModel extends Fabric {
                                     break;
                             }
                         }
+
+
                     }
-        
-                     return value;
-        
+
+                    return value;
+
                 },
-        
+
                 // -- gettingProperty ----------------------------------------------------------------------
-        
-                gettingProperty: function( nodeID, propertyName, propertyValue ) {
-        
+
+                gettingProperty: function (nodeID, propertyName, propertyValue) {
+
                     let self = this;
                     let node = this.state.nodes[nodeID];
                     let value = undefined;
@@ -306,6 +474,87 @@ class ToneModel extends Fabric {
                         //     }
                         // }
 
+
+                        if (value === undefined && self.state.isTransportDefinition(node.prototypes)) {
+
+                            switch (propertyName) {
+
+                                case "bpm":
+                                    value = toneObject.bpm.value
+                                    break;
+
+                                // case "state":
+                                //     value = toneObject.state
+                                //     break;
+
+                                case "position":
+                                    value = toneObject.position
+                                    break;
+
+                                case "loopStart":
+                                    value = toneObject.loopStart
+                                    break;
+
+                                case "loopEnd":
+                                    value = toneObject.loopEnd
+                                    break;
+
+
+                                case "duration":
+                                    value = toneObject.duration
+                                    break;
+
+                                case "loop":
+                                    value = toneObject.loop
+                                    break;
+
+                            }
+                        }
+
+                        if (value === undefined && self.state.isPlayerDefinition(node.prototypes)) {
+
+                            switch (propertyName) {
+
+                                case "autostart":
+                                    value = toneObject.autostart
+                                    break;
+
+                                // case "state":
+                                //     value = toneObject.state
+                                //     break;
+
+                                case "startTime":
+                                    value = toneObject.startTime
+                                    break;
+
+                                case "volume":
+                                    value = toneObject.volume.value
+                                    break;
+
+                                case "mute":
+                                    value = toneObject.mute
+                                    break;
+
+                                case "loopStart":
+                                    value = toneObject.loopStart
+                                    break;
+
+                                case "loopEnd":
+                                    value = toneObject.loopEnd
+                                    break;
+
+
+                                case "duration":
+                                    value = toneObject.buffer.duration
+                                    break;
+
+                                case "loop":
+                                    value = toneObject.loop
+                                    break;
+
+                            }
+                        }
+
                         if (value === undefined && self.state.isSynthDefinition(node.prototypes)) {
 
                             switch (propertyName) {
@@ -316,42 +565,41 @@ class ToneModel extends Fabric {
                             }
                         }
 
-        
+
                     }
 
-                     if ( value !== undefined ) {
+                    if (value !== undefined) {
                         propertyValue = value;
                     }
-        
+
                     return value;
-        
-                     
+
+
                 }
 
 
 
 
-        
-            } );
 
-        }
+            });
+
+    }
 
 
     getPrototypes(kernel, extendsID) {
         var prototypes = [];
         var id = extendsID;
-    
+
         while (id !== undefined) {
             prototypes.push(id);
             id = kernel.prototype(id);
         }
         return prototypes;
     }
-    
 
-    }
 
-    export {
-        ToneModel as default
-      }
-    
+}
+
+export {
+    ToneModel as default
+}

public/drivers/model/two.js

@@ -0,0 +1,1098 @@
+/*
+The MIT License (MIT)
+Copyright (c) 2014-2020 Nikolai Suslov and the Krestianstvo.org project contributors. (https://github.com/NikolaySuslov/livecodingspace/blob/master/LICENSE.md)
+
+*/
+
+// VWF & TWO JS model driver
+
+import { Fabric } from '/core/vwf/fabric.js';
+
+class TwoModel extends Fabric {
+
+    constructor(module) {
+
+        console.log("TwoModel constructor");
+        super(module, "Model");
+    }
+
+    factory() {
+        let _self_ = this;
+
+        return this.load(this.module,
+            {
+
+                // == Module Definition ====================================================================
+
+                // -- pipeline -----------------------------------------------------------------------------
+
+                // pipeline: [ log ], // vwf <=> log <=> scene
+
+                // -- initialize ---------------------------------------------------------------------------
+
+                initialize: function () {
+
+                    var self = this;
+
+                    this.state = {
+                        nodes: {},
+                        scenes: {},
+                        prototypes: {},
+                        createLocalNode: function (nodeID, childID, childExtendsID, childImplementsIDs,
+                            childSource, childType, childIndex, childName, callback) {
+                            return {
+                                "parentID": nodeID,
+                                "ID": childID,
+                                "extendsID": childExtendsID,
+                                "implementsIDs": childImplementsIDs,
+                                "source": childSource,
+                                "type": childType,
+                                "name": childName,
+                                "prototypes": undefined
+                            };
+                        },
+                        isNodeComponent: function (prototypes) {
+                            var found = false;
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length && !found; i++) {
+                                    found = (prototypes[i] === "proxy/two/node.vwf");
+                                }
+                            }
+                            return found;
+                        },
+                        isClass: function (prototypes, classID) {
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length; i++) {
+                                    if (prototypes[i] === classID) {
+                                        //console.info( "prototypes[ i ]: " + prototypes[ i ] );
+                                        return true;
+                                    }
+                                }
+                            }
+                            return false;
+                        },
+                        isTwoTextureDefinition: function (prototypes) {
+                            var found = false;
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length && !found; i++) {
+                                    found = (prototypes[i] == "proxy/two/texture.vwf");
+                                }
+                            }
+                            return found;
+                        },
+                        isTwoRectangleDefinition: function (prototypes) {
+                            var found = false;
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length && !found; i++) {
+                                    found = (prototypes[i] == "proxy/two/rectangle.vwf");
+                                }
+                            }
+                            return found;
+                        },
+                        isTwoCurveDefinition: function (prototypes) {
+                            var found = false;
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length && !found; i++) {
+                                    found = (prototypes[i] == "proxy/two/curve.vwf");
+                                }
+                            }
+                            return found;
+                        },
+                        isTwoEllipseDefinition: function (prototypes) {
+                            var found = false;
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length && !found; i++) {
+                                    found = (prototypes[i] == "proxy/two/ellipse.vwf");
+                                }
+                            }
+                            return found;
+                        },
+                        isTwoAnchorDefinition: function (prototypes) {
+                            var found = false;
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length && !found; i++) {
+                                    found = (prototypes[i] == "proxy/two/anchor.vwf");
+                                }
+                            }
+                            return found;
+                        },
+                        isTwoGroupDefinition: function (prototypes) {
+                            var found = false;
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length && !found; i++) {
+                                    found = (prototypes[i] == "proxy/two/group.vwf");
+                                }
+                            }
+                            return found;
+                        },
+                        isTwoPathDefinition: function (prototypes) {
+                            var found = false;
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length && !found; i++) {
+                                    found = (prototypes[i] == "proxy/two/path.vwf");
+                                }
+                            }
+                            return found;
+                        },
+                        isTwoTextDefinition: function (prototypes) {
+                            var found = false;
+                            if (prototypes) {
+                                for (var i = 0; i < prototypes.length && !found; i++) {
+                                    found = (prototypes[i] == "proxy/two/text.vwf");
+                                }
+                            }
+                            return found;
+                        },
+
+                        setFromValue: function (propertyValue) {
+
+                            var value = []; //goog.vec.Vec3.create();
+                            if (Array.isArray(propertyValue) || propertyValue instanceof Float32Array) {
+                                value = propertyValue;
+                            } else if (typeof propertyValue === 'string') {
+
+                                if (propertyValue.includes(',')) {
+                                    value = propertyValue.split(',').map(el => { return parseFloat(el) })
+                                }
+                            }
+
+                            return value
+                        },
+
+                        createObject: function (node, config) {
+
+                            var protos = node.prototypes;
+                            var obj = undefined;
+
+                            if (this.isClass(protos, "proxy/two/scene.vwf")) {
+
+                                // Make an instance of two and place it on the page.
+                                // let el = document.createElement("space");
+                                // document.querySelector("body").appendChild(el);
+
+                                // let params = { width: 800, height: 600 };
+                                // obj = new Two(params).appendTo(el);
+
+                                obj = new Two({
+                                    type: Two.Types.webgl, //webgl
+                                    fullscreen: true,
+                                    autostart: true
+                                }).appendTo(document.body);
+
+                                obj.renderer.domElement.style.position = 'absolute';
+                                obj.renderer.domElement.style.top = 0;
+                                obj.renderer.domElement.style.left = 0;
+
+
+                                obj.nodeName = "space";
+                                obj.nodeID = node.ID;
+                                this.scenes[node.ID] = node;
+
+
+                            }
+
+                            if (this.isTwoRectangleDefinition(protos)) {
+
+                                obj = new Two.Rectangle(0, 0, 10, 10);
+                                obj.nodeName = "rectangle";
+                                obj.nodeID = node.ID;
+
+                            }
+
+
+                            if (this.isTwoTextDefinition(protos)) {
+
+                                obj = new Two.Text();
+                                obj.nodeName = "text";
+                                obj.nodeID = node.ID;
+
+                            }
+
+                            if (this.isTwoAnchorDefinition(protos)) {
+
+                                obj = new Two.Anchor();
+                                obj.nodeName = "anchor";
+                                obj.nodeID = node.ID;
+
+                            }
+
+
+                            if (this.isTwoEllipseDefinition(protos)) {
+
+                                obj = new Two.Ellipse(0, 0, 10);
+                                obj.nodeName = "ellipse";
+                                obj.nodeID = node.ID;
+
+                            }
+
+                            if (this.isTwoGroupDefinition(protos)) {
+
+                                obj = new Two.Group();
+                                obj.nodeName = "group";
+                                obj.nodeID = node.ID;
+
+                            }
+
+                            if (this.isTwoCurveDefinition(protos)) {
+
+                                obj = new Two.Path();
+                                obj.nodeName = "path";
+                                obj.nodeID = node.ID;
+
+                            }
+
+                            if (this.isTwoTextureDefinition(protos)) {
+
+                                obj = new Two.Texture();
+                                obj.nodeName = "texture";
+                                obj.nodeID = node.ID;
+
+                            }
+
+                            return obj
+                        },
+                        addNodeToHierarchy: function (node) {
+
+                            if (node.obj) {
+
+                                if (this.nodes[node.parentID] !== undefined) {
+                                    var parent = this.nodes[node.parentID];
+                                    if (parent.obj) {
+
+                                        if (parent.children === undefined) {
+                                            parent.children = [];
+                                        }
+                                        parent.children.push(node.ID);
+                                        //console.info( "Adding child: " + childID + " to " + nodeID );
+                                        if (node.obj.nodeName !== "texture" && node.obj.nodeName !== "anchor") {
+                                            parent.obj.add(node.obj);
+                                        }
+                                    }
+                                }
+
+                                if (node.obj.nodeName !== "space") {
+                                    node.scene = this.scenes[self.kernel.application()];
+                                    // if(node.parentID == self.kernel.application()){
+                                    //     node.scene.obj.add(node.obj);
+                                    // }
+                                }
+
+                            }
+
+                        }
+                    };
+
+                    this.state.kernel = this.kernel.kernel.kernel;
+
+                    //this.Tone = Tone;
+                    //this.state.kernel = this.kernel.kernel.kernel;
+
+                },
+                // == Model API ============================================================================
+
+                // -- creatingNode -------------------------------------------------------------------------
+
+                creatingNode: function (nodeID, childID, childExtendsID, childImplementsIDs,
+                    childSource, childType, childIndex, childName, callback /* ( ready ) */) {
+
+                    // If the parent nodeID is 0, this node is attached directly to the root and is therefore either 
+                    // the scene or a prototype.  In either of those cases, save the uri of the new node
+                    var childURI = (nodeID === 0 ? childIndex : undefined);
+                    var appID = this.kernel.application();
+
+                    // If the node being created is a prototype, construct it and add it to the array of prototypes,
+                    // and then return
+                    var prototypeID = _self_.utility.ifPrototypeGetId(appID, this.state.prototypes, nodeID, childID);
+                    if (prototypeID !== undefined) {
+
+                        this.state.prototypes[prototypeID] = {
+                            parentID: nodeID,
+                            ID: childID,
+                            extendsID: childExtendsID,
+                            implementsID: childImplementsIDs,
+                            source: childSource,
+                            type: childType,
+                            name: childName
+                        };
+                        return;
+                    }
+
+                    var protos = _self_.getPrototypes(this.kernel, childExtendsID);
+                    //var kernel = this.kernel.kernel.kernel;
+                    var node;
+
+                    if (this.state.isNodeComponent(protos)) {
+
+                        // Create the local copy of the node properties
+                        if (this.state.nodes[childID] === undefined) {
+                            this.state.nodes[childID] = this.state.createLocalNode(nodeID, childID, childExtendsID, childImplementsIDs,
+                                childSource, childType, childIndex, childName, callback);
+                        }
+
+                        node = this.state.nodes[childID];
+                        node.prototypes = protos;
+
+                        node.obj = this.state.createObject(node);
+                        this.state.addNodeToHierarchy(node);
+
+                        //let aframeDriver = vwf.views["/drivers/view/aframe"];
+
+
+                        //notifyDriverOfPrototypeAndBehaviorProps();
+                    }
+                },
+
+                // -- initializingNode -------------------------------------------------------------------------
+
+                //   initializingNode: function( nodeID, childID, childExtendsID, childImplementsIDs,
+                //     childSource, childType, childIndex, childName ) {
+
+                // },
+
+                // -- deletingNode -------------------------------------------------------------------------
+
+                deletingNode: function (nodeID) {
+
+                    if (nodeID) {
+                        var childNode = this.state.nodes[nodeID];
+                        if (!childNode) return;
+
+
+                        if (childNode !== undefined) {
+
+                            if (childNode.children) {
+
+                                for (var i = 0; i < childNode.children.length; i++) {
+                                    this.deletingNode(childNode.children[i]);
+                                }
+                            }
+
+                            if (childNode.obj !== undefined) {
+                                // removes and destroys object
+
+                                //let space = childNode.scene.obj;
+                                childNode.obj.parent.remove(childNode.obj);
+                                childNode.obj = undefined;
+                            }
+
+                            delete this.state.nodes[nodeID];
+                        }
+
+                    }
+
+
+                },
+
+                // -- initializingProperty -----------------------------------------------------------------
+
+                initializingProperty: function (nodeID, propertyName, propertyValue) {
+
+                    var value = undefined;
+                    var node = this.state.nodes[nodeID];
+                    if (node !== undefined) {
+                        value = this.settingProperty(nodeID, propertyName, propertyValue);
+                    }
+                    return value;
+
+                },
+
+                //callingMethod
+
+                callingMethod: function (nodeID, methodName, methodParameters) {
+
+                    let self = this;
+                    var node = this.state.nodes[nodeID];
+
+                    if (!node) return;
+
+                    if (node && node.obj) {
+
+
+
+                        if (methodName == "getJointsAtTime") {
+
+                            let time = methodParameters[0];
+                            return node.motionData[time];
+
+                        }
+
+                        if (methodName == "getJointAtTime") {
+
+                            let time = methodParameters[0];
+                            let jointID = methodParameters[1];
+
+                            return node.motionData[time][jointID];
+
+                        }
+
+
+                    }
+                },
+
+
+                // -- creatingProperty ---------------------------------------------------------------------
+
+                creatingProperty: function (nodeID, propertyName, propertyValue) {
+                    return this.initializingProperty(nodeID, propertyName, propertyValue);
+                },
+
+
+                // -- settingProperty ----------------------------------------------------------------------
+
+                settingProperty: function (nodeID, propertyName, propertyValue) {
+
+                    let self = this;
+                    let node = this.state.nodes[nodeID];
+                    var value = undefined;
+
+                    if (node && node.obj && _self_.utility.validObject(propertyValue)) {
+
+                        let object = node.obj;
+
+                        if (value === undefined && self.state.isTwoGroupDefinition(node.prototypes)) {
+
+                            value = propertyValue;
+
+                            switch (propertyName) {
+
+                                case "x":
+
+                                    object.translation.x = propertyValue
+                                    break;
+
+                                case "y":
+                                    object.translation.y = propertyValue
+                                    break;
+
+                                case "translation":
+                                    let translation = this.state.setFromValue(propertyValue);
+                                    object.translation.set(translation[0], translation[1])
+                                    break;
+
+                                case "rotation":
+                                    object.rotation = propertyValue
+                                    break;
+
+                                case "scale":
+                                    object.scale = propertyValue
+                                    break;
+
+                                case "opacity":
+                                    object.opacity = propertyValue
+                                    break;
+
+                                // case "mask":
+                                //     object.mask = propertyValue
+                                // break;
+
+
+                                case "visible":
+                                    object.visible = propertyValue
+                                    break;
+
+                                default:
+                                    value = undefined;
+                                    break;
+                            }
+                        }
+
+
+
+
+                        if (value === undefined && self.state.isTwoTextDefinition(node.prototypes)) {
+
+                            value = propertyValue;
+
+                            switch (propertyName) {
+
+                                case "translation":
+
+                                    let translation = this.state.setFromValue(propertyValue);
+                                    object.translation.set(translation[0], translation[1])
+                                    break;
+
+                                case "rotation":
+                                    object.rotation = propertyValue
+                                    break;
+
+                                case "scale":
+                                    object.scale = propertyValue
+                                    break;
+
+                                case "fill":
+
+                                    object.fill = propertyValue
+
+
+                                    break;
+
+                                case "stroke":
+                                    object.stroke = propertyValue
+                                    break;
+
+                                case "linewidth":
+
+                                    object.linewidth = propertyValue
+                                    break;
+
+                                case "opacity":
+                                    object.opacity = propertyValue
+                                    break;
+
+                                case "text":
+                                    object.value = propertyValue
+                                    break;
+
+                                case "family":
+                                    object.family = propertyValue
+                                    break;
+
+
+                                case "size":
+                                    object.size = propertyValue
+                                    break;
+
+
+                                case "style":
+                                    object.style = propertyValue
+                                    break;
+
+                                case "weight":
+                                    object.weight = propertyValue
+                                    break;
+
+                                case "visible":
+                                    object.visible = propertyValue
+                                    break;
+                                // "text": null,
+                                // "family": null,
+                                // "size": null,
+                                // "style": null,
+                                // "weight": null,
+                                // "visible": null,
+
+
+                                default:
+                                    value = undefined;
+                                    break;
+                            }
+                        }
+
+
+                        if (value === undefined && self.state.isTwoPathDefinition(node.prototypes)) {
+
+                            value = propertyValue;
+
+                            switch (propertyName) {
+
+                                case "x":
+
+                                    object.translation.x = propertyValue
+                                    break;
+
+                                case "y":
+                                    object.translation.y = propertyValue
+                                    break;
+
+                                case "translation":
+
+                                    object.translation.set(propertyValue[0], propertyValue[1])
+                                    break;
+
+                                case "rotation":
+                                    object.rotation = propertyValue
+                                    break;
+
+                                case "scale":
+                                    object.scale = propertyValue
+                                    break;
+
+                                case "fill":
+
+                                    if (propertyValue.includes('https') || propertyValue.startsWith('/')) {
+                                        let name = propertyValue//.split('=')[1];
+                                        if (name.includes('webm') || name.includes('mp4')) {
+                                            var video = document.createElement('video');
+                                            video.src = name;
+                                            video.autoplay = false;
+                                            video.loop = true;
+                                            video.muted = true;
+
+                                            object.fill = new Two.Texture(video);
+                                            node.fillType = "video";
+                                        } else {
+                                            let texture = new Two.Texture(name);
+                                            object.fill = texture
+                                            node.fillType = "image";
+                                        }
+
+                                    } else {
+                                        object.fill = propertyValue
+                                        node.fillType = "color";
+                                    }
+
+
+                                    break;
+
+                                case "stroke":
+                                    object.stroke = propertyValue
+                                    break;
+
+                                case "linewidth":
+
+                                    object.linewidth = propertyValue
+                                    break;
+
+                                case "opacity":
+                                    object.opacity = propertyValue
+                                    break;
+
+                                case "clip":
+                                    object.clip = propertyValue
+                                    break;
+
+                                case "curved":
+                                    object.curved = propertyValue
+                                    break;
+
+                                case "closed":
+                                    object.closed = propertyValue
+                                    break;
+
+                                case "join":
+                                    object.join = propertyValue
+                                    break;
+
+                                case "automatic":
+                                    object.automatic = propertyValue
+                                    break;
+
+                                case "vertices":
+                                    object.vertices = [];
+                                    propertyValue.forEach(v => {
+                                        let a = new Two.Anchor(v.x, v.y);
+                                        object.vertices.push(a);
+                                    })
+                                    break;
+
+                                default:
+                                    value = undefined;
+                                    break;
+                            }
+                        }
+
+                        if (value === undefined && self.state.isTwoAnchorDefinition(node.prototypes)) {
+
+                            value = propertyValue;
+
+                            switch (propertyName) {
+
+
+                                case "x":
+
+                                    object.x = propertyValue
+                                    break;
+
+                                case "y":
+                                    object.y = propertyValue
+                                    break;
+
+                                case "command":
+                                    object.command = propertyValue
+                                    break;
+
+
+                                default:
+                                    value = undefined;
+                                    break;
+                            }
+                        }
+
+                        if (value === undefined && self.state.isTwoRectangleDefinition(node.prototypes)) {
+
+                            value = propertyValue;
+
+                            switch (propertyName) {
+
+
+                                case "height":
+
+                                    object.height = propertyValue
+                                    break;
+
+                                case "width":
+                                    object.width = propertyValue
+                                    break;
+
+
+
+                                default:
+                                    value = undefined;
+                                    break;
+                            }
+                        }
+
+                        if (value === undefined && self.state.isTwoEllipseDefinition(node.prototypes)) {
+
+                            value = propertyValue;
+
+                            switch (propertyName) {
+
+
+                                case "height":
+
+                                    object.height = propertyValue
+                                    break;
+
+                                case "width":
+                                    object.width = propertyValue
+                                    break;
+
+
+
+                                default:
+                                    value = undefined;
+                                    break;
+                            }
+                        }
+
+                        if (value === undefined && self.state.isTwoTextureDefinition(node.prototypes)) {
+
+                            value = propertyValue;
+
+                            switch (propertyName) {
+
+
+                                case "src":
+
+                                    object.src = propertyValue
+                                    break;
+
+
+
+                                default:
+                                    value = undefined;
+                                    break;
+                            }
+                        }
+
+
+
+                    }
+
+                    return value;
+
+                },
+
+                // -- gettingProperty ----------------------------------------------------------------------
+
+                gettingProperty: function (nodeID, propertyName, propertyValue) {
+
+                    let self = this;
+                    let node = this.state.nodes[nodeID];
+                    let value = undefined;
+                    if (node && node.obj) {
+
+                        let object = node.obj;
+
+                        if (value === undefined && self.state.isTwoGroupDefinition(node.prototypes)) {
+
+                            switch (propertyName) {
+
+                                case "x":
+                                    value = object.translation.x
+
+                                    break;
+
+                                case "y":
+                                    value = object.translation.y
+                                    break;
+
+                                case "translation":
+                                    let translation = [object.translation.x, object.translation.y]
+                                    value = translation
+
+                                    break;
+
+                                case "rotation":
+                                    value = object.rotation
+                                    break;
+
+                                case "scale":
+                                    value = object.scale
+                                    break;
+
+                                case "opacity":
+                                    value = object.opacity
+                                    break;
+
+                                case "twoWidth":
+                                    value = node.scene.obj.width
+                                    break;
+
+                                case "twoHeight":
+                                    value = node.scene.obj.height
+                                    break;
+
+
+                                case "visible":
+                                    value = object.visible
+                                    break;
+                                // case "mask":
+                                //     value =  object.mask
+                                //    break;
+
+                            }
+                        }
+
+
+                        if (value === undefined && self.state.isTwoTextDefinition(node.prototypes)) {
+
+                            switch (propertyName) {
+
+
+                                case "translation":
+                                    let translation = [object.translation.x, object.translation.y]
+                                    value = translation
+
+                                    break;
+
+                                case "rotation":
+                                    value = object.rotation
+                                    break;
+
+                                case "scale":
+                                    value = object.scale
+                                    break;
+
+                                case "fill":
+                                    value = object.fill
+                                    break;
+
+                                case "text":
+                                    value = object.value
+                                    break;
+
+                                case "family":
+                                    value = object.family
+                                    break;
+
+                                case "size":
+                                    value = object.size
+                                    break;
+
+                                case "stroke":
+                                    value = object.stroke
+                                    break;
+
+                                case "linewidth":
+
+                                    value = object.linewidth
+
+                                    break;
+
+                                case "opacity":
+                                    value = object.opacity
+                                    break;
+
+                                case "style":
+                                    value = object.style
+                                    break;
+
+
+                                case "weight":
+                                    value = object.weight
+                                    break;
+
+                                case "visible":
+                                    value = object.visible
+                                    break;
+
+                            }
+
+                        }
+
+                        if (value === undefined && self.state.isTwoPathDefinition(node.prototypes)) {
+
+                            switch (propertyName) {
+
+                                case "x":
+                                    value = object.translation.x
+
+                                    break;
+
+                                case "y":
+                                    value = object.translation.y
+                                    break;
+
+
+
+                                case "translation":
+                                    let translation = [object.translation.x, object.translation.y]
+                                    value = translation
+
+                                    break;
+
+                                case "rotation":
+                                    value = object.rotation
+                                    break;
+
+                                case "scale":
+                                    value = object.scale
+                                    break;
+
+                                case "fill":
+
+                                    if (typeof object.fill == 'object' && object.fill.src) {
+                                        value = object.fill.src
+                                    } else {
+                                        value = object.fill
+                                    }
+
+
+                                    break;
+
+                                case "stroke":
+                                    value = object.stroke
+                                    break;
+
+                                case "linewidth":
+
+                                    value = object.linewidth
+
+                                    break;
+
+                                case "opacity":
+                                    value = object.opacity
+                                    break;
+
+                                case "clip":
+                                    value = object.clip
+                                    break;
+
+
+                                case "twoWidth":
+                                    value = node.scene.obj.width
+                                    break;
+
+                                case "twoHeight":
+                                    value = node.scene.obj.height
+                                    break;
+
+                                case "curved":
+                                    value = object.curved
+                                    break;
+
+                                case "automatic":
+                                    value = object.automatic
+                                    break;
+
+                                case "closed":
+                                    value = object.closed
+                                    break;
+
+                                case "join":
+                                    value = object.join
+                                    break;
+
+                                case "vertices":
+                                    let anchors = object.vertices;
+                                    let vertices = anchors.map(a => {
+                                        return { x: a.x, y: a.y }
+                                    })
+                                    value = vertices
+                                    break;
+
+                            }
+                        }
+
+                        if (value === undefined && self.state.isTwoAnchorDefinition(node.prototypes)) {
+
+                            switch (propertyName) {
+
+                                case "x":
+                                    value = object.x
+                                    break;
+
+                                case "y":
+                                    value = object.y
+                                    break;
+
+                                case "command":
+                                    value = object.command
+                                    break;
+
+                            }
+                        }
+
+                        if (value === undefined && self.state.isTwoRectangleDefinition(node.prototypes)) {
+
+                            switch (propertyName) {
+
+                                case "height":
+                                    value = object.height
+                                    break;
+
+                                case "width":
+                                    value = object.width
+                                    break;
+
+                            }
+                        }
+
+                        if (value === undefined && self.state.isTwoEllipseDefinition(node.prototypes)) {
+
+                            switch (propertyName) {
+
+                                case "height":
+                                    value = object.height
+                                    break;
+
+                                case "width":
+                                    value = object.width
+                                    break;
+
+                            }
+                        }
+
+                        if (value === undefined && self.state.isTwoTextureDefinition(node.prototypes)) {
+
+                            switch (propertyName) {
+
+                                case "src":
+                                    value = object.src
+                                    break;
+
+                            }
+                        }
+
+
+                    }
+
+                    if (value !== undefined) {
+                        propertyValue = value;
+                    }
+
+                    return value;
+                }
+
+            });
+
+    }
+
+
+    getPrototypes(kernel, extendsID) {
+        var prototypes = [];
+        var id = extendsID;
+
+        while (id !== undefined) {
+            prototypes.push(id);
+            id = kernel.prototype(id);
+        }
+        return prototypes;
+    }
+}
+
+export {
+    TwoModel as default
+}