@kosatyi/ejs 0.0.105 → 0.0.106

package/dist/cjs/worker.js

@@ -3,14 +3,6 @@
 function _OverloadYield(e, d) {
   this.v = e, this.k = d;
 }
-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 asyncGeneratorStep(n, t, e, r, o, a, c) {
   try {
     var i = n[a](c),
@@ -36,90 +28,6 @@ function _asyncToGenerator(n) {
     });
   };
 }
-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 _regenerator() {
   /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
   var e,
@@ -293,47 +201,6 @@ function _regeneratorValues(e) {
   }
   throw new TypeError(typeof e + " is not iterable");
 }
-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);
-}
 function _regeneratorRuntime() {
 
   var r = _regenerator(),
@@ -464,12 +331,6 @@ var safeValue = function safeValue(value, escape) {
   var check = value;
   return check == null ? '' : Boolean(escape) === true ? entities(check) : check;
 };
-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('.');
@@ -490,14 +351,6 @@ 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) {
@@ -612,7 +465,7 @@ defaults.token = {
 };
 
 var configSchema = function configSchema(config, options) {
-  extend(config, {
+  return extend(config, {
     path: typeProp(isString, defaults.path, config.path, options.path),
     "export": typeProp(isString, defaults["export"], config["export"], options["export"]),
     resolver: typeProp(isFunction, defaults.resolver, config.resolver, options.resolver),
@@ -626,223 +479,192 @@ var configSchema = function configSchema(config, options) {
   });
 };
 
-var global = typeof globalThis !== 'undefined' ? globalThis : window || self;
-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, {});
-    this.configure(config);
-  }
-  return _createClass(Cache, [{
-    key: "load",
-    value: function load(data) {
-      if (_classPrivateFieldGet2(_enabled, this)) {
-        extend(_classPrivateFieldGet2(_list, this), data || {});
-      }
-    }
-  }, {
-    key: "get",
-    value: function get(key) {
-      if (_classPrivateFieldGet2(_enabled, this)) {
-        return _classPrivateFieldGet2(_list, this)[key];
-      }
-    }
-  }, {
-    key: "set",
-    value: function set(key, value) {
-      if (_classPrivateFieldGet2(_enabled, this)) {
-        _classPrivateFieldGet2(_list, this)[key] = value;
-      }
-    }
-  }, {
-    key: "exist",
-    value: function exist(key) {
-      if (_classPrivateFieldGet2(_enabled, this)) {
-        return hasProp(_classPrivateFieldGet2(_list, this), key);
-      }
-    }
-  }, {
-    key: "clear",
-    value: function clear() {
-      _classPrivateFieldSet2(_list, this, {});
-    }
-  }, {
-    key: "remove",
-    value: function remove(key) {
-      delete _classPrivateFieldGet2(_list, this)[key];
+var Template = function Template(options, cache, compiler) {
+  var config = {
+    path: null,
+    resolver: null
+  };
+  var resolve = function resolve(path) {
+    return config.resolver(config.path, path);
+  };
+  var result = function result(template, content) {
+    cache.set(template, content);
+    return content;
+  };
+  var compile = function compile(content, template) {
+    if (isFunction(content)) {
+      return content;
+    } else {
+      return compiler.compile(content, template);
     }
-  }, {
-    key: "resolve",
-    value: function resolve(key) {
-      return Promise.resolve(this.get(key));
+  };
+  var get = function get(template) {
+    if (cache.exist(template)) {
+      return cache.resolve(template);
     }
-  }, {
-    key: "configure",
-    value: function configure(config) {
-      _classPrivateFieldSet2(_enabled, this, config.cache);
-      if (isNode() === false) {
-        this.load(global[config["export"]]);
-      }
+    return resolve(template).then(function (content) {
+      return result(template, compile(content, template));
+    });
+  };
+  var configure = function configure(options) {
+    config.path = options.path;
+    if (isFunction(options.resolver)) {
+      config.resolver = options.resolver;
     }
-  }]);
-}();
+  };
+  configure(options);
+  return {
+    get: get,
+    configure: configure,
+    compile: compile
+  };
+};
 
-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, "('");
-      }
-    }]);
-    this.configure(config);
+var configSymbols = [{
+  symbol: '-',
+  format: function format(value) {
+    return "')\n".concat(this.BUFFER, "(").concat(this.SAFE, "(").concat(value, ",1))\n").concat(this.BUFFER, "('");
   }
-  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));
-      });
-      _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');
+}, {
+  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 Compiler = function Compiler(options) {
+  var config = {};
+  var configure = function configure(options) {
+    config.withObject = options.withObject;
+    config.rmWhitespace = options.rmWhitespace;
+    config.token = options.token;
+    config.vars = options.vars;
+    config.globalHelpers = options.globalHelpers;
+    config.matches = [];
+    config.formats = [];
+    config.slurp = {
+      match: '[s\t\n]*',
+      start: [config.token.start, '_'],
+      end: ['_', config.token.end]
+    };
+    configSymbols.forEach(function (item) {
+      config.matches.push(config.token.start.concat(item.symbol).concat(config.token.regex).concat(config.token.end));
+      config.formats.push(item.format.bind(config.vars));
+    });
+    config.regex = new RegExp(config.matches.join('|').concat('|$'), 'g');
+    config.slurpStart = new RegExp([config.slurp.match, config.slurp.start.join('')].join(''), 'gm');
+    config.slurpEnd = new RegExp([config.slurp.end.join(''), config.slurp.match].join(''), 'gm');
+  };
+  var compile = function compile(content, path) {
+    var _config$vars = config.vars,
+      SCOPE = _config$vars.SCOPE,
+      SAFE = _config$vars.SAFE,
+      BUFFER = _config$vars.BUFFER,
+      COMPONENT = _config$vars.COMPONENT,
+      ELEMENT = _config$vars.ELEMENT;
+    var GLOBALS = config.globalHelpers;
+    if (config.rmWhitespace) {
+      content = String(content).replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
     }
-  }, {
-    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,
-        ELEMENT = _classPrivateFieldGet2$1.ELEMENT;
-      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);
-          }
-        });
+    content = String(content).replace(config.slurpStart, config.token.start).replace(config.slurpEnd, config.token.end);
+    var source = "".concat(BUFFER, "('");
+    matchTokens(config.regex, content, function (params, index, offset) {
+      source += symbols(content.slice(index, offset));
+      params.forEach(function (value, index) {
+        if (value) {
+          source += config.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, ELEMENT, 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;
+    });
+    source += "');";
+    source = "try{".concat(source, "}catch(e){return ").concat(BUFFER, ".error(e)}");
+    if (config.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, ELEMENT, 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;
+  };
+  configure(options);
+  return {
+    configure: configure,
+    compile: compile
+  };
+};
 
-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);
-    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);
-      }
+var global = typeof globalThis !== 'undefined' ? globalThis : window || self;
+var Cache = function Cache() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var config = {};
+  var list = {};
+  var load = function load(data) {
+    if (config.enabled) {
+      extend(list, data || {});
     }
-  }, {
-    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));
-      });
+  };
+  var get = function get(key) {
+    if (config.enabled) {
+      return list[key];
     }
-  }]);
-}();
-function _resolve(path) {
-  return _classPrivateFieldGet2(_resolver, this).call(this, _classPrivateFieldGet2(_path, this), path);
-}
-function _result(template, content) {
-  _classPrivateFieldGet2(_cache$1, this).set(template, content);
-  return content;
-}
-function _compile(content, template) {
-  if (isFunction(content)) {
-    return content;
-  } else {
-    return _classPrivateFieldGet2(_compiler$1, this).compile(content, template);
-  }
-}
+  };
+  var set = function set(key, value) {
+    if (config.enabled) {
+      list[key] = value;
+    }
+  };
+  var exist = function exist(key) {
+    if (config.enabled) {
+      return hasProp(list, key);
+    }
+  };
+  var clear = function clear() {
+    Object.keys(list).forEach(remove);
+  };
+  var remove = function remove(key) {
+    delete list[key];
+  };
+  var resolve = function resolve(key) {
+    return Promise.resolve(get(key));
+  };
+  var configure = function configure() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    config.enabled = options.cache;
+    config["export"] = options["export"];
+    if (isNode() === false) {
+      load(global[config["export"]]);
+    }
+  };
+  configure(options);
+  return {
+    configure: configure,
+    load: load,
+    set: set,
+    get: get,
+    exist: exist,
+    clear: clear,
+    remove: remove,
+    resolve: resolve
+  };
+};
 
 var selfClosed = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
 var space = ' ';
@@ -869,61 +691,50 @@ var element = function element(tag, attrs, content) {
   return result.join('');
 };
 
-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;
+/**
+ *
+ * @constructor
+ */
+function TemplateError() {
+  TemplateError.call(this);
+}
+Object.setPrototypeOf(TemplateError.prototype, Error.prototype);
+Object.assign(TemplateError.prototype, {
+  code: 0,
+  getCode: function getCode() {
+    return this.code;
+  },
+  getMessage: function getMessage() {
+    return this.message;
+  },
+  toString: function toString() {
+    return this.getMessage();
   }
-  _inherits(TemplateSyntaxError, _TemplateError3);
-  return _createClass(TemplateSyntaxError);
-}(TemplateError);
+});
+
+/**
+ *
+ * @constructor
+ */
+function TemplateNotFound() {
+  TemplateError.call(this);
+}
+Object.setPrototypeOf(TemplateNotFound.prototype, TemplateError.prototype);
+Object.assign(TemplateNotFound.prototype, {
+  code: 404
+});
+
+/**
+ *
+ * @constructor
+ */
+function TemplateSyntaxError() {
+  TemplateError.call(this);
+}
+Object.setPrototypeOf(TemplateSyntaxError.prototype, TemplateError.prototype);
+Object.assign(TemplateSyntaxError.prototype, {
+  code: 500
+});
 
 function resolve(list) {
   return Promise.all(list || []).then(function (list) {
@@ -979,6 +790,7 @@ var createContextScope = function createContextScope(config, methods) {
     SCOPE = _config$vars.SCOPE,
     COMPONENT = _config$vars.COMPONENT,
     ELEMENT = _config$vars.ELEMENT;
+
   /**
    *
    * @type {symbol}
@@ -1275,149 +1087,113 @@ var createContextScope = function createContextScope(config, methods) {
   });
   return ContextScope;
 };
-var _scope = /*#__PURE__*/new WeakMap();
-var Context = /*#__PURE__*/function () {
-  function Context(config, methods) {
-    _classCallCheck(this, Context);
-    _classPrivateFieldInitSpec(this, _scope, void 0);
-    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, createContextScope(config, methods));
-    }
-  }, {
-    key: "helpers",
-    value: function helpers(methods) {
-      extend(_classPrivateFieldGet2(_scope, this).prototype, methods || {});
-    }
-  }]);
-}();
+var Context = function Context(options, methods) {
+  /**
+   * @type {InstanceType<ContextScope>}
+   */
+  var Scope;
+  var create = function create(data) {
+    return new Scope(data);
+  };
+  var helpers = function helpers(methods) {
+    extend(Scope.prototype, methods || {});
+  };
+  var configure = function configure(options, methods) {
+    Scope = createContextScope(options, methods);
+  };
+  configure(options, methods);
+  return {
+    configure: configure,
+    create: create,
+    helpers: helpers
+  };
+};
 
-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', 'require', 'context', 'preload', 'compile', 'helpers']);
-    //
-    this.helpers({
-      require: this.require,
-      render: this.render
+var _EJS$1 = function EJS() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var config = configSchema({}, options);
+  var methods = {};
+  var context = Context(config, methods);
+  var compiler = Compiler(config);
+  var cache = Cache(config);
+  var template = Template(config, cache, compiler);
+  var configure = function configure() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    configSchema(config, options || {});
+    context.configure(config, methods);
+    compiler.configure(config);
+    cache.configure(config);
+    template.configure(config);
+    return config;
+  };
+  var filePath = function filePath(name) {
+    return ext(name, config.extension);
+  };
+  var require = function require(name) {
+    var scope = createContext({});
+    return output(filePath(name), scope).then(function () {
+      return scope.getMacro();
     });
-  }
-  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: "filePath",
-    value: function filePath(name) {
-      return ext(name, _classPrivateFieldGet2(_config, this).extension);
-    }
-  }, {
-    key: "require",
-    value: function require(name) {
-      var scope = this.context({});
-      return _assertClassBrand(_EJS_brand, this, _output).call(this, this.filePath(name), scope).then(function () {
-        return scope.getMacro();
-      });
-    }
-  }, {
-    key: "render",
-    value: function render(name, data) {
-      var scope = this.context(data);
-      return _assertClassBrand(_EJS_brand, this, _output).call(this, this.filePath(name), scope).then(this.outputContent(name, scope));
-    }
-  }, {
-    key: "outputContent",
-    value: function outputContent(name, scope) {
-      var _this = this;
-      return function (content) {
-        if (scope.getExtend()) {
-          scope.setExtend(false);
-          return _this.renderLayout(scope.getLayout(), scope, name);
-        }
-        return content;
-      };
-    }
-  }, {
-    key: "renderLayout",
-    value: function renderLayout(name, data, parent) {
-      var scope = this.context(data);
-      if (parent) scope.setParentTemplate(parent);
-      return _assertClassBrand(_EJS_brand, this, _output).call(this, this.filePath(name), scope).then(this.outputContent(name, scope));
-    }
-  }, {
-    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);
-    }
-  }]);
-}();
-function _output(path, scope) {
-  var _classPrivateFieldGet2$1 = _classPrivateFieldGet2(_config, this),
-    globalHelpers = _classPrivateFieldGet2$1.globalHelpers;
-  var params = [scope, scope.useComponent, scope.useElement, scope.getBuffer(), scope.useSafeValue];
-  var globals = 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.concat(globals));
+  };
+  var render = function render(name, data) {
+    var scope = createContext(data);
+    return output(filePath(name), scope).then(outputContent(name, scope));
+  };
+  var outputContent = function outputContent(name, scope) {
+    return function (content) {
+      if (scope.getExtend()) {
+        scope.setExtend(false);
+        return renderLayout(scope.getLayout(), scope, name);
+      }
+      return content;
+    };
+  };
+  var renderLayout = function renderLayout(name, data, parent) {
+    var scope = createContext(data);
+    if (parent) scope.setParentTemplate(parent);
+    return output(filePath(name), scope).then(outputContent(name, scope));
+  };
+  var helpers = function helpers(extendMethods) {
+    context.helpers(extend(methods, extendMethods));
+  };
+  var createContext = function createContext(data) {
+    return context.create(data);
+  };
+  var compile = function compile(content, path) {
+    return compiler.compile(content, path);
+  };
+  var preload = function preload(list) {
+    return cache.load(list || {});
+  };
+  var create = function create(config) {
+    return _EJS$1(config);
+  };
+  var output = function output(path, scope) {
+    var params = [scope, scope.useComponent, scope.useElement, scope.getBuffer(), scope.useSafeValue];
+    var globals = config.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.concat(globals));
+    });
+  };
+  helpers({
+    render: render,
+    require: require
   });
-}
+  return {
+    configure: configure,
+    create: create,
+    createContext: createContext,
+    render: render,
+    require: require,
+    preload: preload,
+    compile: compile,
+    helpers: helpers
+  };
+};
 
 var templateCache = {};
 var getOrigin = function getOrigin(url, secure) {
@@ -1425,7 +1201,7 @@ var getOrigin = function getOrigin(url, secure) {
   url.protocol = secure ? 'https:' : 'http:';
   return url.origin;
 };
-var _EJS = new EJS({
+var _EJS = _EJS$1({
     cache: false,
     withObject: false,
     resolver: function resolver(path, name) {
@@ -1433,13 +1209,13 @@ var _EJS = new EJS({
         if (isFunction(templateCache[name])) {
           resolve(templateCache[name]);
         } else {
-          reject(new TemplateNotFound("template ".concat(name, " not found")));
+          reject(new TemplateNotFound());
         }
       });
     }
   }),
   render = _EJS.render,
-  context = _EJS.context,
+  createContext = _EJS.createContext,
   helpers = _EJS.helpers,
   configure = _EJS.configure;
 function useTemplates() {
@@ -1480,7 +1256,7 @@ function useRenderer() {
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            c.data = context({});
+            c.data = createContext({});
             c.data.set('version', version);
             c.data.set('origin', getOrigin(c.req.url, secure));
             c.data.set('path', c.req.path);
@@ -1519,7 +1295,7 @@ exports.TemplateError = TemplateError;
 exports.TemplateNotFound = TemplateNotFound;
 exports.TemplateSyntaxError = TemplateSyntaxError;
 exports.configure = configure;
-exports.context = context;
+exports.createContext = createContext;
 exports.helpers = helpers;
 exports.render = render;
 exports.setRenderer = setRenderer;