text: (() => {
  
  	const names = /^(?:\[(app|inc|test|node|lib)\])?([-:_a-zA-Z0-9]+)$/;
  
  	const _cache = { def: { app: {}, lib: {}, test: {} }, inc: { lib: {} } };
  
  	const argv = ('object' === typeof navigator)
  		? window.location.search.substr(1).split('&')
  		: process.argv;
  
  	function parseArguments() {
  		const candidates = argv.filter(a => -1 !== a.indexOf('='));
  		return candidates.reduce((a, b) => {
  			const [k, v] = b.split('=');
  			a[k] = a[k] || [];
  			a[k].push(v);
  			return a;
  		}, {});
  	}
  
  	function parseFlags() {
  		const candidates = argv.filter(a => 0 === a.indexOf('--'));
  		return candidates.reduce((a, b) => {
  			const k = b.substr(2);
  			a[k] = true;
  			return a;
  		}, {});
  	}
  
  	const args = parseArguments();
  	const flags = parseFlags();
  
  	function getInterface(name)  {
  		const info = decodeName(name, 'inc');
  		const module = _cache.inc.lib[info.name];
  		if (!module) {
  			throw new Error(`invalid interface: ${JSON.stringify(info)}`);
  		}
  		return module || null;
  	};
  
  	function decodeName(name, type) {
  		const matches = names.exec(name);
  		const info = !matches ? null : {
  			type: matches[1] || type || null,
  			name: matches[2]
  		};
  		if (!info) {
  			throw `invalid component name: ${name}`;
  		}
  		return info;
  	};
  
  	function Modular(name, definition) {
  		this.dependencies = definition || {};
  		this.name = name;
  		this.args = args;
  		this.flags = flags;
  		if (-1 !== name.indexOf('mdlr::')) {
  			this.cache = _cache;
  			this.decodeName = decodeName;
  			this.getInterface = getInterface;
  		}
  	}
  
  	Modular.prototype.expose = function (name, object) {
  		const missing = [];
  		const definition = getInterface(name);
  		const wrapper = Object.keys(definition).reduce((scope, member) => {
  			if (!object[member]) {
  				missing.push(`- '${member}' is not implemented`);
  			}
  			else {
  				scope[member] = object[member].bind(object);
  			}
  			return scope;
  		}, {});
  
  		if (missing.length) {
  			throw new Error(`'${name}' not fully implemented by '${this.name}'\n${missing.join('\n')}`);
  		}
  		return Object.freeze(wrapper);
  	}
  
  	Modular.prototype.require = function (name, inject) {
  		if ((-1 !== name.indexOf('mdlr::') && -1 === this.name.indexOf('mdlr::'))) {
  			throw new Error('Invalid use of mdlr modules');
  		}
  
  		if (this.dependencies[name]) {
  			return this.dependencies[name];
  		}
  
  		const info = decodeName(name, 'lib');
  		if (info.type === 'node' && typeof require !== 'undefined') {
  			return require(info.name);
  		}
  		const module = _cache.def[info.type][info.name];
  		if (!module) {
  			throw new Error(`invalid require: ${JSON.stringify(info)}`);
  		}
  		return module(new Modular(info.name, inject || null));
  	}
  
  	mdlr = (name, definition) => {
  		const info = decodeName(name, 'lib');
  
  		// interface definition
  		if ('object' === typeof definition) {
  			_cache.inc.lib[info.name] = definition;
  			return;
  		}
  
  		// module definitions
  		if ('function' === typeof definition) {
  			if (_cache.def[info.type][info.name]) {
  				throw new Error(`double registration of ${JSON.stringify(info)}`);
  			}
  			_cache.def[info.type][info.name] = definition;
  			return;
  		}
  
  		// module invocations
  		const module = _cache.def[info.type][info.name];
  		if (!module) {
  			throw new Error(`invalid definition: ${JSON.stringify(info)}`);
  		}
  		module(new Modular(info.name, definition));
  	};
  
  })();