@kosatyi/ejs 0.0.62 → 0.0.64

package/dist/cjs/index.js

@@ -1,131 +1,7 @@
 'use strict';
 
-var fs = require('fs');
 var path = require('path');
-
-function _typeof(o) {
-  "@babel/helpers - typeof";
-
-  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 _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
-  }
-}
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  Object.defineProperty(Constructor, "prototype", {
-    writable: false
-  });
-  return Constructor;
-}
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-  return arr2;
-}
-function _createForOfIteratorHelper(o, allowArrayLike) {
-  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-  if (!it) {
-    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-      if (it) o = it;
-      var i = 0;
-      var F = function () {};
-      return {
-        s: F,
-        n: function () {
-          if (i >= o.length) return {
-            done: true
-          };
-          return {
-            done: false,
-            value: o[i++]
-          };
-        },
-        e: function (e) {
-          throw e;
-        },
-        f: F
-      };
-    }
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-  var normalCompletion = true,
-    didErr = false,
-    err;
-  return {
-    s: function () {
-      it = it.call(o);
-    },
-    n: function () {
-      var step = it.next();
-      normalCompletion = step.done;
-      return step;
-    },
-    e: function (e) {
-      didErr = true;
-      err = e;
-    },
-    f: function () {
-      try {
-        if (!normalCompletion && it.return != null) it.return();
-      } finally {
-        if (didErr) throw err;
-      }
-    }
-  };
-}
-function _toPrimitive(input, hint) {
-  if (typeof input !== "object" || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || "default");
-    if (typeof res !== "object") return res;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
-  }
-  return (hint === "string" ? String : Number)(input);
-}
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-  return typeof key === "symbol" ? key : String(key);
-}
+var fs = require('fs');
 
 var typeProp = function typeProp() {
   var args = [].slice.call(arguments);
@@ -141,9 +17,6 @@ var isString = function isString(v) {
 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';
 };
@@ -184,39 +57,33 @@ var symbols = function symbols(string) {
     return '\\' + symbolEntities[match];
   });
 };
-var safeValue = function safeValue(value, escape, check) {
-  return (check = value) == null ? '' : escape ? entities(check) : check;
+var safeValue = function safeValue(value, escape) {
+  var check = value;
+  return check == null ? '' : escape === true ? entities(check) : check;
+};
+var instanceOf = function instanceOf(object, instance) {
+  return object instanceof instance;
 };
 var getPath = function getPath(context, name, strict) {
   var data = context;
   var chunks = String(name).split('.');
   var prop = chunks.pop();
-  var _iterator = _createForOfIteratorHelper(chunks),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var part = _step.value;
-      if (strict && data.hasOwnProperty(part) === false) {
-        data = {};
-        break;
-      }
-      data = data[part] = data[part] || {};
+  for (var i = 0; i < chunks.length; i++) {
+    var part = chunks[i];
+    if (isFunction(data['toJSON'])) {
+      data = data.toJSON();
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+    if (strict && data.hasOwnProperty(part) === false) {
+      data = {};
+      break;
+    }
+    data = data[part] = data[part] || {};
+  }
+  if (isFunction(data['toJSON'])) {
+    data = data.toJSON();
   }
   return [data, prop];
 };
-var bindContext = function bindContext(object, context) {
-  var methods = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-  methods.forEach(function (name) {
-    if (name in object) {
-      object[name] = object[name].bind(context);
-    }
-  });
-};
 var ext = function ext(path, defaults) {
   var ext = path.split('.').pop();
   if (ext !== defaults) {
@@ -285,7 +152,7 @@ var hasProp = function hasProp(object, prop) {
 
 var defaults = {};
 defaults["export"] = 'ejsPrecompiled';
-defaults.watch = false;
+defaults.cache = true;
 defaults.chokidar = null;
 defaults.path = 'views';
 defaults.resolver = null;
@@ -308,6 +175,31 @@ defaults.token = {
   regex: '([\\s\\S]+?)'
 };
 
+var selfClosed = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
+var space = ' ';
+var quote = '"';
+var equal = '=';
+var slash = '/';
+var lt = '<';
+var gt = '>';
+var element = function element(tag, attrs, content) {
+  var result = [];
+  var hasClosedTag = selfClosed.indexOf(tag) === -1;
+  var attributes = map(attrs, function (value, key) {
+    if (value !== null && value !== undefined) {
+      return [entities(key), [quote, entities(value), quote].join('')].join(equal);
+    }
+  }).join(space);
+  result.push([lt, tag, space, attributes, gt].join(''));
+  if (content) {
+    result.push(content instanceof Array ? content.join('') : content);
+  }
+  if (hasClosedTag) {
+    result.push([lt, slash, tag, gt].join(''));
+  }
+  return result.join('');
+};
+
 var configSchema = function configSchema(config, options) {
   extend(config, {
     path: typeProp(isString, defaults.path, config.path, options.path),
@@ -316,8 +208,7 @@ var configSchema = function configSchema(config, options) {
     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"]),
+    cache: typeProp(isBoolean, defaults.watch, config.watch, options.watch),
     token: extend({}, defaults.token, config.token, options.token),
     vars: extend({}, defaults.vars, config.vars, options.vars)
   });
@@ -344,72 +235,41 @@ var fileSystem = function fileSystem(path, template) {
     });
   });
 };
-var Template = /*#__PURE__*/function () {
-  function Template(config, cache, compiler) {
-    _classCallCheck(this, Template);
-    this.cache = cache;
-    this.watcher = {
-      unwatch: function unwatch() {},
-      on: function on() {}
-    };
-    this.compiler = compiler;
-    this.configure(config);
-  }
-  _createClass(Template, [{
-    key: "configure",
-    value: function configure(config) {
-      var _this = this;
-      this.path = config.path;
-      this.chokidar = config.chokidar;
-      this.resolver = isFunction(config.resolver) ? config.resolver : isNode() ? fileSystem : httpRequest;
-      if (config.watch && isNode()) {
-        if (this.watcher) {
-          this.watcher.unwatch('.');
-        }
-        if (this.chokidar) {
-          this.watcher = this.chokidar.watch('.', {
-            cwd: this.path
-          }).on('change', function (name) {
-            _this.cache.remove(name);
-          });
-        }
-      }
-    }
-  }, {
-    key: "resolve",
-    value: function resolve(template) {
-      return this.resolver(this.path, template);
-    }
-  }, {
-    key: "result",
-    value: function result(template, content) {
-      this.cache.set(template, content);
+var fileResolver = function fileResolver(resolver) {
+  return isFunction(resolver) ? resolver : isNode() ? fileSystem : httpRequest;
+};
+function Template(config, cache, compiler) {
+  if (instanceOf(this, Template) === false) return new Template(config, cache, compiler);
+  var template = {};
+  var result = function result(template, content) {
+    cache.set(template, content);
+    return content;
+  };
+  var resolve = function resolve(path) {
+    return template.resolver(template.path, path);
+  };
+  var compile = function compile(content, template) {
+    if (isFunction(content)) {
       return content;
+    } else {
+      return compiler.compile(content, template);
     }
-  }, {
-    key: "compile",
-    value: function compile(content, template) {
-      if (isFunction(content)) {
-        return content;
-      } else {
-        return this.compiler.compile(content, template);
-      }
-    }
-  }, {
-    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));
-      });
-      return this.result(template, content);
+  };
+  this.configure = function (config) {
+    template.path = config.path;
+    template.cache = config.cache;
+    template.resolver = fileResolver(config.resolver);
+  };
+  this.get = function (template) {
+    if (cache.exist(template)) {
+      return cache.resolve(template);
     }
-  }]);
-  return Template;
-}();
+    return result(template, resolve(template).then(function (content) {
+      return result(template, compile(content, template));
+    }));
+  };
+  this.configure(config);
+}
 
 var tagList = [{
   symbol: '-',
@@ -432,7 +292,7 @@ var tagList = [{
     return "')\n".concat(value.trim(), "\n").concat(this.BUFFER, "('");
   }
 }];
-var matchTokens = function matchTokens(regex, text, callback) {
+function matchTokens(regex, text, callback) {
   var index = 0;
   text.replace(regex, function () {
     var params = [].slice.call(arguments, 0, -1);
@@ -442,165 +302,117 @@ var matchTokens = function matchTokens(regex, text, callback) {
     index = offset + match.length;
     return match;
   });
-};
-var Compiler = /*#__PURE__*/function () {
-  function Compiler(config) {
-    _classCallCheck(this, Compiler);
-    this.configure(config);
-  }
-  _createClass(Compiler, [{
-    key: "configure",
-    value: function configure(config) {
-      var _this = this;
-      this.withObject = config.withObject;
-      this.rmWhitespace = config.rmWhitespace;
-      this.token = config.token;
-      this.vars = config.vars;
-      this.matches = [];
-      this.formats = [];
-      this.slurp = {
-        match: '[ \\t]*',
-        start: [this.token.start, '_'],
-        end: ['_', this.token.end]
-      };
-      tagList.forEach(function (item) {
-        _this.matches.push(_this.token.start.concat(item.symbol).concat(_this.token.regex).concat(_this.token.end));
-        _this.formats.push(item.format.bind(_this.vars));
-      });
-      this.regex = new RegExp(this.matches.join('|').concat('|$'), 'g');
-      this.slurpStart = new RegExp([this.slurp.match, this.slurp.start.join('')].join(''), 'gm');
-      this.slurpEnd = new RegExp([this.slurp.end.join(''), this.slurp.match].join(''), 'gm');
-    }
-  }, {
-    key: "truncate",
-    value: function truncate(value) {
-      return value && value.replace(/^(?:\r\n|\r|\n)/, '');
-    }
-  }, {
-    key: "compile",
-    value: function compile(content, path) {
-      var _this2 = this;
-      var _this$vars = this.vars,
-        SCOPE = _this$vars.SCOPE,
-        SAFE = _this$vars.SAFE,
-        BUFFER = _this$vars.BUFFER,
-        COMPONENT = _this$vars.COMPONENT;
-      if (this.rmWhitespace) {
-        content = content.replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
-      }
-      content = content.replace(this.slurpStart, this.token.start).replace(this.slurpEnd, this.token.end);
-      var source = "".concat(BUFFER, "('");
-      matchTokens(this.regex, content, function (params, index, offset) {
-        source += symbols(content.slice(index, offset));
-        params.forEach(function (value, index) {
-          if (value) {
-            source += _this2.formats[index](value);
-          }
-        });
+}
+function Compiler(config) {
+  if (instanceOf(this, Compiler) === false) return new Compiler(config);
+  var compiler = {};
+  this.configure = function (config) {
+    compiler.withObject = config.withObject;
+    compiler.rmWhitespace = config.rmWhitespace;
+    compiler.token = config.token;
+    compiler.vars = config.vars;
+    compiler.matches = [];
+    compiler.formats = [];
+    compiler.slurp = {
+      match: '[ \\t]*',
+      start: [compiler.token.start, '_'],
+      end: ['_', compiler.token.end]
+    };
+    tagList.forEach(function (item) {
+      compiler.matches.push(compiler.token.start.concat(item.symbol).concat(compiler.token.regex).concat(compiler.token.end));
+      compiler.formats.push(item.format.bind(compiler.vars));
+    });
+    compiler.regex = new RegExp(compiler.matches.join('|').concat('|$'), 'g');
+    compiler.slurpStart = new RegExp([compiler.slurp.match, compiler.slurp.start.join('')].join(''), 'gm');
+    compiler.slurpEnd = new RegExp([compiler.slurp.end.join(''), compiler.slurp.match].join(''), 'gm');
+  };
+  this.compile = function (content, path) {
+    var _compiler$vars = compiler.vars,
+      SCOPE = _compiler$vars.SCOPE,
+      SAFE = _compiler$vars.SAFE,
+      BUFFER = _compiler$vars.BUFFER,
+      COMPONENT = _compiler$vars.COMPONENT;
+    if (compiler.rmWhitespace) {
+      content = content.replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
+    }
+    content = content.replace(compiler.slurpStart, compiler.token.start).replace(compiler.slurpEnd, compiler.token.end);
+    var source = "".concat(BUFFER, "('");
+    matchTokens(compiler.regex, content, function (params, index, offset) {
+      source += symbols(content.slice(index, offset));
+      params.forEach(function (value, index) {
+        if (value) {
+          source += compiler.formats[index](value);
+        }
       });
-      source += "');";
-      source = "try{".concat(source, "}catch(e){console.info(e)}");
-      if (this.withObject) {
-        source = "with(".concat(SCOPE, "){").concat(source, "}");
-      }
-      source = "".concat(BUFFER, ".start();").concat(source, "return ").concat(BUFFER, ".end();");
-      source += "\n//# sourceURL=".concat(path);
-      var result = null;
-      try {
-        result = new Function(SCOPE, COMPONENT, BUFFER, SAFE, source);
-        result.source = "(function(".concat(SCOPE, ",").concat(COMPONENT, ",").concat(BUFFER, ",").concat(SAFE, "){\n").concat(source, "\n})");
-      } catch (e) {
-        e.filename = path;
-        e.source = source;
-        throw e;
-      }
-      return result;
-    }
-  }]);
-  return Compiler;
-}();
+    });
+    source += "');";
+    source = "try{".concat(source, "}catch(e){console.info(e)}");
+    if (compiler.withObject) {
+      source = "with(".concat(SCOPE, "){").concat(source, "}");
+    }
+    source = "".concat(BUFFER, ".start();").concat(source, "return ").concat(BUFFER, ".end();");
+    source += "\n//# sourceURL=".concat(path);
+    var result = null;
+    try {
+      result = new Function(SCOPE, COMPONENT, BUFFER, SAFE, source);
+      result.source = "(function(".concat(SCOPE, ",").concat(COMPONENT, ",").concat(BUFFER, ",").concat(SAFE, "){\n").concat(source, "\n})");
+    } catch (e) {
+      e.filename = path;
+      e.source = source;
+      throw e;
+    }
+    return result;
+  };
+  this.configure(config);
+}
 
 var global = typeof globalThis !== 'undefined' ? globalThis : window || self;
-var Cache = /*#__PURE__*/function () {
-  function Cache(config) {
-    _classCallCheck(this, Cache);
-    _defineProperty(this, "list", {});
-    this.configure(config);
-  }
-  _createClass(Cache, [{
-    key: "configure",
-    value: function configure(config) {
-      this.list = {};
-      if (isNode() === false) {
-        this.load(global[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];
+function Cache(config) {
+  if (instanceOf(this, Cache) === false) return new Cache();
+  var cache = {
+    enabled: true,
+    list: {}
+  };
+  this.configure = function (config) {
+    cache.list = {};
+    cache.enabled = config.cache;
+    if (isNode() === false) {
+      this.load(global[config["export"]]);
     }
-  }, {
-    key: "resolve",
-    value: function resolve(key) {
-      return Promise.resolve(this.get(key));
+  };
+  this.load = function (data) {
+    if (cache.enabled) {
+      extend(cache.list, data || {});
     }
-  }, {
-    key: "set",
-    value: function set(key, value) {
-      this.list[key] = value;
-      return this;
+    return this;
+  };
+  this.get = function (key) {
+    if (cache.enabled) {
+      return cache.list[key];
     }
-  }]);
-  return Cache;
-}();
-
-var selfClosed = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
-var space = ' ';
-var quote = '"';
-var equal = '=';
-var slash = '/';
-var lt = '<';
-var gt = '>';
-var element = function element(tag, attrs, content) {
-  var result = [];
-  var hasClosedTag = selfClosed.indexOf(tag) === -1;
-  var attributes = map(attrs, function (value, key) {
-    if (value !== null && value !== undefined) {
-      return [entities(key), [quote, entities(value), quote].join('')].join(equal);
+  };
+  this.set = function (key, value) {
+    if (cache.enabled) {
+      cache.list[key] = value;
     }
-  }).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('');
-};
+    return this;
+  };
+  this.resolve = function (key) {
+    return Promise.resolve(this.get(key));
+  };
+  this.remove = function (key) {
+    delete cache.list[key];
+  };
+  this.exist = function (key) {
+    return hasProp(cache.list, key);
+  };
+}
 
-var resolve = function resolve(list) {
-  return Promise.all(list).then(function (list) {
+function resolve(list) {
+  return Promise.all(list || []).then(function (list) {
     return list.join('');
   });
-};
+}
 var createBuffer = function createBuffer() {
   var store = [],
     array = [];
@@ -628,329 +440,263 @@ var createBuffer = function createBuffer() {
   return buffer;
 };
 
-var Context = /*#__PURE__*/function () {
-  function Context(config) {
-    _classCallCheck(this, Context);
-    this.configure(config);
-  }
-  _createClass(Context, [{
-    key: "configure",
-    value: function configure(config, methods) {
-      var _config$vars = config.vars,
-        EXTEND = _config$vars.EXTEND,
-        LAYOUT = _config$vars.LAYOUT,
-        BLOCKS = _config$vars.BLOCKS,
-        BUFFER = _config$vars.BUFFER,
-        MACRO = _config$vars.MACRO,
-        COMPONENT = _config$vars.COMPONENT;
-      this.create = function (data) {
-        return new Scope(data);
+function Context(config) {
+  if (instanceOf(this, Context) === false) return new Context(config);
+  this.configure = function (config, methods) {
+    var _config$vars = config.vars,
+      BLOCKS = _config$vars.BLOCKS,
+      MACRO = _config$vars.MACRO,
+      EXTEND = _config$vars.EXTEND,
+      LAYOUT = _config$vars.LAYOUT,
+      BUFFER = _config$vars.BUFFER,
+      COMPONENT = _config$vars.COMPONENT;
+    this.create = function (data) {
+      return new Scope(data);
+    };
+    this.helpers = function (methods) {
+      extend(Scope.prototype, methods || {});
+    };
+    function Scope(data) {
+      this[BLOCKS] = {};
+      this[MACRO] = {};
+      extend(this, data || {});
+    }
+    Scope.prototype = extend({}, methods || {});
+    Scope.method = Scope.define = function (name, value, writable, configurable, enumerable) {
+      Object.defineProperty(Scope.prototype, name, {
+        value: value,
+        writable: writable || false,
+        configurable: configurable || false,
+        enumerable: enumerable || false
+      });
+    };
+    Scope.define(BUFFER, createBuffer());
+    Scope.define(BLOCKS, {}, true);
+    Scope.define(MACRO, {}, true);
+    Scope.define(LAYOUT, false, true);
+    Scope.define(EXTEND, false, true);
+    Scope.method('getMacro', function () {
+      return this[MACRO];
+    });
+    Scope.method('getBuffer', function () {
+      return this[BUFFER];
+    });
+    Scope.method('getComponent', function () {
+      var context = this;
+      if (COMPONENT in context) {
+        return function () {
+          return context[COMPONENT].apply(context, arguments);
+        };
+      }
+      return function () {
+        console.log('%s function not defined', COMPONENT);
       };
-      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, true);
+      var result = path.shift();
+      var prop = path.pop();
+      return hasProp(result, prop) ? result[prop] : defaults;
+    });
+    Scope.method('set', function (name, value) {
+      var path = getPath(this, name, false);
+      var result = path.shift();
+      var prop = path.pop();
+      if (this.getExtend() && hasProp(result, prop)) {
+        return result[prop];
       }
-      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, true);
-        var result = path.shift();
-        var prop = path.pop();
-        return hasProp(result, prop) ? result[prop] : defaults;
-      });
-      Scope.method('set', function (name, value) {
-        var path = getPath(this, name, false);
-        var result = path.shift();
-        var prop = path.pop();
-        if (this.getExtend() && hasProp(result, prop)) {
-          return result[prop];
-        }
-        return result[prop] = value;
-      });
-      Scope.method('macro', function (name, callback) {
-        var list = this.getMacro();
-        var macro = this.fn(callback);
-        var context = this;
-        list[name] = function () {
-          return context.echo(macro.apply(undefined, arguments));
-        };
-      });
-      Scope.method('call', function (name) {
+      };
+      this.echo(current()(next()));
+    });
+    Scope.method('include', function (path, data, cx) {
+      var context = cx === false ? {} : this.clone(true);
+      var params = extend(context, data || {});
+      var promise = this.render(path, params);
+      this.echo(promise);
+    });
+    Scope.method('use', function (path, namespace) {
+      var promise = this.require(path);
+      this.echo(resolve$1(promise, function (exports) {
         var list = this.getMacro();
-        var macro = list[name];
-        var params = [].slice.call(arguments, 1);
-        if (isFunction(macro)) {
-          return macro.apply(macro, params);
-        }
-      });
-      Scope.method('block', function (name, callback) {
-        var _this = this;
-        var blocks = this.getBlocks();
-        blocks[name] = blocks[name] || [];
-        blocks[name].push(this.fn(callback));
-        if (this.getExtend()) return;
-        var list = Object.assign([], blocks[name]);
-        var current = function current() {
-          return list.shift();
-        };
-        var next = function next() {
-          var parent = current();
-          if (parent) {
-            return function () {
-              _this.echo(parent(next()));
-            };
-          } else {
-            return noop;
-          }
-        };
-        this.echo(current()(next()));
-      });
-      Scope.method('include', function (path, data, cx) {
-        var context = cx === false ? {} : this.clone(true);
-        var params = extend(context, data || {});
-        var promise = this.render(path, params);
-        this.echo(promise);
-      });
-      Scope.method('use', function (path, namespace) {
-        var promise = this.require(path);
-        this.echo(resolve$1(promise, function (exports) {
-          var list = this.getMacro();
-          each(exports, function (macro, name) {
-            list[[namespace, name].join('.')] = macro;
-          });
-        }, this));
-      });
-      Scope.method('async', function (promise, callback) {
-        this.echo(resolve$1(promise, function (data) {
-          return this.fn(callback)(data);
-        }, this));
-      });
-      Scope.method('node', function (tag, attr, content) {
+        each(exports, function (macro, name) {
+          list[[namespace, name].join('.')] = macro;
+        });
+      }, this));
+    });
+    Scope.method('async', function (promise, callback) {
+      this.echo(resolve$1(promise, function (data) {
+        return this.fn(callback)(data);
+      }, this));
+    });
+    Scope.method('node', function (tag, attr, content) {
+      return element(tag, attr, content);
+    });
+    Scope.method('el', function (tag, attr, content) {
+      if (isFunction(content)) {
+        content = this.fn(content)();
+      }
+      this.echo(resolve$1(content, function (content) {
         return element(tag, attr, content);
-      });
-      Scope.method('el', function (tag, attr, content) {
-        if (isFunction(content)) {
-          content = this.fn(content)();
-        }
-        this.echo(resolve$1(content, function (content) {
-          return element(tag, attr, content);
-        }, this));
-      });
-      Scope.method('each', function (object, callback) {
-        if (isString(object)) {
-          object = this.get(object, []);
-        }
-        each(object, callback);
-      });
-    }
-  }]);
-  return Context;
-}();
+      }, this));
+    });
+    Scope.method('each', function (object, callback) {
+      if (isString(object)) {
+        object = this.get(object, []);
+      }
+      each(object, callback);
+    });
+  };
+  this.configure(config);
+}
 
-var EJS = /*#__PURE__*/function () {
-  function EJS() {
-    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    _classCallCheck(this, EJS);
-    _defineProperty(this, "export", ['cache', 'render', 'require', 'helpers', 'configure', 'preload', 'compile', 'create', '__express']);
-    this.config = {};
-    this.scope = {};
-    configSchema(this.config, options);
-    bindContext(this, this, this["export"]);
-    this.context = new Context(this.config);
-    this.compiler = new Compiler(this.config);
-    this.cache = new Cache(this.config);
-    this.template = new Template(this.config, this.cache, this.compiler);
-    this.helpers({
-      require: this.require,
-      render: this.render
+function EJS(options) {
+  if (instanceOf(this, EJS) === false) return new EJS(options);
+  var scope = {};
+  var config = {};
+  configSchema(config, options || {});
+  var context = new Context(config);
+  var compiler = new Compiler(config);
+  var cache = new Cache();
+  var template = new Template(config, cache, compiler);
+  var output = function output(path, scope) {
+    return template.get(path).then(function (callback) {
+      return callback.call(scope, scope, scope.getComponent(), scope.getBuffer(), safeValue);
     });
-  }
-  _createClass(EJS, [{
-    key: "configure",
-    value: function configure() {
-      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      configSchema(this.config, options);
-      this.context.configure(this.config, this.scope);
-      this.compiler.configure(this.config);
-      this.cache.configure(this.config);
-      this.template.configure(this.config);
-      return this.config;
-    }
-  }, {
-    key: "output",
-    value: function output(path, scope) {
-      return this.template.get(path).then(function (callback) {
-        return callback.call(scope, scope, scope.getComponent(), scope.getBuffer(), safeValue);
-      });
-    }
-  }, {
-    key: "render",
-    value: function render(name, data) {
-      var _this = this;
-      var filepath = ext(name, this.config.extension);
-      var scope = this.context.create(data);
-      return this.output(filepath, scope).then(function (content) {
-        if (scope.getExtend()) {
-          scope.setExtend(false);
-          var layout = scope.getLayout();
-          var _data = scope.clone();
-          return _this.render(layout, _data);
-        }
-        return content;
-      });
-    }
-  }, {
-    key: "require",
-    value: function require(name) {
-      var filepath = ext(name, this.config.extension);
-      var scope = this.context.create({});
-      return this.output(filepath, scope).then(function () {
-        return scope.getMacro();
-      });
-    }
-  }, {
-    key: "create",
-    value: function create() {
-      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      return new EJS(options);
-    }
-  }, {
-    key: "helpers",
-    value: function helpers() {
-      var methods = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      this.context.helpers(extend(this.scope, methods));
-    }
-  }, {
-    key: "preload",
-    value: function preload() {
-      var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      return this.cache.load(list);
-    }
-  }, {
-    key: "compile",
-    value: function compile(content, path) {
-      return this.compiler.compile(content, path);
-    }
-  }, {
-    key: "__express",
-    value: function __express(name, options, callback) {
-      if (isFunction(options)) {
-        callback = options;
-        options = {};
+  };
+  var require = function require(name) {
+    var filepath = ext(name, config.extension);
+    var scope = context.create({});
+    return output(filepath, scope).then(function () {
+      return scope.getMacro();
+    });
+  };
+  var render = function render(name, data) {
+    var filepath = ext(name, config.extension);
+    var scope = context.create(data);
+    return output(filepath, scope).then(function (content) {
+      if (scope.getExtend()) {
+        scope.setExtend(false);
+        var layout = scope.getLayout();
+        var _data = scope.clone();
+        return render(layout, _data);
       }
-      options = options || {};
-      var settings = extend({}, options.settings);
-      var viewPath = typeProp(isString, defaults.path, settings['views']);
-      var viewCache = typeProp(isBoolean, defaults.cache, settings['view cache']);
-      var viewOptions = extend({}, settings['view options']);
-      var filename = path.relative(viewPath, name);
-      viewOptions.path = viewPath;
-      viewOptions.cache = viewCache;
-      this.configure(viewOptions);
-      return this.render(filename, options).then(function (content) {
-        callback(null, content);
-      })["catch"](function (error) {
-        callback(error);
-      });
-    }
-  }]);
-  return EJS;
-}();
+      return content;
+    });
+  };
+  this.configure = function (options) {
+    options = options || {};
+    configSchema(config, options);
+    context.configure(config, scope);
+    compiler.configure(config);
+    cache.configure(config);
+    template.configure(config);
+    return config;
+  };
+  this.render = function (name, data) {
+    return render(name, data);
+  };
+  this.helpers = function (methods) {
+    context.helpers(Object.assign(scope, methods || {}));
+  };
+  this.preload = function (list) {
+    return cache.load(list || {});
+  };
+  this.create = function (options) {
+    return new EJS(options);
+  };
+  this.compile = function (content, path) {
+    return compiler.compile(content, path);
+  };
+  this.context = function (data) {
+    return context.create(data);
+  };
+  this.helpers({
+    require: require,
+    render: render
+  });
+}
 
-var ejs = new EJS({
-  /** defaults options **/
-});
-var __express = ejs.__express,
-  render = ejs.render,
+var ejs = new EJS();
+var render = ejs.render,
   context = ejs.context,
   compile = ejs.compile,
   helpers = ejs.helpers,
@@ -958,6 +704,27 @@ var __express = ejs.__express,
   configure = ejs.configure,
   create = ejs.create;
 
+function __express(name, options, callback) {
+  if (isFunction(options)) {
+    callback = options;
+    options = {};
+  }
+  options = options || {};
+  var settings = extend({}, options.settings);
+  var viewPath = typeProp(isString, defaults.path, settings['views']);
+  var viewCache = typeProp(isBoolean, defaults.cache, settings['view cache']);
+  var viewOptions = extend({}, settings['view options']);
+  var filename = path.relative(viewPath, name);
+  viewOptions.path = viewPath;
+  viewOptions.cache = viewCache;
+  configure(viewOptions);
+  return this.render(filename, options).then(function (content) {
+    callback(null, content);
+  })["catch"](function (error) {
+    callback(error);
+  });
+}
+
 exports.EJS = EJS;
 exports.__express = __express;
 exports.compile = compile;