@kosatyi/ejs 0.0.105 → 0.0.106

package/dist/umd/index.js

@@ -1,515 +1,332 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-  typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ejs = {}));
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ejs = {}));
 })(this, (function (exports) { 'use strict';
 
-  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);
-    var callback = args.shift();
-    return args.filter(callback).pop();
-  };
-  var isArray = function isArray(v) {
-    return Array.isArray(v);
-  };
-  var isFunction = function isFunction(v) {
-    return typeof v === 'function';
-  };
-  var isString = function isString(v) {
-    return typeof v === 'string';
-  };
-  var isBoolean = function isBoolean(v) {
-    return typeof v === 'boolean';
-  };
-  var isUndefined = function isUndefined(v) {
-    return typeof v === 'undefined';
-  };
+    var typeProp = function typeProp() {
+      var args = [].slice.call(arguments);
+      var callback = args.shift();
+      return args.filter(callback).pop();
+    };
+    var isArray = function isArray(v) {
+      return Array.isArray(v);
+    };
+    var isFunction = function isFunction(v) {
+      return typeof v === 'function';
+    };
+    var isString = function isString(v) {
+      return typeof v === 'string';
+    };
+    var isBoolean = function isBoolean(v) {
+      return typeof v === 'boolean';
+    };
+    var isUndefined = function isUndefined(v) {
+      return typeof v === 'undefined';
+    };
 
-  var isNodeEnv = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
-  var isNode = function isNode() {
-    return isNodeEnv;
-  };
-  var symbolEntities = {
-    "'": "'",
-    '\\': '\\',
-    '\r': 'r',
-    '\n': 'n',
-    '\t': 't',
-    "\u2028": 'u2028',
-    "\u2029": 'u2029'
-  };
-  var htmlEntities = {
-    '&': '&amp;',
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    "'": '&#x27;'
-  };
-  var regexKeys = function regexKeys(obj) {
-    return new RegExp(['[', Object.keys(obj).join(''), ']'].join(''), 'g');
-  };
-  var htmlEntitiesMatch = regexKeys(htmlEntities);
-  var symbolEntitiesMatch = regexKeys(symbolEntities);
-  var entities = function entities() {
-    var string = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-    return ('' + string).replace(htmlEntitiesMatch, function (match) {
-      return htmlEntities[match];
-    });
-  };
-  var symbols = function symbols(string) {
-    return ('' + string).replace(symbolEntitiesMatch, function (match) {
-      return '\\' + symbolEntities[match];
-    });
-  };
-  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('.');
-    var prop = chunks.pop();
-    for (var i = 0; i < chunks.length; i++) {
-      var part = chunks[i];
+    var isNodeEnv = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
+    var isNode = function isNode() {
+      return isNodeEnv;
+    };
+    var symbolEntities = {
+      "'": "'",
+      '\\': '\\',
+      '\r': 'r',
+      '\n': 'n',
+      '\t': 't',
+      "\u2028": 'u2028',
+      "\u2029": 'u2029'
+    };
+    var htmlEntities = {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#x27;'
+    };
+    var regexKeys = function regexKeys(obj) {
+      return new RegExp(['[', Object.keys(obj).join(''), ']'].join(''), 'g');
+    };
+    var htmlEntitiesMatch = regexKeys(htmlEntities);
+    var symbolEntitiesMatch = regexKeys(symbolEntities);
+    var entities = function entities() {
+      var string = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      return ('' + string).replace(htmlEntitiesMatch, function (match) {
+        return htmlEntities[match];
+      });
+    };
+    var symbols = function symbols(string) {
+      return ('' + string).replace(symbolEntitiesMatch, function (match) {
+        return '\\' + symbolEntities[match];
+      });
+    };
+    var safeValue = function safeValue(value, escape) {
+      var check = value;
+      return check == null ? '' : Boolean(escape) === true ? entities(check) : check;
+    };
+    var getPath = function getPath(context, name, strict) {
+      var data = context;
+      var chunks = String(name).split('.');
+      var prop = chunks.pop();
+      for (var i = 0; i < chunks.length; i++) {
+        var part = chunks[i];
+        if (isFunction(data['toJSON'])) {
+          data = data.toJSON();
+        }
+        if (strict && data.hasOwnProperty(part) === false) {
+          data = {};
+          break;
+        }
+        data = data[part] = data[part] || {};
+      }
       if (isFunction(data['toJSON'])) {
         data = data.toJSON();
       }
-      if (strict && data.hasOwnProperty(part) === false) {
-        data = {};
-        break;
-      }
-      data = data[part] = data[part] || {};
-    }
-    if (isFunction(data['toJSON'])) {
-      data = data.toJSON();
-    }
-    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);
+      return [data, prop];
+    };
+    var ext = function ext(path, defaults) {
+      var ext = path.split('.').pop();
+      if (ext !== defaults) {
+        path = [path, defaults].join('.');
       }
-    });
-  };
-  var ext = function ext(path, defaults) {
-    var ext = path.split('.').pop();
-    if (ext !== defaults) {
-      path = [path, defaults].join('.');
-    }
-    return path;
-  };
+      return path;
+    };
 
-  /**
-   * @type {<T extends {}, U, V, W,Y>(T,U,V,W,Y)=> T & U & V & W & Y}
-   */
-  var extend = function extend(target) {
-    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      args[_key - 1] = arguments[_key];
-    }
-    return args.filter(function (source) {
-      return source;
-    }).reduce(function (target, source) {
-      return Object.assign(target, source);
-    }, target);
-  };
-  var noop = function noop() {};
-  var each = function each(object, callback) {
-    var prop;
-    for (prop in object) {
-      if (hasProp(object, prop)) {
-        callback(object[prop], prop, object);
-      }
-    }
-  };
-  var map = function map(object, callback, context) {
-    var result = [];
-    each(object, function (value, key, object) {
-      var item = callback(value, key, object);
-      if (isUndefined(item) === false) {
-        result.push(item);
+    /**
+     * @type {<T extends {}, U, V, W,Y>(T,U,V,W,Y)=> T & U & V & W & Y}
+     */
+    var extend = function extend(target) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      return args.filter(function (source) {
+        return source;
+      }).reduce(function (target, source) {
+        return Object.assign(target, source);
+      }, target);
+    };
+    var noop = function noop() {};
+    var each = function each(object, callback) {
+      var prop;
+      for (prop in object) {
+        if (hasProp(object, prop)) {
+          callback(object[prop], prop, object);
+        }
       }
-    });
-    return result;
-  };
-  var filter = function filter(object, callback, context) {
-    var isArray = object instanceof Array;
-    var result = isArray ? [] : {};
-    each(object, function (value, key, object) {
-      var item = callback(value, key, object);
-      if (isUndefined(item) === false) {
-        if (isArray) {
+    };
+    var map = function map(object, callback, context) {
+      var result = [];
+      each(object, function (value, key, object) {
+        var item = callback(value, key, object);
+        if (isUndefined(item) === false) {
           result.push(item);
-        } else {
-          result[key] = item;
         }
-      }
-    });
-    return result;
-  };
-  var omit = function omit(object, list) {
-    return filter(object, function (value, key) {
-      if (list.indexOf(key) === -1) {
-        return value;
-      }
-    });
-  };
+      });
+      return result;
+    };
+    var filter = function filter(object, callback, context) {
+      var isArray = object instanceof Array;
+      var result = isArray ? [] : {};
+      each(object, function (value, key, object) {
+        var item = callback(value, key, object);
+        if (isUndefined(item) === false) {
+          if (isArray) {
+            result.push(item);
+          } else {
+            result[key] = item;
+          }
+        }
+      });
+      return result;
+    };
+    var omit = function omit(object, list) {
+      return filter(object, function (value, key) {
+        if (list.indexOf(key) === -1) {
+          return value;
+        }
+      });
+    };
 
-  /**
-   *
-   * @param object
-   * @param prop
-   * @return {boolean}
-   */
-  var hasProp = function hasProp(object, prop) {
-    return object && object.hasOwnProperty(prop);
-  };
-  var joinPath = function joinPath(path, template) {
-    template = [path, template].join('/');
-    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;
-    });
-  };
+    /**
+     *
+     * @param object
+     * @param prop
+     * @return {boolean}
+     */
+    var hasProp = function hasProp(object, prop) {
+      return object && object.hasOwnProperty(prop);
+    };
+    var joinPath = function joinPath(path, template) {
+      template = [path, template].join('/');
+      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';
-  defaults.cache = true;
-  defaults.chokidar = null;
-  defaults.path = 'views';
-  defaults.resolver = function (path, template) {
-    return Promise.resolve(['resolver is not defined', path, template].join(' '));
-  };
-  defaults.extension = 'ejs';
-  defaults.rmWhitespace = true;
-  defaults.withObject = true;
-  defaults.globalHelpers = [];
-  defaults.vars = {
-    SCOPE: 'ejs',
-    COMPONENT: 'ui',
-    ELEMENT: 'el',
-    EXTEND: '$$e',
-    BUFFER: '$$a',
-    LAYOUT: '$$l',
-    BLOCKS: '$$b',
-    MACRO: '$$m',
-    SAFE: '$$v'
-  };
-  defaults.token = {
-    start: '<%',
-    end: '%>',
-    regex: '([\\s\\S]+?)'
-  };
+    var defaults = {};
+    defaults["export"] = 'ejsPrecompiled';
+    defaults.cache = true;
+    defaults.chokidar = null;
+    defaults.path = 'views';
+    defaults.resolver = function (path, template) {
+      return Promise.resolve(['resolver is not defined', path, template].join(' '));
+    };
+    defaults.extension = 'ejs';
+    defaults.rmWhitespace = true;
+    defaults.withObject = true;
+    defaults.globalHelpers = [];
+    defaults.vars = {
+      SCOPE: 'ejs',
+      COMPONENT: 'ui',
+      ELEMENT: 'el',
+      EXTEND: '$$e',
+      BUFFER: '$$a',
+      LAYOUT: '$$l',
+      BLOCKS: '$$b',
+      MACRO: '$$m',
+      SAFE: '$$v'
+    };
+    defaults.token = {
+      start: '<%',
+      end: '%>',
+      regex: '([\\s\\S]+?)'
+    };
 
-  var configSchema = function configSchema(config, options) {
-    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),
-      extension: typeProp(isString, defaults.extension, config.extension, options.extension),
-      withObject: typeProp(isBoolean, defaults.withObject, config.withObject, options.withObject),
-      rmWhitespace: typeProp(isBoolean, defaults.rmWhitespace, config.rmWhitespace, options.rmWhitespace),
-      cache: typeProp(isBoolean, defaults.cache, config.cache, options.cache),
-      token: extend({}, defaults.token, config.token, options.token),
-      vars: extend({}, defaults.vars, config.vars, options.vars),
-      globalHelpers: typeProp(isArray, defaults.globalHelpers, config.globalHelpers, options.globalHelpers)
-    });
-  };
+    var configSchema = function configSchema(config, options) {
+      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),
+        extension: typeProp(isString, defaults.extension, config.extension, options.extension),
+        withObject: typeProp(isBoolean, defaults.withObject, config.withObject, options.withObject),
+        rmWhitespace: typeProp(isBoolean, defaults.rmWhitespace, config.rmWhitespace, options.rmWhitespace),
+        cache: typeProp(isBoolean, defaults.cache, config.cache, options.cache),
+        token: extend({}, defaults.token, config.token, options.token),
+        vars: extend({}, defaults.vars, config.vars, options.vars),
+        globalHelpers: typeProp(isArray, defaults.globalHelpers, config.globalHelpers, options.globalHelpers)
+      });
+    };
 
-  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;
+    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: "exist",
-      value: function exist(key) {
-        if (_classPrivateFieldGet2(_enabled, this)) {
-          return hasProp(_classPrivateFieldGet2(_list, this), key);
+      };
+      var get = function get(template) {
+        if (cache.exist(template)) {
+          return cache.resolve(template);
         }
+        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 configSymbols = [{
+      symbol: '-',
+      format: function format(value) {
+        return "')\n".concat(this.BUFFER, "(").concat(this.SAFE, "(").concat(value, ",1))\n").concat(this.BUFFER, "('");
       }
     }, {
-      key: "clear",
-      value: function clear() {
-        _classPrivateFieldSet2(_list, this, {});
-      }
-    }, {
-      key: "remove",
-      value: function remove(key) {
-        delete _classPrivateFieldGet2(_list, this)[key];
+      symbol: '=',
+      format: function format(value) {
+        return "')\n".concat(this.BUFFER, "(").concat(this.SAFE, "(").concat(value, "))\n").concat(this.BUFFER, "('");
       }
     }, {
-      key: "resolve",
-      value: function resolve(key) {
-        return Promise.resolve(this.get(key));
+      symbol: '#',
+      format: function format(value) {
+        return "')\n/**".concat(value, "**/\n").concat(this.BUFFER, "('");
       }
     }, {
-      key: "configure",
-      value: function configure(config) {
-        _classPrivateFieldSet2(_enabled, this, config.cache);
-        if (isNode() === false) {
-          this.load(global[config["export"]]);
-        }
-      }
-    }]);
-  }();
-
-  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);
-    }
-    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 = {
+      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: [_classPrivateFieldGet2(_config$1, this).token.start, '_'],
-          end: ['_', _classPrivateFieldGet2(_config$1, this).token.end]
+          start: [config.token.start, '_'],
+          end: ['_', config.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));
+        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));
         });
-        _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');
-      }
-    }, {
-      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) {
+        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, '');
         }
-        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);
+        content = String(content).replace(config.slurpStart, config.token.start).replace(config.slurpEnd, config.token.end);
         var source = "".concat(BUFFER, "('");
-        matchTokens(_classPrivateFieldGet2(_config$1, this).regex, content, function (params, index, offset) {
+        matchTokens(config.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 += config.formats[index](value);
             }
           });
         });
         source += "');";
         source = "try{".concat(source, "}catch(e){return ").concat(BUFFER, ".error(e)}");
-        if (_classPrivateFieldGet2(_config$1, this).withObject) {
+        if (config.withObject) {
           source = "with(".concat(SCOPE, "){").concat(source, "}");
         }
         source = "".concat(BUFFER, ".start();").concat(source, "return ").concat(BUFFER, ".end();");
@@ -525,705 +342,663 @@
           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);
-        }
-      }
-    }, {
-      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 _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 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 || {});
+        }
+      };
+      var get = function get(key) {
+        if (config.enabled) {
+          return list[key];
+        }
+      };
+      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 = ' ';
-  var quote = '"';
-  var equal = '=';
-  var slash = '/';
-  var lt = '<';
-  var gt = '>';
-  var element = function element(tag, attrs, content) {
-    var result = [];
-    var hasClosedTag = selfClosed.indexOf(tag) === -1;
-    var attributes = map(attrs, function (value, key) {
-      if (value !== null && value !== undefined) {
-        return [entities(key), [quote, entities(value), quote].join('')].join(equal);
-      }
-    }).join(space);
-    result.push([lt, tag, space, attributes, gt].join(''));
-    if (content && hasClosedTag) {
-      result.push(content instanceof Array ? content.join('') : content);
-    }
-    if (hasClosedTag) {
-      result.push([lt, slash, tag, gt].join(''));
-    }
-    return result.join('');
-  };
+    var selfClosed = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
+    var space = ' ';
+    var quote = '"';
+    var equal = '=';
+    var slash = '/';
+    var lt = '<';
+    var gt = '>';
+    var element = function element(tag, attrs, content) {
+      var result = [];
+      var hasClosedTag = selfClosed.indexOf(tag) === -1;
+      var attributes = map(attrs, function (value, key) {
+        if (value !== null && value !== undefined) {
+          return [entities(key), [quote, entities(value), quote].join('')].join(equal);
+        }
+      }).join(space);
+      result.push([lt, tag, space, attributes, gt].join(''));
+      if (content && hasClosedTag) {
+        result.push(content instanceof Array ? content.join('') : content);
+      }
+      if (hasClosedTag) {
+        result.push([lt, slash, tag, gt].join(''));
+      }
+      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;
+    /**
+     *
+     * @constructor
+     */
+    function TemplateError() {
+      TemplateError.call(this);
     }
-    _inherits(TemplateError, _Error);
-    return _createClass(TemplateError, [{
-      key: "getCode",
-      value: function getCode() {
+    Object.setPrototypeOf(TemplateError.prototype, Error.prototype);
+    Object.assign(TemplateError.prototype, {
+      code: 0,
+      getCode: function getCode() {
         return this.code;
-      }
-    }, {
-      key: "getMessage",
-      value: function getMessage() {
+      },
+      getMessage: function getMessage() {
         return this.message;
-      }
-    }, {
-      key: "toString",
-      value: function toString() {
+      },
+      toString: 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) {
-      return list.join('');
-    })["catch"](function (e) {
-      return e;
     });
-  }
-  function reject(error) {
-    return Promise.reject(new TemplateSyntaxError(error.message));
-  }
 
-  /**
-   *
-   * @return {buffer}
-   */
-  function createBuffer() {
-    var store = [],
-      array = [];
-    var buffer = function buffer(value) {
-      array.push(value);
-    };
-    buffer.start = function () {
-      array = [];
-    };
-    buffer.backup = function () {
-      store.push(array.concat());
-      array = [];
-    };
-    buffer.restore = function () {
-      var result = array.concat();
-      array = store.pop();
-      return resolve(result);
-    };
-    buffer.error = function (e) {
-      return reject(e);
-    };
-    buffer.end = function () {
-      return resolve(array);
-    };
-    return buffer;
-  }
-
-  var PARENT = Symbol('ContextScope.parentTemplate');
-  var createContextScope = function createContextScope(config, methods) {
-    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,
-      SAFE = _config$vars.SAFE,
-      SCOPE = _config$vars.SCOPE,
-      COMPONENT = _config$vars.COMPONENT,
-      ELEMENT = _config$vars.ELEMENT;
     /**
      *
-     * @type {symbol}
+     * @constructor
      */
+    function TemplateNotFound() {
+      TemplateError.call(this);
+    }
+    Object.setPrototypeOf(TemplateNotFound.prototype, TemplateError.prototype);
+    Object.assign(TemplateNotFound.prototype, {
+      code: 404
+    });
 
     /**
-     * @name ContextScope
-     * @param data
+     *
      * @constructor
      */
-    function ContextScope(data) {
-      this[PARENT] = null;
-      this[BLOCKS] = {};
-      this[MACRO] = {};
-      Object.assign(this, omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT]));
+    function TemplateSyntaxError() {
+      TemplateError.call(this);
     }
-    Object.assign(ContextScope.prototype, methods);
-    Object.defineProperty(ContextScope.prototype, BUFFER, {
-      value: createBuffer()
-    });
-    Object.defineProperty(ContextScope.prototype, BLOCKS, {
-      value: {},
-      writable: true
-    });
-    Object.defineProperty(ContextScope.prototype, MACRO, {
-      value: {},
-      writable: true
+    Object.setPrototypeOf(TemplateSyntaxError.prototype, TemplateError.prototype);
+    Object.assign(TemplateSyntaxError.prototype, {
+      code: 500
     });
-    Object.defineProperty(ContextScope.prototype, LAYOUT, {
-      value: false,
-      writable: true
-    });
-    Object.defineProperty(ContextScope.prototype, EXTEND, {
-      value: false,
-      writable: true
-    });
-    Object.defineProperty(ContextScope.prototype, PARENT, {
-      value: null,
-      writable: true
-    });
-    Object.defineProperties(ContextScope.prototype, {
-      /** @type {function} */
-      setParentTemplate: {
-        value: function value(_value) {
-          this[PARENT] = _value;
-          return this;
-        }
-      },
-      /** @type {function} */
-      getParentTemplate: {
-        value: function value() {
-          return this[PARENT];
-        }
-      },
-      /** @type {function} */
-      useSafeValue: {
-        get: function get() {
-          return safeValue;
-        }
-      },
-      /** @type {function} */
-      useComponent: {
-        get: function get() {
-          if (isFunction(this[COMPONENT])) {
-            return this[COMPONENT].bind(this);
-          } else {
-            return function () {
-              throw new Error("".concat(COMPONENT, " must be a function"));
-            };
+
+    function resolve(list) {
+      return Promise.all(list || []).then(function (list) {
+        return list.join('');
+      })["catch"](function (e) {
+        return e;
+      });
+    }
+    function reject(error) {
+      return Promise.reject(new TemplateSyntaxError(error.message));
+    }
+
+    /**
+     *
+     * @return {buffer}
+     */
+    function createBuffer() {
+      var store = [],
+        array = [];
+      var buffer = function buffer(value) {
+        array.push(value);
+      };
+      buffer.start = function () {
+        array = [];
+      };
+      buffer.backup = function () {
+        store.push(array.concat());
+        array = [];
+      };
+      buffer.restore = function () {
+        var result = array.concat();
+        array = store.pop();
+        return resolve(result);
+      };
+      buffer.error = function (e) {
+        return reject(e);
+      };
+      buffer.end = function () {
+        return resolve(array);
+      };
+      return buffer;
+    }
+
+    var PARENT = Symbol('ContextScope.parentTemplate');
+    var createContextScope = function createContextScope(config, methods) {
+      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,
+        SAFE = _config$vars.SAFE,
+        SCOPE = _config$vars.SCOPE,
+        COMPONENT = _config$vars.COMPONENT,
+        ELEMENT = _config$vars.ELEMENT;
+
+      /**
+       *
+       * @type {symbol}
+       */
+
+      /**
+       * @name ContextScope
+       * @param data
+       * @constructor
+       */
+      function ContextScope(data) {
+        this[PARENT] = null;
+        this[BLOCKS] = {};
+        this[MACRO] = {};
+        Object.assign(this, omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT]));
+      }
+      Object.assign(ContextScope.prototype, methods);
+      Object.defineProperty(ContextScope.prototype, BUFFER, {
+        value: createBuffer()
+      });
+      Object.defineProperty(ContextScope.prototype, BLOCKS, {
+        value: {},
+        writable: true
+      });
+      Object.defineProperty(ContextScope.prototype, MACRO, {
+        value: {},
+        writable: true
+      });
+      Object.defineProperty(ContextScope.prototype, LAYOUT, {
+        value: false,
+        writable: true
+      });
+      Object.defineProperty(ContextScope.prototype, EXTEND, {
+        value: false,
+        writable: true
+      });
+      Object.defineProperty(ContextScope.prototype, PARENT, {
+        value: null,
+        writable: true
+      });
+      Object.defineProperties(ContextScope.prototype, {
+        /** @type {function} */
+        setParentTemplate: {
+          value: function value(_value) {
+            this[PARENT] = _value;
+            return this;
           }
-        }
-      },
-      /** @type {function} */
-      useElement: {
-        get: function get() {
-          if (isFunction(this[ELEMENT])) {
-            return this[ELEMENT].bind(this);
-          } else {
-            return function () {
-              throw new Error("".concat(ELEMENT, " must be a function"));
-            };
+        },
+        /** @type {function} */
+        getParentTemplate: {
+          value: function value() {
+            return this[PARENT];
           }
-        }
-      },
-      /** @type {()=>this[MACRO]} */
-      getMacro: {
-        value: function value() {
-          return this[MACRO];
-        }
-      },
-      /** @type {function} */
-      getBuffer: {
-        value: function value() {
-          return this[BUFFER];
-        }
-      },
-      /** @type {function} */
-      getBlocks: {
-        value: function value() {
-          return this[BLOCKS];
-        }
-      },
-      /** @type {function} */
-      setExtend: {
-        value: function value(_value2) {
-          this[EXTEND] = _value2;
-          return this;
-        }
-      },
-      /** @type {function} */
-      getExtend: {
-        value: function value() {
-          return this[EXTEND];
-        }
-      },
-      /** @type {function} */
-      setLayout: {
-        value: function value(layout) {
-          this[LAYOUT] = layout;
-          return this;
-        }
-      },
-      /** @type {function} */
-      getLayout: {
-        value: function value() {
-          return this[LAYOUT];
-        }
-      },
-      /** @type {function} */
-      clone: {
-        value: function value(exclude_blocks) {
-          var filter = [LAYOUT, EXTEND, BUFFER];
-          if (exclude_blocks === true) {
-            filter.push(BLOCKS);
+        },
+        /** @type {function} */
+        useSafeValue: {
+          get: function get() {
+            return safeValue;
           }
-          return omit(this, filter);
-        }
-      },
-      /** @type {function} */
-      extend: {
-        value: function value(layout) {
-          this.setExtend(true);
-          this.setLayout(layout);
-        }
-      },
-      /** @type {function} */
-      echo: {
-        value: function value(layout) {
-          var buffer = this.getBuffer();
-          var params = [].slice.call(arguments);
-          params.forEach(buffer);
-        }
-      },
-      /** @type {function} */
-      fn: {
-        value: function value(callback) {
-          var buffer = this.getBuffer();
-          var context = this;
-          return function () {
-            if (isFunction(callback)) {
-              buffer.backup();
-              buffer(callback.apply(context, arguments));
-              return buffer.restore();
+        },
+        /** @type {function} */
+        useComponent: {
+          get: function get() {
+            if (isFunction(this[COMPONENT])) {
+              return this[COMPONENT].bind(this);
+            } else {
+              return function () {
+                throw new Error("".concat(COMPONENT, " must be a function"));
+              };
             }
-          };
-        }
-      },
-      /** @type {function} */
-      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));
-          };
-        }
-      },
-      /** @type {function} */
-      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);
           }
-        }
-      },
-      /** @type {function} */
-      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) {
+        },
+        /** @type {function} */
+        useElement: {
+          get: function get() {
+            if (isFunction(this[ELEMENT])) {
+              return this[ELEMENT].bind(this);
+            } else {
               return function () {
-                _this.echo(parent(_next()));
+                throw new Error("".concat(ELEMENT, " must be a function"));
               };
-            } else {
-              return noop;
             }
-          };
-          this.echo(current()(_next()));
-        }
-      },
-      /** @type {function} */
-      hasBlock: {
-        value: function value(name) {
-          return this.getBlocks().hasOwnProperty(name);
-        }
-      },
-      /** @type {function} */
-      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);
-        }
-      },
-      /** @type {function} */
-      use: {
-        value: function value(path, namespace) {
-          var _this2 = this;
-          this.echo(Promise.resolve(this.require(path)).then(function (exports) {
-            var list = _this2.getMacro();
-            each(exports, function (macro, name) {
-              list[[namespace, name].join('.')] = macro;
-            });
-          }));
-        }
-      },
-      /** @type {function} */
-      async: {
-        value: function value(promise, callback) {
-          this.echo(Promise.resolve(promise).then(callback));
-        }
-      },
-      /** @type {function} */
-      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;
-        }
-      },
-      /** @type {function} */
-      set: {
-        value: function value(name, _value3) {
-          var path = getPath(this, name, false);
-          var result = path.shift();
-          var prop = path.pop();
-          if (this.getParentTemplate() && hasProp(result, prop)) {
-            return result[prop];
           }
-          return result[prop] = _value3;
-        }
-      },
-      /** @type {function} */
-      each: {
-        value: function value(object, callback) {
-          if (isString(object)) {
-            object = this.get(object, []);
+        },
+        /** @type {()=>this[MACRO]} */
+        getMacro: {
+          value: function value() {
+            return this[MACRO];
           }
-          each(object, callback);
         },
-        writable: true
-      },
-      /** @type {function} */
-      el: {
-        value: function value(tag, attr, content) {
-          content = isFunction(content) ? this.fn(content)() : content;
-          this.echo(Promise.resolve(content).then(function (content) {
-            return element(tag, attr, content);
-          }));
+        /** @type {function} */
+        getBuffer: {
+          value: function value() {
+            return this[BUFFER];
+          }
         },
-        writable: true
-      },
-      /** @type {function} */
-      ui: {
-        value: function value(layout) {},
-        writable: true
-      }
-    });
-    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 _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
+        /** @type {function} */
+        getBlocks: {
+          value: function value() {
+            return this[BLOCKS];
+          }
+        },
+        /** @type {function} */
+        setExtend: {
+          value: function value(_value2) {
+            this[EXTEND] = _value2;
+            return this;
+          }
+        },
+        /** @type {function} */
+        getExtend: {
+          value: function value() {
+            return this[EXTEND];
+          }
+        },
+        /** @type {function} */
+        setLayout: {
+          value: function value(layout) {
+            this[LAYOUT] = layout;
+            return this;
+          }
+        },
+        /** @type {function} */
+        getLayout: {
+          value: function value() {
+            return this[LAYOUT];
+          }
+        },
+        /** @type {function} */
+        clone: {
+          value: function value(exclude_blocks) {
+            var filter = [LAYOUT, EXTEND, BUFFER];
+            if (exclude_blocks === true) {
+              filter.push(BLOCKS);
+            }
+            return omit(this, filter);
+          }
+        },
+        /** @type {function} */
+        extend: {
+          value: function value(layout) {
+            this.setExtend(true);
+            this.setLayout(layout);
+          }
+        },
+        /** @type {function} */
+        echo: {
+          value: function value(layout) {
+            var buffer = this.getBuffer();
+            var params = [].slice.call(arguments);
+            params.forEach(buffer);
+          }
+        },
+        /** @type {function} */
+        fn: {
+          value: function value(callback) {
+            var buffer = this.getBuffer();
+            var context = this;
+            return function () {
+              if (isFunction(callback)) {
+                buffer.backup();
+                buffer(callback.apply(context, arguments));
+                return buffer.restore();
+              }
+            };
+          }
+        },
+        /** @type {function} */
+        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));
+            };
+          }
+        },
+        /** @type {function} */
+        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);
+            }
+          }
+        },
+        /** @type {function} */
+        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()));
+          }
+        },
+        /** @type {function} */
+        hasBlock: {
+          value: function value(name) {
+            return this.getBlocks().hasOwnProperty(name);
+          }
+        },
+        /** @type {function} */
+        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);
+          }
+        },
+        /** @type {function} */
+        use: {
+          value: function value(path, namespace) {
+            var _this2 = this;
+            this.echo(Promise.resolve(this.require(path)).then(function (exports) {
+              var list = _this2.getMacro();
+              each(exports, function (macro, name) {
+                list[[namespace, name].join('.')] = macro;
+              });
+            }));
+          }
+        },
+        /** @type {function} */
+        async: {
+          value: function value(promise, callback) {
+            this.echo(Promise.resolve(promise).then(callback));
+          }
+        },
+        /** @type {function} */
+        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;
+          }
+        },
+        /** @type {function} */
+        set: {
+          value: function value(name, _value3) {
+            var path = getPath(this, name, false);
+            var result = path.shift();
+            var prop = path.pop();
+            if (this.getParentTemplate() && hasProp(result, prop)) {
+              return result[prop];
+            }
+            return result[prop] = _value3;
+          }
+        },
+        /** @type {function} */
+        each: {
+          value: function value(object, callback) {
+            if (isString(object)) {
+              object = this.get(object, []);
+            }
+            each(object, callback);
+          },
+          writable: true
+        },
+        /** @type {function} */
+        el: {
+          value: function value(tag, attr, content) {
+            content = isFunction(content) ? this.fn(content)() : content;
+            this.echo(Promise.resolve(content).then(function (content) {
+              return element(tag, attr, content);
+            }));
+          },
+          writable: true
+        },
+        /** @type {function} */
+        ui: {
+          value: function value(layout) {},
+          writable: true
+        }
       });
-    }
-    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 ContextScope;
+    };
+    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 _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();
         });
-      }
-    }, {
-      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;
+      };
+      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 _this.renderLayout(scope.getLayout(), scope, name);
+            return renderLayout(scope.getLayout(), scope, name);
           }
           return content;
         };
-      }
-    }, {
-      key: "renderLayout",
-      value: function renderLayout(name, data, parent) {
-        var scope = this.context(data);
+      };
+      var renderLayout = function renderLayout(name, data, parent) {
+        var scope = createContext(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));
-    });
-  }
+        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 path = {};
+    var path = {};
 
-  function readFile(path$1, template) {
-    return new Promise(function (resolve, reject) {
-      path.readFile(joinPath(path$1, template), function (error, data) {
-        if (error) {
-          reject(new TemplateError(error));
-        } else {
-          resolve(data.toString());
-        }
+    var readFile = function readFile(path$1, template) {
+      return new Promise(function (resolve, reject) {
+        path.readFile(joinPath(path$1, template), function (error, data) {
+          if (error) {
+            reject(new TemplateError());
+          } else {
+            resolve(data.toString());
+          }
+        });
       });
-    });
-  }
+    };
 
-  /**
-   *
-   * @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(configure, render) {
-    return function (name, options, callback) {
-      if (isFunction(options)) {
-        callback = options;
-        options = {};
-      }
-      options = options || {};
-      var settings = extend({}, options.settings);
-      var viewPath = typeProp(isString, defaults.path, settings['views']);
-      var viewCache = typeProp(isBoolean, defaults.cache, settings['view cache']);
-      var viewOptions = extend({}, settings['view options']);
-      var filename = path.relative(viewPath, name);
-      viewOptions.path = viewPath;
-      viewOptions.cache = viewCache;
-      configure(viewOptions);
-      return render(filename, options).then(function (content) {
-        callback(null, content);
-      })["catch"](function (error) {
-        callback(error);
-      });
+    /**
+     *
+     * @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>}
+     */
+    var expressRenderer = function expressRenderer(configure, render) {
+      return function (name, options, callback) {
+        if (isFunction(options)) {
+          callback = options;
+          options = {};
+        }
+        options = options || {};
+        var settings = extend({}, options.settings);
+        var viewPath = typeProp(isString, defaults.path, settings['views']);
+        var viewCache = typeProp(isBoolean, defaults.cache, settings['view cache']);
+        var viewOptions = extend({}, settings['view options']);
+        var filename = path.relative(viewPath, name);
+        viewOptions.path = viewPath;
+        viewOptions.cache = viewCache;
+        configure(viewOptions);
+        return render(filename, options).then(function (content) {
+          callback(null, content);
+        })["catch"](function (error) {
+          callback(error);
+        });
+      };
     };
-  }
 
-  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);
+    var _EJS = _EJS$1({
+        resolver: readFile
+      }),
+      render = _EJS.render,
+      createContext = _EJS.createContext,
+      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;
-  exports.TemplateSyntaxError = TemplateSyntaxError;
-  exports.__express = __express;
-  exports.compile = compile;
-  exports.configure = configure;
-  exports.context = context;
-  exports.create = create;
-  exports.helpers = helpers;
-  exports.preload = preload;
-  exports.render = render;
+    exports.TemplateError = TemplateError;
+    exports.TemplateNotFound = TemplateNotFound;
+    exports.TemplateSyntaxError = TemplateSyntaxError;
+    exports.__express = __express;
+    exports.compile = compile;
+    exports.configure = configure;
+    exports.create = create;
+    exports.createContext = createContext;
+    exports.helpers = helpers;
+    exports.preload = preload;
+    exports.render = render;
 
 }));