bundle.js

(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({"/media/sylvain/data/projects/absolute/DomNodeContainer.js":[function(require,module,exports){
var compose = require('ksf/utils/compose');
var Elmt = require('./Element');

/**
Permet de placer un composant dans un domNode enfant plutôt que dans le parentNode directement (crée un nouveau contexte)
*/
module.exports = compose(Elmt.prototype,  function(content) {
	Elmt.call(this, 'div');
	content.parentNode(this._domNode);
});
},{"./Element":"/media/sylvain/data/projects/absolute/Element.js","ksf/utils/compose":"/media/sylvain/data/projects/absolute/node_modules/ksf/utils/compose.js"}],"/media/sylvain/data/projects/absolute/Element.js":[function(require,module,exports){
var compose = require('ksf/utils/compose');

module.exports = compose(function(tag) {
	var node = this._domNode = document.createElement(tag || 'div');
	node.style.position = 'absolute';
	node.style.boxSizing = 'border-box';
	node.style.display = 'block'; // est-ce nécessaire de le forcer au démarrage ?
	this._visible = true;
}, {
	left: function(left) {
		if (arguments.length) {
			this._left = left;
			this._domNode.style.left = left+'px';
			return this;
		} else {
			return this._left;
		}
	},
	top: function(top) {
		if (arguments.length) {
			this._top = top;
			this._domNode.style.top = top+'px';
			return this;
		} else {
			return this._top;
		}
	},
	zIndex: function(zIndex) {
		if (arguments.length) {
			this._zIndex = zIndex;
			this._domNode.style.zIndex = zIndex;
			return this;
		} else {
			return this._zIndex;
		}
	},
	width: function(width) {
		if (arguments.length) {
			this._width = width;
			this._domNode.style.width = width+'px';
			return this;
		} else {
			return this._width;
		}
	},
	height: function(height) {
		if (arguments.length) {
			this._height = height;
			this._domNode.style.height = height+'px';
			return this;
		} else {
			return this._height;
		}
	},
	depth: function() {
		return 1;
	},
	parentNode: function(parentNode) {
		if (arguments.length) {
			if (parentNode) {
				parentNode.appendChild(this._domNode);
			} else {
				this._parentNode && this._parentNode.removeChild(this._domNode);
			}
			this._parentNode = parentNode;
			return this;
		} else {
			return this._parentNode;
		}
	},
	visible: function(visible) {
		if (arguments.length) {
			this._visible = visible;
			this._domNode.style.display = (visible ? 'block' : 'none');
			return this;
		} else {
			return this._visible;
		}
	},
}, {
	prop: function(prop, value) {
		this._domNode[prop] = value;
		return this;
	},
	props: function(props) {
		Object.keys(props).forEach(function(prop) {
			this.prop(prop, props[prop]);
		}, this);
	},
	styleProp: function(prop, value) {
		this._domNode.style[prop] = value;
	},
	style: function(style) {
		Object.keys(style).forEach(function(prop) {
			this.styleProp(prop, style[prop]);
		}, this);
	},
});

},{"ksf/utils/compose":"/media/sylvain/data/projects/absolute/node_modules/ksf/utils/compose.js"}],"/media/sylvain/data/projects/absolute/IncrementalContainer.js":[function(require,module,exports){
var compose = require('ksf/utils/compose');


module.exports = compose(function() {
	this._children = {};
}, {
	add: function(key, cmp) {
		this._children[key] = cmp;
		this._insertInParentNode(key);
		return cmp;
	},
	remove: function(key) {
		var cmp = this._children[key];
		this._removeFromParentNode(key);
		delete this._children[key];
		return cmp;
	},
	parentNode: function(node) {
		if (arguments.length) {
			this._parentNode = node;
			Object.keys(this._children).forEach(this._insertInParentNode, this);
			return this;
		} else {
			return this._parentNode;
		}
	},
	visible: function(visible) {
		if (arguments.length) {
			this._visible = visible;
			Object.keys(this._children).forEach(this._applyVisible, this);
			return this;
		} else {
			return this._visible;
		}
	},
	_insertInParentNode: function(key) {
		var cmp = this._children[key];
		cmp.parentNode(this._parentNode);
	},
	_removeFromParentNode: function(key) {
		var cmp = this._children[key];
		cmp.parentNode(null);
	},
	_applyVisible: function(key) {
		var cmp = this._children[key];
		cmp.visible(this._visible);
	},
});
},{"ksf/utils/compose":"/media/sylvain/data/projects/absolute/node_modules/ksf/utils/compose.js"}],"/media/sylvain/data/projects/absolute/Label.js":[function(require,module,exports){
var compose = require('ksf/utils/compose');
var Elmt = require('./Element');
var _ContentDelegate = require('./_ContentDelegate');

module.exports = compose(_ContentDelegate, function() {
	this._content = new Elmt();
}, {
	value: function(value) {
		this._content.prop('textContent', (typeof value === 'string' ? value : ''));
		return this;
	},
});

},{"./Element":"/media/sylvain/data/projects/absolute/Element.js","./_ContentDelegate":"/media/sylvain/data/projects/absolute/_ContentDelegate.js","ksf/utils/compose":"/media/sylvain/data/projects/absolute/node_modules/ksf/utils/compose.js"}],"/media/sylvain/data/projects/absolute/VPile.js":[function(require,module,exports){
var compose = require('ksf/utils/compose');
var delegateGetSet = require('./utils/delegateGetSet');

var Pile = require('./layout/Pile');
var Full = require('./layout/Full');
var ZFlat = require('./layout/ZFlat');
var IncrementalContainer = require('./IncrementalContainer');


// empile des composants en 'top' mais leur impose le 'width'
// incrémental
module.exports = compose(function() {
	this._container = new IncrementalContainer();
	this._verticalLayouter = new Pile('vertical');
	this._horizontalLayouter = new Full('horizontal');
	this._zLayouter = new ZFlat();
}, {
	add: function(key, cmp, beforeKey) {
		this._verticalLayouter.add(key, cmp, beforeKey);
		this._horizontalLayouter.add(key, cmp);
		this._zLayouter.add(key, cmp);
		this._container.add(key, cmp);
		return cmp;
	},
	remove: function(key) {
		var cmp = this._container.remove(key);
		this._verticalLayouter.remove(key);
		this._horizontalLayouter.remove(key);
		this._zLayouter.remove(key);
		return cmp;
	},
	width: delegateGetSet('_horizontalLayouter', 'size'),
	height: delegateGetSet('_verticalLayouter', 'size'),
	depth: delegateGetSet('_zLayouter', 'size'),
	left: delegateGetSet('_horizontalLayouter', 'position'),
	top: delegateGetSet('_verticalLayouter', 'position'),
	zIndex: delegateGetSet('_zLayouter', 'position'),
	parentNode: delegateGetSet('_container', 'parentNode'),
	visible: delegateGetSet('_container', 'visible'),

	// est-ce bien utile ?
/*	content: function(content) {
			// remove current children
			var children = this._verticalLayout.children();
			Object.keys(children).forEach(function(key) {
				this.remove(key);
			}, this);
			// add new children
			content.forEach(function(cmp, i) {
				this.add(i+'', cmp, null);
			}, this);
			return this;
		},
	at: function(key) {
		return this._container.children()[key].cmp;
	},
*/});

},{"./IncrementalContainer":"/media/sylvain/data/projects/absolute/IncrementalContainer.js","./layout/Full":"/media/sylvain/data/projects/absolute/layout/Full.js","./layout/Pile":"/media/sylvain/data/projects/absolute/layout/Pile.js","./layout/ZFlat":"/media/sylvain/data/projects/absolute/layout/ZFlat.js","./utils/delegateGetSet":"/media/sylvain/data/projects/absolute/utils/delegateGetSet.js","ksf/utils/compose":"/media/sylvain/data/projects/absolute/node_modules/ksf/utils/compose.js"}],"/media/sylvain/data/projects/absolute/VScroll.js":[function(require,module,exports){
var compose = require('ksf/utils/compose');
var delegateGetSet = require('./utils/delegateGetSet');

var Marge = require('./layout/Marge');
var DomNodeContainer = require('./DomNodeContainer');


/**
Impose la largeur à son enfant mais pas la hauteur
Crée un domNode avec un ascenseur toujours visible
*/
module.exports = compose(function(content, options) {
	this._content = content;
	this._container = new DomNodeContainer(content);
	content.left(0).top(0).zIndex(0);
	this._container.style({
		overflowX: 'hidden',
		overflowY: options && options.scrollbarDisplay || 'scroll',
	});
	this._horizontalLayouter = new Marge('horizontal', content, 0, options && options.scrollBarSize || 15);
}, {
	width: function(width) {
		if (arguments.length) {
			this._horizontalLayouter.size(width);
			this._container.width(width);
			return this;
		} else {
			return this._container.width();
		}
	},
	height: delegateGetSet('_container', 'height'),
	depth: delegateGetSet('_container', 'depth'),
	left: delegateGetSet('_container', 'left'),
	top: delegateGetSet('_container', 'top'),
	zIndex: delegateGetSet('_container', 'zIndex'),
	parentNode: delegateGetSet('_container', 'parentNode'),
	visible: delegateGetSet('_container', 'visible'),
});

},{"./DomNodeContainer":"/media/sylvain/data/projects/absolute/DomNodeContainer.js","./layout/Marge":"/media/sylvain/data/projects/absolute/layout/Marge.js","./utils/delegateGetSet":"/media/sylvain/data/projects/absolute/utils/delegateGetSet.js","ksf/utils/compose":"/media/sylvain/data/projects/absolute/node_modules/ksf/utils/compose.js"}],"/media/sylvain/data/projects/absolute/_ContentDelegate.js":[function(require,module,exports){
var delegateGetSet = require('./utils/delegateGetSet');

// délègue tous les get/set des propriétés de layout à '_content'
// réutilisable pour tous les cas où l'on veut simplement déléguer à un composant principal, en surchargeant uniquement certaines méthodes
module.exports = {
	width: delegateGetSet('_content', 'width'),
	height: delegateGetSet('_content', 'height'),
	depth: delegateGetSet('_content', 'depth'),
	left: delegateGetSet('_content', 'left'),
	top: delegateGetSet('_content', 'top'),
	zIndex: delegateGetSet('_content', 'zIndex'),
	parentNode: delegateGetSet('_content', 'parentNode'),
	visible: delegateGetSet('_content', 'visible'),
};
},{"./utils/delegateGetSet":"/media/sylvain/data/projects/absolute/utils/delegateGetSet.js"}],"/media/sylvain/data/projects/absolute/layout/Full.js":[function(require,module,exports){
var compose = require('ksf/utils/compose');
/**
Layouter qui positionne et dimensionne tous les enfants à la même position et dimension que lui-même
*/
module.exports = compose(function(axis) {
	this._children = {};
	this._sizeProp = (axis === 'vertical' ? 'height' : 'width');
	this._positionProp = (axis === 'vertical' ? 'top' : 'left');
}, {
	content: function(cmps) {
		Object.keys(this._children).forEach(this.remove, this);
		Object.keys(cmps).forEach(function(key) {
			this.add(key, cmps[key]);
		}, this);
		return this;
	},
	add: function(key, cmp) {
		this._children[key] = cmp;
		this._applySize(key);
		this._applyPosition(key);
	},
	remove: function(key) {
		delete this._children[key];
	},
	_applySize: function(key) {
		if (this._size) {
			this._children[key][this._sizeProp](this._size);
		}
	},
	_applyPosition: function(key) {
		if (typeof this._position === 'number') {
			this._children[key][this._positionProp](this._position);
		}
	},
	size: function(size) {
		if (arguments.length) {
			this._size = size;
			Object.keys(this._children).forEach(this._applySize, this);
			return this;
		} else {
			return this._size;
		}
	},
	position: function(position) {
		if (arguments.length) {
			this._position = position;
			Object.keys(this._children).forEach(this._applyPosition, this);
			return this;
		} else {
			return this._position;
		}
	},
});
},{"ksf/utils/compose":"/media/sylvain/data/projects/absolute/node_modules/ksf/utils/compose.js"}],"/media/sylvain/data/projects/absolute/layout/Marge.js":[function(require,module,exports){
var compose = require('ksf/utils/compose');

/**
Layouter qui dimensionne et positionne un enfant de façon réactive en fonction de sa taille et de sa position
*/

module.exports = compose(function(axis, content, headMarge, tailMarge) {
	this._sizeProp = (axis === 'horizontal' ? 'width' : 'height');
	this._positionProp = (axis === 'horizontal' ? 'left' : 'top');
	this._size = null;
	this._position = null;
	this._content = content;
	this._headMarge = headMarge;
	this._tailMarge = tailMarge;
}, {
	size: function(size) {
		if (arguments.length) {
			this._size = size;
			this._sizeContent();
			return this;
		} else {
			return this._size;
		}
	},
	position: function(position) {
		if (arguments.length) {
			this._position = position;
			this._positionContent();
			return this;
		} else {
			return this._position;
		}
	},
	_sizeContent: function() {
		this._content[this._sizeProp](this._size - (this._headMarge + this._tailMarge));
	},
	_positionContent: function() {
		this._content[this._positionProp](this._position + this._headMarge);
	},
});
},{"ksf/utils/compose":"/media/sylvain/data/projects/absolute/node_modules/ksf/utils/compose.js"}],"/media/sylvain/data/projects/absolute/layout/Pile.js":[function(require,module,exports){
var compose = require('ksf/utils/compose');

/**
Container qui positionne des enfants de taille fixe dans un ordre donné.
Peut-être utilisé de façon incrémental
*/
module.exports = compose(function(axis) {
	this._children = {};
	this._sizeProp = (axis === 'vertical' ? 'height' : 'width');
	this._positionProp = (axis === 'vertical' ? 'top' : 'left');
	this._firstChildKey = null;
	this._lastChildKey = null;
}, {
	content: function(config) {
		var sizeProp = this._sizeProp;
		var children = this._children = {};
		var offset = 0;
		var previous = null;
		config.forEach(function(child) {
			previous && (children[previous].next = child.key);
			var cmpSize = child.cmp[sizeProp]();
			children[child.key] = {
				previous: previous,
				next: null,
				key: child.key,
				cmp: child.cmp,
				size: cmpSize,
				offset: offset,
			};
			offset += cmpSize;
			previous = child.key;
		}, this);
		this._size = offset;

		this._firstChildKey = config[0].key;
		this._lastChildKey = config[config.length-1].key;
		this._layoutFrom(this._firstChildKey);

		// this._emit('size', this._size);

		return this;
	},
	add: function(key, cmp, beforeKey) {
		beforeKey = beforeKey || null;
		var sizeProp = this._sizeProp;

		var previousKey = beforeKey ? this._children[beforeKey].previous : this._lastChildKey;
		var previousChild = previousKey ? this._children[previousKey] : null;
		var offset = previousChild ? previousChild.offset + previousChild.size : 0;
		var cmpSize = cmp[sizeProp]();
		this._children[key] = {
			previous: previousKey,
			next: beforeKey,
			key: key,
			cmp: cmp,
			size: cmpSize,
			offset: offset,
		};
		previousKey && (this._children[previousKey].next = key);
		beforeKey && (this._children[beforeKey].previous = key);

		this._layoutFrom(key);
		if (beforeKey === this._firstChildKey) {
			this._firstChildKey = key;
		}
		if (beforeKey === null) {
			this._lastChildKey = key;
		}

		this._size = (this._size || 0) + cmpSize;
		// this._emit('size', this._size);
	},
	remove: function(key) {
		var child = this._children[key];

		var previousKey = child.previous;
		var previousChild = previousKey ? this._children[previousKey] : null;

		var nextKey = child.next;
		var nextChild = nextKey ? this._children[nextKey] : null;

		previousChild && (previousChild.next = nextKey);
		nextChild && (nextChild.previous = previousKey);

		this._layoutFrom(nextKey);
		if (previousKey === null) {
			this._firstChildKey = nextKey;
		}
		if (nextKey === null) {
			this._lastChildKey = previousKey;
		}

		delete this._children[key];

		this._size = this._size - child.size;
	},
	_layoutFrom: function(key) {
		var positionProp = this._positionProp;
		var children = this._children;
		while(key) {
			var child = children[key];
			var previousChild = children[child.previous];
			var offset = child.offset = previousChild ? previousChild.offset + previousChild.size : 0;
			child.cmp[positionProp](this._position + offset); // apply offset
			key = child.next;
		}
	},
	children: function() {
		return this._children;
	},
	position: function(position) {
		if (arguments.length) {
			this._position = position;
			this._layoutFrom(this._firstChildKey);
			return this;
		} else {
			return this._position;
		}
	},
	size: function() {
		return this._size;
	},
	// onSize: function(cb) {
	// 	return this._on('size', cb);
	// },
});

},{"ksf/utils/compose":"/media/sylvain/data/projects/absolute/node_modules/ksf/utils/compose.js"}],"/media/sylvain/data/projects/absolute/layout/ZFlat.js":[function(require,module,exports){
var compose = require('ksf/utils/compose');
/**
Layouter qui positionne tous les enfants à la même position et a comme dimension celle du plus grand enfant (mais ne diminue jamais de taille car en z ça ne sert à rien)
TODO: le rendre réactif
*/
module.exports = compose(function() {
	this._children = {};
	this._size = 0;
}, {
	content: function(cmps) {
		Object.keys(this._children).forEach(this.remove, this);
		Object.keys(cmps).forEach(function(key) {
			this.add(key, cmps[key]);
		}, this);
		return this;
	},
	add: function(key, cmp) {
		this._children[key] = cmp;
		this._applyPosition(key);
		this._updateSize(key);
	},
	remove: function(key) {
		delete this._children[key];
	},
	_updateSize: function(key) {
		var cmpSize = this._children[key].depth();
		if (cmpSize > this._size) {
			this._size = cmpSize;
		}
	},
	_applyPosition: function(key) {
		if (typeof this._position === 'number') {
			this._children[key].zIndex(this._position);
		}
	},
	size: function() {
		return this._size;
	},
	position: function(position) {
		if (arguments.length) {
			this._position = position;
			Object.keys(this._children).forEach(this._applyPosition, this);
			return this;
		} else {
			return this._position;
		}
	},
});
},{"ksf/utils/compose":"/media/sylvain/data/projects/absolute/node_modules/ksf/utils/compose.js"}],"/media/sylvain/data/projects/absolute/node_modules/ksf/utils/compose.js":[function(require,module,exports){
var compose = function (base) {
    var constructors = [];
    var prototypes = [];
    var trait;
    var i, props;
    for (i = 0; i < arguments.length; i++) {
        trait = arguments[i];
        if (typeof trait === 'function') {
            constructors.push(trait);
            prototypes.push(trait.prototype);
        } else {
            prototypes.push(trait);
        }
    }
    var constructorsLenght = constructors.length;
    var Ctr = function () {
        for (i = 0; i < constructorsLenght; i++) {
            constructors[i].apply(this, arguments);
        }
    };
    Ctr.prototype = Object.create(typeof base === 'function' ? base.prototype : base);
    for (i = 1; i < prototypes.length; i++) {
        props = prototypes[i];
        for (var key in props) {
            Ctr.prototype[key] = props[key];
        }
    }
    return Ctr;
};
compose.create = function (base) {
    var trait, instance, i, l, props;
    var constructors = [];
    if (typeof base === 'function') {
        instance = Object.create(base.prototype);
        constructors.push(base);
    } else {
        instance = Object.create(base);
    }
    for (i = 1, l = arguments.length; i < l; i++) {
        trait = arguments[i];
        if (typeof trait === 'function') {
            constructors.push(trait);
            props = trait.prototype;
        } else {
            props = trait;
        }
        for (var key in props) {
            instance[key] = props[key];
        }
    }
    for (i = 0, l = constructors.length; i < l; i++) {
        constructors[i].call(instance);
    }
    return instance;
};
module.exports = compose;
},{}],"/media/sylvain/data/projects/absolute/test/demo.js":[function(require,module,exports){
var VScroll = require('../VScroll');
var VPile = require('../VPile');
var Label = require('../Label');

var pile = new VPile().left(0).top(0).zIndex(0);

new VScroll(pile, {scrollbarDisplay: 'auto'}).left(0).top(0).zIndex(0).width(100).height(100).parentNode(document.body);

['syv', 'aur', 'ant', 'leo'].forEach(function(key) {
	pile.add(key, new Label().height(40).value(key));
});
},{"../Label":"/media/sylvain/data/projects/absolute/Label.js","../VPile":"/media/sylvain/data/projects/absolute/VPile.js","../VScroll":"/media/sylvain/data/projects/absolute/VScroll.js"}],"/media/sylvain/data/projects/absolute/utils/delegateGetSet.js":[function(require,module,exports){
module.exports = function delegateGetSet (component, method) {
	return function(value) {
		if (arguments.length) {
			this[component][method](value);
			return this;
		} else {
			return this[component][method]();
		}
	};
};

},{}]},{},["/media/sylvain/data/projects/absolute/test/demo.js"])
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../usr/lib/node_modules/watchify/node_modules/browserify/node_modules/browser-pack/_prelude.js","DomNodeContainer.js","Element.js","IncrementalContainer.js","Label.js","VPile.js","VScroll.js","_ContentDelegate.js","layout/Full.js","layout/Marge.js","layout/Pile.js","layout/ZFlat.js","node_modules/ksf/utils/compose.js","test/demo.js","utils/delegateGetSet.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","var compose = require('ksf/utils/compose');\nvar Elmt = require('./Element');\n\n/**\nPermet de placer un composant dans un domNode enfant plutôt que dans le parentNode directement (crée un nouveau contexte)\n*/\nmodule.exports = compose(Elmt.prototype,  function(content) {\n\tElmt.call(this, 'div');\n\tcontent.parentNode(this._domNode);\n});","var compose = require('ksf/utils/compose');\n\nmodule.exports = compose(function(tag) {\n\tvar node = this._domNode = document.createElement(tag || 'div');\n\tnode.style.position = 'absolute';\n\tnode.style.boxSizing = 'border-box';\n\tnode.style.display = 'block'; // est-ce nécessaire de le forcer au démarrage ?\n\tthis._visible = true;\n}, {\n\tleft: function(left) {\n\t\tif (arguments.length) {\n\t\t\tthis._left = left;\n\t\t\tthis._domNode.style.left = left+'px';\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._left;\n\t\t}\n\t},\n\ttop: function(top) {\n\t\tif (arguments.length) {\n\t\t\tthis._top = top;\n\t\t\tthis._domNode.style.top = top+'px';\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._top;\n\t\t}\n\t},\n\tzIndex: function(zIndex) {\n\t\tif (arguments.length) {\n\t\t\tthis._zIndex = zIndex;\n\t\t\tthis._domNode.style.zIndex = zIndex;\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._zIndex;\n\t\t}\n\t},\n\twidth: function(width) {\n\t\tif (arguments.length) {\n\t\t\tthis._width = width;\n\t\t\tthis._domNode.style.width = width+'px';\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._width;\n\t\t}\n\t},\n\theight: function(height) {\n\t\tif (arguments.length) {\n\t\t\tthis._height = height;\n\t\t\tthis._domNode.style.height = height+'px';\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._height;\n\t\t}\n\t},\n\tdepth: function() {\n\t\treturn 1;\n\t},\n\tparentNode: function(parentNode) {\n\t\tif (arguments.length) {\n\t\t\tif (parentNode) {\n\t\t\t\tparentNode.appendChild(this._domNode);\n\t\t\t} else {\n\t\t\t\tthis._parentNode && this._parentNode.removeChild(this._domNode);\n\t\t\t}\n\t\t\tthis._parentNode = parentNode;\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._parentNode;\n\t\t}\n\t},\n\tvisible: function(visible) {\n\t\tif (arguments.length) {\n\t\t\tthis._visible = visible;\n\t\t\tthis._domNode.style.display = (visible ? 'block' : 'none');\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._visible;\n\t\t}\n\t},\n}, {\n\tprop: function(prop, value) {\n\t\tthis._domNode[prop] = value;\n\t\treturn this;\n\t},\n\tprops: function(props) {\n\t\tObject.keys(props).forEach(function(prop) {\n\t\t\tthis.prop(prop, props[prop]);\n\t\t}, this);\n\t},\n\tstyleProp: function(prop, value) {\n\t\tthis._domNode.style[prop] = value;\n\t},\n\tstyle: function(style) {\n\t\tObject.keys(style).forEach(function(prop) {\n\t\t\tthis.styleProp(prop, style[prop]);\n\t\t}, this);\n\t},\n});\n","var compose = require('ksf/utils/compose');\n\n\nmodule.exports = compose(function() {\n\tthis._children = {};\n}, {\n\tadd: function(key, cmp) {\n\t\tthis._children[key] = cmp;\n\t\tthis._insertInParentNode(key);\n\t\treturn cmp;\n\t},\n\tremove: function(key) {\n\t\tvar cmp = this._children[key];\n\t\tthis._removeFromParentNode(key);\n\t\tdelete this._children[key];\n\t\treturn cmp;\n\t},\n\tparentNode: function(node) {\n\t\tif (arguments.length) {\n\t\t\tthis._parentNode = node;\n\t\t\tObject.keys(this._children).forEach(this._insertInParentNode, this);\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._parentNode;\n\t\t}\n\t},\n\tvisible: function(visible) {\n\t\tif (arguments.length) {\n\t\t\tthis._visible = visible;\n\t\t\tObject.keys(this._children).forEach(this._applyVisible, this);\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._visible;\n\t\t}\n\t},\n\t_insertInParentNode: function(key) {\n\t\tvar cmp = this._children[key];\n\t\tcmp.parentNode(this._parentNode);\n\t},\n\t_removeFromParentNode: function(key) {\n\t\tvar cmp = this._children[key];\n\t\tcmp.parentNode(null);\n\t},\n\t_applyVisible: function(key) {\n\t\tvar cmp = this._children[key];\n\t\tcmp.visible(this._visible);\n\t},\n});","var compose = require('ksf/utils/compose');\nvar Elmt = require('./Element');\nvar _ContentDelegate = require('./_ContentDelegate');\n\nmodule.exports = compose(_ContentDelegate, function() {\n\tthis._content = new Elmt();\n}, {\n\tvalue: function(value) {\n\t\tthis._content.prop('textContent', (typeof value === 'string' ? value : ''));\n\t\treturn this;\n\t},\n});\n","var compose = require('ksf/utils/compose');\nvar delegateGetSet = require('./utils/delegateGetSet');\n\nvar Pile = require('./layout/Pile');\nvar Full = require('./layout/Full');\nvar ZFlat = require('./layout/ZFlat');\nvar IncrementalContainer = require('./IncrementalContainer');\n\n\n// empile des composants en 'top' mais leur impose le 'width'\n// incrémental\nmodule.exports = compose(function() {\n\tthis._container = new IncrementalContainer();\n\tthis._verticalLayouter = new Pile('vertical');\n\tthis._horizontalLayouter = new Full('horizontal');\n\tthis._zLayouter = new ZFlat();\n}, {\n\tadd: function(key, cmp, beforeKey) {\n\t\tthis._verticalLayouter.add(key, cmp, beforeKey);\n\t\tthis._horizontalLayouter.add(key, cmp);\n\t\tthis._zLayouter.add(key, cmp);\n\t\tthis._container.add(key, cmp);\n\t\treturn cmp;\n\t},\n\tremove: function(key) {\n\t\tvar cmp = this._container.remove(key);\n\t\tthis._verticalLayouter.remove(key);\n\t\tthis._horizontalLayouter.remove(key);\n\t\tthis._zLayouter.remove(key);\n\t\treturn cmp;\n\t},\n\twidth: delegateGetSet('_horizontalLayouter', 'size'),\n\theight: delegateGetSet('_verticalLayouter', 'size'),\n\tdepth: delegateGetSet('_zLayouter', 'size'),\n\tleft: delegateGetSet('_horizontalLayouter', 'position'),\n\ttop: delegateGetSet('_verticalLayouter', 'position'),\n\tzIndex: delegateGetSet('_zLayouter', 'position'),\n\tparentNode: delegateGetSet('_container', 'parentNode'),\n\tvisible: delegateGetSet('_container', 'visible'),\n\n\t// est-ce bien utile ?\n/*\tcontent: function(content) {\n\t\t\t// remove current children\n\t\t\tvar children = this._verticalLayout.children();\n\t\t\tObject.keys(children).forEach(function(key) {\n\t\t\t\tthis.remove(key);\n\t\t\t}, this);\n\t\t\t// add new children\n\t\t\tcontent.forEach(function(cmp, i) {\n\t\t\t\tthis.add(i+'', cmp, null);\n\t\t\t}, this);\n\t\t\treturn this;\n\t\t},\n\tat: function(key) {\n\t\treturn this._container.children()[key].cmp;\n\t},\n*/});\n","var compose = require('ksf/utils/compose');\nvar delegateGetSet = require('./utils/delegateGetSet');\n\nvar Marge = require('./layout/Marge');\nvar DomNodeContainer = require('./DomNodeContainer');\n\n\n/**\nImpose la largeur à son enfant mais pas la hauteur\nCrée un domNode avec un ascenseur toujours visible\n*/\nmodule.exports = compose(function(content, options) {\n\tthis._content = content;\n\tthis._container = new DomNodeContainer(content);\n\tcontent.left(0).top(0).zIndex(0);\n\tthis._container.style({\n\t\toverflowX: 'hidden',\n\t\toverflowY: options && options.scrollbarDisplay || 'scroll',\n\t});\n\tthis._horizontalLayouter = new Marge('horizontal', content, 0, options && options.scrollBarSize || 15);\n}, {\n\twidth: function(width) {\n\t\tif (arguments.length) {\n\t\t\tthis._horizontalLayouter.size(width);\n\t\t\tthis._container.width(width);\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._container.width();\n\t\t}\n\t},\n\theight: delegateGetSet('_container', 'height'),\n\tdepth: delegateGetSet('_container', 'depth'),\n\tleft: delegateGetSet('_container', 'left'),\n\ttop: delegateGetSet('_container', 'top'),\n\tzIndex: delegateGetSet('_container', 'zIndex'),\n\tparentNode: delegateGetSet('_container', 'parentNode'),\n\tvisible: delegateGetSet('_container', 'visible'),\n});\n","var delegateGetSet = require('./utils/delegateGetSet');\n\n// délègue tous les get/set des propriétés de layout à '_content'\n// réutilisable pour tous les cas où l'on veut simplement déléguer à un composant principal, en surchargeant uniquement certaines méthodes\nmodule.exports = {\n\twidth: delegateGetSet('_content', 'width'),\n\theight: delegateGetSet('_content', 'height'),\n\tdepth: delegateGetSet('_content', 'depth'),\n\tleft: delegateGetSet('_content', 'left'),\n\ttop: delegateGetSet('_content', 'top'),\n\tzIndex: delegateGetSet('_content', 'zIndex'),\n\tparentNode: delegateGetSet('_content', 'parentNode'),\n\tvisible: delegateGetSet('_content', 'visible'),\n};","var compose = require('ksf/utils/compose');\n/**\nLayouter qui positionne et dimensionne tous les enfants à la même position et dimension que lui-même\n*/\nmodule.exports = compose(function(axis) {\n\tthis._children = {};\n\tthis._sizeProp = (axis === 'vertical' ? 'height' : 'width');\n\tthis._positionProp = (axis === 'vertical' ? 'top' : 'left');\n}, {\n\tcontent: function(cmps) {\n\t\tObject.keys(this._children).forEach(this.remove, this);\n\t\tObject.keys(cmps).forEach(function(key) {\n\t\t\tthis.add(key, cmps[key]);\n\t\t}, this);\n\t\treturn this;\n\t},\n\tadd: function(key, cmp) {\n\t\tthis._children[key] = cmp;\n\t\tthis._applySize(key);\n\t\tthis._applyPosition(key);\n\t},\n\tremove: function(key) {\n\t\tdelete this._children[key];\n\t},\n\t_applySize: function(key) {\n\t\tif (this._size) {\n\t\t\tthis._children[key][this._sizeProp](this._size);\n\t\t}\n\t},\n\t_applyPosition: function(key) {\n\t\tif (typeof this._position === 'number') {\n\t\t\tthis._children[key][this._positionProp](this._position);\n\t\t}\n\t},\n\tsize: function(size) {\n\t\tif (arguments.length) {\n\t\t\tthis._size = size;\n\t\t\tObject.keys(this._children).forEach(this._applySize, this);\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._size;\n\t\t}\n\t},\n\tposition: function(position) {\n\t\tif (arguments.length) {\n\t\t\tthis._position = position;\n\t\t\tObject.keys(this._children).forEach(this._applyPosition, this);\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._position;\n\t\t}\n\t},\n});","var compose = require('ksf/utils/compose');\n\n/**\nLayouter qui dimensionne et positionne un enfant de façon réactive en fonction de sa taille et de sa position\n*/\n\nmodule.exports = compose(function(axis, content, headMarge, tailMarge) {\n\tthis._sizeProp = (axis === 'horizontal' ? 'width' : 'height');\n\tthis._positionProp = (axis === 'horizontal' ? 'left' : 'top');\n\tthis._size = null;\n\tthis._position = null;\n\tthis._content = content;\n\tthis._headMarge = headMarge;\n\tthis._tailMarge = tailMarge;\n}, {\n\tsize: function(size) {\n\t\tif (arguments.length) {\n\t\t\tthis._size = size;\n\t\t\tthis._sizeContent();\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._size;\n\t\t}\n\t},\n\tposition: function(position) {\n\t\tif (arguments.length) {\n\t\t\tthis._position = position;\n\t\t\tthis._positionContent();\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._position;\n\t\t}\n\t},\n\t_sizeContent: function() {\n\t\tthis._content[this._sizeProp](this._size - (this._headMarge + this._tailMarge));\n\t},\n\t_positionContent: function() {\n\t\tthis._content[this._positionProp](this._position + this._headMarge);\n\t},\n});","var compose = require('ksf/utils/compose');\n\n/**\nContainer qui positionne des enfants de taille fixe dans un ordre donné.\nPeut-être utilisé de façon incrémental\n*/\nmodule.exports = compose(function(axis) {\n\tthis._children = {};\n\tthis._sizeProp = (axis === 'vertical' ? 'height' : 'width');\n\tthis._positionProp = (axis === 'vertical' ? 'top' : 'left');\n\tthis._firstChildKey = null;\n\tthis._lastChildKey = null;\n}, {\n\tcontent: function(config) {\n\t\tvar sizeProp = this._sizeProp;\n\t\tvar children = this._children = {};\n\t\tvar offset = 0;\n\t\tvar previous = null;\n\t\tconfig.forEach(function(child) {\n\t\t\tprevious && (children[previous].next = child.key);\n\t\t\tvar cmpSize = child.cmp[sizeProp]();\n\t\t\tchildren[child.key] = {\n\t\t\t\tprevious: previous,\n\t\t\t\tnext: null,\n\t\t\t\tkey: child.key,\n\t\t\t\tcmp: child.cmp,\n\t\t\t\tsize: cmpSize,\n\t\t\t\toffset: offset,\n\t\t\t};\n\t\t\toffset += cmpSize;\n\t\t\tprevious = child.key;\n\t\t}, this);\n\t\tthis._size = offset;\n\n\t\tthis._firstChildKey = config[0].key;\n\t\tthis._lastChildKey = config[config.length-1].key;\n\t\tthis._layoutFrom(this._firstChildKey);\n\n\t\t// this._emit('size', this._size);\n\n\t\treturn this;\n\t},\n\tadd: function(key, cmp, beforeKey) {\n\t\tbeforeKey = beforeKey || null;\n\t\tvar sizeProp = this._sizeProp;\n\n\t\tvar previousKey = beforeKey ? this._children[beforeKey].previous : this._lastChildKey;\n\t\tvar previousChild = previousKey ? this._children[previousKey] : null;\n\t\tvar offset = previousChild ? previousChild.offset + previousChild.size : 0;\n\t\tvar cmpSize = cmp[sizeProp]();\n\t\tthis._children[key] = {\n\t\t\tprevious: previousKey,\n\t\t\tnext: beforeKey,\n\t\t\tkey: key,\n\t\t\tcmp: cmp,\n\t\t\tsize: cmpSize,\n\t\t\toffset: offset,\n\t\t};\n\t\tpreviousKey && (this._children[previousKey].next = key);\n\t\tbeforeKey && (this._children[beforeKey].previous = key);\n\n\t\tthis._layoutFrom(key);\n\t\tif (beforeKey === this._firstChildKey) {\n\t\t\tthis._firstChildKey = key;\n\t\t}\n\t\tif (beforeKey === null) {\n\t\t\tthis._lastChildKey = key;\n\t\t}\n\n\t\tthis._size = (this._size || 0) + cmpSize;\n\t\t// this._emit('size', this._size);\n\t},\n\tremove: function(key) {\n\t\tvar child = this._children[key];\n\n\t\tvar previousKey = child.previous;\n\t\tvar previousChild = previousKey ? this._children[previousKey] : null;\n\n\t\tvar nextKey = child.next;\n\t\tvar nextChild = nextKey ? this._children[nextKey] : null;\n\n\t\tpreviousChild && (previousChild.next = nextKey);\n\t\tnextChild && (nextChild.previous = previousKey);\n\n\t\tthis._layoutFrom(nextKey);\n\t\tif (previousKey === null) {\n\t\t\tthis._firstChildKey = nextKey;\n\t\t}\n\t\tif (nextKey === null) {\n\t\t\tthis._lastChildKey = previousKey;\n\t\t}\n\n\t\tdelete this._children[key];\n\n\t\tthis._size = this._size - child.size;\n\t},\n\t_layoutFrom: function(key) {\n\t\tvar positionProp = this._positionProp;\n\t\tvar children = this._children;\n\t\twhile(key) {\n\t\t\tvar child = children[key];\n\t\t\tvar previousChild = children[child.previous];\n\t\t\tvar offset = child.offset = previousChild ? previousChild.offset + previousChild.size : 0;\n\t\t\tchild.cmp[positionProp](this._position + offset); // apply offset\n\t\t\tkey = child.next;\n\t\t}\n\t},\n\tchildren: function() {\n\t\treturn this._children;\n\t},\n\tposition: function(position) {\n\t\tif (arguments.length) {\n\t\t\tthis._position = position;\n\t\t\tthis._layoutFrom(this._firstChildKey);\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._position;\n\t\t}\n\t},\n\tsize: function() {\n\t\treturn this._size;\n\t},\n\t// onSize: function(cb) {\n\t// \treturn this._on('size', cb);\n\t// },\n});\n","var compose = require('ksf/utils/compose');\n/**\nLayouter qui positionne tous les enfants à la même position et a comme dimension celle du plus grand enfant (mais ne diminue jamais de taille car en z ça ne sert à rien)\nTODO: le rendre réactif\n*/\nmodule.exports = compose(function() {\n\tthis._children = {};\n\tthis._size = 0;\n}, {\n\tcontent: function(cmps) {\n\t\tObject.keys(this._children).forEach(this.remove, this);\n\t\tObject.keys(cmps).forEach(function(key) {\n\t\t\tthis.add(key, cmps[key]);\n\t\t}, this);\n\t\treturn this;\n\t},\n\tadd: function(key, cmp) {\n\t\tthis._children[key] = cmp;\n\t\tthis._applyPosition(key);\n\t\tthis._updateSize(key);\n\t},\n\tremove: function(key) {\n\t\tdelete this._children[key];\n\t},\n\t_updateSize: function(key) {\n\t\tvar cmpSize = this._children[key].depth();\n\t\tif (cmpSize > this._size) {\n\t\t\tthis._size = cmpSize;\n\t\t}\n\t},\n\t_applyPosition: function(key) {\n\t\tif (typeof this._position === 'number') {\n\t\t\tthis._children[key].zIndex(this._position);\n\t\t}\n\t},\n\tsize: function() {\n\t\treturn this._size;\n\t},\n\tposition: function(position) {\n\t\tif (arguments.length) {\n\t\t\tthis._position = position;\n\t\t\tObject.keys(this._children).forEach(this._applyPosition, this);\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this._position;\n\t\t}\n\t},\n});","var compose = function (base) {\n    var constructors = [];\n    var prototypes = [];\n    var trait;\n    var i, props;\n    for (i = 0; i < arguments.length; i++) {\n        trait = arguments[i];\n        if (typeof trait === 'function') {\n            constructors.push(trait);\n            prototypes.push(trait.prototype);\n        } else {\n            prototypes.push(trait);\n        }\n    }\n    var constructorsLenght = constructors.length;\n    var Ctr = function () {\n        for (i = 0; i < constructorsLenght; i++) {\n            constructors[i].apply(this, arguments);\n        }\n    };\n    Ctr.prototype = Object.create(typeof base === 'function' ? base.prototype : base);\n    for (i = 1; i < prototypes.length; i++) {\n        props = prototypes[i];\n        for (var key in props) {\n            Ctr.prototype[key] = props[key];\n        }\n    }\n    return Ctr;\n};\ncompose.create = function (base) {\n    var trait, instance, i, l, props;\n    var constructors = [];\n    if (typeof base === 'function') {\n        instance = Object.create(base.prototype);\n        constructors.push(base);\n    } else {\n        instance = Object.create(base);\n    }\n    for (i = 1, l = arguments.length; i < l; i++) {\n        trait = arguments[i];\n        if (typeof trait === 'function') {\n            constructors.push(trait);\n            props = trait.prototype;\n        } else {\n            props = trait;\n        }\n        for (var key in props) {\n            instance[key] = props[key];\n        }\n    }\n    for (i = 0, l = constructors.length; i < l; i++) {\n        constructors[i].call(instance);\n    }\n    return instance;\n};\nmodule.exports = compose;","var VScroll = require('../VScroll');\nvar VPile = require('../VPile');\nvar Label = require('../Label');\n\nvar pile = new VPile().left(0).top(0).zIndex(0);\n\nnew VScroll(pile, {scrollbarDisplay: 'auto'}).left(0).top(0).zIndex(0).width(100).height(100).parentNode(document.body);\n\n['syv', 'aur', 'ant', 'leo'].forEach(function(key) {\n\tpile.add(key, new Label().height(40).value(key));\n});","module.exports = function delegateGetSet (component, method) {\n\treturn function(value) {\n\t\tif (arguments.length) {\n\t\t\tthis[component][method](value);\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn this[component][method]();\n\t\t}\n\t};\n};\n"]}