webr 0.0.5

data/ext/jsdom/lib/jsdom/level2/core.js

@@ -0,0 +1,406 @@
+var core = require("../level1/core").dom.level1.core,
+    sys  = require("sys");
+
+var testNamespaceName = function(ns, nsuri) {
+  if (!ns) {
+    throw new core.DOMException(core.INVALID_CHARACTER_ERR, "namespace is undefined");
+  }
+  if(ns.match(/[^0-9a-z\.:\-_]/i) !== null) {
+    throw new core.DOMException(core.INVALID_CHARACTER_ERR, ns);
+  }
+  if ((ns === 'xmlns' && nsuri !== "http://www.w3.org/2000/xmlns/") ||
+      (ns === "xml"   && nsuri !== "http://www.w3.org/XML/1998/namespace") ||
+      ns.indexOf('::') > -1 ||
+      nsuri === null ||
+      ns[ns.length-1] === ':' || // handle "namespace:"
+      ns[0] === ':' ||
+      ns.match(/.+:.+:/))
+  {
+    throw new core.DOMException(core.NAMESPACE_ERR);
+  }
+}
+
+var INVALID_STATE_ERR        = core.INVALID_STATE_ERR        = 11;
+var SYNTAX_ERR               = core.SYNTAX_ERR               = 12
+var INVALID_MODIFICATION_ERR = core.INVALID_MODIFICATION_ERR = 13;
+var NAMESPACE_ERR            = core.NAMESPACE_ERR            = 14;
+var INVALID_ACCESS_ERR       = core.INVALID_ACCESS_ERR       = 15;
+
+core.DOMImplementation.prototype.createDocumentType = function(/* String */ qualifiedName,
+                                                               /* String */ publicId,
+                                                               /* String */ systemId)
+{
+  testNamespaceName(qualifiedName);
+  var doctype = new core.DocumentType(null, qualifiedName);
+  doctype._publicId = publicId ? publicId : '';
+  doctype._systemId = systemId ? systemId : '';
+  return doctype;
+};
+
+/**
+  Creates an XML Document object of the specified type with its document element.
+  HTML-only DOM implementations do not need to implement this method.
+*/
+core.DOMImplementation.prototype.createDocument = function(/* String */       namespaceURI,
+                                                           /* String */       qualifiedName,
+                                                           /* DocumentType */ doctype)
+{
+  testNamespaceName(qualifiedName, namespaceURI);
+
+  if (doctype && doctype.ownerDocuemnt !== null) {
+    throw new core.DOMException(core.WRONG_DOCUMENT_ERR);
+  }
+
+  var document = new core.Document();
+  document.namespaceURI = namespaceURI;
+  document.qualifiedName = qualifiedName;
+  document.doctype = doctype;
+  document._ownerDocument = document;
+  return document;
+};
+
+core.Node.prototype.__defineGetter__("ownerDocument", function() {
+  return this._ownerDocument || null;
+});
+
+core.Node.prototype.isSupported = function(/* string */ feature,
+                                           /* string */ version)
+{
+  return this._ownerDocument._implementation.hasFeature(feature, version);
+};
+
+core.Node.prototype._namespaceURI = null;
+core.Node.prototype.__defineGetter__("namespaceURI", function() {
+  return this._namespaceURI || null;
+});
+
+core.Node.prototype.__defineSetter__("namespaceURI", function(value) {
+  this._namespaceURI = value;
+});
+
+core.Node.prototype.__defineGetter__("prefix", function() {
+  return this._prefix || null;
+});
+
+core.Node.prototype.__defineSetter__("prefix", function(value) {
+  if (this._prefix === "xmlns") {
+    throw new core.DOMException(core.NAMESPACE_ERR);
+  }
+  testNamespaceName(value, this._namespaceURI);
+
+  this._prefix = value;
+});
+
+core.Node.prototype.__defineGetter__("localName", function() {
+  return this._localName || null;
+});
+
+/* return boolean */
+core.Node.prototype.hasAttributes = function() {
+  return (this._attributes && this._attributes.length > 0);
+};
+
+
+core.NamedNodeMap.prototype.getNamedItemNS = function(/* string */ namespaceURI,
+                                                      /* string */ localName)
+{
+  var defaultNode = null;
+  return this._map(function(item) {
+
+    if (namespaceURI === item.namespaceURI)
+    {
+      if (item.localName === localName) {
+        return true;
+      }
+    } else if (!namespaceURI && !defaultNode) {
+      defaultNode = true;
+      return true;
+    }
+    return false;
+  })[0] || null;
+};
+
+core.AttrNodeMap.prototype.setNamedItem = function(/* Node */ arg) {
+  if (arg.nodeType !== this._ownerDocument.ATTRIBUTE_NODE) {
+    throw new core.DOMException(core.HIERARCHY_REQUEST_ERR);
+  }
+
+  return core.NamedNodeMap.prototype.setNamedItem.call(this, arg);
+};
+
+core.NamedNodeMap.prototype.setNamedItemNS = function(/* Node */ arg)
+{
+  var owner = this._ownerDocument;
+  if (this.parentNode &&
+      this.parentNode.parentNode &&
+      this.parentNode.parentNode.nodeType === owner.ENTITY_NODE)
+  {
+    throw new core.DOMException(core.NO_MODIFICATION_ALLOWED_ERR);
+  }
+
+  if (arg.nodeType !== owner.ATTRIBUTE_NODE) {
+    throw new core.DOMException(core.HIERARCHY_REQUEST_ERR);
+  }
+
+  if (arg.parentNode) {
+    throw new core.DOMException(core.INUSE_ATTRIBUTE_ERR);
+  }
+  return this.setNamedItem(arg);
+};
+
+core.NamedNodeMap.prototype.removeNamedItemNS = function(/*string */ namespaceURI,
+                                                         /* string */ localName)
+{
+  if (this.parentNode &&
+      this.parentNode.parentNode &&
+      this.parentNode.parentNode.nodeType === this._ownerDocument.ENTITY_NODE)
+  {
+    throw new core.DOMException(core.NO_MODIFICATION_ALLOWED_ERR);
+  }
+
+  throw new core.DOMException(core.NOT_FOUND_ERR);
+};
+
+core.Attr.prototype.__defineGetter__("ownerElement", function() {
+  return this._ownerElement || null;
+});
+
+core.Node.prototype.__defineSetter__("qualifiedName", function(qualifiedName) {
+  testNamespaceName(qualifiedName, this._namespaceURI);
+  qualifiedName       = qualifiedName || "";
+  this._localName     = qualifiedName.split(":")[1] || null;
+  this.prefix         = qualifiedName.split(":")[0] || null;
+  this._qualifiedName = qualifiedName;
+});
+
+core.NamedNodeMap.prototype._map = function(fn) {
+
+  if (this._attributes && this._attributes.length) {
+    var ret = [], l = this._attributes.length, i = 0, attribute;
+    for(i; i<l; i++) {
+      attribute = this._attributes.item(i);
+      if (fn && fn(attribute)) {
+        ret.push(attribute);
+      }
+    }
+    return ret;
+  }
+  return [];
+};
+
+core.Element.prototype.getAttributeNS = function(/* string */ namespaceURI,
+                                                 /* string */ localName)
+{
+  var attr = this._attributes._map(function(attr) {
+    if (namespaceURI === attr.namespaceURI &&
+        attr.localName === localName)
+    {
+      return true;
+    }
+  })[0];
+
+  return (attr) ? attr.nodeValue : null;
+};
+
+core.Element.prototype.setAttributeNS = function(/* string */ namespaceURI,
+                                                 /* string */ qualifiedName,
+                                                 /* string */ value)
+{
+
+  testNamespaceName(qualifiedName, namespaceURI);
+
+  if (qualifiedName.split(':').shift() === "xml" &&
+      namespaceURI !== "http://www.w3.org/XML/1998/namespace")
+  {
+    throw new core.DOMException(core.NAMESPACE_ERR);
+  }
+
+
+  var attr = this.setAttribute(qualifiedName, value);
+  attr.namespaceURI = namespaceURI;
+  var s = qualifiedName.split(':');
+  attr._localName = s.pop();
+  attr._prefix = (s.length > 0) ? s.pop() : null;
+
+
+  return attr;
+};
+
+core.Element.prototype.removeAttributeNS = function(/* string */ namespaceURI,
+                                                    /* string */ localName)
+{
+  var qualifiedName = this._attributes._map(function(attr) {
+    if (namespaceURI === attr.namespaceURI &&
+        attr.localName === localName)
+    {
+      return true;
+    }
+  })[0] || null;
+  return this.removeAttribute(qualifiedName);
+};
+
+core.Element.prototype.getAttributeNodeNS = function(/* string */ namespaceURI,
+                                                     /* string */ localName)
+{
+  return this._attributes._map(function(attr) {
+    if (namespaceURI === attr.namespaceURI &&
+        attr.localName === localName)
+    {
+      return true;
+    }
+  })[0] || null;
+};
+
+core.Element.prototype.setAttributeNodeNS = function(/* Attr */ newAttr)
+{
+  if (newAttr.ownerElement) {
+    throw new core.DOMException(core.INUSE_ATTRIBUTE_ERR);
+  }
+
+  newAttr._ownerElement = this;
+  return this.setAttributeNode(newAttr);
+};
+
+core.Element.prototype.getElementsByTagNameNS = function(/* String */ namespaceURI,
+                                                         /* String */ localName)
+{
+  var nsPrefixCache = {};
+  
+  function filterByTagName(child) {
+    if (child.nodeType && child.nodeType === this.ENTITY_REFERENCE_NODE) {
+      child = child._entity;
+    }
+
+    var localMatch = child.localName === localName,
+        nsMatch    = child.namespaceURI === namespaceURI;
+    if ((localMatch || localName === "*") &&
+        (nsMatch || namespaceURI === "*"))
+    {
+      return true;
+    }
+    return false;
+  }
+
+  var disableLiveLists = this.ownerDocument &&
+      this.ownerDocument.implementation &&
+      this.ownerDocument.implementation.hasFeature("DisableLiveLists");
+
+  return new core.NodeList(core.mapper(this, filterByTagName), !disableLiveLists);
+};
+
+core.Element.prototype.hasAttribute = function(/* string */name)
+{
+  if (!this.attributes) {
+    return false;
+  }
+  return this.attributes.exists(name);
+};
+
+core.Element.prototype.hasAttributeNS = function(/* string */namespaceURI,
+                                                 /* string */localName)
+{
+  if (!this._attributes        ||
+      !this._attributes.length ||
+      this._attributes.length < 1)
+  {
+    return false;
+  }
+  return this.hasAttribute(localName);
+};
+
+core.DocumentType.prototype.__defineGetter__("publicId", function() {
+  return this._publicId || "";
+});
+
+core.DocumentType.prototype.__defineGetter__("systemId", function() {
+  return this._systemId || "";
+});
+
+core.DocumentType.prototype.__defineGetter__("internalSubset", function() {
+  return this._internalSubset || null;
+});
+
+core.Document.prototype.importNode = function(/* Node */ importedNode,
+                                              /* bool */ deep)
+{
+  if (importedNode && importedNode.nodeType) {
+    if (importedNode.nodeType === this.DOCUMENT_NODE ||
+        importedNode.nodeType === this.DOCUMENT_TYPE_NODE) {
+      throw new core.DOMException(core.NOT_SUPPORTED_ERR);
+    }
+  }
+
+  var newNode = importedNode.cloneNode(deep);
+  newNode._ownerDocument = this;
+  newNode._ownerElement = null;
+  newNode._prefix = importedNode.prefix;
+  newNode._localName = importedNode.localName;
+  newNode._namespaceURI = importedNode.namespaceURI;
+  return newNode;
+};
+
+core.Document.prototype.createElementNS = function(/* string */ namespaceURI,
+                                                   /* string */ qualifiedName)
+{
+  testNamespaceName(qualifiedName, namespaceURI);
+
+  var element = this.createElement(qualifiedName),
+      sploded = qualifiedName.split(':');
+
+  element.namespaceURI = namespaceURI;
+  element.qualifiedName = qualifiedName;
+
+  element._localName = sploded.pop();
+
+  if (sploded.length > 0) {
+    element.prefix = sploded.pop();
+  } else if (namespaceURI === "http://www.w3.org/2000/xmlns/") {
+    element.prefix = "xmlns";
+  } else if (namespaceURI === "http://www.w3.org/XML/1998/namespace") {
+    element.prefix = "xml";
+  }
+
+  return element;
+};
+
+core.Document.prototype.createAttributeNS = function(/* string */ namespaceURI,
+                                                     /* string */ qualifiedName)
+{
+  testNamespaceName(qualifiedName, namespaceURI);
+  var attribute = this.createAttribute(qualifiedName);
+  attribute.qualifiedName = qualifiedName;
+  attribute.namespaceURI = namespaceURI;
+  var s = qualifiedName.split(':');
+  attribute._localName = s.pop();
+  attribute._prefix = (s.length > 0) ? s.pop() : null;
+  return attribute;
+};
+
+core.Element.prototype.__defineSetter__("id", function(id) {
+  this.setAttribute("id", id);
+  id = this.getAttribute("id"); //Passed validation
+  if (!this._ownerDocument._ids) {
+      this._ownerDocument._ids = {};
+  }
+  if (id === '') {
+      delete this._ownerDocument._ids[id];
+  } else {
+      this._ownerDocument._ids[id] = this;
+  }
+});
+
+core.Element.prototype.__defineGetter__("id",function() {
+  return this.getAttribute("id");
+});
+
+core.Document.prototype.getElementById = function(id) {
+  return this._ids[id] || null;
+};
+
+
+exports.dom =
+{
+  level2 : {
+    core : core
+  }
+};

data/ext/jsdom/lib/jsdom/level2/events.js

@@ -0,0 +1,358 @@
+/* DOM Level2 Events implemented as described here:
+ *
+ * http://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/events.html
+ *
+ */
+var core = require("./core").dom.level2.core,
+    sys = require("sys");
+
+var events = {};
+
+events.EventException = function() {
+    if (arguments.length > 0) {
+        this._code = arguments[0];
+    } else {
+        this._code = 0;
+    }
+    if (arguments.length > 1) {
+        this._message = arguments[1];
+    } else {
+        this._message = "Unspecified event type";
+    }
+    Error.call(this, this._message);
+    if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, events.EventException);
+    }
+};
+events.EventException.prototype = {
+  get UNSPECIFIED_EVENT_TYPE_ERR() { return 0; },
+  get code() { return this._code;}
+};
+events.EventException.prototype.__proto__ = Error.prototype;
+
+events.Event = function(eventType) { 
+    this._eventType = eventType;
+    this._type = null;
+    this._bubbles = null;
+    this._cancelable = null;
+    this._target = null;
+    this._currentTarget = null;
+    this._eventPhase = null;
+    this._timeStamp = null;
+    this._preventDefault = false;
+    this._stopPropagation = false;
+};
+events.Event.prototype = {
+    initEvent: function(type, bubbles, cancelable) {
+        this._type = type;
+        this._bubbles = bubbles;
+        this._cancelable = cancelable;
+    },
+    preventDefault: function() {
+        if (this._cancelable) {
+            this._preventDefault = true;
+        }
+    },
+    stopPropagation: function() {
+        this._stopPropagation = true;
+    },
+    get CAPTURING_PHASE() { return 1; },
+    get AT_TARGET() { return 2; },
+    get BUBBLING_PHASE() { return 3; },
+    get eventType() { return this._eventType; },
+    get type() { return this._type; },
+    get bubbles() { return this._bubbles; },
+    get cancelable() { return this._cancelable; },
+    get target() { return this._target; },
+    get currentTarget() { return this._currentTarget; },
+    get eventPhase() { return this._eventPhase; },
+    get timeStamp() { return this._timeStamp; }
+};
+
+events.HTMLEvent = function(eventType) {
+    events.Event.call(this, eventType);
+};
+events.HTMLEvent.prototype.__proto__ = events.Event.prototype;
+
+
+events.UIEvent = function(eventType) {
+    events.Event.call(this, eventType);
+    this.view = null;
+    this.detail = null;
+};
+events.UIEvent.prototype = {
+    initUIEvent: function(type, bubbles, cancelable, view, detail) {
+        this.initEvent(type, bubbles, cancelable);
+        this.view = view;
+        this.detail = detail;
+    },
+};
+events.UIEvent.prototype.__proto__ = events.Event.prototype;
+
+
+events.MouseEvent = function(eventType) {
+    events.UIEvent.call(this, eventType);
+    this.screenX = null;
+    this.screenY = null;
+    this.clientX = null;
+    this.clientY = null;
+    this.ctrlKey = null;
+    this.shiftKey = null;
+    this.altKey = null;
+    this.metaKey = null;
+    this.button = null;
+    this.relatedTarget = null;
+};
+events.MouseEvent.prototype = {
+    initMouseEvent:   function(type, 
+                               bubbles, 
+                               cancelable, 
+                               view, 
+                               detail, 
+                               screenX, 
+                               screenY, 
+                               clientX, 
+                               clientY, 
+                               ctrlKey, 
+                               altKey, 
+                               shiftKey, 
+                               metaKey, 
+                               button, 
+                               relatedTarget) {
+        this.initUIEvent(type, bubbles, cancelable, view, detail);
+        this.screenX  = screenX 
+        this.screenY  = screenY 
+        this.clientX  = clientX 
+        this.clientY  = clientY 
+        this.ctrlKey  = ctrlKey 
+        this.shiftKey  = shiftKey 
+        this.altKey  = altKey 
+        this.metaKey  = metaKey 
+        this.button  = button 
+        this.relatedTarget  = relatedTarget 
+    }
+};
+events.MouseEvent.prototype.__proto__ = events.UIEvent.prototype;
+
+
+events.MutationEvent = function(eventType) {
+    events.Event.call(this, eventType);
+    this.relatedNode = null;
+    this.prevValue = null;
+    this.newValue = null;
+    this.attrName = null;
+    this.attrChange = null;
+};
+events.MutationEvent.prototype = {
+    initMutationEvent:   function(type, 
+                                  bubbles, 
+                                  cancelable, 
+                                  relatedNode, 
+                                  prevValue, 
+                                  newValue, 
+                                  attrName, 
+                                  attrChange) {
+        this.initEvent(type, bubbles, cancelable);
+        this.relatedNode = relatedNode; 
+        this.prevValue = prevValue; 
+        this.newValue = newValue; 
+        this.attrName = attrName; 
+        this.attrChange = attrChange;
+    },
+    get MODIFICATION() { return 1; },
+    get ADDITION() { return 2; },
+    get REMOVAL() { return 3; },
+};
+events.MutationEvent.prototype.__proto__ = events.Event.prototype;
+
+
+events.EventTarget = function() {};
+events.EventTarget.prototype = {
+    addEventListener: function(type, listener, capturing) {
+        this._listeners = this._listeners || {};
+        var listeners = this._listeners[type] || {};
+        capturing = (capturing === true);
+        var capturingListeners = listeners[capturing] || []; 
+        for (var i=0; i < capturingListeners.length; i++) {
+            if (capturingListeners[i] === listener) {
+                return;
+            }
+        }
+        capturingListeners.push(listener);
+        listeners[capturing] = capturingListeners;
+        this._listeners[type] = listeners; 
+    },
+
+    removeEventListener: function(type, listener, capturing) {
+        var listeners  = this._listeners && this._listeners[type];
+        if (!listeners) return;
+        var capturingListeners = listeners[(capturing === true)]; 
+        if (!capturingListeners) return;
+        for (var i=0; i < capturingListeners.length; i++) {
+            if (capturingListeners[i] === listener) {
+                capturingListeners.splice(i, 1);
+                return;
+            }
+        }
+    },
+
+    dispatchEvent: function(event) {
+        if (event == null) {
+            throw new events.EventException(0, "Null event");
+        }
+        if (event._type == null || event._type == "") {
+            throw new events.EventException(0, "Uninitialized event");
+        }
+
+
+        var nextTarget = null;
+        var targetList = [];
+
+
+        function _getListeners(target, type, capturing) {
+            var listeners = target._listeners 
+                    && target._listeners[type] 
+                    && target._listeners[type][capturing];
+            if (listeners && listeners.length) {
+                return listeners;
+            }
+            return [];
+        }
+
+        function _dispatchEvent(event, iterator, capturing) {
+            var target = iterator();
+            while (target && !event._stopPropagation) {
+                listeners = _getListeners(target, event._type, capturing);
+                for (var y = 0; y < listeners.length; y++) {
+                    event._currentTarget = target; 
+                    try {
+                        listeners[y].call(target, event);
+                    } catch (e) {
+                        sys.log("Listener " 
+                            + sys.inspect(listeners[y])
+                            + "\n\n on target \n\n"
+                            + sys.inspect(target)
+                            + "\n\n threw error \n\n"
+                            + sys.inspect(e) 
+                            + "\n\n handling event \n\n" 
+                            + sys.inspect(event));
+                    }
+                }
+                target = iterator();
+            }
+            return !event._stopPropagation;
+        }
+            
+
+        event._target = this;
+
+        //per the spec we gather the list of targets first to ensure 
+        //against dom modifications during actual event dispatch
+        nextTarget = this.parentNode;
+        while (nextTarget) { 
+            targetList.push(nextTarget);
+            nextTarget = nextTarget.parentNode;
+        }
+
+
+        var i = targetList.length,
+        iterator = function() { return i >=0 ? targetList[--i] : null };
+
+        event._eventPhase = event.CAPTURING_PHASE;
+        if (!_dispatchEvent(event, iterator, true)) return event._preventDefault;
+
+
+        i = 1;
+        iterator = function() { return i-- ? event._target : null };
+        event._eventPhase = event.AT_TARGET;
+        if (!_dispatchEvent(event, iterator, false)) return event._preventDefault;
+        
+
+        if (event._bubbles && !event._stopPropagation) {
+            i = 0;
+            iterator = function() { return i < targetList.length ? targetList[i++] : null };
+            event._eventPhase = event.BUBBLING_PHASE;
+            _dispatchEvent(event, iterator, false);
+        }
+
+        return event._preventDefault;
+    }
+
+};
+
+
+core.Node.prototype.__proto__ = events.EventTarget.prototype;
+
+// Wrap the level-1 implementation of appendChild() to dispatch a DOMNodeInserted event
+(function(level1) {
+    core.Node.prototype.appendChild = function(newChild) {
+        var ret = level1.call(this, newChild);
+        if (this.nodeType == 1 && this.ownerDocument) {
+            var ev = this.ownerDocument.createEvent("MutationEvents");
+            ev.initMutationEvent("DOMNodeInserted", true, false, this, null, null, null, null);
+            newChild.dispatchEvent(ev);
+        }
+        return ret;
+    };
+})(core.Node.prototype.appendChild);
+
+// Wrap the level-1 implementation of removeChild() to dispatch a DOMNodeRemoved event
+(function(level1) {
+    core.Node.prototype.removeChild = function(oldChild) {
+        if (this.ownerDocument) {
+            var ev = this.ownerDocument.createEvent("MutationEvents");
+            ev.initMutationEvent("DOMNodeRemoved", true, false, this, null, null, null, null);
+            oldChild.dispatchEvent(ev);
+        }
+        return level1.call(this, oldChild);
+    };
+})(core.Node.prototype.removeChild);
+
+// Wrap the level-1 implementation to dispatch a DOMAttrModified event
+(function(level1) {
+    core.AttrNodeMap.prototype.removeNamedItem = function(name) {
+        var node,
+            target = this._parentNode,
+            ev = target.ownerDocument.createEvent("MutationEvents");
+        
+        node = level1.call(this, name);
+        
+        ev.initMutationEvent("DOMAttrModified", true, false, this._parentNode, node.value, null, node.name, ev.REMOVAL);
+        target.dispatchEvent(ev);
+        return node;
+    };
+})(core.AttrNodeMap.prototype.removeNamedItem);
+
+// Wrap the level-1 implementation to dispatch a DOMAttrModified event
+(function(level1) {
+    core.AttrNodeMap.prototype.setNamedItem = function(node) {
+        var target = this._parentNode,
+            ev = target.ownerDocument.createEvent("MutationEvents");
+
+        ev.initMutationEvent("DOMAttrModified", true, false, this._parentNode, null, node.value, node.name, ev.ADDITION);
+        node = level1.call(this, node);
+        target.dispatchEvent(ev);
+        return node;
+    };
+})(core.AttrNodeMap.prototype.setNamedItem);
+
+
+core.Document.prototype.createEvent = function(eventType) {
+    switch (eventType) {
+        case "MutationEvents": return new events.MutationEvent(eventType);
+        case "UIEvents": return new events.UIEvent(eventType);
+        case "MouseEvents": return new events.MouseEvent(eventType);
+        case "HTMLEvents": return new events.HTMLEvent(eventType);
+    }
+    return new events.Event(eventType);
+};
+
+
+exports.dom =
+{
+  level2 : {
+    core   : core,
+    events : events
+  }
+};
+