@kosatyi/ejs 0.0.107 → 0.0.108

package/dist/cjs/index.js

@@ -1,75 +1,110 @@
 'use strict';
 
-var fs = require('node:fs');
 var path = require('node:path');
+var fs = require('node:fs/promises');
 
-var typeProp = function typeProp() {
-  var args = [].slice.call(arguments);
-  var callback = args.shift();
-  return args.filter(callback).pop();
-};
-var isArray = function isArray(v) {
-  return Array.isArray(v);
-};
-var isFunction = function isFunction(v) {
-  return typeof v === 'function';
-};
-var isString = function isString(v) {
-  return typeof v === 'string';
+/**
+ * @type {EjsConfig}
+ */
+const ejsDefaults = {
+  precompiled: 'ejsPrecompiled',
+  cache: true,
+  path: 'views',
+  extension: 'ejs',
+  rmWhitespace: true,
+  strict: true,
+  resolver: (path, template) => {
+    return Promise.resolve(['resolver is not defined', path, template].join(' '));
+  },
+  globals: [],
+  vars: {
+    SCOPE: 'ejs',
+    COMPONENT: 'ui',
+    ELEMENT: 'el',
+    EXTEND: '$$e',
+    BUFFER: '$$a',
+    LAYOUT: '$$l',
+    BLOCKS: '$$b',
+    MACRO: '$$m',
+    SAFE: '$$v'
+  },
+  token: {
+    start: '<%',
+    end: '%>',
+    regex: '([\\s\\S]+?)'
+  }
 };
-var isBoolean = function isBoolean(v) {
-  return typeof v === 'boolean';
+
+const jsVariableName = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+const typeProp = function () {
+  const args = [].slice.call(arguments);
+  const callback = args.shift();
+  return args.filter(callback).pop();
 };
-var isUndefined = function isUndefined(v) {
-  return typeof v === 'undefined';
+const isArray = value => Array.isArray(value);
+const isFunction = value => typeof value === 'function';
+const isString = value => typeof value === 'string';
+const isBoolean = value => typeof value === 'boolean';
+const isArrayOfVariables = value => {
+  if (!isArray(value)) return false;
+  return value.filter(name => {
+    const valid = jsVariableName.test(name);
+    if (valid === false) console.log(`ejsConfig.globals: expected '${name}' to be valid variable name --> skipped`);
+    return valid;
+  });
 };
 
-var isNodeEnv = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
-var isNode = function isNode() {
-  return isNodeEnv;
+const configSchema = (config, options) => {
+  return Object.assign(config, {
+    path: typeProp(isString, ejsDefaults.path, config.path, options.path),
+    precompiled: typeProp(isString, ejsDefaults.precompiled, config.export, options.export),
+    resolver: typeProp(isFunction, ejsDefaults.resolver, config.resolver, options.resolver),
+    extension: typeProp(isString, ejsDefaults.extension, config.extension, options.extension),
+    strict: typeProp(isBoolean, ejsDefaults.strict, config.strict, options.strict),
+    rmWhitespace: typeProp(isBoolean, ejsDefaults.rmWhitespace, config.rmWhitespace, options.rmWhitespace),
+    cache: typeProp(isBoolean, ejsDefaults.cache, config.cache, options.cache),
+    globals: typeProp(isArray, ejsDefaults.globals, config.globals, isArrayOfVariables(options.globals)),
+    token: Object.assign({}, ejsDefaults.token, config.token, options.token),
+    vars: Object.assign({}, ejsDefaults.vars, config.vars, options.vars)
+  });
 };
-var symbolEntities = {
+
+const symbolEntities = {
   "'": "'",
   '\\': '\\',
   '\r': 'r',
   '\n': 'n',
   '\t': 't',
-  "\u2028": 'u2028',
-  "\u2029": 'u2029'
+  '\u2028': 'u2028',
+  '\u2029': 'u2029'
 };
-var htmlEntities = {
+const htmlEntities = {
   '&': '&amp;',
   '<': '&lt;',
   '>': '&gt;',
   '"': '&quot;',
   "'": '&#x27;'
 };
-var regexKeys = function regexKeys(obj) {
-  return new RegExp(['[', Object.keys(obj).join(''), ']'].join(''), 'g');
+const regexKeys = obj => new RegExp(['[', Object.keys(obj).join(''), ']'].join(''), 'g');
+const htmlEntitiesMatch = regexKeys(htmlEntities);
+const symbolEntitiesMatch = regexKeys(symbolEntities);
+const entities = function () {
+  let string = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return ('' + string).replace(htmlEntitiesMatch, match => htmlEntities[match]);
 };
-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];
-  });
+const symbols = string => {
+  return ('' + string).replace(symbolEntitiesMatch, match => '\\' + symbolEntities[match]);
 };
-var safeValue = function safeValue(value, escape) {
-  var check = value;
+const safeValue = (value, escape) => {
+  const check = value;
   return check == null ? '' : Boolean(escape) === true ? entities(check) : check;
 };
-var getPath = function getPath(context, name, strict) {
-  var data = context;
-  var chunks = String(name).split('.');
-  var prop = chunks.pop();
-  for (var i = 0; i < chunks.length; i++) {
-    var part = chunks[i];
+const getPath = (context, name, strict) => {
+  let data = context;
+  let chunks = String(name).split('.');
+  let prop = chunks.pop();
+  for (let i = 0; i < chunks.length; i++) {
+    const part = chunks[i];
     if (isFunction(data['toJSON'])) {
       data = data.toJSON();
     }
@@ -84,344 +119,242 @@ var getPath = function getPath(context, name, strict) {
   }
   return [data, prop];
 };
-var ext = function ext(path, defaults) {
-  var ext = path.split('.').pop();
-  if (ext !== defaults) {
-    path = [path, defaults].join('.');
-  }
-  return path;
-};
-
-/**
- * @type {<T extends {}, U, V, W,Y>(T,U,V,W,Y)=> T & U & V & W & Y}
- */
-var extend = function extend(target) {
-  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    args[_key - 1] = arguments[_key];
-  }
-  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;
+const each = (object, callback) => {
+  let 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) {
-      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;
-      }
-    }
-  });
+const omit = (object, list) => {
+  const result = {
+    ...object
+  };
+  for (const key of list) {
+    delete result[key];
+  }
   return result;
 };
-var omit = function omit(object, list) {
-  return filter(object, function (value, key) {
-    if (list.indexOf(key) === -1) {
-      return value;
-    }
-  });
-};
-
-/**
- *
- * @param object
- * @param prop
- * @return {boolean}
- */
-var hasProp = function hasProp(object, prop) {
-  return object && object.hasOwnProperty(prop);
+const hasProp = (object, prop) => {
+  return object && Object.hasOwn(object, prop);
 };
-var joinPath = function joinPath(path, template) {
+const joinPath = (path, template) => {
   template = [path, template].join('/');
   template = template.replace(/\/\//g, '/');
   return template;
 };
-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 defaults = {};
-defaults["export"] = 'ejsPrecompiled';
-defaults.cache = true;
-defaults.chokidar = null;
-defaults.path = 'views';
-defaults.resolver = function (path, template) {
-  return Promise.resolve(['resolver is not defined', path, template].join(' '));
-};
-defaults.extension = 'ejs';
-defaults.rmWhitespace = true;
-defaults.withObject = true;
-defaults.globalHelpers = [];
-defaults.vars = {
-  SCOPE: 'ejs',
-  COMPONENT: 'ui',
-  ELEMENT: 'el',
-  EXTEND: '$$e',
-  BUFFER: '$$a',
-  LAYOUT: '$$l',
-  BLOCKS: '$$b',
-  MACRO: '$$m',
-  SAFE: '$$v'
-};
-defaults.token = {
-  start: '<%',
-  end: '%>',
-  regex: '([\\s\\S]+?)'
-};
-
-var configSchema = function configSchema(config, options) {
-  return 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),
-    cache: typeProp(isBoolean, defaults.cache, config.cache, options.cache),
-    token: extend({}, defaults.token, config.token, options.token),
-    vars: extend({}, defaults.vars, config.vars, options.vars),
-    globalHelpers: typeProp(isArray, defaults.globalHelpers, config.globalHelpers, options.globalHelpers)
-  });
+const bindContext = function (object) {
+  let methods = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  for (let i = 0, len = methods.length; i < len; i++) {
+    const name = methods[i];
+    if (name in object) {
+      object[name] = object[name].bind(object);
+    }
+  }
 };
 
-var Template = function Template(options, cache, compiler) {
-  var config = {
-    path: null,
-    resolver: null
-  };
-  var resolve = function resolve(path) {
-    return config.resolver(config.path, path);
-  };
-  var result = function result(template, content) {
-    cache.set(template, content);
-    return content;
-  };
-  var compile = function compile(content, template) {
-    if (isFunction(content)) {
-      return content;
-    } else {
-      return compiler.compile(content, template);
+class Template {
+  #path;
+  #resolver;
+  #cache;
+  #compiler;
+  static exports = ['configure', 'get', 'compile'];
+  constructor(options, cache, compiler) {
+    bindContext(this, this.constructor.exports);
+    this.#cache = cache;
+    this.#compiler = compiler;
+    this.configure(options ?? {});
+  }
+  configure(options) {
+    this.#path = options.path;
+    if (isFunction(options.resolver)) {
+      this.#resolver = options.resolver;
     }
-  };
-  var get = function get(template) {
-    if (cache.exist(template)) {
-      return cache.resolve(template);
+  }
+  #resolve(template) {
+    const cached = this.#cache.get(template);
+    if (cached instanceof Promise) return cached;
+    const result = Promise.resolve(this.#resolver(this.#path, template));
+    this.#cache.set(template, result);
+    return result;
+  }
+  compile(content, template) {
+    const cached = this.#cache.get(template);
+    if (typeof cached === 'function') return cached;
+    if (typeof content === 'string') {
+      content = this.#compiler.compile(content, template);
     }
-    return resolve(template).then(function (content) {
-      return result(template, compile(content, template));
-    });
-  };
-  var configure = function configure(options) {
-    config.path = options.path;
-    if (isFunction(options.resolver)) {
-      config.resolver = options.resolver;
+    if (typeof content === 'function') {
+      this.#cache.set(template, content);
+      return content;
     }
-  };
-  configure(options);
-  return {
-    get: get,
-    configure: configure,
-    compile: compile
-  };
-};
+  }
+  get(template) {
+    return this.#resolve(template).then(content => this.compile(content, template));
+  }
+}
 
-var configSymbols = [{
-  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 Compiler = function Compiler(options) {
-  var config = {};
-  var configure = function configure(options) {
-    config.withObject = options.withObject;
-    config.rmWhitespace = options.rmWhitespace;
-    config.token = options.token;
-    config.vars = options.vars;
-    config.globalHelpers = options.globalHelpers;
-    config.matches = [];
-    config.formats = [];
-    config.slurp = {
+const tokenList = [['-', (v, b, s) => `')\n${b}(${s}(${v},1))\n${b}('`], ['=', (v, b, s) => `')\n${b}(${s}(${v}))\n${b}('`], ['#', (v, b) => `')\n/**${v}**/\n${b}('`], ['', (v, b) => `')\n${v}\n${b}('`]];
+const tokensMatch = (regex, content, callback) => {
+  let index = 0;
+  content.replace(regex, function () {
+    const params = [].slice.call(arguments, 0, -1);
+    const offset = params.pop();
+    const match = params.shift();
+    callback(params, index, offset);
+    index = offset + match.length;
+    return match;
+  });
+};
+class Compiler {
+  #config = {};
+  static exports = ['compile'];
+  constructor(options) {
+    bindContext(this, this.constructor.exports);
+    this.configure(options);
+  }
+  configure(options) {
+    this.#config.strict = options.strict;
+    this.#config.rmWhitespace = options.rmWhitespace;
+    this.#config.token = options.token;
+    this.#config.vars = options.vars;
+    this.#config.globals = options.globals;
+    this.#config.legacy = options.legacy ?? true;
+    this.#config.slurp = {
       match: '[s\t\n]*',
-      start: [config.token.start, '_'],
-      end: ['_', config.token.end]
+      start: [this.#config.token.start, '_'],
+      end: ['_', this.#config.token.end]
     };
-    configSymbols.forEach(function (item) {
-      config.matches.push(config.token.start.concat(item.symbol).concat(config.token.regex).concat(config.token.end));
-      config.formats.push(item.format.bind(config.vars));
-    });
-    config.regex = new RegExp(config.matches.join('|').concat('|$'), 'g');
-    config.slurpStart = new RegExp([config.slurp.match, config.slurp.start.join('')].join(''), 'gm');
-    config.slurpEnd = new RegExp([config.slurp.end.join(''), config.slurp.match].join(''), 'gm');
-  };
-  var compile = function compile(content, path) {
-    var _config$vars = config.vars,
-      SCOPE = _config$vars.SCOPE,
-      SAFE = _config$vars.SAFE,
-      BUFFER = _config$vars.BUFFER,
-      COMPONENT = _config$vars.COMPONENT,
-      ELEMENT = _config$vars.ELEMENT;
-    var GLOBALS = config.globalHelpers;
-    if (config.rmWhitespace) {
+    this.#config.matches = [];
+    this.#config.formats = [];
+    for (const [symbol, format] of tokenList) {
+      this.#config.matches.push(this.#config.token.start.concat(symbol).concat(this.#config.token.regex).concat(this.#config.token.end));
+      this.#config.formats.push(format);
+    }
+    this.#config.regex = new RegExp(this.#config.matches.join('|').concat('|$'), 'g');
+    this.#config.slurpStart = new RegExp([this.#config.slurp.match, this.#config.slurp.start.join('')].join(''), 'gm');
+    this.#config.slurpEnd = new RegExp([this.#config.slurp.end.join(''), this.#config.slurp.match].join(''), 'gm');
+    if (this.#config.globals.length) {
+      if (this.#config.legacy) {
+        this.#config.globalVariables = `const ${this.#config.globals.map(name => `${name}=${this.#config.vars.SCOPE}.${name}`).join(',')};`;
+      } else {
+        this.#config.globalVariables = `const {${this.#config.globals.join(',')}} = ${this.#config.vars.SCOPE};`;
+      }
+    }
+  }
+  compile(content, path) {
+    const GLOBALS = this.#config.globalVariables;
+    const {
+      SCOPE,
+      SAFE,
+      BUFFER,
+      COMPONENT,
+      ELEMENT
+    } = this.#config.vars;
+    if (this.#config.rmWhitespace) {
       content = String(content).replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
     }
-    content = String(content).replace(config.slurpStart, config.token.start).replace(config.slurpEnd, config.token.end);
-    var source = "".concat(BUFFER, "('");
-    matchTokens(config.regex, content, function (params, index, offset) {
-      source += symbols(content.slice(index, offset));
-      params.forEach(function (value, index) {
+    content = String(content).replace(this.#config.slurpStart, this.#config.token.start).replace(this.#config.slurpEnd, this.#config.token.end);
+    let OUTPUT = `${BUFFER}('`;
+    tokensMatch(this.#config.regex, content, (params, index, offset) => {
+      OUTPUT += symbols(content.slice(index, offset));
+      params.forEach((value, index) => {
         if (value) {
-          source += config.formats[index](value);
+          OUTPUT += this.#config.formats[index](value.trim(), BUFFER, SAFE);
         }
       });
     });
-    source += "');";
-    source = "try{".concat(source, "}catch(e){return ").concat(BUFFER, ".error(e)}");
-    if (config.withObject) {
-      source = "with(".concat(SCOPE, "){").concat(source, "}");
+    OUTPUT += `');`;
+    OUTPUT = `try{${OUTPUT}}catch(e){return ${BUFFER}.error(e,'${path}')}`;
+    if (this.#config.strict === false) {
+      OUTPUT = `with(${SCOPE}){${OUTPUT}}`;
+    }
+    OUTPUT = `${BUFFER}.start();${OUTPUT}return ${BUFFER}.end();`;
+    OUTPUT += `\n//# sourceURL=${path}`;
+    if (GLOBALS) {
+      OUTPUT = `${GLOBALS}\n${OUTPUT}`;
     }
-    source = "".concat(BUFFER, ".start();").concat(source, "return ").concat(BUFFER, ".end();");
-    source += "\n//# sourceURL=".concat(path);
-    var result = null;
-    var params = [SCOPE, COMPONENT, ELEMENT, BUFFER, SAFE].concat(GLOBALS);
     try {
-      result = Function.apply(null, params.concat(source));
-      result.source = "(function(".concat(params.join(','), "){\n").concat(source, "\n});");
-    } catch (e) {
-      e.filename = path;
-      e.source = source;
-      throw e;
+      const params = [SCOPE, COMPONENT, ELEMENT, BUFFER, SAFE];
+      const result = Function.apply(null, params.concat(OUTPUT));
+      result.source = `(function(${params.join(',')}){\n${OUTPUT}\n});`;
+      return result;
+    } catch (error) {
+      error.filename = path;
+      error.source = OUTPUT;
+      throw error;
     }
-    return result;
-  };
-  configure(options);
-  return {
-    configure: configure,
-    compile: compile
-  };
-};
+  }
+}
 
-var global = typeof globalThis !== 'undefined' ? globalThis : window || self;
-var Cache = function Cache() {
-  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var config = {};
-  var list = {};
-  var load = function load(data) {
-    if (config.enabled) {
-      extend(list, data || {});
+class Cache {
+  static exports = ['load', 'set', 'get', 'exist', 'clear', 'remove', 'resolve'];
+  #cache = true;
+  #precompiled;
+  #list = {};
+  constructor(options) {
+    bindContext(this, this.constructor.exports);
+    this.configure(options);
+  }
+  get(key) {
+    if (this.#cache) {
+      return this.#list[key];
     }
-  };
-  var get = function get(key) {
-    if (config.enabled) {
-      return list[key];
+  }
+  set(key, value) {
+    if (this.#cache) {
+      this.#list[key] = value;
     }
-  };
-  var set = function set(key, value) {
-    if (config.enabled) {
-      list[key] = value;
+  }
+  exist(key) {
+    if (this.#cache) {
+      return this.#list.hasOwnProperty(key);
     }
-  };
-  var exist = function exist(key) {
-    if (config.enabled) {
-      return hasProp(list, key);
+  }
+  clear() {
+    Object.keys(this.#list).forEach(this.remove);
+  }
+  remove(key) {
+    delete this.#list[key];
+  }
+  resolve(key) {
+    return Promise.resolve(this.get(key));
+  }
+  load(data) {
+    if (this.#cache) {
+      Object.assign(this.#list, data || {});
     }
-  };
-  var clear = function clear() {
-    Object.keys(list).forEach(remove);
-  };
-  var remove = function remove(key) {
-    delete list[key];
-  };
-  var resolve = function resolve(key) {
-    return Promise.resolve(get(key));
-  };
-  var configure = function configure() {
-    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    config.enabled = options.cache;
-    config["export"] = options["export"];
-    if (isNode() === false) {
-      load(global[config["export"]]);
+  }
+  configure(options) {
+    this.#cache = options.cache;
+    this.#precompiled = options.precompiled;
+    if (typeof window === 'object') {
+      this.load(window[this.#precompiled]);
     }
-  };
-  configure(options);
-  return {
-    configure: configure,
-    load: load,
-    set: set,
-    get: get,
-    exist: exist,
-    clear: clear,
-    remove: remove,
-    resolve: resolve
-  };
-};
+  }
+}
 
-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);
+const selfClosed = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
+const space = ' ';
+const quote = '"';
+const equal = '=';
+const slash = '/';
+const lt = '<';
+const gt = '>';
+const eachAttribute = _ref => {
+  let [key, value] = _ref;
+  if (value !== null && value !== undefined) {
+    return [entities(key), [quote, entities(value), quote].join('')].join(equal);
+  }
+};
+const element = (tag, attrs, content) => {
+  const result = [];
+  const hasClosedTag = selfClosed.indexOf(tag) === -1;
+  const attributes = Object.entries(attrs ?? {}).map(eachAttribute).filter(e => e).join(space);
   result.push([lt, tag, space, attributes, gt].join(''));
   if (content && hasClosedTag) {
-    result.push(content instanceof Array ? content.join('') : content);
+    result.push(Array.isArray(content) ? content.join('') : content);
   }
   if (hasClosedTag) {
     result.push([lt, slash, tag, gt].join(''));
@@ -429,237 +362,204 @@ var element = function element(tag, attrs, content) {
   return result.join('');
 };
 
-/**
- *
- * @constructor
- */
-function TemplateError() {
-  TemplateError.call(this);
-}
-Object.setPrototypeOf(TemplateError.prototype, Error.prototype);
-Object.assign(TemplateError.prototype, {
-  code: 0,
-  getCode: function getCode() {
-    return this.code;
-  },
-  getMessage: function getMessage() {
-    return this.message;
-  },
-  toString: function toString() {
-    return this.getMessage();
+class TemplateError extends Error {
+  name = 'TemplateError';
+  constructor(error) {
+    super(error);
+    if (error instanceof Error) {
+      this.stack = error.stack;
+      this.filename = error.filename;
+      this.lineno = error.lineno;
+    }
   }
-});
-
-/**
- *
- * @constructor
- */
-function TemplateNotFound() {
-  TemplateError.call(this);
-}
-Object.setPrototypeOf(TemplateNotFound.prototype, TemplateError.prototype);
-Object.assign(TemplateNotFound.prototype, {
-  code: 404
-});
-
-/**
- *
- * @constructor
- */
-function TemplateSyntaxError() {
-  TemplateError.call(this);
 }
-Object.setPrototypeOf(TemplateSyntaxError.prototype, TemplateError.prototype);
-Object.assign(TemplateSyntaxError.prototype, {
-  code: 500
-});
-
-function resolve(list) {
-  return Promise.all(list || []).then(function (list) {
-    return list.join('');
-  })["catch"](function (e) {
-    return e;
-  });
+class TemplateNotFound extends TemplateError {
+  name = 'TemplateNotFound';
+  code = 404;
 }
-function reject(error) {
-  return Promise.reject(new TemplateSyntaxError(error.message));
+class TemplateSyntaxError extends TemplateError {
+  name = 'TemplateSyntaxError';
+  code = 500;
 }
 
-/**
- *
- * @return {buffer}
- */
-function createBuffer() {
-  var store = [],
-    array = [];
-  var buffer = function buffer(value) {
+const resolve = list => {
+  return Promise.all(list || []).then(list => list.join('')).catch(e => e);
+};
+const reject = error => {
+  return Promise.reject(new TemplateSyntaxError(error));
+};
+const EjsBuffer = () => {
+  let store = [];
+  let array = [];
+  /**
+   *
+   * @param value
+   * @constructor
+   */
+  const EjsBuffer = value => {
     array.push(value);
   };
-  buffer.start = function () {
+  EjsBuffer.start = () => {
     array = [];
   };
-  buffer.backup = function () {
+  EjsBuffer.backup = () => {
     store.push(array.concat());
     array = [];
   };
-  buffer.restore = function () {
-    var result = array.concat();
+  EjsBuffer.restore = () => {
+    const result = array.concat();
     array = store.pop();
     return resolve(result);
   };
-  buffer.error = function (e) {
+  EjsBuffer.error = (e, filename) => {
     return reject(e);
   };
-  buffer.end = function () {
+  EjsBuffer.end = () => {
     return resolve(array);
   };
-  return buffer;
-}
-
-var PARENT = Symbol('ContextScope.parentTemplate');
-var createContextScope = function createContextScope(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,
-    SAFE = _config$vars.SAFE,
-    SCOPE = _config$vars.SCOPE,
-    COMPONENT = _config$vars.COMPONENT,
-    ELEMENT = _config$vars.ELEMENT;
-  /**
-   *
-   * @type {symbol}
-   */
+  return EjsBuffer;
+};
 
-  /**
-   * @name ContextScope
-   * @param data
-   * @constructor
-   */
-  function ContextScope(data) {
+const PARENT = Symbol('EjsContext.parentTemplate');
+const createContext$1 = (config, methods) => {
+  const {
+    BLOCKS,
+    MACRO,
+    EXTEND,
+    LAYOUT,
+    BUFFER,
+    SAFE,
+    SCOPE,
+    COMPONENT,
+    ELEMENT
+  } = config.vars;
+  const globals = config.globals || [];
+  function EjsContext(data) {
     this[PARENT] = null;
     this[BLOCKS] = {};
     this[MACRO] = {};
     Object.assign(this, omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT]));
   }
-  Object.assign(ContextScope.prototype, methods);
-  Object.defineProperty(ContextScope.prototype, BUFFER, {
-    value: createBuffer()
+  Object.entries(methods).forEach(_ref => {
+    let [name, value] = _ref;
+    if (isFunction(value) && globals.includes(name)) {
+      value = value.bind(EjsContext.prototype);
+    }
+    EjsContext.prototype[name] = value;
+  });
+  Object.defineProperty(EjsContext.prototype, BUFFER, {
+    value: EjsBuffer()
   });
-  Object.defineProperty(ContextScope.prototype, BLOCKS, {
+  Object.defineProperty(EjsContext.prototype, BLOCKS, {
     value: {},
     writable: true
   });
-  Object.defineProperty(ContextScope.prototype, MACRO, {
+  Object.defineProperty(EjsContext.prototype, MACRO, {
     value: {},
     writable: true
   });
-  Object.defineProperty(ContextScope.prototype, LAYOUT, {
+  Object.defineProperty(EjsContext.prototype, LAYOUT, {
     value: false,
     writable: true
   });
-  Object.defineProperty(ContextScope.prototype, EXTEND, {
+  Object.defineProperty(EjsContext.prototype, EXTEND, {
     value: false,
     writable: true
   });
-  Object.defineProperty(ContextScope.prototype, PARENT, {
+  Object.defineProperty(EjsContext.prototype, PARENT, {
     value: null,
     writable: true
   });
-  Object.defineProperties(ContextScope.prototype, {
+  Object.defineProperties(EjsContext.prototype, {
     /** @type {function} */
     setParentTemplate: {
-      value: function value(_value) {
-        this[PARENT] = _value;
+      value(value) {
+        this[PARENT] = value;
         return this;
       }
     },
     /** @type {function} */
     getParentTemplate: {
-      value: function value() {
+      value() {
         return this[PARENT];
       }
     },
     /** @type {function} */
     useSafeValue: {
-      get: function get() {
-        return safeValue;
-      }
+      get: () => safeValue
     },
     /** @type {function} */
     useComponent: {
-      get: function get() {
+      get() {
         if (isFunction(this[COMPONENT])) {
           return this[COMPONENT].bind(this);
         } else {
-          return function () {
-            throw new Error("".concat(COMPONENT, " must be a function"));
+          return () => {
+            throw new Error(`${COMPONENT} must be a function`);
           };
         }
       }
     },
     /** @type {function} */
     useElement: {
-      get: function get() {
+      get() {
         if (isFunction(this[ELEMENT])) {
           return this[ELEMENT].bind(this);
         } else {
-          return function () {
-            throw new Error("".concat(ELEMENT, " must be a function"));
+          return () => {
+            throw new Error(`${ELEMENT} must be a function`);
           };
         }
       }
     },
-    /** @type {()=>this[MACRO]} */
-    getMacro: {
-      value: function value() {
-        return this[MACRO];
+    /** @type {function} */
+    useBuffer: {
+      get() {
+        return this[BUFFER];
       }
     },
     /** @type {function} */
-    getBuffer: {
-      value: function value() {
-        return this[BUFFER];
+    getMacro: {
+      value() {
+        return this[MACRO];
       }
     },
     /** @type {function} */
     getBlocks: {
-      value: function value() {
+      value() {
         return this[BLOCKS];
       }
     },
     /** @type {function} */
     setExtend: {
-      value: function value(_value2) {
-        this[EXTEND] = _value2;
+      value(value) {
+        this[EXTEND] = value;
         return this;
       }
     },
     /** @type {function} */
     getExtend: {
-      value: function value() {
+      value() {
         return this[EXTEND];
       }
     },
     /** @type {function} */
     setLayout: {
-      value: function value(layout) {
+      value(layout) {
         this[LAYOUT] = layout;
         return this;
       }
     },
     /** @type {function} */
     getLayout: {
-      value: function value() {
+      value() {
         return this[LAYOUT];
       }
     },
     /** @type {function} */
     clone: {
-      value: function value(exclude_blocks) {
-        var filter = [LAYOUT, EXTEND, BUFFER];
+      value(exclude_blocks) {
+        const filter = [LAYOUT, EXTEND, BUFFER];
         if (exclude_blocks === true) {
           filter.push(BLOCKS);
         }
@@ -668,39 +568,35 @@ var createContextScope = function createContextScope(config, methods) {
     },
     /** @type {function} */
     extend: {
-      value: function value(layout) {
+      value(layout) {
         this.setExtend(true);
         this.setLayout(layout);
       }
     },
     /** @type {function} */
     echo: {
-      value: function value(layout) {
-        var buffer = this.getBuffer();
-        var params = [].slice.call(arguments);
-        params.forEach(buffer);
+      value() {
+        return [].slice.call(arguments).forEach(this.useBuffer);
       }
     },
     /** @type {function} */
     fn: {
-      value: function value(callback) {
-        var buffer = this.getBuffer();
-        var context = this;
-        return function () {
+      value(callback) {
+        return () => {
           if (isFunction(callback)) {
-            buffer.backup();
-            buffer(callback.apply(context, arguments));
-            return buffer.restore();
+            this.useBuffer.backup();
+            this.useBuffer(callback.apply(this, arguments));
+            return this.useBuffer.restore();
           }
         };
       }
     },
     /** @type {function} */
     macro: {
-      value: function value(name, callback) {
-        var list = this.getMacro();
-        var macro = this.fn(callback);
-        var context = this;
+      value(name, callback) {
+        const list = this.getMacro();
+        const macro = this.fn(callback);
+        const context = this;
         list[name] = function () {
           return context.echo(macro.apply(undefined, arguments));
         };
@@ -708,10 +604,10 @@ var createContextScope = function createContextScope(config, methods) {
     },
     /** @type {function} */
     call: {
-      value: function value(name) {
-        var list = this.getMacro();
-        var macro = list[name];
-        var params = [].slice.call(arguments, 1);
+      value(name) {
+        const list = this.getMacro();
+        const macro = list[name];
+        const params = [].slice.call(arguments, 1);
         if (isFunction(macro)) {
           return macro.apply(macro, params);
         }
@@ -719,51 +615,47 @@ var createContextScope = function createContextScope(config, methods) {
     },
     /** @type {function} */
     block: {
-      value: function value(name, callback) {
-        var _this = this;
-        var blocks = this.getBlocks();
+      value(name, callback) {
+        const 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();
+        const list = Object.assign([], blocks[name]);
+        const shift = () => list.shift();
+        const next = () => {
+          const parent = shift();
           if (parent) {
-            return function () {
-              _this.echo(parent(_next()));
+            return () => {
+              this.echo(parent(next()));
             };
           } else {
-            return noop;
+            return () => {};
           }
         };
-        this.echo(current()(_next()));
+        this.echo(shift()(next()));
       }
     },
     /** @type {function} */
     hasBlock: {
-      value: function value(name) {
+      value(name) {
         return this.getBlocks().hasOwnProperty(name);
       }
     },
     /** @type {function} */
     include: {
-      value: function value(path, data, cx) {
-        var context = cx === false ? {} : this.clone(true);
-        var params = extend(context, data || {});
-        var promise = this.render(path, params);
+      value(path, data, cx) {
+        const context = cx === false ? {} : this.clone(true);
+        const params = Object.assign(context, data || {});
+        const promise = this.render(path, params);
         this.echo(promise);
       }
     },
     /** @type {function} */
     use: {
-      value: function value(path, namespace) {
-        var _this2 = this;
-        this.echo(Promise.resolve(this.require(path)).then(function (exports) {
-          var list = _this2.getMacro();
-          each(exports, function (macro, name) {
+      value(path, namespace) {
+        this.echo(Promise.resolve(this.require(path)).then(exports$1 => {
+          const list = this.getMacro();
+          each(exports$1, (macro, name) => {
             list[[namespace, name].join('.')] = macro;
           });
         }));
@@ -771,34 +663,34 @@ var createContextScope = function createContextScope(config, methods) {
     },
     /** @type {function} */
     async: {
-      value: function value(promise, callback) {
+      value(promise, callback) {
         this.echo(Promise.resolve(promise).then(callback));
       }
     },
     /** @type {function} */
     get: {
-      value: function value(name, defaults) {
-        var path = getPath(this, name, true);
-        var result = path.shift();
-        var prop = path.pop();
+      value(name, defaults) {
+        const path = getPath(this, name, true);
+        const result = path.shift();
+        const prop = path.pop();
         return hasProp(result, prop) ? result[prop] : defaults;
       }
     },
     /** @type {function} */
     set: {
-      value: function value(name, _value3) {
-        var path = getPath(this, name, false);
-        var result = path.shift();
-        var prop = path.pop();
+      value(name, value) {
+        const path = getPath(this, name, false);
+        const result = path.shift();
+        const prop = path.pop();
         if (this.getParentTemplate() && hasProp(result, prop)) {
           return result[prop];
         }
-        return result[prop] = _value3;
+        return result[prop] = value;
       }
     },
     /** @type {function} */
     each: {
-      value: function value(object, callback) {
+      value(object, callback) {
         if (isString(object)) {
           object = this.get(object, []);
         }
@@ -808,143 +700,118 @@ var createContextScope = function createContextScope(config, methods) {
     },
     /** @type {function} */
     el: {
-      value: function value(tag, attr, content) {
+      value(tag, attr, content) {
         content = isFunction(content) ? this.fn(content)() : content;
-        this.echo(Promise.resolve(content).then(function (content) {
-          return element(tag, attr, content);
-        }));
+        this.echo(Promise.resolve(content).then(content => element(tag, attr, content)));
       },
       writable: true
     },
     /** @type {function} */
     ui: {
-      value: function value(layout) {},
+      value(layout) {},
       writable: true
     }
   });
-  return ContextScope;
-};
-var Context = function Context(options, methods) {
-  var config = {
-    Scope: null
-  };
-  /**
-   * @return {ContextScope}
-   */
-  var create = function create(data) {
-    return new config.Scope(data);
-  };
-  var helpers = function helpers(methods) {
-    extend(config.Scope.prototype, methods || {});
-  };
-  var configure = function configure(options, methods) {
-    config.Scope = createContextScope(options, methods);
-  };
-  configure(options, methods);
-  return {
-    configure: configure,
-    create: create,
-    helpers: helpers
-  };
-};
+  return EjsContext;
+};
+class Context {
+  #context;
+  static exports = ['create', 'globals', 'helpers'];
+  constructor(options, methods) {
+    bindContext(this, this.constructor.exports);
+    this.configure(options, methods);
+  }
+  create(data) {
+    return new this.#context(data);
+  }
+  helpers(methods) {
+    Object.assign(this.#context.prototype, methods);
+  }
+  configure(options, methods) {
+    this.#context = createContext$1(options, methods);
+  }
+}
 
-var _EJS$1 = function EJS() {
-  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var config = configSchema({}, options);
-  var methods = {};
-  var context = Context(config, methods);
-  var compiler = Compiler(config);
-  var cache = Cache(config);
-  var template = Template(config, cache, compiler);
-  var configure = function configure() {
-    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    configSchema(config, options || {});
-    context.configure(config, methods);
-    compiler.configure(config);
-    cache.configure(config);
-    template.configure(config);
-    return config;
-  };
-  var filePath = function filePath(name) {
-    return ext(name, config.extension);
-  };
-  var require = function require(name) {
-    var scope = createContext({});
-    return output(filePath(name), scope).then(function () {
-      return scope.getMacro();
+class EjsInstance {
+  #cache;
+  #context;
+  #compiler;
+  #template;
+  #config = {};
+  #methods = {};
+  static exports = ['configure', 'create', 'createContext', 'render', 'require', 'preload', 'compile', 'helpers'];
+  constructor() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    bindContext(this, this.constructor.exports);
+    this.#methods = {};
+    this.#config = configSchema({}, options);
+    this.#context = new Context(this.#config, this.#methods);
+    this.#compiler = new Compiler(this.#config);
+    this.#cache = new Cache(this.#config);
+    this.#template = new Template(this.#config, this.#cache, this.#compiler);
+    this.helpers({
+      render: this.render,
+      require: this.require
     });
-  };
-  var render = function render(name, data) {
-    var scope = createContext(data);
-    return output(filePath(name), scope).then(outputContent(name, scope));
-  };
-  var outputContent = function outputContent(name, scope) {
-    return function (content) {
-      if (scope.getExtend()) {
-        scope.setExtend(false);
-        return renderLayout(scope.getLayout(), scope, name);
+  }
+  create(options) {
+    return new this.constructor(options);
+  }
+  configure(options) {
+    if (options) {
+      configSchema(this.#config, options);
+      this.#context.configure(this.#config, this.#methods);
+      this.#compiler.configure(this.#config);
+      this.#cache.configure(this.#config);
+      this.#template.configure(this.#config);
+    }
+    return this.#config;
+  }
+  createContext(data) {
+    return this.#context.create(data);
+  }
+  preload(list) {
+    return this.#cache.load(list || {});
+  }
+  compile(content, path) {
+    return this.#compiler.compile(content, path);
+  }
+  helpers(methods) {
+    this.#context.helpers(Object.assign(this.#methods, methods));
+  }
+  async render(name, params) {
+    const data = this.createContext(params);
+    return this.#output(this.#path(name), data).then(this.#outputContent(name, data));
+  }
+  async require(name) {
+    const data = this.createContext({});
+    return this.#output(this.#path(name), data).then(() => data.getMacro());
+  }
+  #path(name) {
+    const ext = name.split('.').pop();
+    if (ext !== this.#config.extension) {
+      name = [name, this.#config.extension].join('.');
+    }
+    return name;
+  }
+  #output(path, data) {
+    return this.#template.get(path).then(callback => callback.apply(data, [data, data.useComponent, data.useElement, data.useBuffer, data.useSafeValue]));
+  }
+  #renderLayout(name, params, parentTemplate) {
+    const data = this.createContext(params);
+    if (parentTemplate) data.setParentTemplate(parentTemplate);
+    return this.#output(this.#path(name), data).then(this.#outputContent(name, data));
+  }
+  #outputContent(name, data) {
+    return content => {
+      if (data.getExtend()) {
+        data.setExtend(false);
+        return this.#renderLayout(data.getLayout(), data, name);
       }
       return content;
     };
-  };
-  var renderLayout = function renderLayout(name, data, parent) {
-    var scope = createContext(data);
-    if (parent) scope.setParentTemplate(parent);
-    return output(filePath(name), scope).then(outputContent(name, scope));
-  };
-  var helpers = function helpers(extendMethods) {
-    context.helpers(extend(methods, extendMethods));
-  };
-  var createContext = function createContext(data) {
-    return context.create(data);
-  };
-  var compile = function compile(content, path) {
-    return compiler.compile(content, path);
-  };
-  var preload = function preload(list) {
-    return cache.load(list || {});
-  };
-  var create = function create(config) {
-    return _EJS$1(config);
-  };
-  var output = function output(path, scope) {
-    var params = [scope, scope.useComponent, scope.useElement, scope.getBuffer(), scope.useSafeValue];
-    var globals = config.globalHelpers.filter(function (name) {
-      return isFunction(scope[name]);
-    }).map(function (name) {
-      return scope[name].bind(scope);
-    });
-    return template.get(path).then(function (callback) {
-      return callback.apply(scope, params.concat(globals));
-    });
-  };
-  helpers({
-    render: render,
-    require: require
-  });
-  return {
-    configure: configure,
-    create: create,
-    createContext: createContext,
-    render: render,
-    require: require,
-    preload: preload,
-    compile: compile,
-    helpers: helpers
-  };
-};
-
-var readFile = function readFile(path, template) {
-  return new Promise(function (resolve, reject) {
-    fs.readFile(joinPath(path, template), function (error, data) {
-      if (error) {
-        reject(new TemplateError());
-      } else {
-        resolve(data.toString());
-      }
-    });
-  });
-};
+  }
+}
 
 /**
  *
@@ -952,40 +819,45 @@ var readFile = function readFile(path, template) {
  * @param {function(name: string, data?: object):Promise<string>} render
  * @return {function(name:any, options:any, callback: any): Promise<void>}
  */
-var expressRenderer = function expressRenderer(configure, render) {
+const expressRenderer = (configure, render) => {
   return function (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);
+    const settings = Object.assign({}, options.settings);
+    const viewPath = typeProp(isString, ejsDefaults.path, settings['views']);
+    const viewCache = typeProp(isBoolean, ejsDefaults.cache, settings['view cache']);
+    const viewOptions = Object.assign({}, settings['view options']);
+    const filename = path.relative(viewPath, name);
     viewOptions.path = viewPath;
     viewOptions.cache = viewCache;
     configure(viewOptions);
-    return render(filename, options).then(function (content) {
+    return render(filename, options).then(content => {
       callback(null, content);
-    })["catch"](function (error) {
+    }).catch(error => {
       callback(error);
     });
   };
 };
 
-var _EJS = _EJS$1({
-    resolver: readFile
-  }),
-  render = _EJS.render,
-  createContext = _EJS.createContext,
-  compile = _EJS.compile,
-  helpers = _EJS.helpers,
-  preload = _EJS.preload,
-  configure = _EJS.configure,
-  create = _EJS.create;
-var __express = expressRenderer(configure, render);
+const readFile = (path, template) => {
+  return fs.readFile(joinPath(path, template)).then(contents => contents.toString()).then(text => String(text));
+};
+
+const {
+  render,
+  createContext,
+  compile,
+  helpers,
+  preload,
+  configure,
+  create
+} = new EjsInstance({
+  resolver: readFile
+});
+const __express = expressRenderer(configure, render);
 
 exports.TemplateError = TemplateError;
 exports.TemplateNotFound = TemplateNotFound;