@kosatyi/ejs 0.0.25 → 0.0.27

package/dist/ejs.cjs

@@ -1,14 +1,15 @@
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
 var path = require('path');
 var fs = require('fs');
-var chokidar = require('chokidar');
+require('chokidar');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-var chokidar__default = /*#__PURE__*/_interopDefaultLegacy(chokidar);
 
 var defaults = {};
 defaults["export"] = 'ejs.precompiled';
@@ -168,7 +169,7 @@ var equal = '=';
 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) {
@@ -184,9 +185,60 @@ function element(tag, attrs, content) {
     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, "('");
@@ -207,7 +259,7 @@ var tags = [{
     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);
@@ -218,78 +270,105 @@ var match = function match(regex, text, callback) {
     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) {
@@ -307,46 +386,50 @@ var fileSystem = function fileSystem(template) {
     });
   });
 };
-var enableWatcher = function enableWatcher(path, cache) {
-  return chokidar__default["default"].watch('.', {
-    cwd: path
-  }).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) {
@@ -380,325 +463,376 @@ var createBuffer = function createBuffer() {
   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__default["default"].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__default["default"].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);
   };
-  ejs.configure(options || {});
-  ejs.helpers({
+  var compile = function compile(content, path) {
+    return compiler.compile(content, path);
+  };
+  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;
 
-module.exports = instance;
+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;