function Node () {
    this._requestingUpdate = false;
    this._inUpdate = false;
    this._mounted = false;
    this._shown = true;
    this._updater = null;
    this._opacity = 1;
    this._UIEvents = [];

    this._updateQueue = [];
    this._nextUpdateQueue = [];

    this._freedComponentIndicies = [];
    this._components = [];

    this._freedChildIndicies = [];
    this._children = [];

    this._fullChildren = [];

    this._parent = null;

    this._id = null;

    this._transformID = null;
    this._sizeID = null;

    if (!this.constructor.NO_DEFAULT_COMPONENTS) this._init();
}
Nodes define hierarchy and geometrical transformations. They can be moved
(translated), scaled and rotated.

A Node is either mounted or unmounted. Unmounted nodes are detached from the
scene graph. Unmounted nodes have no parent node, while each mounted node has
exactly one parent. Nodes have an arbitrary number of children, which can be
dynamically added using {@link Node#addChild}.

Each Node has an arbitrary number of `components`. Those components can
send `draw` commands to the renderer or mutate the node itself, in which case
they define behavior in the most explicit way. Components that send `draw`
commands are considered `renderables`. From the node's perspective, there is
no distinction between nodes that send draw commands and nodes that define
behavior.

Because of the fact that Nodes themself are very unopinioted (they don't
"render" to anything), they are often being subclassed in order to add e.g.
components at initialization to them. Because of this flexibility, they might
as well have been called `Entities`.

@example
// create three detached (unmounted) nodes
var parent = new Node();
var child1 = new Node();
var child2 = new Node();

// build an unmounted subtree (parent is still detached)
parent.addChild(child1);
parent.addChild(child2);

// mount parent by adding it to the context
var context = Famous.createContext("body");
context.addChild(parent);

@class Node
@constructor