@kosatyi/ejs 0.0.107 → 0.0.108

package/dist/umd/browser.js

@@ -1,76 +1,111 @@
 (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 = {}));
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ejsInstance = {}));
 })(this, (function (exports) { 'use strict';
 
-    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();
         }
@@ -85,344 +120,242 @@
       }
       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(''));
@@ -430,237 +363,204 @@
       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);
             }
@@ -669,39 +569,35 @@
         },
         /** @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));
             };
@@ -709,10 +605,10 @@
         },
         /** @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);
             }
@@ -720,51 +616,47 @@
         },
         /** @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;
               });
             }));
@@ -772,34 +664,34 @@
         },
         /** @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, []);
             }
@@ -809,150 +701,139 @@
         },
         /** @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 httpRequest = function httpRequest(path, template) {
-      return fetch(joinPath(path, template)).then(function (response) {
-        return response.text();
-      }, function (reason) {
-        return new TemplateError();
+    const httpRequest = (path, template) => {
+      return fetch(joinPath(path, template)).then(response => {
+        if (response.ok) return response.text();
+        throw new TemplateNotFound(`template ${path} / ${template} not found`);
+      }, reason => {
+        return new TemplateError(reason);
       });
     };
 
-    var _EJS = _EJS$1({
-        resolver: httpRequest
-      }),
-      render = _EJS.render,
-      createContext = _EJS.createContext,
-      compile = _EJS.compile,
-      helpers = _EJS.helpers,
-      preload = _EJS.preload,
-      configure = _EJS.configure,
-      create = _EJS.create;
+    const {
+      render,
+      createContext,
+      compile,
+      helpers,
+      preload,
+      configure,
+      create
+    } = new EjsInstance({
+      resolver: httpRequest
+    });
 
     exports.TemplateError = TemplateError;
     exports.TemplateNotFound = TemplateNotFound;