@kosatyi/ejs 0.0.96 → 0.0.98

package/dist/cjs/index.js

@@ -1,7 +1,141 @@
 'use strict';
 
-var fs = require('fs');
-var path = require('path');
+var fs = require('node:fs');
+var path = require('node:path');
+
+function _assertClassBrand(e, t, n) {
+  if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+  throw new TypeError("Private element is not present on this object");
+}
+function _assertThisInitialized(e) {
+  if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+function _callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function _checkPrivateRedeclaration(e, t) {
+  if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _classPrivateFieldGet2(s, a) {
+  return s.get(_assertClassBrand(s, a));
+}
+function _classPrivateFieldInitSpec(e, t, a) {
+  _checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+function _classPrivateFieldSet2(s, a, r) {
+  return s.set(_assertClassBrand(s, a), r), r;
+}
+function _classPrivateMethodInitSpec(e, a) {
+  _checkPrivateRedeclaration(e, a), a.add(e);
+}
+function _construct(t, e, r) {
+  if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, e);
+  var p = new (t.bind.apply(t, o))();
+  return r && _setPrototypeOf(p, r.prototype), p;
+}
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+function _getPrototypeOf(t) {
+  return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+    return t.__proto__ || Object.getPrototypeOf(t);
+  }, _getPrototypeOf(t);
+}
+function _inherits(t, e) {
+  if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(e && e.prototype, {
+    constructor: {
+      value: t,
+      writable: !0,
+      configurable: !0
+    }
+  }), Object.defineProperty(t, "prototype", {
+    writable: !1
+  }), e && _setPrototypeOf(t, e);
+}
+function _isNativeFunction(t) {
+  try {
+    return -1 !== Function.toString.call(t).indexOf("[native code]");
+  } catch (n) {
+    return "function" == typeof t;
+  }
+}
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function () {
+    return !!t;
+  })();
+}
+function _possibleConstructorReturn(t, e) {
+  if (e && ("object" == typeof e || "function" == typeof e)) return e;
+  if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
+  return _assertThisInitialized(t);
+}
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (String )(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _wrapNativeSuper(t) {
+  var r = "function" == typeof Map ? new Map() : void 0;
+  return _wrapNativeSuper = function (t) {
+    if (null === t || !_isNativeFunction(t)) return t;
+    if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
+    if (void 0 !== r) {
+      if (r.has(t)) return r.get(t);
+      r.set(t, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(t, arguments, _getPrototypeOf(this).constructor);
+    }
+    return Wrapper.prototype = Object.create(t.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      }
+    }), _setPrototypeOf(Wrapper, t);
+  }, _wrapNativeSuper(t);
+}
 
 var typeProp = function typeProp() {
   var args = [].slice.call(arguments);
@@ -67,6 +201,9 @@ var safeValue = function safeValue(value, escape) {
 var instanceOf = function instanceOf(object, instance) {
   return Boolean(object instanceof instance);
 };
+var assertInstanceOf = function assertInstanceOf(object, instance) {
+  if (instanceOf(object, instance) === false) throw new TypeError("".concat(object, " in not instance of ").concat(instance));
+};
 var getPath = function getPath(context, name, strict) {
   var data = context;
   var chunks = String(name).split('.');
@@ -87,6 +224,14 @@ var getPath = function getPath(context, name, strict) {
   }
   return [data, prop];
 };
+var bindContext = function bindContext(object) {
+  var methods = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  methods.forEach(function (name) {
+    if (name in object) {
+      object[name] = object[name].bind(object);
+    }
+  });
+};
 var ext = function ext(path, defaults) {
   var ext = path.split('.').pop();
   if (ext !== defaults) {
@@ -149,6 +294,13 @@ var omit = function omit(object, list) {
     }
   });
 };
+
+/**
+ *
+ * @param object
+ * @param prop
+ * @return {boolean}
+ */
 var hasProp = function hasProp(object, prop) {
   return object && object.hasOwnProperty(prop);
 };
@@ -157,6 +309,17 @@ var joinPath = function joinPath(path, template) {
   template = template.replace(/\/\//g, '/');
   return template;
 };
+var matchTokens = function matchTokens(regex, text, callback) {
+  var index = 0;
+  text.replace(regex, function () {
+    var params = [].slice.call(arguments, 0, -1);
+    var offset = params.pop();
+    var match = params.shift();
+    callback(params, index, offset);
+    index = offset + match.length;
+    return match;
+  });
+};
 
 var defaults = {};
 defaults["export"] = 'ejsPrecompiled';
@@ -202,206 +365,221 @@ var configSchema = function configSchema(config, options) {
 };
 
 var global = typeof globalThis !== 'undefined' ? globalThis : window || self;
-function Cache(config) {
-  if (instanceOf(this, Cache) === false) return new Cache();
-  var cache = {
-    enabled: true,
-    list: {}
-  };
-  this.configure = function (config) {
-    cache.enabled = config.cache;
-    if (isNode() === false) {
-      this.load(global[config["export"]]);
+var _enabled = /*#__PURE__*/new WeakMap();
+var _list = /*#__PURE__*/new WeakMap();
+var Cache = /*#__PURE__*/function () {
+  function Cache(config) {
+    _classCallCheck(this, Cache);
+    _classPrivateFieldInitSpec(this, _enabled, true);
+    _classPrivateFieldInitSpec(this, _list, {});
+    bindContext(this, ['configure']);
+    this.configure(config);
+  }
+  return _createClass(Cache, [{
+    key: "load",
+    value: function load(data) {
+      if (_classPrivateFieldGet2(_enabled, this)) {
+        extend(_classPrivateFieldGet2(_list, this), data || {});
+      }
     }
-  };
-  this.clear = function () {
-    cache.list = {};
-  };
-  this.load = function (data) {
-    if (cache.enabled) {
-      extend(cache.list, data || {});
+  }, {
+    key: "get",
+    value: function get(key) {
+      if (_classPrivateFieldGet2(_enabled, this)) {
+        return _classPrivateFieldGet2(_list, this)[key];
+      }
     }
-    return this;
-  };
-  this.get = function (key) {
-    if (cache.enabled) {
-      return cache.list[key];
+  }, {
+    key: "set",
+    value: function set(key, value) {
+      if (_classPrivateFieldGet2(_enabled, this)) {
+        _classPrivateFieldGet2(_list, this)[key] = value;
+      }
     }
-  };
-  this.set = function (key, value) {
-    if (cache.enabled) {
-      cache.list[key] = value;
+  }, {
+    key: "exist",
+    value: function exist(key) {
+      return hasProp(_classPrivateFieldGet2(_list, this), key);
     }
-    return this;
-  };
-  this.resolve = function (key) {
-    return Promise.resolve(this.get(key));
-  };
-  this.remove = function (key) {
-    delete cache.list[key];
-  };
-  this.exist = function (key) {
-    return hasProp(cache.list, key);
-  };
-}
+  }, {
+    key: "clear",
+    value: function clear() {
+      _classPrivateFieldSet2(_list, this, {});
+    }
+  }, {
+    key: "remove",
+    value: function remove(key) {
+      delete _classPrivateFieldGet2(_list, this)[key];
+    }
+  }, {
+    key: "resolve",
+    value: function resolve(key) {
+      return Promise.resolve(this.get(key));
+    }
+  }, {
+    key: "configure",
+    value: function configure(config) {
+      _classPrivateFieldSet2(_enabled, this, config.cache);
+      if (isNode() === false) {
+        this.load(global[config["export"]]);
+      }
+    }
+  }]);
+}();
 
-var tagList = [{
-  symbol: '-',
-  format: function format(value) {
-    return "')\n".concat(this.BUFFER, "(").concat(this.SAFE, "(").concat(value, ",1))\n").concat(this.BUFFER, "('");
-  }
-}, {
-  symbol: '=',
-  format: function format(value) {
-    return "')\n".concat(this.BUFFER, "(").concat(this.SAFE, "(").concat(value, "))\n").concat(this.BUFFER, "('");
-  }
-}, {
-  symbol: '#',
-  format: function format(value) {
-    return "')\n/**".concat(value, "**/\n").concat(this.BUFFER, "('");
-  }
-}, {
-  symbol: '',
-  format: function format(value) {
-    return "')\n".concat(value.trim(), "\n").concat(this.BUFFER, "('");
+var _config$1 = /*#__PURE__*/new WeakMap();
+var _symbols = /*#__PURE__*/new WeakMap();
+var Compiler = /*#__PURE__*/function () {
+  function Compiler(config) {
+    _classCallCheck(this, Compiler);
+    _classPrivateFieldInitSpec(this, _config$1, {});
+    _classPrivateFieldInitSpec(this, _symbols, [{
+      symbol: '-',
+      format: function format(value) {
+        return "')\n".concat(this.BUFFER, "(").concat(this.SAFE, "(").concat(value, ",1))\n").concat(this.BUFFER, "('");
+      }
+    }, {
+      symbol: '=',
+      format: function format(value) {
+        return "')\n".concat(this.BUFFER, "(").concat(this.SAFE, "(").concat(value, "))\n").concat(this.BUFFER, "('");
+      }
+    }, {
+      symbol: '#',
+      format: function format(value) {
+        return "')\n/**".concat(value, "**/\n").concat(this.BUFFER, "('");
+      }
+    }, {
+      symbol: '',
+      format: function format(value) {
+        return "')\n".concat(value.trim(), "\n").concat(this.BUFFER, "('");
+      }
+    }]);
+    bindContext(this, ['configure', 'compile']);
+    this.configure(config);
   }
-}];
-function matchTokens(regex, text, callback) {
-  var index = 0;
-  text.replace(regex, function () {
-    var params = [].slice.call(arguments, 0, -1);
-    var offset = params.pop();
-    var match = params.shift();
-    callback(params, index, offset);
-    index = offset + match.length;
-    return match;
-  });
-}
-function Compiler(config) {
-  if (instanceOf(this, Compiler) === false) return new Compiler(config);
-  var compiler = {};
-  this.configure = function (config) {
-    compiler.withObject = config.withObject;
-    compiler.rmWhitespace = config.rmWhitespace;
-    compiler.token = config.token;
-    compiler.vars = config.vars;
-    compiler.globalHelpers = config.globalHelpers;
-    compiler.matches = [];
-    compiler.formats = [];
-    compiler.slurp = {
-      match: '[\s\t\n]*',
-      start: [compiler.token.start, '_'],
-      end: ['_', compiler.token.end]
-    };
-    tagList.forEach(function (item) {
-      compiler.matches.push(compiler.token.start.concat(item.symbol).concat(compiler.token.regex).concat(compiler.token.end));
-      compiler.formats.push(item.format.bind(compiler.vars));
-    });
-    compiler.regex = new RegExp(compiler.matches.join('|').concat('|$'), 'g');
-    compiler.slurpStart = new RegExp([compiler.slurp.match, compiler.slurp.start.join('')].join(''), 'gm');
-    compiler.slurpEnd = new RegExp([compiler.slurp.end.join(''), compiler.slurp.match].join(''), 'gm');
-  };
-  this.compile = function (content, path) {
-    var _compiler$vars = compiler.vars,
-      SCOPE = _compiler$vars.SCOPE,
-      SAFE = _compiler$vars.SAFE,
-      BUFFER = _compiler$vars.BUFFER,
-      COMPONENT = _compiler$vars.COMPONENT;
-    var GLOBALS = compiler.globalHelpers;
-    content = String(content);
-    if (compiler.rmWhitespace) {
-      content = content.replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
-    }
-    content = content.replace(compiler.slurpStart, compiler.token.start).replace(compiler.slurpEnd, compiler.token.end);
-    var source = "".concat(BUFFER, "('");
-    matchTokens(compiler.regex, content, function (params, index, offset) {
-      source += symbols(content.slice(index, offset));
-      params.forEach(function (value, index) {
-        if (value) {
-          source += compiler.formats[index](value);
-        }
+  return _createClass(Compiler, [{
+    key: "configure",
+    value: function configure(config) {
+      var _this = this;
+      _classPrivateFieldGet2(_config$1, this).withObject = config.withObject;
+      _classPrivateFieldGet2(_config$1, this).rmWhitespace = config.rmWhitespace;
+      _classPrivateFieldGet2(_config$1, this).token = config.token;
+      _classPrivateFieldGet2(_config$1, this).vars = config.vars;
+      _classPrivateFieldGet2(_config$1, this).globalHelpers = config.globalHelpers;
+      _classPrivateFieldGet2(_config$1, this).matches = [];
+      _classPrivateFieldGet2(_config$1, this).formats = [];
+      _classPrivateFieldGet2(_config$1, this).slurp = {
+        match: '[s\t\n]*',
+        start: [_classPrivateFieldGet2(_config$1, this).token.start, '_'],
+        end: ['_', _classPrivateFieldGet2(_config$1, this).token.end]
+      };
+      _classPrivateFieldGet2(_symbols, this).forEach(function (item) {
+        _classPrivateFieldGet2(_config$1, _this).matches.push(_classPrivateFieldGet2(_config$1, _this).token.start.concat(item.symbol).concat(_classPrivateFieldGet2(_config$1, _this).token.regex).concat(_classPrivateFieldGet2(_config$1, _this).token.end));
+        _classPrivateFieldGet2(_config$1, _this).formats.push(item.format.bind(_classPrivateFieldGet2(_config$1, _this).vars));
       });
-    });
-    source += "');";
-    source = "try{".concat(source, "}catch(e){return ").concat(BUFFER, ".error(e)}");
-    if (compiler.withObject) {
-      source = "with(".concat(SCOPE, "){").concat(source, "}");
-    }
-    source = "".concat(BUFFER, ".start();").concat(source, "return ").concat(BUFFER, ".end();");
-    source += "\n//# sourceURL=".concat(path);
-    var result = null;
-    var params = [SCOPE, COMPONENT, BUFFER, SAFE].concat(GLOBALS);
-    try {
-      result = Function.apply(null, params.concat(source));
-      result.source = "(function(".concat(params.join(','), "){\n").concat(source, "\n});");
-    } catch (e) {
-      e.filename = path;
-      e.source = source;
-      throw e;
-    }
-    return result;
-  };
-  this.configure(config);
-}
-
-function Template(config, cache, compiler) {
-  if (instanceOf(this, Template) === false) return new Template(config, cache, compiler);
-  if (instanceOf(cache, Cache) === false) throw new TypeError('cache is not instance of Cache');
-  if (instanceOf(compiler, Compiler) === false) throw new TypeError('compiler is not instance of Compiler');
-  var template = {};
-  var result = function result(template, content) {
-    cache.set(template, content);
-    return content;
-  };
-  var resolve = function resolve(path) {
-    return template.resolver(template.path, path);
-  };
-  var compile = function compile(content, template) {
-    if (isFunction(content)) {
-      return content;
-    } else {
-      return compiler.compile(content, template);
+      _classPrivateFieldGet2(_config$1, this).regex = new RegExp(_classPrivateFieldGet2(_config$1, this).matches.join('|').concat('|$'), 'g');
+      _classPrivateFieldGet2(_config$1, this).slurpStart = new RegExp([_classPrivateFieldGet2(_config$1, this).slurp.match, _classPrivateFieldGet2(_config$1, this).slurp.start.join('')].join(''), 'gm');
+      _classPrivateFieldGet2(_config$1, this).slurpEnd = new RegExp([_classPrivateFieldGet2(_config$1, this).slurp.end.join(''), _classPrivateFieldGet2(_config$1, this).slurp.match].join(''), 'gm');
     }
-  };
-  this.configure = function (config) {
-    template.path = config.path;
-    template.cache = config.cache;
-    if (isFunction(config.resolver)) {
-      template.resolver = config.resolver;
+  }, {
+    key: "compile",
+    value: function compile(content, path) {
+      var _this2 = this;
+      var _classPrivateFieldGet2$1 = _classPrivateFieldGet2(_config$1, this).vars,
+        SCOPE = _classPrivateFieldGet2$1.SCOPE,
+        SAFE = _classPrivateFieldGet2$1.SAFE,
+        BUFFER = _classPrivateFieldGet2$1.BUFFER,
+        COMPONENT = _classPrivateFieldGet2$1.COMPONENT;
+      var GLOBALS = _classPrivateFieldGet2(_config$1, this).globalHelpers;
+      if (_classPrivateFieldGet2(_config$1, this).rmWhitespace) {
+        content = String(content).replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
+      }
+      content = String(content).replace(_classPrivateFieldGet2(_config$1, this).slurpStart, _classPrivateFieldGet2(_config$1, this).token.start).replace(_classPrivateFieldGet2(_config$1, this).slurpEnd, _classPrivateFieldGet2(_config$1, this).token.end);
+      var source = "".concat(BUFFER, "('");
+      matchTokens(_classPrivateFieldGet2(_config$1, this).regex, content, function (params, index, offset) {
+        source += symbols(content.slice(index, offset));
+        params.forEach(function (value, index) {
+          if (value) {
+            source += _classPrivateFieldGet2(_config$1, _this2).formats[index](value);
+          }
+        });
+      });
+      source += "');";
+      source = "try{".concat(source, "}catch(e){return ").concat(BUFFER, ".error(e)}");
+      if (_classPrivateFieldGet2(_config$1, this).withObject) {
+        source = "with(".concat(SCOPE, "){").concat(source, "}");
+      }
+      source = "".concat(BUFFER, ".start();").concat(source, "return ").concat(BUFFER, ".end();");
+      source += "\n//# sourceURL=".concat(path);
+      var result = null;
+      var params = [SCOPE, COMPONENT, BUFFER, SAFE].concat(GLOBALS);
+      try {
+        result = Function.apply(null, params.concat(source));
+        result.source = "(function(".concat(params.join(','), "){\n").concat(source, "\n});");
+      } catch (e) {
+        e.filename = path;
+        e.source = source;
+        throw e;
+      }
+      return result;
     }
-  };
-  this.get = function (template) {
-    if (cache.exist(template)) {
-      return cache.resolve(template);
+  }]);
+}();
+
+var _path = /*#__PURE__*/new WeakMap();
+var _cache$1 = /*#__PURE__*/new WeakMap();
+var _compiler$1 = /*#__PURE__*/new WeakMap();
+var _resolver = /*#__PURE__*/new WeakMap();
+var _Template_brand = /*#__PURE__*/new WeakSet();
+var Template = /*#__PURE__*/function () {
+  function Template(config, cache, compiler) {
+    _classCallCheck(this, Template);
+    _classPrivateMethodInitSpec(this, _Template_brand);
+    _classPrivateFieldInitSpec(this, _path, void 0);
+    _classPrivateFieldInitSpec(this, _cache$1, void 0);
+    _classPrivateFieldInitSpec(this, _compiler$1, void 0);
+    _classPrivateFieldInitSpec(this, _resolver, void 0);
+    assertInstanceOf(cache, Cache);
+    assertInstanceOf(compiler, Compiler);
+    _classPrivateFieldSet2(_cache$1, this, cache);
+    _classPrivateFieldSet2(_compiler$1, this, compiler);
+    bindContext(this, ['configure', 'get']);
+    this.configure(config);
+  }
+  return _createClass(Template, [{
+    key: "configure",
+    value: function configure(config) {
+      _classPrivateFieldSet2(_path, this, config.path);
+      if (isFunction(config.resolver)) {
+        _classPrivateFieldSet2(_resolver, this, config.resolver);
+      }
     }
-    return resolve(template).then(function (content) {
-      return result(template, compile(content, template));
-    });
-  };
-  this.configure(config);
+  }, {
+    key: "get",
+    value: function get(template) {
+      var _this = this;
+      if (_classPrivateFieldGet2(_cache$1, this).exist(template)) {
+        return _classPrivateFieldGet2(_cache$1, this).resolve(template);
+      }
+      return _assertClassBrand(_Template_brand, this, _resolve).call(this, template).then(function (content) {
+        return _assertClassBrand(_Template_brand, _this, _result).call(_this, template, _assertClassBrand(_Template_brand, _this, _compile).call(_this, content, template));
+      });
+    }
+  }]);
+}();
+function _resolve(path) {
+  return _classPrivateFieldGet2(_resolver, this).call(this, _classPrivateFieldGet2(_path, this), path);
 }
-
-function _defineProperty(e, r, t) {
-  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-    value: t,
-    enumerable: !0,
-    configurable: !0,
-    writable: !0
-  }) : e[r] = t, e;
+function _result(template, content) {
+  _classPrivateFieldGet2(_cache$1, this).set(template, content);
+  return content;
 }
-function _toPrimitive(t, r) {
-  if ("object" != typeof t || !t) return t;
-  var e = t[Symbol.toPrimitive];
-  if (void 0 !== e) {
-    var i = e.call(t, r || "default");
-    if ("object" != typeof i) return i;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
+function _compile(content, template) {
+  if (isFunction(content)) {
+    return content;
+  } else {
+    return _classPrivateFieldGet2(_compiler$1, this).compile(content, template);
   }
-  return ("string" === r ? String : Number)(t);
-}
-function _toPropertyKey(t) {
-  var i = _toPrimitive(t, "string");
-  return "symbol" == typeof i ? i : i + "";
 }
 
 var selfClosed = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
@@ -420,7 +598,7 @@ var element = function element(tag, attrs, content) {
     }
   }).join(space);
   result.push([lt, tag, space, attributes, gt].join(''));
-  if (content) {
+  if (content && hasClosedTag) {
     result.push(content instanceof Array ? content.join('') : content);
   }
   if (hasClosedTag) {
@@ -429,82 +607,61 @@ var element = function element(tag, attrs, content) {
   return result.join('');
 };
 
-/**
- * @extends Error
- * @property code
- * @param {string} message
- * @constructor
- */
-function TemplateError(message) {
-  this.name = 'TemplateError';
-  this.message = message;
-  Error.call(this);
-}
-
-/**
- *
- */
-Object.setPrototypeOf(TemplateError.prototype, Error.prototype);
-Object.assign(TemplateError.prototype, {
-  code: 1
-});
-/**
- *
- * @return {number}
- */
-TemplateError.prototype.getCode = function () {
-  return this.code;
-};
-/**
- *
- * @return {string}
- */
-TemplateError.prototype.getMessage = function () {
-  return this.message;
-};
-/**
- * @return {string}
- */
-TemplateError.prototype.toString = function () {
-  return this.getMessage();
-};
-
-/**
- * @extends TemplateError
- * @param {string} message
- * @constructor
- */
-function TemplateNotFound(message) {
-  TemplateError.call(this);
-  this.name = 'TemplateNotFound';
-  this.message = message;
-}
-
-/**
- *
- */
-Object.setPrototypeOf(TemplateNotFound.prototype, TemplateError.prototype);
-Object.assign(TemplateNotFound.prototype, {
-  code: 404
-});
-/**
- * @extends TemplateError
- * @param {string} message
- * @constructor
- */
-function TemplateSyntaxError(message) {
-  TemplateError.call(this);
-  this.name = 'TemplateSyntaxError';
-  this.message = message;
-}
-
-/**
- *
- */
-Object.setPrototypeOf(TemplateSyntaxError.prototype, TemplateError.prototype);
-Object.assign(TemplateSyntaxError.prototype, {
-  code: 500
-});
+var TemplateError = /*#__PURE__*/function (_Error) {
+  function TemplateError(message) {
+    var _this;
+    _classCallCheck(this, TemplateError);
+    _this = _callSuper(this, TemplateError);
+    _defineProperty(_this, "code", 0);
+    _this.message = message;
+    return _this;
+  }
+  _inherits(TemplateError, _Error);
+  return _createClass(TemplateError, [{
+    key: "getCode",
+    value: function getCode() {
+      return this.code;
+    }
+  }, {
+    key: "getMessage",
+    value: function getMessage() {
+      return this.message;
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return this.getMessage();
+    }
+  }]);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+var TemplateNotFound = /*#__PURE__*/function (_TemplateError2) {
+  function TemplateNotFound() {
+    var _this2;
+    _classCallCheck(this, TemplateNotFound);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this2 = _callSuper(this, TemplateNotFound, [].concat(args));
+    _defineProperty(_this2, "code", 404);
+    return _this2;
+  }
+  _inherits(TemplateNotFound, _TemplateError2);
+  return _createClass(TemplateNotFound);
+}(TemplateError);
+var TemplateSyntaxError = /*#__PURE__*/function (_TemplateError3) {
+  function TemplateSyntaxError() {
+    var _this3;
+    _classCallCheck(this, TemplateSyntaxError);
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    _this3 = _callSuper(this, TemplateSyntaxError, [].concat(args));
+    _defineProperty(_this3, "code", 500);
+    return _this3;
+  }
+  _inherits(TemplateSyntaxError, _TemplateError3);
+  return _createClass(TemplateSyntaxError);
+}(TemplateError);
 
 function resolve(list) {
   return Promise.all(list || []).then(function (list) {
@@ -516,12 +673,17 @@ function resolve(list) {
 function reject(error) {
   return Promise.reject(new TemplateSyntaxError(error.message));
 }
+
+/**
+ *
+ * @return {buffer}
+ */
 function createBuffer() {
   var store = [],
     array = [];
-  function buffer(value) {
+  var buffer = function buffer(value) {
     array.push(value);
-  }
+  };
   buffer.start = function () {
     array = [];
   };
@@ -543,387 +705,499 @@ function createBuffer() {
   return buffer;
 }
 
-function Context(config) {
-  if (instanceOf(this, Context) === false) return new Context(config);
-  this.configure = function (config, methods) {
-    var _Object$definePropert;
-    var _config$vars = config.vars,
-      BLOCKS = _config$vars.BLOCKS,
-      MACRO = _config$vars.MACRO,
-      EXTEND = _config$vars.EXTEND,
-      LAYOUT = _config$vars.LAYOUT,
-      BUFFER = _config$vars.BUFFER,
-      COMPONENT = _config$vars.COMPONENT;
-    this.create = function (data) {
-      return new Scope(data);
-    };
-    this.helpers = function (methods) {
-      extend(Scope.prototype, methods || {});
-    };
-    /**
-     * @name ContextScope
-     * @param data
-     * @constructor
-     */
-    function Scope(data) {
-      this[BLOCKS] = {};
-      this[MACRO] = {};
-      extend(this, data || {});
-    }
-    Scope.prototype = extend({}, methods || {});
-    Object.defineProperties(Scope.prototype, (_Object$definePropert = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_Object$definePropert, BUFFER, {
-      value: createBuffer(),
-      writable: true,
-      configurable: false,
-      enumerable: false
-    }), BLOCKS, {
-      value: {},
-      writable: true,
-      configurable: false,
-      enumerable: false
-    }), MACRO, {
-      value: {},
-      writable: true,
-      configurable: false,
-      enumerable: false
-    }), LAYOUT, {
-      value: false,
-      writable: true,
-      configurable: false,
-      enumerable: false
-    }), EXTEND, {
-      value: false,
-      writable: true,
-      configurable: false,
-      enumerable: false
-    }), "getMacro", {
-      value: function value() {
-        return this[MACRO];
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "getBuffer", {
-      value: function value() {
-        return this[BUFFER];
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "getComponent", {
-      value: function value() {
-        var context = this;
-        if (COMPONENT in context) {
-          return function () {
-            return context[COMPONENT].apply(context, arguments);
-          };
-        }
+var createScope = function createScope(config, methods) {
+  var _Object$definePropert;
+  var _config$vars = config.vars,
+    BLOCKS = _config$vars.BLOCKS,
+    MACRO = _config$vars.MACRO,
+    EXTEND = _config$vars.EXTEND,
+    LAYOUT = _config$vars.LAYOUT,
+    BUFFER = _config$vars.BUFFER,
+    COMPONENT = _config$vars.COMPONENT,
+    SAFE = _config$vars.SAFE,
+    SCOPE = _config$vars.SCOPE;
+  /**
+   * @name ContextScope
+   * @param data
+   * @constructor
+   */
+  function ContextScope(data) {
+    this[BLOCKS] = {};
+    this[MACRO] = {};
+    Object.assign(this, omit(data, [SCOPE, BUFFER, SAFE, COMPONENT]));
+  }
+  Object.assign(ContextScope.prototype, methods);
+  Object.defineProperties(ContextScope.prototype, (_Object$definePropert = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_Object$definePropert, BUFFER, {
+    value: createBuffer()
+  }), BLOCKS, {
+    value: {},
+    writable: true
+  }), MACRO, {
+    value: {},
+    writable: true
+  }), LAYOUT, {
+    value: false,
+    writable: true
+  }), EXTEND, {
+    value: false,
+    writable: true
+  }), "getMacro", {
+    value: function value() {
+      return this[MACRO];
+    }
+  }), "getBuffer", {
+    value: function value() {
+      return this[BUFFER];
+    }
+  }), "getComponent", {
+    value: function value() {
+      var context = this;
+      if (COMPONENT in context) {
         return function () {
-          console.log('%s function not defined', COMPONENT);
+          return context[COMPONENT].apply(context, arguments);
         };
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "getBlocks", {
-      value: function value() {
-        return this[BLOCKS];
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "setExtend", {
-      value: function value(_value) {
-        this[EXTEND] = _value;
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_Object$definePropert, "getExtend", {
-      value: function value() {
-        return this[EXTEND];
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "setLayout", {
-      value: function value(layout) {
-        this[LAYOUT] = layout;
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "getLayout", {
-      value: function value() {
-        return this[LAYOUT];
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "clone", {
-      value: function value(exclude_blocks) {
-        var filter = [LAYOUT, EXTEND, BUFFER];
-        if (exclude_blocks === true) {
-          filter.push(BLOCKS);
+      }
+      return function () {
+        console.log('%s function not defined', COMPONENT);
+      };
+    }
+  }), "getBlocks", {
+    value: function value() {
+      return this[BLOCKS];
+    }
+  }), "setExtend", {
+    value: function value(_value) {
+      this[EXTEND] = _value;
+    }
+  }), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_Object$definePropert, "getExtend", {
+    value: function value() {
+      return this[EXTEND];
+    }
+  }), "setLayout", {
+    value: function value(layout) {
+      this[LAYOUT] = layout;
+    }
+  }), "getLayout", {
+    value: function value() {
+      return this[LAYOUT];
+    }
+  }), "clone", {
+    value: function value(exclude_blocks) {
+      var filter = [LAYOUT, EXTEND, BUFFER];
+      if (exclude_blocks === true) {
+        filter.push(BLOCKS);
+      }
+      return omit(this, filter);
+    }
+  }), "extend", {
+    value: function value(layout) {
+      this.setExtend(true);
+      this.setLayout(layout);
+    }
+  }), "echo", {
+    value: function value(layout) {
+      var buffer = this.getBuffer();
+      var params = [].slice.call(arguments);
+      params.forEach(buffer);
+    }
+  }), "fn", {
+    value: function value(callback) {
+      var buffer = this.getBuffer();
+      var context = this;
+      return function () {
+        buffer.backup();
+        if (isFunction(callback)) {
+          callback.apply(context, arguments);
         }
-        return omit(this, filter);
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "extend", {
-      value: function value(layout) {
-        this.setExtend(true);
-        this.setLayout(layout);
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "echo", {
-      value: function value(layout) {
-        var buffer = this.getBuffer();
-        var params = [].slice.call(arguments);
-        params.forEach(buffer);
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "fn", {
-      value: function value(callback) {
-        var buffer = this.getBuffer();
-        var context = this;
-        return function () {
-          buffer.backup();
-          if (isFunction(callback)) {
-            callback.apply(context, arguments);
-          }
-          return buffer.restore();
-        };
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "get", {
-      value: function value(name, defaults) {
-        var path = getPath(this, name, true);
-        var result = path.shift();
-        var prop = path.pop();
-        return hasProp(result, prop) ? result[prop] : defaults;
-      },
-      writable: true,
-      configurable: true,
-      enumerable: false
-    }), "set", {
-      value: function value(name, _value2) {
-        var path = getPath(this, name, false);
-        var result = path.shift();
-        var prop = path.pop();
-        if (this.getExtend() && hasProp(result, prop)) {
-          return result[prop];
+        return buffer.restore();
+      };
+    }
+  }), "get", {
+    value: function value(name, defaults) {
+      var path = getPath(this, name, true);
+      var result = path.shift();
+      var prop = path.pop();
+      return hasProp(result, prop) ? result[prop] : defaults;
+    }
+  }), "set", {
+    value: function value(name, _value2) {
+      var path = getPath(this, name, false);
+      var result = path.shift();
+      var prop = path.pop();
+      if (this.getExtend() && hasProp(result, prop)) {
+        return result[prop];
+      }
+      return result[prop] = _value2;
+    }
+  }), "macro", {
+    value: function value(name, callback) {
+      var list = this.getMacro();
+      var macro = this.fn(callback);
+      var context = this;
+      list[name] = function () {
+        return context.echo(macro.apply(undefined, arguments));
+      };
+    }
+  }), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_Object$definePropert, "call", {
+    value: function value(name) {
+      var list = this.getMacro();
+      var macro = list[name];
+      var params = [].slice.call(arguments, 1);
+      if (isFunction(macro)) {
+        return macro.apply(macro, params);
+      }
+    }
+  }), "block", {
+    value: function value(name, callback) {
+      var _this = this;
+      var blocks = this.getBlocks();
+      blocks[name] = blocks[name] || [];
+      blocks[name].push(this.fn(callback));
+      if (this.getExtend()) return;
+      var list = Object.assign([], blocks[name]);
+      var current = function current() {
+        return list.shift();
+      };
+      var _next = function next() {
+        var parent = current();
+        if (parent) {
+          return function () {
+            _this.echo(parent(_next()));
+          };
+        } else {
+          return noop;
         }
-        return result[prop] = _value2;
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "macro", {
-      value: function value(name, callback) {
-        var list = this.getMacro();
-        var macro = this.fn(callback);
-        var context = this;
-        list[name] = function () {
-          return context.echo(macro.apply(undefined, arguments));
-        };
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_Object$definePropert, "call", {
-      value: function value(name) {
+      };
+      this.echo(current()(_next()));
+    }
+  }), "hasBlock", {
+    value: function value(name) {
+      return this.getBlocks().hasOwnProperty(name);
+    }
+  }), "include", {
+    value: function value(path, data, cx) {
+      var context = cx === false ? {} : this.clone(true);
+      var params = extend(context, data || {});
+      var promise = this.render(path, params);
+      this.echo(promise);
+    }
+  }), "promiseResolve", {
+    value: function value(_value3, callback) {
+      return Promise.resolve(isFunction(_value3) ? this.fn(_value3)() : _value3).then(callback.bind(this));
+    }
+  }), "use", {
+    value: function value(path, namespace) {
+      this.echo(this.promiseResolve(this.require(path), function (exports) {
         var list = this.getMacro();
-        var macro = list[name];
-        var params = [].slice.call(arguments, 1);
-        if (isFunction(macro)) {
-          return macro.apply(macro, params);
-        }
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "block", {
-      value: function value(name, callback) {
-        var _this = this;
-        var blocks = this.getBlocks();
-        blocks[name] = blocks[name] || [];
-        blocks[name].push(this.fn(callback));
-        if (this.getExtend()) return;
-        var list = Object.assign([], blocks[name]);
-        var current = function current() {
-          return list.shift();
-        };
-        var _next = function next() {
-          var parent = current();
-          if (parent) {
-            return function () {
-              _this.echo(parent(_next()));
-            };
-          } else {
-            return noop;
-          }
-        };
-        this.echo(current()(_next()));
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "hasBlock", {
-      value: function value(name) {
-        return this.getBlocks().hasOwnProperty(name);
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "include", {
-      value: function value(path, data, cx) {
-        var context = cx === false ? {} : this.clone(true);
-        var params = extend(context, data || {});
-        var promise = this.render(path, params);
-        this.echo(promise);
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "promiseResolve", {
-      value: function value(_value3, callback) {
-        return Promise.resolve(isFunction(_value3) ? this.fn(_value3)() : _value3).then(callback.bind(this));
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "use", {
-      value: function value(path, namespace) {
-        this.echo(this.promiseResolve(this.require(path), function (exports) {
-          var list = this.getMacro();
-          each(exports, function (macro, name) {
-            list[[namespace, name].join('.')] = macro;
-          });
-        }));
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "async", {
-      value: function value(promise, callback) {
-        this.echo(this.promiseResolve(promise, function (data) {
-          return this.fn(callback)(data);
-        }));
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "each", {
-      value: function value(object, callback) {
-        if (isString(object)) {
-          object = this.get(object, []);
-        }
-        each(object, callback);
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "element", {
-      value: function value(tag, attr, content) {
-        return element(tag, attr, content);
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }), "el", {
-      value: function value(tag, attr, content) {
-        this.echo(this.promiseResolve(content, function (content) {
-          return this.element(tag, attr, content);
-        }));
-      },
-      writable: false,
-      configurable: false,
-      enumerable: false
-    })));
-  };
-  this.configure(config);
-}
-
-function EJS(options) {
-  if (instanceOf(this, EJS) === false) return new EJS(options);
-  var scope = {};
-  var config = {};
-  configSchema(config, options || {});
-  var context = new Context(config);
-  var compiler = new Compiler(config);
-  var cache = new Cache();
-  var template = new Template(config, cache, compiler);
-  var output = function output(path, scope) {
-    var globalHelpers = config.globalHelpers;
-    var params = [scope, scope.getComponent(), scope.getBuffer(), safeValue].concat(globalHelpers.filter(function (name) {
-      return isFunction(scope[name]);
-    }).map(function (name) {
-      return scope[name].bind(scope);
-    }));
-    return template.get(path).then(function (callback) {
-      return callback.apply(scope, params);
-    });
-  };
-  var require = function require(name) {
-    var filepath = ext(name, config.extension);
-    var scope = context.create({});
-    return output(filepath, scope).then(function () {
-      return scope.getMacro();
-    });
-  };
-  var _render = function render(name, data) {
-    var filepath = ext(name, config.extension);
-    var scope = context.create(data);
-    return output(filepath, scope).then(function (content) {
-      if (scope.getExtend()) {
-        scope.setExtend(false);
-        var layout = scope.getLayout();
-        var _data = scope.clone();
-        return _render(layout, _data);
+        each(exports, function (macro, name) {
+          list[[namespace, name].join('.')] = macro;
+        });
+      }));
+    }
+  }), "async", {
+    value: function value(promise, callback) {
+      this.echo(this.promiseResolve(promise, function (data) {
+        return this.fn(callback)(data);
+      }));
+    }
+  }), "each", {
+    value: function value(object, callback) {
+      if (isString(object)) {
+        object = this.get(object, []);
       }
-      return content;
+      each(object, callback);
+    }
+  }), "element", {
+    value: function value(tag, attr, content) {
+      return element(tag, attr, content);
+    }
+  }), "el", {
+    value: function value(tag, attr, content) {
+      this.echo(this.promiseResolve(content, function (content) {
+        return this.element(tag, attr, content);
+      }));
+    }
+  })));
+  return ContextScope;
+};
+var _scope = /*#__PURE__*/new WeakMap();
+var Context = /*#__PURE__*/function () {
+  function Context(config, methods) {
+    _classCallCheck(this, Context);
+    _classPrivateFieldInitSpec(this, _scope, void 0);
+    bindContext(this, ['create', 'helpers', 'configure']);
+    this.configure(config, methods);
+  }
+  return _createClass(Context, [{
+    key: "create",
+    value: function create(data) {
+      return new (_classPrivateFieldGet2(_scope, this))(data);
+    }
+  }, {
+    key: "configure",
+    value: function configure(config, methods) {
+      _classPrivateFieldSet2(_scope, this, createScope(config, methods));
+    }
+  }, {
+    key: "helpers",
+    value: function helpers(methods) {
+      extend(_classPrivateFieldGet2(_scope, this).prototype, methods || {});
+    }
+  }]);
+}();
+
+var _config = /*#__PURE__*/new WeakMap();
+var _extend = /*#__PURE__*/new WeakMap();
+var _context = /*#__PURE__*/new WeakMap();
+var _compiler = /*#__PURE__*/new WeakMap();
+var _cache = /*#__PURE__*/new WeakMap();
+var _template = /*#__PURE__*/new WeakMap();
+var _EJS_brand = /*#__PURE__*/new WeakSet();
+var EJS = /*#__PURE__*/function () {
+  function EJS(options) {
+    _classCallCheck(this, EJS);
+    _classPrivateMethodInitSpec(this, _EJS_brand);
+    _classPrivateFieldInitSpec(this, _config, {});
+    _classPrivateFieldInitSpec(this, _extend, {});
+    _classPrivateFieldInitSpec(this, _context, void 0);
+    _classPrivateFieldInitSpec(this, _compiler, void 0);
+    _classPrivateFieldInitSpec(this, _cache, void 0);
+    _classPrivateFieldInitSpec(this, _template, void 0);
+    configSchema(_classPrivateFieldGet2(_config, this), options || {});
+    _classPrivateFieldSet2(_context, this, new Context(_classPrivateFieldGet2(_config, this), _classPrivateFieldGet2(_extend, this)));
+    _classPrivateFieldSet2(_compiler, this, new Compiler(_classPrivateFieldGet2(_config, this)));
+    _classPrivateFieldSet2(_cache, this, new Cache(_classPrivateFieldGet2(_config, this)));
+    _classPrivateFieldSet2(_template, this, new Template(_classPrivateFieldGet2(_config, this), _classPrivateFieldGet2(_cache, this), _classPrivateFieldGet2(_compiler, this)));
+    //
+    bindContext(this, ['configure', 'create', 'render', 'context', 'preload', 'compile', 'helpers']);
+    //
+    this.helpers({
+      require: _assertClassBrand(_EJS_brand, this, _require),
+      render: this.render
     });
-  };
-  this.configure = function (options) {
-    options = options || {};
-    configSchema(config, options);
-    context.configure(config, scope);
-    compiler.configure(config);
-    cache.configure(config);
-    template.configure(config);
-    return config;
-  };
-  this.render = function (name, data) {
-    return _render(name, data);
-  };
-  this.helpers = function (methods) {
-    context.helpers(extend(scope, methods));
-  };
-  this.preload = function (list) {
-    return cache.load(list || {});
-  };
-  this.create = function (options) {
-    return new EJS(options);
-  };
-  this.compile = function (content, path) {
-    return compiler.compile(content, path);
-  };
-  this.context = function (data) {
-    return context.create(data);
-  };
-  this.helpers({
-    require: require,
-    render: _render
+  }
+  return _createClass(EJS, [{
+    key: "configure",
+    value: function configure(options) {
+      configSchema(_classPrivateFieldGet2(_config, this), options || {});
+      _classPrivateFieldGet2(_context, this).configure(_classPrivateFieldGet2(_config, this), _classPrivateFieldGet2(_extend, this));
+      _classPrivateFieldGet2(_compiler, this).configure(_classPrivateFieldGet2(_config, this));
+      _classPrivateFieldGet2(_cache, this).configure(_classPrivateFieldGet2(_config, this));
+      _classPrivateFieldGet2(_template, this).configure(_classPrivateFieldGet2(_config, this));
+      return _classPrivateFieldGet2(_config, this);
+    }
+  }, {
+    key: "render",
+    value: function render(name, data) {
+      var _this = this;
+      var filepath = ext(name, _classPrivateFieldGet2(_config, this).extension);
+      var scope = this.context(data);
+      return _assertClassBrand(_EJS_brand, this, _output).call(this, filepath, scope).then(function (content) {
+        if (scope.getExtend()) {
+          scope.setExtend(false);
+          var layout = scope.getLayout();
+          var _data = scope.clone();
+          return _this.render(layout, _data);
+        }
+        return content;
+      });
+    }
+  }, {
+    key: "helpers",
+    value: function helpers(methods) {
+      _classPrivateFieldGet2(_context, this).helpers(extend(_classPrivateFieldGet2(_extend, this), methods));
+    }
+  }, {
+    key: "context",
+    value: function context(data) {
+      return _classPrivateFieldGet2(_context, this).create(data);
+    }
+  }, {
+    key: "compile",
+    value: function compile(content, path) {
+      return _classPrivateFieldGet2(_compiler, this).compile(content, path);
+    }
+  }, {
+    key: "preload",
+    value: function preload(list) {
+      return _classPrivateFieldGet2(_cache, this).load(list || {});
+    }
+  }, {
+    key: "create",
+    value: function create(options) {
+      return new this.constructor(options);
+    }
+  }]);
+}();
+
+// export function EJS2(options) {
+//     const self = {
+//         config: {},
+//         helpers: {},
+//         /**
+//          * @type {Context}
+//          */
+//         context: null,
+//         /**
+//          * @type {Compiler}
+//          */
+//         compiler: null,
+//         /**
+//          * @type {Template}
+//          */
+//         template: null,
+//         /**
+//          * @type {Cache}
+//          */
+//         cache: null,
+//     }
+//     /**
+//      *
+//      */
+//     configSchema(self.config, options || {})
+//     self.context = useContext(self.config, self.helpers)
+//     self.compiler = useCompiler(self.config)
+//     self.cache = useCache(self.config)
+//     self.template = useTemplate(self.config, self.cache, self.compiler)
+//     /**
+//      *
+//      * @param {string} path
+//      * @param {ContextScope} scope
+//      * @return {Promise<string>}
+//      */
+//     const output = (path, scope) => {
+//         const { globalHelpers } = self.config
+//         const params = [
+//             scope,
+//             scope.getComponent(),
+//             scope.getBuffer(),
+//             safeValue,
+//         ].concat(
+//             globalHelpers
+//                 .filter((name) => isFunction(scope[name]))
+//                 .map((name) => scope[name].bind(scope))
+//         )
+//         return self.template
+//             .get(path)
+//             .then((callback) => callback.apply(scope, params))
+//     }
+//     /**
+//      *
+//      * @param name
+//      * @return {Promise<string>}
+//      */
+//     const require = (name) => {
+//         const filepath = ext(name, self.config.extension)
+//         const scope = context({})
+//         return output(filepath, scope).then(() => scope.getMacro())
+//     }
+//     /**
+//      *
+//      * @param {string} name
+//      * @param {{}} [data]
+//      * @return {Promise<string>}
+//      */
+//     const render = (name, data) => {
+//         const filepath = ext(name, self.config.extension)
+//         const scope = context(data)
+//         return output(filepath, scope).then((content) => {
+//             if (scope.getExtend()) {
+//                 scope.setExtend(false)
+//                 const layout = scope.getLayout()
+//                 const data = scope.clone()
+//                 return render(layout, data)
+//             }
+//             return content
+//         })
+//     }
+//     /**
+//      *
+//      * @param options
+//      * @return {{}}
+//      */
+//     const configure = (options = {}) => {
+//         configSchema(self.config, options || {})
+//         self.context.configure(self.config, self.helpers)
+//         self.compiler.configure(self.config)
+//         self.cache.configure(self.config)
+//         self.template.configure(self.config)
+//         return self.config
+//     }
+//     /**
+//      *
+//      * @param methods
+//      */
+//     const helpers = (methods) => {
+//         self.context.helpers(extend(self.helpers, methods))
+//     }
+//     /**
+//      *
+//      * @param list
+//      * @return {*}
+//      */
+//     const preload = (list) => {
+//         return self.cache.load(list || {})
+//     }
+//     /**
+//      *
+//      * @param options
+//      * @return {any}
+//      */
+//     const create = (options) => {
+//         return EJS(options)
+//     }
+//     /**
+//      *
+//      * @param content
+//      * @param path
+//      * @return {Function}
+//      */
+//     const compile = (content, path) => {
+//         return self.compiler.compile(content, path)
+//     }
+//     /**
+//      *
+//      * @param data
+//      * @return {ContextScope}
+//      */
+//     const context = (data = {}) => {
+//         return self.context.create(data)
+//     }
+//     /**
+//      *
+//      */
+//     helpers({ require, render })
+//     /**
+//      *
+//      */
+//     return {
+//         configure,
+//         helpers,
+//         preload,
+//         context,
+//         compile,
+//         create,
+//         render,
+//     }
+// }
+function _output(path, scope) {
+  var _classPrivateFieldGet2$1 = _classPrivateFieldGet2(_config, this),
+    globalHelpers = _classPrivateFieldGet2$1.globalHelpers;
+  var params = [scope, scope.getComponent(), scope.getBuffer(), safeValue].concat(globalHelpers.filter(function (name) {
+    return isFunction(scope[name]);
+  }).map(function (name) {
+    return scope[name].bind(scope);
+  }));
+  return _classPrivateFieldGet2(_template, this).get(path).then(function (callback) {
+    return callback.apply(scope, params);
+  });
+}
+function _require(name) {
+  var filepath = ext(name, _classPrivateFieldGet2(_config, this).extension);
+  var scope = this.context({});
+  return _assertClassBrand(_EJS_brand, this, _output).call(this, filepath, scope).then(function () {
+    return scope.getMacro();
   });
-  return this;
 }
 
 function readFile(path, template) {
@@ -940,10 +1214,11 @@ function readFile(path, template) {
 
 /**
  *
- * @param {EJS} ejs
- * @return {function(name, options, callback): Promise<String>}
+ * @param {function(config: object):object} configure
+ * @param {function(name: string, data?: object):Promise<string>} render
+ * @return {function(name:any, options:any, callback: any): Promise<void>}
  */
-function expressRenderer(ejs) {
+function expressRenderer(configure, render) {
   return function (name, options, callback) {
     if (isFunction(options)) {
       callback = options;
@@ -957,8 +1232,8 @@ function expressRenderer(ejs) {
     var filename = path.relative(viewPath, name);
     viewOptions.path = viewPath;
     viewOptions.cache = viewCache;
-    ejs.configure(viewOptions);
-    return ejs.render(filename, options).then(function (content) {
+    configure(viewOptions);
+    return render(filename, options).then(function (content) {
       callback(null, content);
     })["catch"](function (error) {
       callback(error);
@@ -966,17 +1241,17 @@ function expressRenderer(ejs) {
   };
 }
 
-var ejs = new EJS({
-  resolver: readFile
-});
-var render = ejs.render,
-  context = ejs.context,
-  compile = ejs.compile,
-  helpers = ejs.helpers,
-  preload = ejs.preload,
-  configure = ejs.configure,
-  create = ejs.create;
-var __express = expressRenderer(ejs);
+var _EJS = new EJS({
+    resolver: readFile
+  }),
+  render = _EJS.render,
+  context = _EJS.context,
+  compile = _EJS.compile,
+  helpers = _EJS.helpers,
+  preload = _EJS.preload,
+  configure = _EJS.configure,
+  create = _EJS.create;
+var __express = expressRenderer(configure, render);
 
 exports.TemplateError = TemplateError;
 exports.TemplateNotFound = TemplateNotFound;