IJ2TPL.parse(`{?settings}{?account} {-}{?username} {username} {/username}{-} {?password} {password} {/password} {/account}{/settings}`);

let template = parse(`\
{?settings}
	{?account}
		{-}{?username}{username}{/username}
		{-}{?password}{password}{/password}
	{/account}
{/settings}
`);

/**
 * @param {string} name
 * @param {((value: any) => any)[]} filters
 * @returns {(context: Context) => any}
 */
function filter(name, filters) {
	/**
	 * @param {Context} context
	 * @returns {any}
	 */
	return function(context) {
		var value = context.resolve(name);

		for (var i = 0, l = filters.length; i < l; i++) {
			value = filters[i](value);
		}

		return value;
	}
}

function toUpperCase(string) {
	return string.toUpperCase();
}

var _v = {
	bookName: filter('name', [toUpperCase]),
	
};

exports.escape = function(string) {
    return JSON.stringify(string);
}

function escapeHTML(string) {
	return string.replace(/[&<>"'`=\/]/g, function(key) {
		return ({
			'&': '&amp;',
			'<': '&lt;',
			'>': '&gt;',
			'"': '&quot;',
			"'": '&#39;',
			'`': '&#x60;',
			'=': '&#x3D;',
			'/': '&#x2F;'
		})[key];
	});
}

var context = {
  cache: {},
  data: { A: 9 },
  parent: {
    cache: { 'A': 10 },
    data: { A: 10 },
    parent: null
  }
}

template.pipe('formatSize', function formatSize(size) {
    var i = 0,
    dataUnits = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB', 'BiB', 'NiB', 'DiB'];

    while (size >= 1024)
        i++, size /= 1024;

    return String(size.toFixed(2)) + dataUnits[i];
});

template.render("Hello"); // -> ''

// rollup.config.js

import { IJ2Loader } from './base-loader';

export default {
  input: 'src/main.js',
  output: {
    file: 'bundle.js',
    format: 'umd'
  },
  plugins: [ IJ2Loader() ]
};

var ij2tpl = require('./ij2tpl.min'),
	mustache = require('./mustache.min');

mustache.tags = ['{', '}'];

var renderData = (function() {
    var datas = [];
    for (var i = 0; i < 20000; i++) {
        datas.push({
            is_shown_in_index: i % 2,
            author: Math.pow(i, 2),
            tags: String(i).split(''),
            preview: 'https' + String(i)
        });
    }

    return datas;
})();

var timer = {
	startTime: 0,
	start: function() {
		this.startTime = new Date().getTime();
	},
	stop: function() {
		return new Date().getTime() - this.startTime;
	},
};

var engines = {
	ij2tpl: ij2tpl,
	mustache: mustache
};

var templates = {
	ij2tplTemplate: `
{?.}
	{?is_shown_in_index}
		{author} {tags} {preview_url}
	{*is_shown_in_index}
		{author} {tags} {preview_url}
	{/is_shown_in_index}
{/.}
`,
	mustacheTemplate: `
{#.}
	{#is_shown_in_index}
		{author} {tags} {preview_url}
	{/is_shown_in_index}
	{^is_shown_in_index}
		{author} {tags} {preview_url}
	{/is_shown_in_index}
{/.}
`,
	mustacheTemplate4ij2tpl: `
{?.}
	{?is_shown_in_index}
		{author} {tags} {preview_url}
	{/is_shown_in_index}
	{!is_shown_in_index}
		{author} {tags} {preview_url}
	{/is_shown_in_index}
{/.}
`
};

var templateInstances = [];

// Test engine parser
[
	['ij2tpl', 'ij2tplTemplate'],
	['mustache', 'mustacheTemplate'],
	['ij2tpl', 'mustacheTemplate4ij2tpl']
].forEach((tuple) => {
	var engine = tuple[0],
		template = tuple[1];

	timer.start();
	templateInstances.push([
		engine, template, 
		engines[engine].parse(templates[template])
	]);
	console.log(`${engine}.parse(${template}): ${timer.stop()}ms`);
});

// Test engine renderer
templateInstances.forEach((tuple) => {
	var engine = tuple[0],
		template = tuple[1],
		instance = tuple[2];

	timer.start();
	instance.render ?
		instance.render(renderData)
	:
		engines[engine].render(templates[template], renderData)
	;
	console.log(`${engine}.render(${template}, renderData): ${timer.stop()}ms`);
});

// Test engine resolver
[
	['ij2tpl', 'resolve'],
	['mustache', 'lookup']
].forEach(function(tuple) {
	var engine = tuple[0],
		method = tuple[1]
		context = new engines[engine]
			.Context({name: 'urain39' });

	for (let i = 0; i < renderData.length; i++)
		context = new engines[engine].Context({}, context);

	timer.start();
	eval(`context.${method}('name')`);
	console.log(`${engine}.Context.resolve('name'): ${timer.stop()}ms`);
});