@kosatyi/ejs 0.0.97 → 0.0.99

package/dist/umd/browser.js

@@ -1,337 +1,519 @@
 (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';
 
-    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 = {
-      '&': '&',
-      '<': '&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 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] || {};
+  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 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];
       if (isFunction(data['toJSON'])) {
         data = data.toJSON();
       }
-      return [data, prop];
-    };
-    var ext = function ext(path, defaults) {
-      var ext = path.split('.').pop();
-      if (ext !== defaults) {
-        path = [path, defaults].join('.');
+      if (strict && data.hasOwnProperty(part) === false) {
+        data = {};
+        break;
       }
-      return path;
-    };
+      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);
+      }
+    });
+  };
+  var ext = function ext(path, defaults) {
+    var ext = path.split('.').pop();
+    if (ext !== defaults) {
+      path = [path, defaults].join('.');
+    }
+    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);
-        }
+  /**
+   * @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) {
+    }
+  };
+  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);
+      }
+    });
+    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 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;
-        }
-      });
-    };
-    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;
-    };
+      }
+    });
+    return result;
+  };
+  var omit = function omit(object, list) {
+    return filter(object, function (value, key) {
+      if (list.indexOf(key) === -1) {
+        return value;
+      }
+    });
+  };
 
-    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',
-      EXTEND: '$$e',
-      BUFFER: '$$a',
-      LAYOUT: '$$l',
-      BLOCKS: '$$b',
-      MACRO: '$$m',
-      SAFE: '$$v'
-    };
-    defaults.token = {
-      start: '<%',
-      end: '%>',
-      regex: '([\\s\\S]+?)'
-    };
+  /**
+   *
+   * @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 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 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 global = typeof globalThis !== 'undefined' ? globalThis : window || self;
+  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) {
-      if (instanceOf(this, Cache) === false) return new Cache();
-      var cache = {
-        enabled: true,
-        list: {}
-      };
-      this.configure = function (config) {
-        cache.enabled = config.cache;
-        if (isNode() === false) {
-          this.load(global[config["export"]]);
-        }
-      };
-      this.clear = function () {
-        cache.list = {};
-      };
-      this.load = function (data) {
-        if (cache.enabled) {
-          extend(cache.list, data || {});
+      _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 || {});
         }
-        return this;
-      };
-      this.get = function (key) {
-        if (cache.enabled) {
-          return cache.list[key];
+      }
+    }, {
+      key: "get",
+      value: function get(key) {
+        if (_classPrivateFieldGet2(_enabled, this)) {
+          return _classPrivateFieldGet2(_list, this)[key];
         }
-      };
-      this.set = function (key, value) {
-        if (cache.enabled) {
-          cache.list[key] = value;
+      }
+    }, {
+      key: "set",
+      value: function set(key, value) {
+        if (_classPrivateFieldGet2(_enabled, this)) {
+          _classPrivateFieldGet2(_list, this)[key] = value;
         }
-        return this;
-      };
-      this.resolve = function (key) {
-        return Promise.resolve(this.get(key));
-      };
-      this.remove = function (key) {
-        delete cache.list[key];
-      };
-      this.exist = function (key) {
-        return hasProp(cache.list, key);
-      };
-    }
-
-    var tagList = [{
-      symbol: '-',
-      format: function format(value) {
-        return "')\n".concat(this.BUFFER, "(").concat(this.SAFE, "(").concat(value, ",1))\n").concat(this.BUFFER, "('");
       }
     }, {
-      symbol: '=',
-      format: function format(value) {
-        return "')\n".concat(this.BUFFER, "(").concat(this.SAFE, "(").concat(value, "))\n").concat(this.BUFFER, "('");
+      key: "exist",
+      value: function exist(key) {
+        return hasProp(_classPrivateFieldGet2(_list, this), key);
       }
     }, {
-      symbol: '#',
-      format: function format(value) {
-        return "')\n/**".concat(value, "**/\n").concat(this.BUFFER, "('");
+      key: "clear",
+      value: function clear() {
+        _classPrivateFieldSet2(_list, this, {});
       }
     }, {
-      symbol: '',
-      format: function format(value) {
-        return "')\n".concat(value.trim(), "\n").concat(this.BUFFER, "('");
-      }
-    }];
-    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;
-      });
-    }
+      key: "remove",
+      value: function remove(key) {
+        delete _classPrivateFieldGet2(_list, this)[key];
+      }
+    }, {
+      key: "resolve",
+      value: function resolve(key) {
+        return Promise.resolve(this.get(key));
+      }
+    }, {
+      key: "configure",
+      value: function configure(config) {
+        _classPrivateFieldSet2(_enabled, this, config.cache);
+        if (isNode() === false) {
+          this.load(global[config["export"]]);
+        }
+      }
+    }]);
+  }();
+
+  var _config$1 = /*#__PURE__*/new WeakMap();
+  var _symbols = /*#__PURE__*/new WeakMap();
+  var Compiler = /*#__PURE__*/function () {
     function Compiler(config) {
-      if (instanceOf(this, Compiler) === false) return new Compiler(config);
-      var compiler = {};
-      this.configure = function (config) {
-        compiler.withObject = config.withObject;
-        compiler.rmWhitespace = config.rmWhitespace;
-        compiler.token = config.token;
-        compiler.vars = config.vars;
-        compiler.globalHelpers = config.globalHelpers;
-        compiler.matches = [];
-        compiler.formats = [];
-        compiler.slurp = {
-          match: '[\s\t\n]*',
-          start: [compiler.token.start, '_'],
-          end: ['_', compiler.token.end]
+      _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 = {
+          match: '[s\t\n]*',
+          start: [_classPrivateFieldGet2(_config$1, this).token.start, '_'],
+          end: ['_', _classPrivateFieldGet2(_config$1, this).token.end]
         };
-        tagList.forEach(function (item) {
-          compiler.matches.push(compiler.token.start.concat(item.symbol).concat(compiler.token.regex).concat(compiler.token.end));
-          compiler.formats.push(item.format.bind(compiler.vars));
+        _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));
         });
-        compiler.regex = new RegExp(compiler.matches.join('|').concat('|$'), 'g');
-        compiler.slurpStart = new RegExp([compiler.slurp.match, compiler.slurp.start.join('')].join(''), 'gm');
-        compiler.slurpEnd = new RegExp([compiler.slurp.end.join(''), compiler.slurp.match].join(''), 'gm');
-      };
-      this.compile = function (content, path) {
-        var _compiler$vars = compiler.vars,
-          SCOPE = _compiler$vars.SCOPE,
-          SAFE = _compiler$vars.SAFE,
-          BUFFER = _compiler$vars.BUFFER,
-          COMPONENT = _compiler$vars.COMPONENT;
-        var GLOBALS = compiler.globalHelpers;
-        content = String(content);
-        if (compiler.rmWhitespace) {
-          content = content.replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
+        _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) {
+          content = String(content).replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
         }
-        content = content.replace(compiler.slurpStart, compiler.token.start).replace(compiler.slurpEnd, compiler.token.end);
+        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(compiler.regex, content, function (params, index, offset) {
+        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 += compiler.formats[index](value);
+              source += _classPrivateFieldGet2(_config$1, _this2).formats[index](value);
             }
           });
         });
         source += "');";
         source = "try{".concat(source, "}catch(e){return ").concat(BUFFER, ".error(e)}");
-        if (compiler.withObject) {
+        if (_classPrivateFieldGet2(_config$1, this).withObject) {
           source = "with(".concat(SCOPE, "){").concat(source, "}");
         }
         source = "".concat(BUFFER, ".start();").concat(source, "return ").concat(BUFFER, ".end();");
         source += "\n//# sourceURL=".concat(path);
         var result = null;
-        var params = [SCOPE, COMPONENT, BUFFER, SAFE].concat(GLOBALS);
+        var params = [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT].concat(GLOBALS);
         try {
           result = Function.apply(null, params.concat(source));
           result.source = "(function(".concat(params.join(','), "){\n").concat(source, "\n});");
@@ -341,620 +523,571 @@
           throw e;
         }
         return result;
-      };
-      this.configure(config);
-    }
+      }
+    }]);
+  }();
 
+  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) {
-      if (instanceOf(this, Template) === false) return new Template(config, cache, compiler);
-      if (instanceOf(cache, Cache) === false) throw new TypeError('cache is not instance of Cache');
-      if (instanceOf(compiler, Compiler) === false) throw new TypeError('compiler is not instance of Compiler');
-      var template = {};
-      var result = function result(template, content) {
-        cache.set(template, content);
-        return content;
-      };
-      var resolve = function resolve(path) {
-        return template.resolver(template.path, path);
-      };
-      var compile = function compile(content, template) {
-        if (isFunction(content)) {
-          return content;
-        } else {
-          return compiler.compile(content, template);
-        }
-      };
-      this.configure = function (config) {
-        template.path = config.path;
-        template.cache = config.cache;
+      _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)) {
-          template.resolver = config.resolver;
+          _classPrivateFieldSet2(_resolver, this, config.resolver);
         }
-      };
-      this.get = function (template) {
-        if (cache.exist(template)) {
-          return cache.resolve(template);
+      }
+    }, {
+      key: "get",
+      value: function get(template) {
+        var _this = this;
+        if (_classPrivateFieldGet2(_cache$1, this).exist(template)) {
+          return _classPrivateFieldGet2(_cache$1, this).resolve(template);
         }
-        return resolve(template).then(function (content) {
-          return result(template, compile(content, 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));
         });
-      };
-      this.configure(config);
+      }
+    }]);
+  }();
+  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);
     }
+  }
 
-    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 _toPrimitive(t, r) {
-      if ("object" != typeof t || !t) return t;
-      var e = t[Symbol.toPrimitive];
-      if (void 0 !== e) {
-        var i = e.call(t, r || "default");
-        if ("object" != typeof i) return i;
-        throw new TypeError("@@toPrimitive must return a primitive value.");
-      }
-      return ("string" === r ? String : Number)(t);
+  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);
     }
-    function _toPropertyKey(t) {
-      var i = _toPrimitive(t, "string");
-      return "symbol" == typeof i ? i : i + "";
+    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);
+  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;
       }
-      if (hasClosedTag) {
-        result.push([lt, slash, tag, gt].join(''));
+    }, {
+      key: "getMessage",
+      value: function getMessage() {
+        return this.message;
       }
-      return result.join('');
-    };
-
-    /**
-     * @extends Error
-     * @property code
-     * @param {string} message
-     * @constructor
-     */
-    function TemplateError(message) {
-      this.name = 'TemplateError';
-      this.message = message;
-      Error.call(this);
+    }, {
+      key: "toString",
+      value: function toString() {
+        return this.getMessage();
+      }
+    }]);
+  }(/*#__PURE__*/_wrapNativeSuper(Error));
+  var TemplateNotFound = /*#__PURE__*/function (_TemplateError2) {
+    function TemplateNotFound() {
+      var _this2;
+      _classCallCheck(this, TemplateNotFound);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this2 = _callSuper(this, TemplateNotFound, [].concat(args));
+      _defineProperty(_this2, "code", 404);
+      return _this2;
+    }
+    _inherits(TemplateNotFound, _TemplateError2);
+    return _createClass(TemplateNotFound);
+  }(TemplateError);
+  var TemplateSyntaxError = /*#__PURE__*/function (_TemplateError3) {
+    function TemplateSyntaxError() {
+      var _this3;
+      _classCallCheck(this, TemplateSyntaxError);
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      _this3 = _callSuper(this, TemplateSyntaxError, [].concat(args));
+      _defineProperty(_this3, "code", 500);
+      return _this3;
     }
+    _inherits(TemplateSyntaxError, _TemplateError3);
+    return _createClass(TemplateSyntaxError);
+  }(TemplateError);
 
-    /**
-     *
-     */
-    Object.setPrototypeOf(TemplateError.prototype, Error.prototype);
-    Object.assign(TemplateError.prototype, {
-      code: 1
+  function resolve(list) {
+    return Promise.all(list || []).then(function (list) {
+      return list.join('');
+    })["catch"](function (e) {
+      return e;
     });
-    /**
-     *
-     * @return {number}
-     */
-    TemplateError.prototype.getCode = function () {
-      return this.code;
+  }
+  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);
     };
-    /**
-     *
-     * @return {string}
-     */
-    TemplateError.prototype.getMessage = function () {
-      return this.message;
+    buffer.start = function () {
+      array = [];
     };
-    /**
-     * @return {string}
-     */
-    TemplateError.prototype.toString = function () {
-      return this.getMessage();
+    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 createContextScope = function createContextScope(config, methods) {
+    var _Object$definePropert;
+    var _config$vars = config.vars,
+      BLOCKS = _config$vars.BLOCKS,
+      MACRO = _config$vars.MACRO,
+      EXTEND = _config$vars.EXTEND,
+      LAYOUT = _config$vars.LAYOUT,
+      BUFFER = _config$vars.BUFFER,
+      SAFE = _config$vars.SAFE,
+      SCOPE = _config$vars.SCOPE,
+      COMPONENT = _config$vars.COMPONENT,
+      ELEMENT = _config$vars.ELEMENT;
     /**
-     * @extends TemplateError
-     * @param {string} message
-     * @constructor
-     */
-    function TemplateNotFound(message) {
-      TemplateError.call(this);
-      this.name = 'TemplateNotFound';
-      this.message = message;
-    }
-
-    /**
-     *
-     */
-    Object.setPrototypeOf(TemplateNotFound.prototype, TemplateError.prototype);
-    Object.assign(TemplateNotFound.prototype, {
-      code: 404
-    });
-    /**
-     * @extends TemplateError
-     * @param {string} message
+     * @name ContextScope
+     * @param data
      * @constructor
      */
-    function TemplateSyntaxError(message) {
-      TemplateError.call(this);
-      this.name = 'TemplateSyntaxError';
-      this.message = message;
-    }
-
-    /**
-     *
-     */
-    Object.setPrototypeOf(TemplateSyntaxError.prototype, TemplateError.prototype);
-    Object.assign(TemplateSyntaxError.prototype, {
-      code: 500
-    });
-
-    function resolve(list) {
-      return Promise.all(list || []).then(function (list) {
-        return list.join('');
-      })["catch"](function (e) {
-        return e;
-      });
+    function ContextScope(data) {
+      this[BLOCKS] = {};
+      this[MACRO] = {};
+      Object.assign(this, omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT]));
     }
-    function reject(error) {
-      return Promise.reject(new TemplateSyntaxError(error.message));
-    }
-    function createBuffer() {
-      var store = [],
-        array = [];
-      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;
-    }
-
-    function Context(config) {
-      if (instanceOf(this, Context) === false) return new Context(config);
-      this.configure = function (config, methods) {
-        var _Object$definePropert;
-        var _config$vars = config.vars,
-          BLOCKS = _config$vars.BLOCKS,
-          MACRO = _config$vars.MACRO,
-          EXTEND = _config$vars.EXTEND,
-          LAYOUT = _config$vars.LAYOUT,
-          BUFFER = _config$vars.BUFFER,
-          COMPONENT = _config$vars.COMPONENT;
-        this.create = function (data) {
-          return new Scope(data);
+    Object.assign(ContextScope.prototype, methods);
+    Object.defineProperties(ContextScope.prototype, (_Object$definePropert = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_Object$definePropert, BUFFER, {
+      value: createBuffer()
+    }), BLOCKS, {
+      value: {},
+      writable: true
+    }), MACRO, {
+      value: {},
+      writable: true
+    }), LAYOUT, {
+      value: false,
+      writable: true
+    }), EXTEND, {
+      value: false,
+      writable: true
+    }), "useSafeValue", {
+      get: function get() {
+        return safeValue;
+      }
+    }), "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"));
+          };
+        }
+      }
+    }), "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"));
+          };
+        }
+      }
+    }), "getMacro", {
+      value: function value() {
+        return this[MACRO];
+      }
+    }), "getBuffer", {
+      value: function value() {
+        return this[BUFFER];
+      }
+    }), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_Object$definePropert, "getBlocks", {
+      value: function value() {
+        return this[BLOCKS];
+      }
+    }), "setExtend", {
+      value: function value(_value) {
+        this[EXTEND] = _value;
+      }
+    }), "getExtend", {
+      value: function value() {
+        return this[EXTEND];
+      }
+    }), "setLayout", {
+      value: function value(layout) {
+        this[LAYOUT] = layout;
+      }
+    }), "getLayout", {
+      value: function value() {
+        return this[LAYOUT];
+      }
+    }), "clone", {
+      value: function value(exclude_blocks) {
+        var filter = [LAYOUT, EXTEND, BUFFER];
+        if (exclude_blocks === true) {
+          filter.push(BLOCKS);
+        }
+        return omit(this, filter);
+      }
+    }), "extend", {
+      value: function value(layout) {
+        this.setExtend(true);
+        this.setLayout(layout);
+      }
+    }), "echo", {
+      value: function value(layout) {
+        var buffer = this.getBuffer();
+        var params = [].slice.call(arguments);
+        params.forEach(buffer);
+      }
+    }), "fn", {
+      value: function value(callback) {
+        var buffer = this.getBuffer();
+        var context = this;
+        return function () {
+          if (isFunction(callback)) {
+            buffer.backup();
+            buffer(callback.apply(context, arguments));
+            return buffer.restore();
+          }
         };
-        this.helpers = function (methods) {
-          extend(Scope.prototype, methods || {});
+      }
+    }), "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));
         };
-        /**
-         * @name ContextScope
-         * @param data
-         * @constructor
-         */
-        function Scope(data) {
-          this[BLOCKS] = {};
-          this[MACRO] = {};
-          extend(this, data || {});
+      }
+    }), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_Object$definePropert, "call", {
+      value: function value(name) {
+        var list = this.getMacro();
+        var macro = list[name];
+        var params = [].slice.call(arguments, 1);
+        if (isFunction(macro)) {
+          return macro.apply(macro, params);
         }
-        Scope.prototype = extend({}, methods || {});
-        Object.defineProperties(Scope.prototype, (_Object$definePropert = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_Object$definePropert, BUFFER, {
-          value: createBuffer(),
-          writable: true,
-          configurable: false,
-          enumerable: false
-        }), BLOCKS, {
-          value: {},
-          writable: true,
-          configurable: false,
-          enumerable: false
-        }), MACRO, {
-          value: {},
-          writable: true,
-          configurable: false,
-          enumerable: false
-        }), LAYOUT, {
-          value: false,
-          writable: true,
-          configurable: false,
-          enumerable: false
-        }), EXTEND, {
-          value: false,
-          writable: true,
-          configurable: false,
-          enumerable: false
-        }), "getMacro", {
-          value: function value() {
-            return this[MACRO];
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "getBuffer", {
-          value: function value() {
-            return this[BUFFER];
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "getComponent", {
-          value: function value() {
-            var context = this;
-            if (COMPONENT in context) {
-              return function () {
-                return context[COMPONENT].apply(context, arguments);
-              };
-            }
-            return function () {
-              console.log('%s function not defined', COMPONENT);
-            };
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "getBlocks", {
-          value: function value() {
-            return this[BLOCKS];
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "setExtend", {
-          value: function value(_value) {
-            this[EXTEND] = _value;
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_Object$definePropert, "getExtend", {
-          value: function value() {
-            return this[EXTEND];
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "setLayout", {
-          value: function value(layout) {
-            this[LAYOUT] = layout;
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "getLayout", {
-          value: function value() {
-            return this[LAYOUT];
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "clone", {
-          value: function value(exclude_blocks) {
-            var filter = [LAYOUT, EXTEND, BUFFER];
-            if (exclude_blocks === true) {
-              filter.push(BLOCKS);
-            }
-            return omit(this, filter);
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "extend", {
-          value: function value(layout) {
-            this.setExtend(true);
-            this.setLayout(layout);
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "echo", {
-          value: function value(layout) {
-            var buffer = this.getBuffer();
-            var params = [].slice.call(arguments);
-            params.forEach(buffer);
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "fn", {
-          value: function value(callback) {
-            var buffer = this.getBuffer();
-            var context = this;
+      }
+    }), "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 () {
-              buffer.backup();
-              if (isFunction(callback)) {
-                callback.apply(context, arguments);
-              }
-              return buffer.restore();
-            };
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "get", {
-          value: function value(name, defaults) {
-            var path = getPath(this, name, true);
-            var result = path.shift();
-            var prop = path.pop();
-            return hasProp(result, prop) ? result[prop] : defaults;
-          },
-          writable: true,
-          configurable: true,
-          enumerable: false
-        }), "set", {
-          value: function value(name, _value2) {
-            var path = getPath(this, name, false);
-            var result = path.shift();
-            var prop = path.pop();
-            if (this.getExtend() && hasProp(result, prop)) {
-              return result[prop];
-            }
-            return result[prop] = _value2;
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "macro", {
-          value: function value(name, callback) {
-            var list = this.getMacro();
-            var macro = this.fn(callback);
-            var context = this;
-            list[name] = function () {
-              return context.echo(macro.apply(undefined, arguments));
-            };
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_Object$definePropert, "call", {
-          value: function value(name) {
-            var list = this.getMacro();
-            var macro = list[name];
-            var params = [].slice.call(arguments, 1);
-            if (isFunction(macro)) {
-              return macro.apply(macro, params);
-            }
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "block", {
-          value: function value(name, callback) {
-            var _this = this;
-            var blocks = this.getBlocks();
-            blocks[name] = blocks[name] || [];
-            blocks[name].push(this.fn(callback));
-            if (this.getExtend()) return;
-            var list = Object.assign([], blocks[name]);
-            var current = function current() {
-              return list.shift();
-            };
-            var _next = function next() {
-              var parent = current();
-              if (parent) {
-                return function () {
-                  _this.echo(parent(_next()));
-                };
-              } else {
-                return noop;
-              }
+              _this.echo(parent(_next()));
             };
-            this.echo(current()(_next()));
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "hasBlock", {
-          value: function value(name) {
-            return this.getBlocks().hasOwnProperty(name);
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "include", {
-          value: function value(path, data, cx) {
-            var context = cx === false ? {} : this.clone(true);
-            var params = extend(context, data || {});
-            var promise = this.render(path, params);
-            this.echo(promise);
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "promiseResolve", {
-          value: function value(_value3, callback) {
-            return Promise.resolve(isFunction(_value3) ? this.fn(_value3)() : _value3).then(callback.bind(this));
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "use", {
-          value: function value(path, namespace) {
-            this.echo(this.promiseResolve(this.require(path), function (exports) {
-              var list = this.getMacro();
-              each(exports, function (macro, name) {
-                list[[namespace, name].join('.')] = macro;
-              });
-            }));
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "async", {
-          value: function value(promise, callback) {
-            this.echo(this.promiseResolve(promise, function (data) {
-              return this.fn(callback)(data);
-            }));
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "each", {
-          value: function value(object, callback) {
-            if (isString(object)) {
-              object = this.get(object, []);
-            }
-            each(object, callback);
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "element", {
-          value: function value(tag, attr, content) {
-            return element(tag, attr, content);
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        }), "el", {
-          value: function value(tag, attr, content) {
-            this.echo(this.promiseResolve(content, function (content) {
-              return this.element(tag, attr, content);
-            }));
-          },
-          writable: false,
-          configurable: false,
-          enumerable: false
-        })));
-      };
-      this.configure(config);
+          } else {
+            return noop;
+          }
+        };
+        this.echo(current()(_next()));
+      }
+    }), "hasBlock", {
+      value: function value(name) {
+        return this.getBlocks().hasOwnProperty(name);
+      }
+    }), "include", {
+      value: function value(path, data, cx) {
+        var context = cx === false ? {} : this.clone(true);
+        var params = extend(context, data || {});
+        var promise = this.render(path, params);
+        this.echo(promise);
+      }
+    }), "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;
+          });
+        }));
+      }
+    }), "async", {
+      value: function value(promise, callback) {
+        this.echo(Promise.resolve(promise).then(callback));
+      }
+    }), "get", {
+      value: function value(name, defaults) {
+        var path = getPath(this, name, true);
+        var result = path.shift();
+        var prop = path.pop();
+        return hasProp(result, prop) ? result[prop] : defaults;
+      }
+    }), "set", {
+      value: function value(name, _value2) {
+        var path = getPath(this, name, false);
+        var result = path.shift();
+        var prop = path.pop();
+        if (this.getExtend() && hasProp(result, prop)) {
+          return result[prop];
+        }
+        return result[prop] = _value2;
+      }
+    }), "each", {
+      value: function value(object, callback) {
+        if (isString(object)) {
+          object = this.get(object, []);
+        }
+        each(object, callback);
+      },
+      writable: true
+    }), "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
+    }), _defineProperty(_Object$definePropert, "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) {
-      if (instanceOf(this, EJS) === false) return new EJS(options);
-      var scope = {};
-      var config = {};
-      configSchema(config, options || {});
-      var context = new Context(config);
-      var compiler = new Compiler(config);
-      var cache = new Cache();
-      var template = new Template(config, cache, compiler);
-      var output = function output(path, scope) {
-        var globalHelpers = config.globalHelpers;
-        var params = [scope, scope.getComponent(), scope.getBuffer(), safeValue].concat(globalHelpers.filter(function (name) {
-          return isFunction(scope[name]);
-        }).map(function (name) {
-          return scope[name].bind(scope);
-        }));
-        return template.get(path).then(function (callback) {
-          return callback.apply(scope, params);
-        });
-      };
-      var require = function require(name) {
-        var filepath = ext(name, config.extension);
-        var scope = context.create({});
-        return output(filepath, scope).then(function () {
-          return scope.getMacro();
-        });
-      };
-      var _render = function render(name, data) {
-        var filepath = ext(name, config.extension);
-        var scope = context.create(data);
-        return output(filepath, scope).then(function (content) {
+      _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
+      });
+    }
+    return _createClass(EJS, [{
+      key: "configure",
+      value: function configure(options) {
+        configSchema(_classPrivateFieldGet2(_config, this), options || {});
+        _classPrivateFieldGet2(_context, this).configure(_classPrivateFieldGet2(_config, this), _classPrivateFieldGet2(_extend, this));
+        _classPrivateFieldGet2(_compiler, this).configure(_classPrivateFieldGet2(_config, this));
+        _classPrivateFieldGet2(_cache, this).configure(_classPrivateFieldGet2(_config, this));
+        _classPrivateFieldGet2(_template, this).configure(_classPrivateFieldGet2(_config, this));
+        return _classPrivateFieldGet2(_config, this);
+      }
+    }, {
+      key: "render",
+      value: function render(name, data) {
+        var _this = this;
+        var filepath = ext(name, _classPrivateFieldGet2(_config, this).extension);
+        var scope = this.context(data);
+        return _assertClassBrand(_EJS_brand, this, _output).call(this, filepath, scope).then(function (content) {
           if (scope.getExtend()) {
             scope.setExtend(false);
             var layout = scope.getLayout();
             var _data = scope.clone();
-            return _render(layout, _data);
+            return _this.render(layout, _data);
           }
           return content;
         });
-      };
-      this.configure = function (options) {
-        options = options || {};
-        configSchema(config, options);
-        context.configure(config, scope);
-        compiler.configure(config);
-        cache.configure(config);
-        template.configure(config);
-        return config;
-      };
-      this.render = function (name, data) {
-        return _render(name, data);
-      };
-      this.helpers = function (methods) {
-        context.helpers(extend(scope, methods));
-      };
-      this.preload = function (list) {
-        return cache.load(list || {});
-      };
-      this.create = function (options) {
-        return new EJS(options);
-      };
-      this.compile = function (content, path) {
-        return compiler.compile(content, path);
-      };
-      this.context = function (data) {
-        return context.create(data);
-      };
-      this.helpers({
-        require: require,
-        render: _render
-      });
-      return this;
-    }
+      }
+    }, {
+      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);
+      }
+    }, {
+      key: "require",
+      value: function require(name) {
+        var filepath = ext(name, _classPrivateFieldGet2(_config, this).extension);
+        var scope = this.context({});
+        return _assertClassBrand(_EJS_brand, this, _output).call(this, filepath, scope).then(function () {
+          return scope.getMacro();
+        });
+      }
+    }]);
+  }();
+  function _output(path, scope) {
+    var _classPrivateFieldGet2$1 = _classPrivateFieldGet2(_config, this),
+      globalHelpers = _classPrivateFieldGet2$1.globalHelpers;
+    var params = [scope, scope.getBuffer(), scope.useSafeValue, scope.useComponent, scope.useElement].concat(globalHelpers.filter(function (name) {
+      return isFunction(scope[name]);
+    }).map(function (name) {
+      return scope[name].bind(scope);
+    }));
+    return _classPrivateFieldGet2(_template, this).get(path).then(function (callback) {
+      return callback.apply(scope, params);
+    });
+  }
 
-    var httpRequest = function httpRequest(path, template) {
-      return fetch(joinPath(path, template)).then(function (response) {
-        return response.text();
-      }, function (reason) {
-        return new TemplateError(reason);
-      });
-    };
+  var httpRequest = function httpRequest(path, template) {
+    return fetch(joinPath(path, template)).then(function (response) {
+      return response.text();
+    }, function (reason) {
+      return new TemplateError(reason);
+    });
+  };
 
-    var ejs = new EJS({
+  var _EJS = new EJS({
       resolver: httpRequest
-    });
-    var render = ejs.render,
-      context = ejs.context,
-      compile = ejs.compile,
-      helpers = ejs.helpers,
-      preload = ejs.preload,
-      configure = ejs.configure,
-      create = ejs.create;
+    }),
+    render = _EJS.render,
+    context = _EJS.context,
+    compile = _EJS.compile,
+    helpers = _EJS.helpers,
+    preload = _EJS.preload,
+    configure = _EJS.configure,
+    create = _EJS.create;
 
-    exports.TemplateError = TemplateError;
-    exports.TemplateNotFound = TemplateNotFound;
-    exports.TemplateSyntaxError = TemplateSyntaxError;
-    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.compile = compile;
+  exports.configure = configure;
+  exports.context = context;
+  exports.create = create;
+  exports.helpers = helpers;
+  exports.preload = preload;
+  exports.render = render;
 
 }));