@kosatyi/ejs 0.0.25 → 0.0.27

package/dist/ejs.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-    typeof define === 'function' && define.amd ? define(factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.ejs = factory());
-})(this, (function () { 'use strict';
+    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 path = {};
 
@@ -164,7 +164,7 @@
     var slash = '/';
     var lt = '<';
     var gt = '>';
-    function element(tag, attrs, content) {
+    var element = function element(tag, attrs, content) {
       var result = [];
       var hasClosedTag = selfClosed.indexOf(tag) === -1;
       var attributes = map(attrs, function (value, key) {
@@ -180,9 +180,60 @@
         result.push([lt, slash, tag, gt].join(''));
       }
       return result.join('');
+    };
+
+    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 _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 tags = [{
+    var tagList = [{
       symbol: '-',
       format: function format(value) {
         return "')\n".concat(this.BUFFER, "(").concat(this.SAFE, "(").concat(value, ",1))\n").concat(this.BUFFER, "('");
@@ -203,7 +254,7 @@
         return "')\n".concat(value.trim(), "\n").concat(this.BUFFER, "('");
       }
     }];
-    var match = function match(regex, text, callback) {
+    var matchTokens = function matchTokens(regex, text, callback) {
       var index = 0;
       text.replace(regex, function () {
         var params = [].slice.call(arguments, 0, -1);
@@ -214,78 +265,105 @@
         return match;
       });
     };
-    var configureCompiler = function configureCompiler(ejs, config) {
-      var withObject = config.withObject;
-      var token = config.token;
-      var vars = config.vars;
-      var matches = [];
-      var formats = [];
-      var slurp = {
-        match: '[ \\t]*',
-        start: [token.start, '_'],
-        end: ['_', token.end]
-      };
-      tags.forEach(function (item) {
-        matches.push(token.start.concat(item.symbol).concat(token.regex).concat(token.end));
-        formats.push(item.format.bind(vars));
-      });
-      var regex = new RegExp(matches.join('|').concat('|$'), 'g');
-      var slurpStart = new RegExp([slurp.match, slurp.start].join(''), 'gm');
-      var slurpEnd = new RegExp([slurp.end, slurp.match].join(''), 'gm');
-      return function compiler(content, path) {
-        var SCOPE = vars.SCOPE,
-          SAFE = vars.SAFE,
-          BUFFER = vars.BUFFER;
-        content = content.replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
-        content = content.replace(slurpStart, slurp.start).replace(slurpEnd, slurp.end);
-        var source = "".concat(BUFFER, "('");
-        match(regex, content, function (params, index, offset) {
-          source += symbols(content.slice(index, offset));
-          params.forEach(function (value, index) {
-            if (value) source += formats[index](value);
+    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.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));
           });
-        });
-        source += "');";
-        source = "try{".concat(source, "}catch(e){console.info(e)}");
-        if (withObject) {
-          source = "with(".concat(SCOPE, "){").concat(source, "}");
+          this.regex = new RegExp(this.matches.join('|').concat('|$'), 'g');
+          this.slurpStart = new RegExp([this.slurp.match, this.slurp.start].join(''), 'gm');
+          this.slurpEnd = new RegExp([this.slurp.end, this.slurp.match].join(''), 'gm');
         }
-        source = "".concat(BUFFER, ".start();").concat(source, "return ").concat(BUFFER, ".end();");
-        source += "\n//# sourceURL=".concat(path);
-        var result = null;
-        try {
-          result = new Function(SCOPE, BUFFER, SAFE, source);
-          result.source = "(function(".concat(SCOPE, ",").concat(BUFFER, ",").concat(SAFE, "){\n").concat(source, "\n})");
-        } catch (e) {
-          e.filename = path;
-          e.source = source;
-          throw e;
+      }, {
+        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;
+          content = content.replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
+          content = content.replace(this.slurpStart, this.slurp.start).replace(this.slurpEnd, this.slurp.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);
+            });
+          });
+          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, BUFFER, SAFE, source);
+            result.source = "(function(".concat(SCOPE, ",").concat(BUFFER, ",").concat(SAFE, "){\n").concat(source, "\n})");
+          } catch (e) {
+            e.filename = path;
+            e.source = source;
+            throw e;
+          }
+          return result;
         }
-        return result;
-      };
-    };
+      }]);
+      return Compiler;
+    }();
 
-    var configureWrapper = function configureWrapper(config) {
-      var name = config["export"];
-      var useStrict = config.withObject !== true;
-      return function Wrapper(list) {
-        var out = '';
-        out += '(function(global,factory){';
-        out += 'typeof exports === "object" && typeof module !== "undefined" ?';
-        out += 'module.exports = factory():';
-        out += 'typeof define === "function" && define.amd ? define(factory):';
-        out += '(global = typeof globalThis !== "undefined" ? globalThis:';
-        out += 'global || self,global["' + name + '"] = factory())';
-        out += '})(this,(function(){';
-        if (useStrict) out += "'use strict';\n";
-        out += 'var list = {};\n';
-        list.forEach(function (item) {
-          out += 'list[' + JSON.stringify(item.name) + ']=' + String(item.content) + ';\n';
-        });
-        out += 'return list;}));\n';
-        return out;
-      };
-    };
+    var Bundler = /*#__PURE__*/function () {
+      function Bundler(config) {
+        _classCallCheck(this, Bundler);
+        this.configure(config);
+      }
+      _createClass(Bundler, [{
+        key: "configure",
+        value: function configure(config) {
+          this.namespace = config["export"];
+          this.useStrict = config.withObject === false;
+        }
+      }, {
+        key: "wrapper",
+        value: function wrapper(list) {
+          var out = '';
+          out += '(function(global,factory){';
+          out += 'typeof exports === "object" && typeof module !== "undefined" ?';
+          out += 'module.exports = factory():';
+          out += 'typeof define === "function" && define.amd ? define(factory):';
+          out += '(global = typeof globalThis !== "undefined" ? globalThis:';
+          out += 'global || self,global["' + this.namespace + '"] = factory())';
+          out += '})(this,(function(){';
+          if (this.useStrict) out += "'use strict';\n";
+          out += 'var list = {};\n';
+          list.forEach(function (item) {
+            out += 'list[' + JSON.stringify(item.name) + ']=' + String(item.content) + ';\n';
+          });
+          out += 'return list;}));\n';
+          return out;
+        }
+      }]);
+      return Bundler;
+    }();
 
     var httpRequest = function httpRequest(template) {
       return fetch(template).then(function (response) {
@@ -303,46 +381,50 @@
         });
       });
     };
-    var enableWatcher = function enableWatcher(path$1, cache) {
-      return path.watch('.', {
-        cwd: path$1
-      }).on('change', function (name) {
-        cache.remove(name);
-      }).on('error', function (error) {
-        console.log('watcher error: ' + error);
-      });
-    };
-    var configureTemplate = function configureTemplate(ejs, config) {
-      var path = config.path;
-      var cache = ejs.cache,
-        compile = ejs.compile;
-      var resolver = isFunction(config.resolver) ? config.resolver : isNode() ? fileSystem : httpRequest;
-      var normalize = function normalize(template) {
-        template = [path, template].join('/');
-        template = template.replace(/\/\//g, '/');
-        return template;
-      };
-      var resolve = function resolve(template) {
-        return resolver(normalize(template));
-      };
-      var result = function result(content, template) {
-        cache.set(template, content);
-        return content;
-      };
-      var template = function template(_template) {
-        if (cache.exist(_template)) {
-          return cache.resolve(_template);
-        }
-        var content = resolve(_template).then(function (content) {
-          return result(compile(content, _template), _template);
-        });
-        return result(content, _template);
-      };
-      if (config.watch && isNode()) {
-        enableWatcher(path, cache);
-      }
+    var normalizePath = function normalizePath(path, template) {
+      template = [path, template].join('/');
+      template = template.replace(/\/\//g, '/');
       return template;
     };
+    var Template = /*#__PURE__*/function () {
+      function Template(config, cache, compiler) {
+        _classCallCheck(this, Template);
+        this.cache = cache;
+        this.compiler = compiler;
+        this.configure(config);
+      }
+      _createClass(Template, [{
+        key: "configure",
+        value: function configure(config) {
+          this.path = config.path;
+          this.resolver = isFunction(config.resolver) ? config.resolver : isNode() ? fileSystem : httpRequest;
+        }
+      }, {
+        key: "resolve",
+        value: function resolve(template) {
+          return this.resolver(normalizePath(this.path, template));
+        }
+      }, {
+        key: "result",
+        value: function result(content, template) {
+          this.cache.set(template, content);
+          return content;
+        }
+      }, {
+        key: "get",
+        value: function get(template) {
+          var _this = this;
+          if (this.cache.exist(template)) {
+            return this.cache.resolve(template);
+          }
+          var content = this.resolve(template).then(function (content) {
+            return _this.result(_this.compiler.compile(content, template), template);
+          });
+          return this.result(content, template);
+        }
+      }]);
+      return Template;
+    }();
 
     var resolve = function resolve(list) {
       return Promise.all(list).then(function (list) {
@@ -376,327 +458,380 @@
       return buffer;
     };
 
-    var configureScope = function configureScope(ejs, config) {
-      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;
-      function Scope() {
-        var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-        this.initBlocks();
-        this.initMacro();
-        extend(this, data);
+    var Context = /*#__PURE__*/function () {
+      function Context(config) {
+        _classCallCheck(this, Context);
+        this.configure(config);
       }
-      Scope.helpers = function (methods) {
-        extend(Scope.prototype, methods);
-      };
-      Scope.property = function (name, descriptor) {
-        Object.defineProperty(Scope.prototype, name, descriptor);
-      };
-      Scope.method = function (name, method) {
-        Object.defineProperty(Scope.prototype, name, {
-          value: method,
-          writable: false,
-          configurable: false,
-          enumerable: false
-        });
-      };
-      Scope.property(BUFFER, {
-        value: createBuffer(),
-        writable: false,
-        configurable: false,
-        enumerable: false
-      });
-      Scope.property(BLOCKS, {
-        value: {},
-        writable: true,
-        configurable: false,
-        enumerable: false
-      });
-      Scope.property(MACRO, {
-        value: {},
-        writable: true,
-        configurable: false,
-        enumerable: false
-      });
-      Scope.property(LAYOUT, {
-        value: false,
-        writable: true,
-        configurable: false,
-        enumerable: false
-      });
-      Scope.property(EXTEND, {
-        value: false,
-        writable: true,
-        configurable: false,
-        enumerable: false
-      });
-      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('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(function (item) {
-          buffer(item);
-        });
-      });
-      Scope.method('fn', function (callback) {
-        var buffer = this.getBuffer();
-        var context = this;
-        return function () {
-          buffer.backup();
-          if (isFunction(callback)) {
-            callback.apply(context, arguments);
+      _createClass(Context, [{
+        key: "configure",
+        value: function configure(config) {
+          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;
+          this.create = function (data) {
+            return new Scope(data);
+          };
+          this.helpers = function (methods) {
+            extend(Scope.prototype, methods);
+          };
+          function Scope() {
+            var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+            this.initBlocks();
+            this.initMacro();
+            extend(this, data);
           }
-          return buffer.restore();
-        };
-      });
-      Scope.method('get', function (name, defaults) {
-        var path = getPath(this, name);
-        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);
-        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) {
-        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) {
+          Scope.helpers = function (methods) {
+            extend(Scope.prototype, methods);
+          };
+          Scope.defineProp = Scope.method = function (name, value) {
+            var writable = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+            var configurable = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+            var enumerable = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+            Object.defineProperty(Scope.prototype, name, {
+              value: value,
+              writable: writable,
+              configurable: configurable,
+              enumerable: enumerable
+            });
+          };
+          Scope.defineProp(BUFFER, createBuffer());
+          Scope.defineProp(BLOCKS, {}, true);
+          Scope.defineProp(MACRO, {}, true);
+          Scope.defineProp(LAYOUT, false, true);
+          Scope.defineProp(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('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 () {
-              _this.echo(parent(next()));
+              buffer.backup();
+              if (isFunction(callback)) {
+                callback.apply(context, arguments);
+              }
+              return buffer.restore();
             };
-          } 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('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, []);
+          Scope.method('get', function (name, defaults) {
+            var path = getPath(this, name);
+            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);
+            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) {
+            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('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);
+          });
         }
-        each(object, callback);
-      });
-      return Scope;
-    };
+      }]);
+      return Context;
+    }();
 
     var global = typeof globalThis !== 'undefined' ? globalThis : window || self;
-    function configureCache(config) {
-      var namespace = config["export"];
-      var list = {};
-      var cache = {
-        preload: function preload() {
-          if (isNode() === false) {
-            this.load(global[namespace]);
-          }
+    var Cache = /*#__PURE__*/function () {
+      function Cache(config) {
+        _classCallCheck(this, Cache);
+        _defineProperty(this, "list", {});
+        this.configure(config);
+        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;
-        },
-        exist: function exist(key) {
-          return hasProp(list, key);
-        },
-        get: function get(key) {
-          return list[key];
-        },
-        remove: function remove(key) {
-          delete list[key];
-        },
-        resolve: function resolve(key) {
+        }
+      }, {
+        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));
-        },
-        set: function set(key, value) {
-          list[key] = value;
-          return this;
-        },
-        load: function load(data) {
-          extend(list, data);
+        }
+      }, {
+        key: "set",
+        value: function set(key, value) {
+          this.list[key] = value;
           return this;
         }
-      };
-      return cache.preload();
-    }
+      }]);
+      return Cache;
+    }();
 
-    function create(options) {
+    var configSchema = function configSchema(config, options) {
+      extend(config, {
+        "export": typeProp(isString, defaults["export"], options["export"]),
+        path: typeProp(isString, defaults.path, options.path),
+        resolver: typeProp(isFunction, defaults.resolver, options.resolver),
+        extension: typeProp(isString, defaults.extension, options.extension),
+        withObject: typeProp(isBoolean, defaults.withObject, options.withObject),
+        token: extend({}, defaults.token, options.token),
+        vars: extend({}, defaults.vars, options.vars)
+      });
+    };
+    var init = function init(options) {
+      /**
+       * EJS template
+       * @module ejs
+       */
       var config = {};
-      var ejs = {
-        safeValue: safeValue,
-        element: element,
-        output: function output(path, scope) {
-          return ejs.template(path).then(function (template) {
-            return template.call(scope, scope, scope.getBuffer(), safeValue);
-          });
-        },
-        render: function render(name, data) {
-          var filepath = ext(name, config.extension);
-          var scope = new ejs.scope(data);
-          return ejs.output(filepath, scope).then(function (content) {
-            if (scope.getExtend()) {
-              scope.setExtend(false);
-              var layout = scope.getLayout();
-              var _data = scope.clone();
-              return ejs.render(layout, _data);
-            }
-            return content;
-          });
-        },
-        require: function require(name) {
-          var filepath = ext(name, config.extension);
-          var scope = new ejs.scope({});
-          return ejs.output(filepath, scope).then(function () {
-            return scope.getMacro();
-          });
-        },
-        helpers: function helpers(methods) {
-          ejs.scope.helpers(methods);
-        },
-        configure: function configure(options) {
-          config["export"] = typeProp(isString, defaults["export"], options["export"]);
-          config.path = typeProp(isString, defaults.path, options.path);
-          config.resolver = typeProp(isFunction, defaults.resolver, options.resolver);
-          config.extension = typeProp(isString, defaults.extension, options.extension);
-          config.withObject = typeProp(isBoolean, defaults.withObject, options.withObject);
-          config.token = extend({}, defaults.token, options.token);
-          config.vars = extend({}, defaults.vars, options.vars);
-          ejs.scope = configureScope(ejs, config);
-          ejs.compile = configureCompiler(ejs, config);
-          ejs.wrapper = configureWrapper(ejs);
-          ejs.cache = configureCache(ejs);
-          ejs.template = configureTemplate(ejs, config);
-          return ejs;
-        },
-        __express: function __express(name, options, callback) {
-          if (isFunction(options)) {
-            callback = options;
-            options = {};
+      configSchema(config, options || {});
+      var context = new Context(config);
+      var compiler = new Compiler(config);
+      var bundler = new Bundler(config);
+      var cache = new Cache(config);
+      var template = new Template(config, cache, compiler);
+      var configure = function configure(options) {
+        configSchema(config, options);
+        context.configure(config);
+        compiler.configure(config);
+        bundler.configure(config);
+        cache.configure(config);
+        template.configure(config);
+      };
+      var output = function output(path, scope) {
+        return template.get(path).then(function (callback) {
+          return callback.call(scope, scope, scope.getBuffer(), safeValue);
+        });
+      };
+      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, settings['views'], defaults.path);
-          var viewCache = typeProp(isBoolean, settings['view cache'], defaults.cache);
-          var viewOptions = extend({}, settings['view options']);
-          var filename = path.relative(viewPath, name);
-          viewOptions.path = viewPath;
-          viewOptions.cache = viewCache;
-          ejs.configure(viewOptions);
-          return ejs.render(filename, options).then(function (content) {
-            callback(null, content);
-          })["catch"](function (error) {
-            callback(error);
-          });
+          return content;
+        });
+      };
+      var helpers = function helpers(methods) {
+        context.helpers(extend(callbacks, methods || {}));
+      };
+      var __express = function __express(name, options, callback) {
+        if (isFunction(options)) {
+          callback = options;
+          options = {};
         }
+        options = options || {};
+        var settings = extend({}, options.settings);
+        var viewPath = typeProp(isString, settings['views'], defaults.path);
+        var viewCache = typeProp(isBoolean, settings['view cache'], defaults.cache);
+        var viewOptions = extend({}, settings['view options']);
+        var filename = path.relative(viewPath, name);
+        viewOptions.path = viewPath;
+        viewOptions.cache = viewCache;
+        configure(viewOptions);
+        return _render(filename, options).then(function (content) {
+          callback(null, content);
+        })["catch"](function (error) {
+          callback(error);
+        });
+      };
+      var preload = function preload(list) {
+        return cache.load(list);
+      };
+      var wrapper = function wrapper(list) {
+        return bundler.wrapper(list);
+      };
+      var compile = function compile(content, path) {
+        return compiler.compile(content, path);
       };
-      ejs.configure(options || {});
-      ejs.helpers({
+      var create = function create(options) {
+        return init(options);
+      };
+      helpers({
         require: function require(name) {
-          return ejs.require(name, this);
+          return _require(name);
         },
         render: function render(name, data) {
-          return ejs.render(name, data);
+          return _render(name, data);
         }
       });
-      return ejs;
-    }
-    var instance = create();
-    instance.create = create;
+      return {
+        render: _render,
+        helpers: helpers,
+        configure: configure,
+        wrapper: wrapper,
+        compile: compile,
+        create: create,
+        preload: preload,
+        __express: __express
+      };
+    };
+    var _init = init({}),
+      render = _init.render,
+      helpers = _init.helpers,
+      configure = _init.configure,
+      wrapper = _init.wrapper,
+      compile = _init.compile,
+      create = _init.create,
+      preload = _init.preload,
+      __express = _init.__express;
+
+    exports.__express = __express;
+    exports.compile = compile;
+    exports.configure = configure;
+    exports.create = create;
+    exports.element = element;
+    exports.helpers = helpers;
+    exports.preload = preload;
+    exports.render = render;
+    exports.safeValue = safeValue;
+    exports.wrapper = wrapper;
 
-    return instance;
+    Object.defineProperty(exports, '__esModule', { value: true });
 
 }));