@kosatyi/ejs 0.0.61 → 0.0.63

package/dist/umd/index.js

@@ -13,120 +13,6 @@
       return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
     }, _typeof(o);
   }
-  function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-      throw new TypeError("Cannot call a class as a function");
-    }
-  }
-  function _defineProperties(target, props) {
-    for (var i = 0; i < props.length; i++) {
-      var descriptor = props[i];
-      descriptor.enumerable = descriptor.enumerable || false;
-      descriptor.configurable = true;
-      if ("value" in descriptor) descriptor.writable = true;
-      Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
-    }
-  }
-  function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    Object.defineProperty(Constructor, "prototype", {
-      writable: false
-    });
-    return Constructor;
-  }
-  function _defineProperty(obj, key, value) {
-    key = _toPropertyKey(key);
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else {
-      obj[key] = value;
-    }
-    return obj;
-  }
-  function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(o);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-  }
-  function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-    return arr2;
-  }
-  function _createForOfIteratorHelper(o, allowArrayLike) {
-    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-    if (!it) {
-      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-        if (it) o = it;
-        var i = 0;
-        var F = function () {};
-        return {
-          s: F,
-          n: function () {
-            if (i >= o.length) return {
-              done: true
-            };
-            return {
-              done: false,
-              value: o[i++]
-            };
-          },
-          e: function (e) {
-            throw e;
-          },
-          f: F
-        };
-      }
-      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
-    var normalCompletion = true,
-      didErr = false,
-      err;
-    return {
-      s: function () {
-        it = it.call(o);
-      },
-      n: function () {
-        var step = it.next();
-        normalCompletion = step.done;
-        return step;
-      },
-      e: function (e) {
-        didErr = true;
-        err = e;
-      },
-      f: function () {
-        try {
-          if (!normalCompletion && it.return != null) it.return();
-        } finally {
-          if (didErr) throw err;
-        }
-      }
-    };
-  }
-  function _toPrimitive(input, hint) {
-    if (typeof input !== "object" || input === null) return input;
-    var prim = input[Symbol.toPrimitive];
-    if (prim !== undefined) {
-      var res = prim.call(input, hint || "default");
-      if (typeof res !== "object") return res;
-      throw new TypeError("@@toPrimitive must return a primitive value.");
-    }
-    return (hint === "string" ? String : Number)(input);
-  }
-  function _toPropertyKey(arg) {
-    var key = _toPrimitive(arg, "string");
-    return typeof key === "symbol" ? key : String(key);
-  }
 
   var typeProp = function typeProp() {
     var args = [].slice.call(arguments);
@@ -185,39 +71,33 @@
       return '\\' + symbolEntities[match];
     });
   };
-  var safeValue = function safeValue(value, escape, check) {
-    return (check = value) == null ? '' : escape ? entities(check) : check;
+  var safeValue = function safeValue(value, escape) {
+    var check = value;
+    return check == null ? '' : escape === true ? entities(check) : check;
+  };
+  var instanceOf = function instanceOf(object, instance) {
+    return object instanceof instance;
   };
   var getPath = function getPath(context, name, strict) {
     var data = context;
     var chunks = String(name).split('.');
     var prop = chunks.pop();
-    var _iterator = _createForOfIteratorHelper(chunks),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var part = _step.value;
-        if (strict && data.hasOwnProperty(part) === false) {
-          data = {};
-          break;
-        }
-        data = data[part] = data[part] || {};
+    for (var i = 0; i < chunks.length; i++) {
+      var part = chunks[i];
+      if (isFunction(data['toJSON'])) {
+        data = data.toJSON();
       }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
+      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, context) {
-    var methods = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-    methods.forEach(function (name) {
-      if (name in object) {
-        object[name] = object[name].bind(context);
-      }
-    });
-  };
   var ext = function ext(path, defaults) {
     var ext = path.split('.').pop();
     if (ext !== defaults) {
@@ -309,6 +189,33 @@
     regex: '([\\s\\S]+?)'
   };
 
+  var path = {};
+
+  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) {
+      result.push(content instanceof Array ? content.join('') : content);
+    }
+    if (hasClosedTag) {
+      result.push([lt, slash, tag, gt].join(''));
+    }
+    return result.join('');
+  };
+
   var configSchema = function configSchema(config, options) {
     extend(config, {
       path: typeProp(isString, defaults.path, config.path, options.path),
@@ -324,8 +231,6 @@
     });
   };
 
-  var path = {};
-
   var resolvePath = function resolvePath(path, template) {
     template = [path, template].join('/');
     template = template.replace(/\/\//g, '/');
@@ -347,72 +252,54 @@
       });
     });
   };
-  var Template = /*#__PURE__*/function () {
-    function Template(config, cache, compiler) {
-      _classCallCheck(this, Template);
-      this.cache = cache;
-      this.watcher = {
-        unwatch: function unwatch() {},
-        on: function on() {}
-      };
-      this.compiler = compiler;
-      this.configure(config);
-    }
-    _createClass(Template, [{
-      key: "configure",
-      value: function configure(config) {
-        var _this = this;
-        this.path = config.path;
-        this.chokidar = config.chokidar;
-        this.resolver = isFunction(config.resolver) ? config.resolver : isNode() ? fileSystem : httpRequest;
-        if (config.watch && isNode()) {
-          if (this.watcher) {
-            this.watcher.unwatch('.');
-          }
-          if (this.chokidar) {
-            this.watcher = this.chokidar.watch('.', {
-              cwd: this.path
-            }).on('change', function (name) {
-              _this.cache.remove(name);
-            });
-          }
-        }
-      }
-    }, {
-      key: "resolve",
-      value: function resolve(template) {
-        return this.resolver(this.path, template);
-      }
-    }, {
-      key: "result",
-      value: function result(template, content) {
-        this.cache.set(template, content);
+  var fileResolver = function fileResolver(resolver) {
+    return isFunction(resolver) ? resolver : isNode() ? fileSystem : httpRequest;
+  };
+  function Template(config, cache, compiler) {
+    if (instanceOf(this, Template) === false) return new Template(config, cache, 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);
       }
-    }, {
-      key: "compile",
-      value: function compile(content, template) {
-        if (isFunction(content)) {
-          return content;
-        } else {
-          return this.compiler.compile(content, template);
-        }
+    };
+    var watcher = function watcher(config) {
+      if (template.watcher) {
+        template.watcher.unwatch('.');
       }
-    }, {
-      key: "get",
-      value: function get(template) {
-        var _this2 = this;
-        if (this.cache.exist(template)) {
-          return this.cache.resolve(template);
-        }
-        var content = this.resolve(template).then(function (content) {
-          return _this2.result(template, _this2.compile(content, template));
+      if (config.watch && config.chokidar && isNode()) {
+        return config.chokidar.watch('.', {
+          cwd: template.path
+        }).on('change', function (name) {
+          cache.remove(name);
         });
-        return this.result(template, content);
       }
-    }]);
-    return Template;
-  }();
+    };
+    this.configure = function (config) {
+      template.path = config.path;
+      template.chokidar = config.chokidar;
+      template.resolver = fileResolver(config.resolver);
+      template.watcher = watcher(config);
+    };
+    this.get = function (template) {
+      if (cache.exist(template)) {
+        return cache.resolve(template);
+      }
+      return result(template, resolve(template).then(function (content) {
+        return result(template, compile(content, template));
+      }));
+    };
+    this.configure(config);
+  }
 
   var tagList = [{
     symbol: '-',
@@ -435,7 +322,7 @@
       return "')\n".concat(value.trim(), "\n").concat(this.BUFFER, "('");
     }
   }];
-  var matchTokens = function matchTokens(regex, text, callback) {
+  function matchTokens(regex, text, callback) {
     var index = 0;
     text.replace(regex, function () {
       var params = [].slice.call(arguments, 0, -1);
@@ -445,166 +332,109 @@
       index = offset + match.length;
       return match;
     });
-  };
-  var Compiler = /*#__PURE__*/function () {
-    function Compiler(config) {
-      _classCallCheck(this, Compiler);
-      this.configure(config);
-    }
-    _createClass(Compiler, [{
-      key: "configure",
-      value: function configure(config) {
-        var _this = this;
-        this.withObject = config.withObject;
-        this.rmWhitespace = config.rmWhitespace;
-        this.token = config.token;
-        this.vars = config.vars;
-        this.matches = [];
-        this.formats = [];
-        this.slurp = {
-          match: '[ \\t]*',
-          start: [this.token.start, '_'],
-          end: ['_', this.token.end]
-        };
-        tagList.forEach(function (item) {
-          _this.matches.push(_this.token.start.concat(item.symbol).concat(_this.token.regex).concat(_this.token.end));
-          _this.formats.push(item.format.bind(_this.vars));
-        });
-        this.regex = new RegExp(this.matches.join('|').concat('|$'), 'g');
-        this.slurpStart = new RegExp([this.slurp.match, this.slurp.start.join('')].join(''), 'gm');
-        this.slurpEnd = new RegExp([this.slurp.end.join(''), this.slurp.match].join(''), 'gm');
-      }
-    }, {
-      key: "truncate",
-      value: function truncate(value) {
-        return value && value.replace(/^(?:\r\n|\r|\n)/, '');
-      }
-    }, {
-      key: "compile",
-      value: function compile(content, path) {
-        var _this2 = this;
-        var _this$vars = this.vars,
-          SCOPE = _this$vars.SCOPE,
-          SAFE = _this$vars.SAFE,
-          BUFFER = _this$vars.BUFFER,
-          COMPONENT = _this$vars.COMPONENT;
-        if (this.rmWhitespace) {
-          content = content.replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
-        }
-        content = content.replace(this.slurpStart, this.token.start).replace(this.slurpEnd, this.token.end);
-        var source = "".concat(BUFFER, "('");
-        matchTokens(this.regex, content, function (params, index, offset) {
-          source += symbols(content.slice(index, offset));
-          params.forEach(function (value, index) {
-            if (value) {
-              source += _this2.formats[index](value);
-            }
-          });
+  }
+  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.matches = [];
+      compiler.formats = [];
+      compiler.slurp = {
+        match: '[ \\t]*',
+        start: [compiler.token.start, '_'],
+        end: ['_', compiler.token.end]
+      };
+      tagList.forEach(function (item) {
+        compiler.matches.push(compiler.token.start.concat(item.symbol).concat(compiler.token.regex).concat(compiler.token.end));
+        compiler.formats.push(item.format.bind(compiler.vars));
+      });
+      compiler.regex = new RegExp(compiler.matches.join('|').concat('|$'), 'g');
+      compiler.slurpStart = new RegExp([compiler.slurp.match, compiler.slurp.start.join('')].join(''), 'gm');
+      compiler.slurpEnd = new RegExp([compiler.slurp.end.join(''), compiler.slurp.match].join(''), 'gm');
+    };
+    this.compile = function (content, path) {
+      var _compiler$vars = compiler.vars,
+        SCOPE = _compiler$vars.SCOPE,
+        SAFE = _compiler$vars.SAFE,
+        BUFFER = _compiler$vars.BUFFER,
+        COMPONENT = _compiler$vars.COMPONENT;
+      if (compiler.rmWhitespace) {
+        content = content.replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
+      }
+      content = content.replace(compiler.slurpStart, compiler.token.start).replace(compiler.slurpEnd, compiler.token.end);
+      var source = "".concat(BUFFER, "('");
+      matchTokens(compiler.regex, content, function (params, index, offset) {
+        source += symbols(content.slice(index, offset));
+        params.forEach(function (value, index) {
+          if (value) {
+            source += compiler.formats[index](value);
+          }
         });
-        source += "');";
-        source = "try{".concat(source, "}catch(e){console.info(e)}");
-        if (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;
-        try {
-          result = new Function(SCOPE, COMPONENT, BUFFER, SAFE, source);
-          result.source = "(function(".concat(SCOPE, ",").concat(COMPONENT, ",").concat(BUFFER, ",").concat(SAFE, "){\n").concat(source, "\n})");
-        } catch (e) {
-          e.filename = path;
-          e.source = source;
-          throw e;
-        }
-        return result;
-      }
-    }]);
-    return Compiler;
-  }();
+      });
+      source += "');";
+      source = "try{".concat(source, "}catch(e){console.info(e)}");
+      if (compiler.withObject) {
+        source = "with(".concat(SCOPE, "){").concat(source, "}");
+      }
+      source = "".concat(BUFFER, ".start();").concat(source, "return ").concat(BUFFER, ".end();");
+      source += "\n//# sourceURL=".concat(path);
+      var result = null;
+      try {
+        result = new Function(SCOPE, COMPONENT, BUFFER, SAFE, source);
+        result.source = "(function(".concat(SCOPE, ",").concat(COMPONENT, ",").concat(BUFFER, ",").concat(SAFE, "){\n").concat(source, "\n})");
+      } catch (e) {
+        e.filename = path;
+        e.source = source;
+        throw e;
+      }
+      return result;
+    };
+    this.configure(config);
+  }
 
   var global = typeof globalThis !== 'undefined' ? globalThis : window || self;
-  var Cache = /*#__PURE__*/function () {
-    function Cache(config) {
-      _classCallCheck(this, Cache);
-      _defineProperty(this, "list", {});
-      this.configure(config);
+  function Cache(config) {
+    if (instanceOf(this, Cache) === false) return new Cache();
+    var cache = {
+      list: {}
+    };
+    this.configure = function (config) {
+      cache.list = {};
       if (isNode() === false) {
-        this.load(global[this.namespace]);
-      }
-    }
-    _createClass(Cache, [{
-      key: "configure",
-      value: function configure(config) {
-        this.list = {};
-        this.namespace = config["export"];
-      }
-    }, {
-      key: "load",
-      value: function load(data) {
-        extend(this.list, data);
-        return this;
-      }
-    }, {
-      key: "exist",
-      value: function exist(key) {
-        return hasProp(this.list, key);
-      }
-    }, {
-      key: "get",
-      value: function get(key) {
-        return this.list[key];
-      }
-    }, {
-      key: "remove",
-      value: function remove(key) {
-        delete this.list[key];
-      }
-    }, {
-      key: "resolve",
-      value: function resolve(key) {
-        return Promise.resolve(this.get(key));
-      }
-    }, {
-      key: "set",
-      value: function set(key, value) {
-        this.list[key] = value;
-        return this;
-      }
-    }]);
-    return Cache;
-  }();
-
-  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);
+        this.load(global[config["export"]]);
       }
-    }).join(space);
-    result.push([lt, tag, space, attributes, gt].join(''));
-    if (content) {
-      result.push(content instanceof Array ? content.join('') : content);
-    }
-    if (hasClosedTag) {
-      result.push([lt, slash, tag, gt].join(''));
-    }
-    return result.join('');
-  };
+    };
+    this.load = function (data) {
+      extend(cache.list, data || {});
+      return this;
+    };
+    this.get = function (key) {
+      return cache.list[key];
+    };
+    this.set = function (key, value) {
+      cache.list[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 resolve = function resolve(list) {
-    return Promise.all(list).then(function (list) {
+  function resolve(list) {
+    return Promise.all(list || []).then(function (list) {
       return list.join('');
     });
-  };
+  }
   var createBuffer = function createBuffer() {
     var store = [],
       array = [];
@@ -632,340 +462,295 @@
     return buffer;
   };
 
-  var Context = /*#__PURE__*/function () {
-    function Context(config) {
-      _classCallCheck(this, Context);
-      this.configure(config);
-    }
-    _createClass(Context, [{
-      key: "configure",
-      value: function configure(config, methods) {
-        var _config$vars = config.vars,
-          EXTEND = _config$vars.EXTEND,
-          LAYOUT = _config$vars.LAYOUT,
-          BLOCKS = _config$vars.BLOCKS,
-          BUFFER = _config$vars.BUFFER,
-          MACRO = _config$vars.MACRO,
-          COMPONENT = _config$vars.COMPONENT;
-        this.create = function (data) {
-          return new Scope(data);
+  function Context(config) {
+    if (instanceOf(this, Context) === false) return new Context(config);
+    this.configure = function (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,
+        COMPONENT = _config$vars.COMPONENT;
+      this.create = function (data) {
+        return new Scope(data);
+      };
+      this.helpers = function (methods) {
+        extend(Scope.prototype, methods || {});
+      };
+      function Scope(data) {
+        this[BLOCKS] = {};
+        this[MACRO] = {};
+        extend(this, data || {});
+      }
+      Scope.prototype = extend({}, methods || {});
+      Scope.method = Scope.define = function (name, value, writable, configurable, enumerable) {
+        Object.defineProperty(Scope.prototype, name, {
+          value: value,
+          writable: writable || false,
+          configurable: configurable || false,
+          enumerable: enumerable || false
+        });
+      };
+      Scope.define(BUFFER, createBuffer());
+      Scope.define(BLOCKS, {}, true);
+      Scope.define(MACRO, {}, true);
+      Scope.define(LAYOUT, false, true);
+      Scope.define(EXTEND, false, true);
+      Scope.method('getMacro', function () {
+        return this[MACRO];
+      });
+      Scope.method('getBuffer', function () {
+        return this[BUFFER];
+      });
+      Scope.method('getComponent', function () {
+        var context = this;
+        if (COMPONENT in context) {
+          return function () {
+            return context[COMPONENT].apply(context, arguments);
+          };
+        }
+        return function () {
+          console.log('%s function not defined', COMPONENT);
+        };
+      });
+      Scope.method('getBlocks', function () {
+        return this[BLOCKS];
+      });
+      Scope.method('setExtend', function (value) {
+        this[EXTEND] = value;
+      });
+      Scope.method('getExtend', function () {
+        return this[EXTEND];
+      });
+      Scope.method('setLayout', function (layout) {
+        this[LAYOUT] = layout;
+      });
+      Scope.method('getLayout', function () {
+        return this[LAYOUT];
+      });
+      Scope.method('clone', function (exclude_blocks) {
+        var filter = [LAYOUT, EXTEND, BUFFER];
+        if (exclude_blocks === true) {
+          filter.push(BLOCKS);
+        }
+        return omit(this, filter);
+      });
+      Scope.method('extend', function (layout) {
+        this.setExtend(true);
+        this.setLayout(layout);
+      });
+      Scope.method('echo', function () {
+        var buffer = this.getBuffer();
+        var params = [].slice.call(arguments);
+        params.forEach(buffer);
+      });
+      Scope.method('fn', function (callback) {
+        var buffer = this.getBuffer();
+        var context = this;
+        return function () {
+          buffer.backup();
+          if (isFunction(callback)) {
+            callback.apply(context, arguments);
+          }
+          return buffer.restore();
         };
-        this.helpers = function (methods) {
-          extend(Scope.prototype, methods);
+      });
+      Scope.method('get', function (name, defaults) {
+        var path = getPath(this, name, true);
+        var result = path.shift();
+        var prop = path.pop();
+        return hasProp(result, prop) ? result[prop] : defaults;
+      });
+      Scope.method('set', function (name, value) {
+        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] = value;
+      });
+      Scope.method('macro', function (name, callback) {
+        var list = this.getMacro();
+        var macro = this.fn(callback);
+        var context = this;
+        list[name] = function () {
+          return context.echo(macro.apply(undefined, arguments));
         };
-        function Scope() {
-          var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-          this.initBlocks();
-          this.initMacro();
-          extend(this, data);
+      });
+      Scope.method('call', function (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 || {});
-        /**
-         * @param {string} name
-         * @param {*} value
-         * @param {boolean} [writable]
-         * @param {boolean} [configurable]
-         * @param {boolean} [enumerable]
-         */
-        Scope.define = Scope.method = function (name, value, writable, configurable, enumerable) {
-          return Object.defineProperty(Scope.prototype, name, {
-            value: value,
-            writable: writable || false,
-            configurable: configurable || false,
-            enumerable: enumerable || false
-          });
+      });
+      Scope.method('block', function (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();
         };
-        Scope.define(BUFFER, createBuffer());
-        Scope.define(BLOCKS, {}, true);
-        Scope.define(MACRO, {}, true);
-        Scope.define(LAYOUT, false, true);
-        Scope.define(EXTEND, false, true);
-        Scope.method('initBlocks', function () {
-          this[BLOCKS] = {};
-        });
-        Scope.method('initMacro', function () {
-          this[MACRO] = {};
-        });
-        Scope.method('getMacro', function () {
-          return this[MACRO];
-        });
-        Scope.method('getBuffer', function () {
-          return this[BUFFER];
-        });
-        Scope.method('getComponent', function () {
-          var context = this;
-          if (COMPONENT in context) {
+        var next = function next() {
+          var parent = current();
+          if (parent) {
             return function () {
-              return context[COMPONENT].apply(context, arguments);
+              _this.echo(parent(next()));
             };
+          } else {
+            return noop;
           }
-          return function () {
-            console.log('%s function not defined', COMPONENT);
-          };
-        });
-        Scope.method('getBlocks', function () {
-          return this[BLOCKS];
-        });
-        Scope.method('setExtend', function (value) {
-          this[EXTEND] = value;
-        });
-        Scope.method('getExtend', function () {
-          return this[EXTEND];
-        });
-        Scope.method('setLayout', function (layout) {
-          this[LAYOUT] = layout;
-        });
-        Scope.method('getLayout', function () {
-          return this[LAYOUT];
-        });
-        Scope.method('clone', function (exclude_blocks) {
-          var filter = [LAYOUT, EXTEND, BUFFER];
-          if (exclude_blocks === true) {
-            filter.push(BLOCKS);
-          }
-          return omit(this, filter);
-        });
-        Scope.method('extend', function (layout) {
-          this.setExtend(true);
-          this.setLayout(layout);
-        });
-        Scope.method('echo', function () {
-          var buffer = this.getBuffer();
-          var params = [].slice.call(arguments);
-          params.forEach(buffer);
-        });
-        Scope.method('fn', function (callback) {
-          var buffer = this.getBuffer();
-          var context = this;
-          return function () {
-            buffer.backup();
-            if (isFunction(callback)) {
-              callback.apply(context, arguments);
-            }
-            return buffer.restore();
-          };
-        });
-        Scope.method('get', function (name, defaults) {
-          var path = getPath(this, name, true);
-          var result = path.shift();
-          var prop = path.pop();
-          return hasProp(result, prop) ? result[prop] : defaults;
-        });
-        Scope.method('set', function (name, value) {
-          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] = value;
-        });
-        Scope.method('macro', function (name, callback) {
-          var list = this.getMacro();
-          var macro = this.fn(callback);
-          var context = this;
-          list[name] = function () {
-            return context.echo(macro.apply(undefined, arguments));
-          };
-        });
-        Scope.method('call', function (name) {
+        };
+        this.echo(current()(next()));
+      });
+      Scope.method('include', function (path, data, cx) {
+        var context = cx === false ? {} : this.clone(true);
+        var params = extend(context, data || {});
+        var promise = this.render(path, params);
+        this.echo(promise);
+      });
+      Scope.method('use', function (path, namespace) {
+        var promise = this.require(path);
+        this.echo(resolve$1(promise, function (exports) {
           var list = this.getMacro();
-          var macro = list[name];
-          var params = [].slice.call(arguments, 1);
-          if (isFunction(macro)) {
-            return macro.apply(macro, params);
-          }
-        });
-        Scope.method('block', function (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()));
-        });
-        Scope.method('include', function (path, data, cx) {
-          var context = cx === false ? {} : this.clone(true);
-          var params = extend(context, data || {});
-          var promise = this.render(path, params);
-          this.echo(promise);
-        });
-        Scope.method('use', function (path, namespace) {
-          var promise = this.require(path);
-          this.echo(resolve$1(promise, function (exports) {
-            var list = this.getMacro();
-            each(exports, function (macro, name) {
-              list[[namespace, name].join('.')] = macro;
-            });
-          }, this));
-        });
-        Scope.method('async', function (promise, callback) {
-          this.echo(resolve$1(promise, function (data) {
-            return this.fn(callback)(data);
-          }, this));
-        });
-        Scope.method('node', function (tag, attr, content) {
+          each(exports, function (macro, name) {
+            list[[namespace, name].join('.')] = macro;
+          });
+        }, this));
+      });
+      Scope.method('async', function (promise, callback) {
+        this.echo(resolve$1(promise, function (data) {
+          return this.fn(callback)(data);
+        }, this));
+      });
+      Scope.method('node', function (tag, attr, content) {
+        return element(tag, attr, content);
+      });
+      Scope.method('el', function (tag, attr, content) {
+        if (isFunction(content)) {
+          content = this.fn(content)();
+        }
+        this.echo(resolve$1(content, function (content) {
           return element(tag, attr, content);
-        });
-        Scope.method('el', function (tag, attr, content) {
-          if (isFunction(content)) {
-            content = this.fn(content)();
-          }
-          this.echo(resolve$1(content, function (content) {
-            return element(tag, attr, content);
-          }, this));
-        });
-        Scope.method('each', function (object, callback) {
-          if (isString(object)) {
-            object = this.get(object, []);
-          }
-          each(object, callback);
-        });
-      }
-    }]);
-    return Context;
-  }();
+        }, this));
+      });
+      Scope.method('each', function (object, callback) {
+        if (isString(object)) {
+          object = this.get(object, []);
+        }
+        each(object, callback);
+      });
+    };
+    this.configure(config);
+  }
 
-  var EJS = /*#__PURE__*/function () {
-    function EJS() {
-      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      _classCallCheck(this, EJS);
-      _defineProperty(this, "export", ['cache', 'render', 'require', 'helpers', 'configure', 'preload', 'compile', 'create', '__express']);
-      this.config = {};
-      this.scope = {};
-      configSchema(this.config, options);
-      bindContext(this, this, this["export"]);
-      this.context = new Context(this.config);
-      this.compiler = new Compiler(this.config);
-      this.cache = new Cache(this.config);
-      this.template = new Template(this.config, this.cache, this.compiler);
-      this.helpers({
-        require: this.require,
-        render: this.render
+  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) {
+      return template.get(path).then(function (callback) {
+        return callback.call(scope, scope, scope.getComponent(), scope.getBuffer(), safeValue);
       });
-    }
-    _createClass(EJS, [{
-      key: "configure",
-      value: function configure() {
-        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-        configSchema(this.config, options);
-        this.context.configure(this.config, this.scope);
-        this.compiler.configure(this.config);
-        this.cache.configure(this.config);
-        this.template.configure(this.config);
-        return this.config;
-      }
-    }, {
-      key: "output",
-      value: function output(path, scope) {
-        return this.template.get(path).then(function (callback) {
-          return callback.call(scope, scope, scope.getComponent(), scope.getBuffer(), safeValue);
-        });
-      }
-    }, {
-      key: "render",
-      value: function render(name, data) {
-        var _this = this;
-        var filepath = ext(name, this.config.extension);
-        var scope = this.context.create(data);
-        return this.output(filepath, scope).then(function (content) {
-          if (scope.getExtend()) {
-            scope.setExtend(false);
-            var layout = scope.getLayout();
-            var _data = scope.clone();
-            return _this.render(layout, _data);
-          }
-          return content;
-        });
-      }
-    }, {
-      key: "require",
-      value: function require(name) {
-        var filepath = ext(name, this.config.extension);
-        var scope = this.context.create({});
-        return this.output(filepath, scope).then(function () {
-          return scope.getMacro();
-        });
-      }
-    }, {
-      key: "create",
-      value: function create() {
-        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-        return new EJS(options);
-      }
-    }, {
-      key: "helpers",
-      value: function helpers() {
-        var methods = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-        this.context.helpers(extend(this.scope, methods));
-      }
-    }, {
-      key: "preload",
-      value: function preload() {
-        var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-        return this.cache.load(list);
-      }
-    }, {
-      key: "compile",
-      value: function compile(content, path) {
-        return this.compiler.compile(content, path);
-      }
-    }, {
-      key: "__express",
-      value: function __express(name, options, callback) {
-        if (isFunction(options)) {
-          callback = options;
-          options = {};
+    };
+    var require = function require(name) {
+      var filepath = ext(name, config.extension);
+      var scope = context.create({});
+      return output(filepath, scope).then(function () {
+        return scope.getMacro();
+      });
+    };
+    var render = function render(name, data) {
+      var filepath = ext(name, config.extension);
+      var scope = context.create(data);
+      return output(filepath, scope).then(function (content) {
+        if (scope.getExtend()) {
+          scope.setExtend(false);
+          var layout = scope.getLayout();
+          var _data = scope.clone();
+          return render(layout, _data);
         }
-        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;
-        this.configure(viewOptions);
-        return this.render(filename, options).then(function (content) {
-          callback(null, content);
-        })["catch"](function (error) {
-          callback(error);
-        });
-      }
-    }]);
-    return EJS;
-  }();
+        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(Object.assign(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
+    });
+  }
 
-  var ejs = new EJS({
-    /** defaults options **/
-  });
-  var __express = ejs.__express,
-    render = ejs.render,
+  var ejs = new EJS();
+  var render = ejs.render,
     context = ejs.context,
     compile = ejs.compile,
     helpers = ejs.helpers,
     preload = ejs.preload,
-    configure = ejs.configure,
+    configure$1 = ejs.configure,
     create = ejs.create;
 
+  function __express(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 this.render(filename, options).then(function (content) {
+      callback(null, content);
+    })["catch"](function (error) {
+      callback(error);
+    });
+  }
+
   exports.EJS = EJS;
   exports.__express = __express;
   exports.compile = compile;
-  exports.configure = configure;
+  exports.configure = configure$1;
   exports.context = context;
   exports.create = create;
   exports.element = element;