@kosatyi/ejs 0.0.54 → 0.0.56

package/dist/umd/index.js

@@ -1,800 +1,855 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ejs = {}));
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ejs = {}));
 })(this, (function (exports) { 'use strict';
 
-    var path = {};
+  function _typeof(o) {
+    "@babel/helpers - typeof";
 
-    var defaults = {};
-    defaults["export"] = 'ejsPrecompiled';
-    defaults.watch = false;
-    defaults.path = 'views';
-    defaults.resolver = null;
-    defaults.extension = 'ejs';
-    defaults.rmWhitespace = true;
-    defaults.withObject = true;
-    defaults.vars = {
-      SCOPE: 'ejs',
-      COMPONENT: 'ui',
-      EXTEND: '$$e',
-      BUFFER: '$$a',
-      LAYOUT: '$$l',
-      BLOCKS: '$$b',
-      MACRO: '$$m',
-      SAFE: '$$v'
-    };
-    defaults.token = {
-      start: '<%',
-      end: '%>',
-      regex: '([\\s\\S]+?)'
-    };
-
-    function _typeof(obj) {
-      "@babel/helpers - typeof";
-
-      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
-        return typeof obj;
-      } : function (obj) {
-        return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-      }, _typeof(obj);
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+      return typeof o;
+    } : function (o) {
+      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 _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 _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
+  }
+  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
       });
-      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);
+    } else {
+      obj[key] = value;
     }
-    function _toPropertyKey(arg) {
-      var key = _toPrimitive(arg, "string");
-      return typeof key === "symbol" ? key : String(key);
+    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 typeProp = function typeProp() {
-      var args = [].slice.call(arguments);
-      var callback = args.shift();
-      return args.filter(callback).pop();
-    };
-    var isFunction = function isFunction(v) {
-      return typeof v === 'function';
-    };
-    var isString = function isString(v) {
-      return typeof v === 'string';
-    };
-    var isBoolean = function isBoolean(v) {
-      return typeof v === 'boolean';
-    };
-    var isObject = function isObject(v) {
-      return _typeof(v) === 'object';
-    };
-    var isUndefined = function isUndefined(v) {
-      return typeof v === 'undefined';
-    };
+  var typeProp = function typeProp() {
+    var args = [].slice.call(arguments);
+    var callback = args.shift();
+    return args.filter(callback).pop();
+  };
+  var isFunction = function isFunction(v) {
+    return typeof v === 'function';
+  };
+  var isString = function isString(v) {
+    return typeof v === 'string';
+  };
+  var isBoolean = function isBoolean(v) {
+    return typeof v === 'boolean';
+  };
+  var isObject = function isObject(v) {
+    return _typeof(v) === 'object';
+  };
+  var isUndefined = function isUndefined(v) {
+    return typeof v === 'undefined';
+  };
 
-    var isNodeEnv = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
-    var isNode = function isNode() {
-      return isNodeEnv;
-    };
-    var symbolEntities = {
-      "'": "'",
-      '\\': '\\',
-      '\r': 'r',
-      '\n': 'n',
-      '\t': 't',
-      "\u2028": 'u2028',
-      "\u2029": 'u2029'
-    };
-    var htmlEntities = {
-      '&': '&amp;',
-      '<': '&lt;',
-      '>': '&gt;',
-      '"': '&quot;',
-      "'": '&#x27;'
-    };
-    var regexKeys = function regexKeys(obj) {
-      return new RegExp(['[', Object.keys(obj).join(''), ']'].join(''), 'g');
-    };
-    var htmlEntitiesMatch = regexKeys(htmlEntities);
-    var symbolEntitiesMatch = regexKeys(symbolEntities);
-    var entities = function entities() {
-      var string = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-      return ('' + string).replace(htmlEntitiesMatch, function (match) {
-        return htmlEntities[match];
-      });
-    };
-    var symbols = function symbols(string) {
-      return ('' + string).replace(symbolEntitiesMatch, function (match) {
-        return '\\' + symbolEntities[match];
-      });
-    };
-    var safeValue = function safeValue(value, escape, check) {
-      return (check = value) == null ? '' : escape ? entities(check) : check;
-    };
-    var getPath = function getPath(context, name) {
-      var data = context;
-      var chunk = name.split('.');
-      var prop = chunk.pop();
-      chunk.forEach(function (part) {
-        data = data[part] = data[part] || {};
-      });
-      return [data, prop];
-    };
-    var ext = function ext(path, defaults) {
-      var ext = path.split('.').pop();
-      if (ext !== defaults) {
-        path = [path, defaults].join('.');
+  var isNodeEnv = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
+  var isNode = function isNode() {
+    return isNodeEnv;
+  };
+  var symbolEntities = {
+    "'": "'",
+    '\\': '\\',
+    '\r': 'r',
+    '\n': 'n',
+    '\t': 't',
+    "\u2028": 'u2028',
+    "\u2029": 'u2029'
+  };
+  var htmlEntities = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#x27;'
+  };
+  var regexKeys = function regexKeys(obj) {
+    return new RegExp(['[', Object.keys(obj).join(''), ']'].join(''), 'g');
+  };
+  var htmlEntitiesMatch = regexKeys(htmlEntities);
+  var symbolEntitiesMatch = regexKeys(symbolEntities);
+  var entities = function entities() {
+    var string = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    return ('' + string).replace(htmlEntitiesMatch, function (match) {
+      return htmlEntities[match];
+    });
+  };
+  var symbols = function symbols(string) {
+    return ('' + string).replace(symbolEntitiesMatch, function (match) {
+      return '\\' + symbolEntities[match];
+    });
+  };
+  var safeValue = function safeValue(value, escape, check) {
+    return (check = value) == null ? '' : escape ? entities(check) : check;
+  };
+  var getPath = function getPath(context, name) {
+    var data = context;
+    var chunk = name.split('.');
+    var prop = chunk.pop();
+    chunk.forEach(function (part) {
+      data = data[part] = data[part] || {};
+    });
+    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);
       }
-      return path;
-    };
-    var extend = function extend() {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-      var target = args.shift();
-      return args.filter(function (source) {
-        return source;
-      }).reduce(function (target, source) {
-        return Object.assign(target, source);
-      }, target);
-    };
-    var noop = function noop() {};
-    var each = function each(object, callback) {
-      var prop;
-      for (prop in object) {
-        if (hasProp(object, prop)) {
-          callback(object[prop], prop, object);
-        }
+    });
+  };
+  var ext = function ext(path, defaults) {
+    var ext = path.split('.').pop();
+    if (ext !== defaults) {
+      path = [path, defaults].join('.');
+    }
+    return path;
+  };
+  var extend = function extend() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    var target = args.shift();
+    return args.filter(function (source) {
+      return source;
+    }).reduce(function (target, source) {
+      return Object.assign(target, source);
+    }, target);
+  };
+  var noop = function noop() {};
+  var each = function each(object, callback) {
+    var prop;
+    for (prop in object) {
+      if (hasProp(object, prop)) {
+        callback(object[prop], prop, object);
       }
-    };
-    var map = function map(object, callback, context) {
-      var result = [];
-      each(object, function (value, key, object) {
-        var item = callback(value, key, object);
-        if (isUndefined(item) === false) {
+    }
+  };
+  var map = function map(object, callback, context) {
+    var result = [];
+    each(object, function (value, key, object) {
+      var item = callback(value, key, object);
+      if (isUndefined(item) === false) {
+        result.push(item);
+      }
+    });
+    return result;
+  };
+  var filter = function filter(object, callback, context) {
+    var isArray = object instanceof Array;
+    var result = isArray ? [] : {};
+    each(object, function (value, key, object) {
+      var item = callback(value, key, object);
+      if (isUndefined(item) === false) {
+        if (isArray) {
           result.push(item);
+        } else {
+          result[key] = item;
         }
-      });
-      return result;
-    };
-    var filter = function filter(object, callback, context) {
-      var isArray = object instanceof Array;
-      var result = isArray ? [] : {};
-      each(object, function (value, key, object) {
-        var item = callback(value, key, object);
-        if (isUndefined(item) === false) {
-          if (isArray) {
-            result.push(item);
-          } else {
-            result[key] = item;
-          }
-        }
-      });
-      return result;
-    };
-    var omit = function omit(object, list) {
-      return filter(object, function (value, key) {
-        if (list.indexOf(key) === -1) {
-          return value;
-        }
-      });
-    };
-    var resolve$1 = function resolve(value, callback, context) {
-      return Promise.resolve(value).then(callback.bind(context));
-    };
-    var hasProp = function hasProp(object, prop) {
-      return object && object.hasOwnProperty(prop);
-    };
-
-    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;
+  };
+  var omit = function omit(object, list) {
+    return filter(object, function (value, key) {
+      if (list.indexOf(key) === -1) {
+        return value;
       }
-      return result.join('');
-    };
+    });
+  };
+  var resolve$1 = function resolve(value, callback, context) {
+    return Promise.resolve(value).then(callback.bind(context));
+  };
+  var hasProp = function hasProp(object, prop) {
+    return object && object.hasOwnProperty(prop);
+  };
 
-    var tagList = [{
-      symbol: '-',
-      format: function format(value) {
-        return "')\n".concat(this.BUFFER, "(").concat(this.SAFE, "(").concat(value, ",1))\n").concat(this.BUFFER, "('");
-      }
-    }, {
-      symbol: '=',
-      format: function format(value) {
-        return "')\n".concat(this.BUFFER, "(").concat(this.SAFE, "(").concat(value, "))\n").concat(this.BUFFER, "('");
-      }
-    }, {
-      symbol: '#',
-      format: function format(value) {
-        return "')\n/**".concat(value, "**/\n").concat(this.BUFFER, "('");
-      }
-    }, {
-      symbol: '',
-      format: function format(value) {
-        return "')\n".concat(value.trim(), "\n").concat(this.BUFFER, "('");
-      }
-    }];
-    var matchTokens = function matchTokens(regex, text, callback) {
-      var index = 0;
-      text.replace(regex, function () {
-        var params = [].slice.call(arguments, 0, -1);
-        var offset = params.pop();
-        var match = params.shift();
-        callback(params, index, offset);
-        index = offset + match.length;
-        return match;
-      });
-    };
-    var 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);
-              }
-            });
-          });
-          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;
-    }();
+  var defaults = {};
+  defaults["export"] = 'ejsPrecompiled';
+  defaults.watch = false;
+  defaults.chokidar = null;
+  defaults.path = 'views';
+  defaults.resolver = null;
+  defaults.extension = 'ejs';
+  defaults.rmWhitespace = true;
+  defaults.withObject = true;
+  defaults.vars = {
+    SCOPE: 'ejs',
+    COMPONENT: 'ui',
+    EXTEND: '$$e',
+    BUFFER: '$$a',
+    LAYOUT: '$$l',
+    BLOCKS: '$$b',
+    MACRO: '$$m',
+    SAFE: '$$v'
+  };
+  defaults.token = {
+    start: '<%',
+    end: '%>',
+    regex: '([\\s\\S]+?)'
+  };
 
-    var resolvePath = function resolvePath(path, template) {
-      template = [path, template].join('/');
-      template = template.replace(/\/\//g, '/');
-      return template;
-    };
-    var httpRequest = function httpRequest(path, template) {
-      return fetch(resolvePath(path, template)).then(function (response) {
-        return response.text();
+  var configSchema = function configSchema(config, options) {
+    extend(config, {
+      path: typeProp(isString, defaults.path, config.path, options.path),
+      "export": typeProp(isString, defaults["export"], config["export"], options["export"]),
+      resolver: typeProp(isFunction, defaults.resolver, config.resolver, options.resolver),
+      extension: typeProp(isString, defaults.extension, config.extension, options.extension),
+      withObject: typeProp(isBoolean, defaults.withObject, config.withObject, options.withObject),
+      rmWhitespace: typeProp(isBoolean, defaults.rmWhitespace, config.rmWhitespace, options.rmWhitespace),
+      watch: typeProp(isBoolean, defaults.watch, config.watch, options.watch),
+      chokidar: typeProp(isObject, defaults["export"], config["export"], options["export"]),
+      token: extend({}, defaults.token, config.token, options.token),
+      vars: extend({}, defaults.vars, config.vars, options.vars)
+    });
+  };
+
+  var path = {};
+
+  var resolvePath = function resolvePath(path, template) {
+    template = [path, template].join('/');
+    template = template.replace(/\/\//g, '/');
+    return template;
+  };
+  var httpRequest = function httpRequest(path, template) {
+    return fetch(resolvePath(path, template)).then(function (response) {
+      return response.text();
+    });
+  };
+  var fileSystem = function fileSystem(path$1, template) {
+    return new Promise(function (resolve, reject) {
+      path.readFile(resolvePath(path$1, template), function (error, data) {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(data.toString());
+        }
       });
-    };
-    var fileSystem = function fileSystem(path$1, template) {
-      return new Promise(function (resolve, reject) {
-        path.readFile(resolvePath(path$1, template), function (error, data) {
-          if (error) {
-            reject(error);
-          } else {
-            resolve(data.toString());
+    });
+  };
+  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('.');
           }
-        });
-      });
-    };
-    var Template = /*#__PURE__*/function () {
-      function Template(config, cache, compiler) {
-        _classCallCheck(this, Template);
-        this.cache = cache;
-        this.watcher = null;
-        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 && config.chokidar && 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);
-            }).on('error', function (error) {
-              console.log('watcher error: ' + error);
             });
           }
         }
-      }, {
-        key: "resolve",
-        value: function resolve(template) {
-          return this.resolver(this.path, template);
-        }
-      }, {
-        key: "result",
-        value: function result(template, content) {
-          this.cache.set(template, content);
+      }
+    }, {
+      key: "resolve",
+      value: function resolve(template) {
+        return this.resolver(this.path, template);
+      }
+    }, {
+      key: "result",
+      value: function result(template, content) {
+        this.cache.set(template, content);
+        return content;
+      }
+    }, {
+      key: "compile",
+      value: function compile(content, template) {
+        if (isFunction(content)) {
           return content;
+        } else {
+          return this.compiler.compile(content, template);
         }
-      }, {
-        key: "compile",
-        value: function compile(content, template) {
-          if (isFunction(content)) {
-            return content;
-          } else {
-            return this.compiler.compile(content, template);
-          }
+      }
+    }, {
+      key: "get",
+      value: function get(template) {
+        var _this2 = this;
+        if (this.cache.exist(template)) {
+          return this.cache.resolve(template);
         }
-      }, {
-        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));
+        var content = this.resolve(template).then(function (content) {
+          return _this2.result(template, _this2.compile(content, template));
+        });
+        return this.result(template, content);
+      }
+    }]);
+    return Template;
+  }();
+
+  var tagList = [{
+    symbol: '-',
+    format: function format(value) {
+      return "')\n".concat(this.BUFFER, "(").concat(this.SAFE, "(").concat(value, ",1))\n").concat(this.BUFFER, "('");
+    }
+  }, {
+    symbol: '=',
+    format: function format(value) {
+      return "')\n".concat(this.BUFFER, "(").concat(this.SAFE, "(").concat(value, "))\n").concat(this.BUFFER, "('");
+    }
+  }, {
+    symbol: '#',
+    format: function format(value) {
+      return "')\n/**".concat(value, "**/\n").concat(this.BUFFER, "('");
+    }
+  }, {
+    symbol: '',
+    format: function format(value) {
+      return "')\n".concat(value.trim(), "\n").concat(this.BUFFER, "('");
+    }
+  }];
+  var matchTokens = function matchTokens(regex, text, callback) {
+    var index = 0;
+    text.replace(regex, function () {
+      var params = [].slice.call(arguments, 0, -1);
+      var offset = params.pop();
+      var match = params.shift();
+      callback(params, index, offset);
+      index = offset + match.length;
+      return match;
+    });
+  };
+  var 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);
+            }
           });
-          return this.result(template, content);
+        });
+        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 Template;
-    }();
+        return result;
+      }
+    }]);
+    return Compiler;
+  }();
 
-    var resolve = function resolve(list) {
-      return Promise.all(list).then(function (list) {
-        return list.join('');
-      });
+  var global = typeof globalThis !== 'undefined' ? globalThis : window || self;
+  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;
+      }
+    }, {
+      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);
+      }
+    }).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 resolve = function resolve(list) {
+    return Promise.all(list).then(function (list) {
+      return list.join('');
+    });
+  };
+  var createBuffer = function createBuffer() {
+    var store = [],
+      array = [];
+    function buffer(value) {
+      array.push(value);
+    }
+    buffer.start = function () {
+      array = [];
     };
-    var createBuffer = function createBuffer() {
-      var store = [],
-        array = [];
-      function buffer(value) {
-        array.push(value);
-      }
-      buffer.start = function () {
-        array = [];
-      };
-      buffer.backup = function () {
-        store.push(array.concat());
-        array = [];
-      };
-      buffer.restore = function () {
-        var result = array.concat();
-        array = store.pop();
-        return resolve(result);
-      };
-      buffer.error = function (e) {
-        throw e;
-      };
-      buffer.end = function () {
-        return resolve(array);
-      };
-      return buffer;
+    buffer.backup = function () {
+      store.push(array.concat());
+      array = [];
+    };
+    buffer.restore = function () {
+      var result = array.concat();
+      array = store.pop();
+      return resolve(result);
     };
+    buffer.error = function (e) {
+      throw e;
+    };
+    buffer.end = function () {
+      return resolve(array);
+    };
+    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);
+  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);
+        };
+        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);
+        }
+        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.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) {
+            return function () {
+              return context[COMPONENT].apply(context, arguments);
+            };
+          }
+          return function () {
+            console.log('%s function not defined', COMPONENT);
           };
-          this.helpers = function (methods) {
-            extend(Scope.prototype, methods);
+        });
+        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();
           };
-          function Scope() {
-            var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-            this.initBlocks();
-            this.initMacro();
-            extend(this, data);
+        });
+        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];
           }
-          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
-            });
+          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.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) {
+        });
+        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 () {
-                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);
-            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) {
+          };
+          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;
-    }();
-
-    var global = typeof globalThis !== 'undefined' ? globalThis : window || self;
-    var Cache = /*#__PURE__*/function () {
-      function Cache(config) {
-        _classCallCheck(this, Cache);
-        _defineProperty(this, "list", {});
-        this.configure(config);
-        if (isNode() === false) {
-          this.load(global[this.namespace]);
-        }
+          }, this));
+        });
+        Scope.method('each', function (object, callback) {
+          if (isString(object)) {
+            object = this.get(object, []);
+          }
+          each(object, callback);
+        });
       }
-      _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;
-    }();
+    }]);
+    return Context;
+  }();
 
-    var configSchema = function configSchema(config, options) {
-      extend(config, {
-        path: typeProp(isString, defaults.path, config.path, options.path),
-        "export": typeProp(isString, defaults["export"], config["export"], options["export"]),
-        resolver: typeProp(isFunction, defaults.resolver, config.resolver, options.resolver),
-        extension: typeProp(isString, defaults.extension, config.extension, options.extension),
-        withObject: typeProp(isBoolean, defaults.withObject, config.withObject, options.withObject),
-        rmWhitespace: typeProp(isBoolean, defaults.rmWhitespace, config.rmWhitespace, options.rmWhitespace),
-        watch: typeProp(isBoolean, defaults.watch, config.watch, options.watch),
-        chokidar: typeProp(isObject, defaults["export"], config["export"], options["export"]),
-        token: extend({}, defaults.token, config.token, options.token),
-        vars: extend({}, defaults.vars, config.vars, options.vars)
+  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', 'compiler', '__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
       });
-    };
-    var create = function create(options) {
-      var config = {};
-      var scope = {};
-      configSchema(config, options || {});
-      var context = new Context(config);
-      var compiler = new Compiler(config);
-      var cache = new Cache(config);
-      var template = new Template(config, cache, compiler);
-      var configure = function configure(options) {
-        configSchema(config, options);
-        context.configure(config, scope);
-        compiler.configure(config);
-        cache.configure(config);
-        template.configure(config);
-        return config;
-      };
-      var output = function output(path, scope) {
-        return template.get(path).then(function (callback) {
+    }
+    _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);
         });
-      };
-      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) {
+      }
+    }, {
+      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 render(layout, _data);
+            return _this.render(layout, _data);
           }
           return content;
         });
-      };
-      var helpers = function helpers(methods) {
-        context.helpers(extend(scope, methods || {}));
-      };
-      var __express = function __express(name, options, callback) {
+      }
+    }, {
+      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 = {};
@@ -807,52 +862,39 @@
         var filename = path.relative(viewPath, name);
         viewOptions.path = viewPath;
         viewOptions.cache = viewCache;
-        configure(viewOptions);
-        return render(filename, options).then(function (content) {
+        this.configure(viewOptions);
+        return this.render(filename, options).then(function (content) {
           callback(null, content);
         })["catch"](function (error) {
           callback(error);
         });
-      };
-      var preload = function preload(list) {
-        return cache.load(list);
-      };
-      var compile = function compile(content, path) {
-        return compiler.compile(content, path);
-      };
-      helpers({
-        require: require,
-        render: render
-      });
-      return {
-        context: context,
-        render: render,
-        helpers: helpers,
-        configure: configure,
-        compile: compile,
-        create: create,
-        preload: preload,
-        __express: __express
-      };
-    };
-    var _create = create({}),
-      context = _create.context,
-      render = _create.render,
-      helpers = _create.helpers,
-      configure = _create.configure,
-      compile = _create.compile,
-      preload = _create.preload,
-      __express = _create.__express;
+      }
+    }]);
+    return EJS;
+  }();
+
+  var ejs = new EJS({
+    /** defaults options **/
+  });
+  var __express = ejs.__express,
+    render = ejs.render,
+    context = ejs.context,
+    compile = ejs.compile,
+    helpers = ejs.helpers,
+    preload = ejs.preload,
+    configure = ejs.configure,
+    create = ejs.create;
 
-    exports.__express = __express;
-    exports.compile = compile;
-    exports.configure = configure;
-    exports.context = context;
-    exports.create = create;
-    exports.element = element;
-    exports.helpers = helpers;
-    exports.preload = preload;
-    exports.render = render;
-    exports.safeValue = safeValue;
+  exports.EJS = EJS;
+  exports.__express = __express;
+  exports.compile = compile;
+  exports.configure = configure;
+  exports.context = context;
+  exports.create = create;
+  exports.element = element;
+  exports.helpers = helpers;
+  exports.preload = preload;
+  exports.render = render;
+  exports.safeValue = safeValue;
 
 }));