@kosatyi/ejs 0.0.109 → 0.0.111

package/dist/umd/index.js

@@ -1,877 +1,933 @@
 (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.ejsInstance = {}));
+  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.ejsInstance = {}));
 })(this, (function (exports) { 'use strict';
 
-    /**
-     * @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 path = {};
 
-    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();
-    };
-    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;
+  function _assertClassBrand(e, t, n) {
+    if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+    throw new TypeError("Private element is not present on this object");
+  }
+  function _checkPrivateRedeclaration(e, t) {
+    if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+  function _classPrivateFieldGet2(s, a) {
+    return s.get(_assertClassBrand(s, a));
+  }
+  function _classPrivateFieldInitSpec(e, t, a) {
+    _checkPrivateRedeclaration(e, t), t.set(e, a);
+  }
+  function _classPrivateFieldSet2(s, a, r) {
+    return s.set(_assertClassBrand(s, a), r), r;
+  }
+  function _classPrivateMethodInitSpec(e, a) {
+    _checkPrivateRedeclaration(e, a), a.add(e);
+  }
+  function _defineProperty(e, r, t) {
+    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }) : e[r] = t, e;
+  }
+  function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function (r) {
+        return Object.getOwnPropertyDescriptor(e, r).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  function _objectSpread2(e) {
+    for (var r = 1; r < arguments.length; r++) {
+      var t = null != arguments[r] ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
+        _defineProperty(e, r, t[r]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+        Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
       });
-    };
+    }
+    return e;
+  }
+  function _toPrimitive(t, r) {
+    if ("object" != typeof t || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r);
+      if ("object" != typeof i) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
+  }
+  function _toPropertyKey(t) {
+    var i = _toPrimitive(t, "string");
+    return "symbol" == typeof i ? i : i + "";
+  }
 
-    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)
-      });
-    };
+  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();
+  };
+  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 '".concat(name, "' to be valid variable name --> skipped"));
+      return valid;
+    });
+  };
 
-    const symbolEntities = {
-      "'": "'",
-      '\\': '\\',
-      '\r': 'r',
-      '\n': 'n',
-      '\t': 't',
-      '\u2028': 'u2028',
-      '\u2029': 'u2029'
-    };
-    const htmlEntities = {
-      '&': '&amp;',
-      '<': '&lt;',
-      '>': '&gt;',
-      '"': '&quot;',
-      "'": '&#x27;'
-    };
-    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]);
-    };
-    const symbols = string => {
-      return ('' + string).replace(symbolEntitiesMatch, match => '\\' + symbolEntities[match]);
-    };
-    const safeValue = (value, escape) => {
-      const check = value;
-      return check == null ? '' : Boolean(escape) === true ? entities(check) : check;
-    };
-    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();
-        }
-        if (strict && data.hasOwnProperty(part) === false) {
-          data = {};
-          break;
-        }
-        data = data[part] = data[part] || {};
-      }
+  const symbolEntities = {
+    "'": "'",
+    '\\': '\\',
+    '\r': 'r',
+    '\n': 'n',
+    '\t': 't',
+    '\u2028': 'u2028',
+    '\u2029': 'u2029'
+  };
+  const htmlEntities = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#x27;'
+  };
+  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]);
+  };
+  const symbols = string => {
+    return ('' + string).replace(symbolEntitiesMatch, match => '\\' + symbolEntities[match]);
+  };
+  const escapeValue = (value, escape) => {
+    const check = value;
+    return check == null ? '' : Boolean(escape) === true ? entities(check) : check;
+  };
+  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();
       }
-      return [data, prop];
-    };
-    const each = (object, callback) => {
-      let prop;
-      for (prop in object) {
-        if (hasProp(object, prop)) {
-          callback(object[prop], prop, object);
-        }
+      if (strict && data.hasOwnProperty(part) === false) {
+        data = {};
+        break;
       }
-    };
-    const omit = (object, list) => {
-      const result = {
-        ...object
-      };
-      for (const key of list) {
-        delete result[key];
+      data = data[part] = data[part] || {};
+    }
+    if (isFunction(data['toJSON'])) {
+      data = data.toJSON();
+    }
+    return [data, prop];
+  };
+  const each = (object, callback) => {
+    let prop;
+    for (prop in object) {
+      if (hasProp(object, prop)) {
+        callback(object[prop], prop, object);
       }
-      return result;
-    };
-    const hasProp = (object, prop) => {
-      return object && Object.hasOwn(object, prop);
-    };
-    const joinPath = (path, template) => {
-      template = [path, template].join('/');
-      template = template.replace(/\/\//g, '/');
-      return template;
-    };
-    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);
-        }
+    }
+  };
+  const omit = (object, list) => {
+    const result = _objectSpread2({}, object);
+    for (const key of list) {
+      delete result[key];
+    }
+    return result;
+  };
+  const hasProp = (object, prop) => {
+    return object && Object.hasOwn(object, prop);
+  };
+  const joinPath = (path, template) => {
+    template = [path, template].join('/');
+    template = template.replace(/\/\//g, '/');
+    return template;
+  };
+  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);
       }
-    };
+    }
+  };
 
-    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;
-        }
-      }
-      #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);
-        }
-        if (typeof content === 'function') {
-          this.#cache.set(template, content);
-          return content;
-        }
-      }
-      get(template) {
-        return this.#resolve(template).then(content => this.compile(content, template));
+  /**
+   * @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]+?)'
+    }
+  };
+
+  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)
+    });
+  };
+
+  class EjsError extends Error {
+    constructor(code, content) {
+      super(content);
+      this.code = code;
+      if (content instanceof Error) {
+        this.stack = content.stack;
+        this.message = content.message;
       }
     }
+  }
+  const error = (code, content) => {
+    throw new EjsError(code, content);
+  };
 
-    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);
+  var _path$1 = /*#__PURE__*/new WeakMap();
+  var _resolver = /*#__PURE__*/new WeakMap();
+  var _cache$2 = /*#__PURE__*/new WeakMap();
+  var _compiler$1 = /*#__PURE__*/new WeakMap();
+  var _EjsTemplate_brand = /*#__PURE__*/new WeakSet();
+  class EjsTemplate {
+    constructor(options, cache, compiler) {
+      _classPrivateMethodInitSpec(this, _EjsTemplate_brand);
+      _classPrivateFieldInitSpec(this, _path$1, void 0);
+      _classPrivateFieldInitSpec(this, _resolver, void 0);
+      _classPrivateFieldInitSpec(this, _cache$2, void 0);
+      _classPrivateFieldInitSpec(this, _compiler$1, void 0);
+      bindContext(this, this.constructor.exports);
+      _classPrivateFieldSet2(_cache$2, this, cache);
+      _classPrivateFieldSet2(_compiler$1, this, compiler);
+      this.configure(options !== null && options !== void 0 ? options : {});
+    }
+    configure(options) {
+      _classPrivateFieldSet2(_path$1, this, options.path);
+      if (isFunction(options.resolver)) {
+        _classPrivateFieldSet2(_resolver, this, options.resolver);
       }
-      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: [this.#config.token.start, '_'],
-          end: ['_', this.#config.token.end]
-        };
-        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};`;
-          }
+    }
+    get(template) {
+      return _assertClassBrand(_EjsTemplate_brand, this, _resolve).call(this, template).then(content => {
+        return _assertClassBrand(_EjsTemplate_brand, this, _compile).call(this, content, template);
+      });
+    }
+  }
+  function _resolve(template) {
+    const cached = _classPrivateFieldGet2(_cache$2, this).get(template);
+    if (cached instanceof Promise) return cached;
+    const result = Promise.resolve(_classPrivateFieldGet2(_resolver, this).call(this, _classPrivateFieldGet2(_path$1, this), template, error));
+    _classPrivateFieldGet2(_cache$2, this).set(template, result);
+    return result;
+  }
+  function _compile(content, template) {
+    const cached = _classPrivateFieldGet2(_cache$2, this).get(template);
+    if (typeof cached === 'function') return cached;
+    if (typeof content === 'string') {
+      content = _classPrivateFieldGet2(_compiler$1, this).compile(content, template);
+    }
+    if (typeof content === 'function') {
+      _classPrivateFieldGet2(_cache$2, this).set(template, content);
+      return content;
+    }
+  }
+  _defineProperty(EjsTemplate, "exports", ['configure', 'get']);
+
+  const tokenList = [['-', (v, b, s) => "')\n".concat(b, "(").concat(s, "(").concat(v, ",1))\n").concat(b, "('")], ['=', (v, b, s) => "')\n".concat(b, "(").concat(s, "(").concat(v, "))\n").concat(b, "('")], ['#', (v, b) => "')\n/**".concat(v, "**/\n").concat(b, "('")], ['', (v, b) => "')\n".concat(v, "\n").concat(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;
+    });
+  };
+  var _config$1 = /*#__PURE__*/new WeakMap();
+  class EjsCompiler {
+    constructor(options) {
+      _classPrivateFieldInitSpec(this, _config$1, {});
+      bindContext(this, this.constructor.exports);
+      this.configure(options);
+    }
+    configure(options) {
+      var _options$legacy;
+      _classPrivateFieldGet2(_config$1, this).strict = options.strict;
+      _classPrivateFieldGet2(_config$1, this).rmWhitespace = options.rmWhitespace;
+      _classPrivateFieldGet2(_config$1, this).token = options.token;
+      _classPrivateFieldGet2(_config$1, this).vars = options.vars;
+      _classPrivateFieldGet2(_config$1, this).globals = options.globals;
+      _classPrivateFieldGet2(_config$1, this).legacy = (_options$legacy = options.legacy) !== null && _options$legacy !== void 0 ? _options$legacy : true;
+      _classPrivateFieldGet2(_config$1, this).slurp = {
+        match: '[s\t\n]*',
+        start: [_classPrivateFieldGet2(_config$1, this).token.start, '_'],
+        end: ['_', _classPrivateFieldGet2(_config$1, this).token.end]
+      };
+      _classPrivateFieldGet2(_config$1, this).matches = [];
+      _classPrivateFieldGet2(_config$1, this).formats = [];
+      for (const [symbol, format] of tokenList) {
+        _classPrivateFieldGet2(_config$1, this).matches.push(_classPrivateFieldGet2(_config$1, this).token.start.concat(symbol).concat(_classPrivateFieldGet2(_config$1, this).token.regex).concat(_classPrivateFieldGet2(_config$1, this).token.end));
+        _classPrivateFieldGet2(_config$1, this).formats.push(format);
+      }
+      _classPrivateFieldGet2(_config$1, this).regex = new RegExp(_classPrivateFieldGet2(_config$1, this).matches.join('|').concat('|$'), 'g');
+      _classPrivateFieldGet2(_config$1, this).slurpStart = new RegExp([_classPrivateFieldGet2(_config$1, this).slurp.match, _classPrivateFieldGet2(_config$1, this).slurp.start.join('')].join(''), 'gm');
+      _classPrivateFieldGet2(_config$1, this).slurpEnd = new RegExp([_classPrivateFieldGet2(_config$1, this).slurp.end.join(''), _classPrivateFieldGet2(_config$1, this).slurp.match].join(''), 'gm');
+      if (_classPrivateFieldGet2(_config$1, this).globals.length) {
+        if (_classPrivateFieldGet2(_config$1, this).legacy) {
+          _classPrivateFieldGet2(_config$1, this).globalVariables = "const ".concat(_classPrivateFieldGet2(_config$1, this).globals.map(name => "".concat(name, "=").concat(_classPrivateFieldGet2(_config$1, this).vars.SCOPE, ".").concat(name)).join(','), ";");
+        } else {
+          _classPrivateFieldGet2(_config$1, this).globalVariables = "const {".concat(_classPrivateFieldGet2(_config$1, this).globals.join(','), "} = ").concat(_classPrivateFieldGet2(_config$1, this).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(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) {
-              OUTPUT += this.#config.formats[index](value.trim(), BUFFER, SAFE);
-            }
-          });
+    }
+    compile(content, path) {
+      const GLOBALS = _classPrivateFieldGet2(_config$1, this).globalVariables;
+      const {
+        SCOPE,
+        SAFE,
+        BUFFER,
+        COMPONENT,
+        ELEMENT
+      } = _classPrivateFieldGet2(_config$1, this).vars;
+      if (_classPrivateFieldGet2(_config$1, this).rmWhitespace) {
+        content = String(content).replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
+      }
+      content = String(content).replace(_classPrivateFieldGet2(_config$1, this).slurpStart, _classPrivateFieldGet2(_config$1, this).token.start).replace(_classPrivateFieldGet2(_config$1, this).slurpEnd, _classPrivateFieldGet2(_config$1, this).token.end);
+      let OUTPUT = "".concat(BUFFER, "('");
+      tokensMatch(_classPrivateFieldGet2(_config$1, this).regex, content, (params, index, offset) => {
+        OUTPUT += symbols(content.slice(index, offset));
+        params.forEach((value, index) => {
+          if (value) {
+            OUTPUT += _classPrivateFieldGet2(_config$1, this).formats[index](value.trim(), BUFFER, SAFE);
+          }
         });
-        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}`;
-        }
-        try {
-          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;
-        }
+      });
+      OUTPUT += "');";
+      OUTPUT = "try{".concat(OUTPUT, "}catch(e){return ").concat(BUFFER, ".error(e)}");
+      if (_classPrivateFieldGet2(_config$1, this).strict === false) {
+        OUTPUT = "with(".concat(SCOPE, "){").concat(OUTPUT, "}");
+      }
+      OUTPUT = "".concat(BUFFER, ".start();").concat(OUTPUT, "return ").concat(BUFFER, ".end();");
+      OUTPUT += "\n//# sourceURL=".concat(path);
+      if (GLOBALS) {
+        OUTPUT = "".concat(GLOBALS, "\n").concat(OUTPUT);
+      }
+      try {
+        const params = [SCOPE, COMPONENT, ELEMENT, BUFFER, SAFE];
+        const result = Function.apply(null, params.concat(OUTPUT));
+        result.source = "(function(".concat(params.join(','), "){\n").concat(OUTPUT, "\n});");
+        return result;
+      } catch (e) {
+        e.filename = path;
+        e.source = OUTPUT;
+        error(0, e);
       }
     }
+  }
+  _defineProperty(EjsCompiler, "exports", ['configure', 'compile']);
 
-    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];
-        }
-      }
-      set(key, value) {
-        if (this.#cache) {
-          this.#list[key] = value;
-        }
-      }
-      exist(key) {
-        if (this.#cache) {
-          return this.#list.hasOwnProperty(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 _cache$1 = /*#__PURE__*/new WeakMap();
+  var _precompiled = /*#__PURE__*/new WeakMap();
+  var _list = /*#__PURE__*/new WeakMap();
+  class EjsCache {
+    constructor(options) {
+      _classPrivateFieldInitSpec(this, _cache$1, true);
+      _classPrivateFieldInitSpec(this, _precompiled, void 0);
+      _classPrivateFieldInitSpec(this, _list, {});
+      bindContext(this, this.constructor.exports);
+      this.configure(options);
+    }
+    get(key) {
+      if (_classPrivateFieldGet2(_cache$1, this)) {
+        return _classPrivateFieldGet2(_list, this)[key];
       }
-      configure(options) {
-        this.#cache = options.cache;
-        this.#precompiled = options.precompiled;
-        if (typeof window === 'object') {
-          this.load(window[this.#precompiled]);
-        }
+    }
+    set(key, value) {
+      if (_classPrivateFieldGet2(_cache$1, this)) {
+        _classPrivateFieldGet2(_list, this)[key] = value;
       }
     }
-
-    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);
+    exist(key) {
+      if (_classPrivateFieldGet2(_cache$1, this)) {
+        return _classPrivateFieldGet2(_list, this).hasOwnProperty(key);
       }
-    };
-    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(Array.isArray(content) ? content.join('') : content);
+    }
+    clear() {
+      Object.keys(_classPrivateFieldGet2(_list, this)).forEach(this.remove);
+    }
+    remove(key) {
+      delete _classPrivateFieldGet2(_list, this)[key];
+    }
+    resolve(key) {
+      return Promise.resolve(this.get(key));
+    }
+    load(data) {
+      if (_classPrivateFieldGet2(_cache$1, this)) {
+        Object.assign(_classPrivateFieldGet2(_list, this), data || {});
       }
-      if (hasClosedTag) {
-        result.push([lt, slash, tag, gt].join(''));
+    }
+    configure(options) {
+      _classPrivateFieldSet2(_cache$1, this, options.cache);
+      _classPrivateFieldSet2(_precompiled, this, options.precompiled);
+      if (typeof window === 'object') {
+        this.load(window[_classPrivateFieldGet2(_precompiled, this)]);
       }
-      return result.join('');
-    };
+    }
+  }
+  _defineProperty(EjsCache, "exports", ['load', 'set', 'get', 'exist', 'clear', 'remove', 'resolve']);
 
-    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;
-        }
-      }
+  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);
     }
-    class TemplateNotFound extends TemplateError {
-      name = 'TemplateNotFound';
-      code = 404;
+  };
+  const element = (tag, attrs, content) => {
+    const result = [];
+    const hasClosedTag = selfClosed.indexOf(tag) === -1;
+    const attributes = Object.entries(attrs !== null && attrs !== void 0 ? attrs : {}).map(eachAttribute).filter(e => e).join(space);
+    result.push([lt, tag, space, attributes, gt].join(''));
+    if (content && hasClosedTag) {
+      result.push(Array.isArray(content) ? content.join('') : content);
     }
-    class TemplateSyntaxError extends TemplateError {
-      name = 'TemplateSyntaxError';
-      code = 500;
+    if (hasClosedTag) {
+      result.push([lt, slash, tag, gt].join(''));
     }
+    return result.join('');
+  };
 
-    const resolve = list => {
-      return Promise.all(list || []).then(list => list.join('')).catch(e => e);
+  const resolve = list => {
+    return Promise.all(list || []).then(list => list.join('')).catch(e => error(0, e));
+  };
+  const reject = e => {
+    return Promise.reject(error(0, e));
+  };
+  const EjsBuffer = () => {
+    let store = [];
+    let array = [];
+    /**
+     *
+     * @param value
+     * @constructor
+     */
+    const EjsBuffer = value => {
+      array.push(value);
     };
-    const reject = error => {
-      return Promise.reject(new TemplateSyntaxError(error));
+    EjsBuffer.start = () => {
+      array = [];
     };
-    const EjsBuffer = () => {
-      let store = [];
-      let array = [];
-      /**
-       *
-       * @param value
-       * @constructor
-       */
-      const EjsBuffer = value => {
-        array.push(value);
-      };
-      EjsBuffer.start = () => {
-        array = [];
-      };
-      EjsBuffer.backup = () => {
-        store.push(array.concat());
-        array = [];
-      };
-      EjsBuffer.restore = () => {
-        const result = array.concat();
-        array = store.pop();
-        return resolve(result);
-      };
-      EjsBuffer.error = (e, filename) => {
-        return reject(e);
-      };
-      EjsBuffer.end = () => {
-        return resolve(array);
-      };
-      return EjsBuffer;
+    EjsBuffer.backup = () => {
+      store.push(array.concat());
+      array = [];
+    };
+    EjsBuffer.restore = () => {
+      const result = array.concat();
+      array = store.pop();
+      return resolve(result);
     };
+    EjsBuffer.error = e => {
+      return reject(e);
+    };
+    EjsBuffer.end = () => {
+      return resolve(array);
+    };
+    return EjsBuffer;
+  };
 
-    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) {
+  const PARENT = Symbol('EjsContext.parentTemplate');
+  const createContext$1 = (config, methods) => {
+    const globals = config.globals || [];
+    const {
+      BLOCKS,
+      MACRO,
+      EXTEND,
+      LAYOUT,
+      BUFFER,
+      SAFE,
+      SCOPE,
+      COMPONENT,
+      ELEMENT
+    } = config.vars;
+    class Context {
+      constructor(data) {
         this[PARENT] = null;
         this[BLOCKS] = {};
         this[MACRO] = {};
         Object.assign(this, omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT]));
       }
-      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, {
+    }
+    Object.defineProperties(Context.prototype, {
+      [BUFFER]: {
         value: EjsBuffer()
-      });
-      Object.defineProperty(EjsContext.prototype, BLOCKS, {
+      },
+      [BLOCKS]: {
         value: {},
         writable: true
-      });
-      Object.defineProperty(EjsContext.prototype, MACRO, {
+      },
+      [MACRO]: {
         value: {},
         writable: true
-      });
-      Object.defineProperty(EjsContext.prototype, LAYOUT, {
+      },
+      [LAYOUT]: {
         value: false,
         writable: true
-      });
-      Object.defineProperty(EjsContext.prototype, EXTEND, {
+      },
+      [EXTEND]: {
         value: false,
         writable: true
-      });
-      Object.defineProperty(EjsContext.prototype, PARENT, {
+      },
+      [PARENT]: {
         value: null,
         writable: true
-      });
-      Object.defineProperties(EjsContext.prototype, {
-        /** @type {function} */
-        setParentTemplate: {
-          value(value) {
-            this[PARENT] = value;
-            return this;
-          }
-        },
-        /** @type {function} */
-        getParentTemplate: {
-          value() {
-            return this[PARENT];
-          }
-        },
-        /** @type {function} */
-        useSafeValue: {
-          get: () => safeValue
-        },
-        /** @type {function} */
-        useComponent: {
-          get() {
-            if (isFunction(this[COMPONENT])) {
-              return this[COMPONENT].bind(this);
-            } else {
-              return () => {
-                throw new Error(`${COMPONENT} must be a function`);
-              };
-            }
-          }
-        },
-        /** @type {function} */
-        useElement: {
-          get() {
-            if (isFunction(this[ELEMENT])) {
-              return this[ELEMENT].bind(this);
-            } else {
-              return () => {
-                throw new Error(`${ELEMENT} must be a function`);
-              };
-            }
-          }
-        },
-        /** @type {function} */
-        useBuffer: {
-          get() {
-            return this[BUFFER];
-          }
-        },
-        /** @type {function} */
-        getMacro: {
-          value() {
-            return this[MACRO];
-          }
-        },
-        /** @type {function} */
-        getBlocks: {
-          value() {
-            return this[BLOCKS];
-          }
-        },
-        /** @type {function} */
-        setExtend: {
-          value(value) {
-            this[EXTEND] = value;
-            return this;
-          }
-        },
-        /** @type {function} */
-        getExtend: {
-          value() {
-            return this[EXTEND];
-          }
-        },
-        /** @type {function} */
-        setLayout: {
-          value(layout) {
-            this[LAYOUT] = layout;
-            return this;
-          }
-        },
-        /** @type {function} */
-        getLayout: {
-          value() {
-            return this[LAYOUT];
-          }
-        },
-        /** @type {function} */
-        clone: {
-          value(exclude_blocks) {
-            const filter = [LAYOUT, EXTEND, BUFFER];
-            if (exclude_blocks === true) {
-              filter.push(BLOCKS);
-            }
-            return omit(this, filter);
-          }
-        },
-        /** @type {function} */
-        extend: {
-          value(layout) {
-            this.setExtend(true);
-            this.setLayout(layout);
-          }
-        },
-        /** @type {function} */
-        echo: {
-          value() {
-            return [].slice.call(arguments).forEach(this.useBuffer);
+      },
+      setParentTemplate: {
+        value(value) {
+          this[PARENT] = value;
+          return this;
+        }
+      },
+      getParentTemplate: {
+        value() {
+          return this[PARENT];
+        }
+      },
+      useEscapeValue: {
+        value() {
+          return escapeValue;
+        }
+      },
+      useComponent: {
+        value() {
+          if (isFunction(this[COMPONENT])) {
+            return this[COMPONENT].bind(this);
+          } else {
+            return function () {
+              error(2, "".concat(COMPONENT, " must be a function"));
+            };
           }
-        },
-        /** @type {function} */
-        fn: {
-          value(callback) {
+        }
+      },
+      useElement: {
+        value() {
+          if (isFunction(this[ELEMENT])) {
+            return this[ELEMENT].bind(this);
+          } else {
             return () => {
-              if (isFunction(callback)) {
-                this.useBuffer.backup();
-                this.useBuffer(callback.apply(this, arguments));
-                return this.useBuffer.restore();
-              }
+              error(2, "".concat(ELEMENT, " must be a function"));
             };
           }
-        },
-        /** @type {function} */
-        macro: {
-          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));
-            };
+        }
+      },
+      useBuffer: {
+        value() {
+          return this[BUFFER];
+        }
+      },
+      getMacro: {
+        value() {
+          return this[MACRO];
+        }
+      },
+      getBlocks: {
+        value() {
+          return this[BLOCKS];
+        }
+      },
+      setExtend: {
+        value(value) {
+          this[EXTEND] = value;
+          return this;
+        }
+      },
+      getExtend: {
+        value() {
+          return this[EXTEND];
+        }
+      },
+      setLayout: {
+        value(layout) {
+          this[LAYOUT] = layout;
+          return this;
+        }
+      },
+      getLayout: {
+        value() {
+          return this[LAYOUT];
+        }
+      },
+      clone: {
+        value(exclude_blocks) {
+          const filter = [LAYOUT, EXTEND, BUFFER];
+          if (exclude_blocks === true) {
+            filter.push(BLOCKS);
           }
-        },
-        /** @type {function} */
-        call: {
-          value(name) {
-            const list = this.getMacro();
-            const macro = list[name];
-            const params = [].slice.call(arguments, 1);
-            if (isFunction(macro)) {
-              return macro.apply(macro, params);
+          return omit(this, filter);
+        }
+      },
+      extend: {
+        value(layout) {
+          this.setExtend(true);
+          this.setLayout(layout);
+        }
+      },
+      echo: {
+        value() {
+          return [].slice.call(arguments).forEach(this.useBuffer());
+        }
+      },
+      fn: {
+        value(callback) {
+          const buffer = this.useBuffer();
+          const context = this;
+          return function () {
+            if (isFunction(callback)) {
+              buffer.backup();
+              buffer(callback.apply(context, arguments));
+              return buffer.restore();
             }
+          };
+        }
+      },
+      macro: {
+        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));
+          };
+        }
+      },
+      call: {
+        value(name) {
+          const list = this.getMacro();
+          const macro = list[name];
+          const params = [].slice.call(arguments, 1);
+          if (isFunction(macro)) {
+            return macro.apply(macro, params);
           }
-        },
-        /** @type {function} */
-        block: {
-          value(name, callback) {
-            const blocks = this.getBlocks();
-            blocks[name] = blocks[name] || [];
-            blocks[name].push(this.fn(callback));
-            if (this.getExtend()) return;
-            const list = Object.assign([], blocks[name]);
-            const shift = () => list.shift();
-            const next = () => {
-              const parent = shift();
-              if (parent) {
-                return () => {
-                  this.echo(parent(next()));
-                };
-              } else {
-                return () => {};
-              }
-            };
-            this.echo(shift()(next()));
-          }
-        },
-        /** @type {function} */
-        hasBlock: {
-          value(name) {
-            return this.getBlocks().hasOwnProperty(name);
-          }
-        },
-        /** @type {function} */
-        include: {
-          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(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;
-              });
-            }));
-          }
-        },
-        /** @type {function} */
-        async: {
-          value(promise, callback) {
-            this.echo(Promise.resolve(promise).then(callback));
-          }
-        },
-        /** @type {function} */
-        get: {
-          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(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];
+        }
+      },
+      block: {
+        value(name, callback) {
+          const blocks = this.getBlocks();
+          blocks[name] = blocks[name] || [];
+          blocks[name].push(this.fn(callback));
+          if (this.getExtend()) return;
+          const context = this;
+          const list = Object.assign([], blocks[name]);
+          const shift = function () {
+            return list.shift();
+          };
+          const next = function () {
+            const parent = shift();
+            if (parent) {
+              return function () {
+                context.echo(parent(next()));
+              };
+            } else {
+              return function () {};
             }
-            return result[prop] = value;
+          };
+          this.echo(shift()(next()));
+        }
+      },
+      hasBlock: {
+        value(name) {
+          return this.getBlocks().hasOwnProperty(name);
+        }
+      },
+      include: {
+        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);
+        }
+      },
+      use: {
+        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;
+            });
+          }));
+        }
+      },
+      get: {
+        value(name, defaults) {
+          const path = getPath(this, name, true);
+          const result = path.shift();
+          const prop = path.pop();
+          return hasProp(result, prop) ? result[prop] : defaults;
+        }
+      },
+      set: {
+        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] = value;
+        }
+      },
+      each: {
+        value(object, callback) {
+          if (isString(object)) {
+            object = this.get(object, []);
+          }
+          each(object, callback);
         },
-        /** @type {function} */
-        each: {
-          value(object, callback) {
-            if (isString(object)) {
-              object = this.get(object, []);
-            }
-            each(object, callback);
-          },
-          writable: true
-        },
-        /** @type {function} */
-        el: {
-          value(tag, attr, content) {
-            content = isFunction(content) ? this.fn(content)() : content;
-            this.echo(Promise.resolve(content).then(content => element(tag, attr, content)));
-          },
-          writable: true
+        writable: true
+      },
+      el: {
+        value(tag, attr, content) {
+          content = isFunction(content) ? this.fn(content)() : content;
+          this.echo(Promise.resolve(content).then(content => element(tag, attr, content)));
         },
-        /** @type {function} */
-        ui: {
-          value(layout) {},
-          writable: true
-        }
-      });
-      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);
+        writable: true
+      },
+      ui: {
+        value() {},
+        writable: true
+      },
+      require: {
+        value() {},
+        writable: true
+      },
+      render: {
+        value() {},
+        writable: true
       }
-      configure(options, methods) {
-        this.#context = createContext$1(options, methods);
+    });
+    Object.entries(methods).forEach(_ref => {
+      let [name, value] = _ref;
+      if (isFunction(value) && globals.includes(name)) {
+        value = value.bind(Context.prototype);
       }
+      Context.prototype[name] = value;
+    });
+    return Context;
+  };
+  var _context$1 = /*#__PURE__*/new WeakMap();
+  class EjsContext {
+    constructor(options, methods) {
+      _classPrivateFieldInitSpec(this, _context$1, void 0);
+      bindContext(this, this.constructor.exports);
+      this.configure(options, methods);
     }
-
-    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
-        });
-      }
-      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;
-        };
-      }
+    create(data) {
+      return new (_classPrivateFieldGet2(_context$1, this))(data);
     }
+    helpers(methods) {
+      Object.assign(_classPrivateFieldGet2(_context$1, this).prototype, methods);
+    }
+    configure(options, methods) {
+      _classPrivateFieldSet2(_context$1, this, createContext$1(options, methods));
+    }
+  }
+  _defineProperty(EjsContext, "exports", ['create', 'globals', 'helpers']);
 
-    var fs = {};
-
+  var _cache = /*#__PURE__*/new WeakMap();
+  var _context = /*#__PURE__*/new WeakMap();
+  var _compiler = /*#__PURE__*/new WeakMap();
+  var _template = /*#__PURE__*/new WeakMap();
+  var _config = /*#__PURE__*/new WeakMap();
+  var _methods = /*#__PURE__*/new WeakMap();
+  var _EjsInstance_brand = /*#__PURE__*/new WeakSet();
+  class EjsInstance {
     /**
      *
-     * @param {function(config: object):object} configure
-     * @param {function(name: string, data?: object):Promise<string>} render
-     * @return {function(name:any, options:any, callback: any): Promise<void>}
+     * @param {EjsConfig} options
      */
-    const expressRenderer = (configure, render) => {
-      return function (name, options, callback) {
-        if (isFunction(options)) {
-          callback = options;
-          options = {};
-        }
-        options = options || {};
-        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 = fs.relative(viewPath, name);
-        viewOptions.path = viewPath;
-        viewOptions.cache = viewCache;
-        configure(viewOptions);
-        return render(filename, options).then(content => {
-          callback(null, content);
-        }).catch(error => {
-          callback(error);
-        });
-      };
-    };
-
-    const readFile = (path, template) => {
-      return fs.readFile(joinPath(path, template)).then(contents => contents.toString()).then(text => String(text));
+    constructor() {
+      let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      _classPrivateMethodInitSpec(this, _EjsInstance_brand);
+      _classPrivateFieldInitSpec(this, _cache, void 0);
+      _classPrivateFieldInitSpec(this, _context, void 0);
+      _classPrivateFieldInitSpec(this, _compiler, void 0);
+      _classPrivateFieldInitSpec(this, _template, void 0);
+      _classPrivateFieldInitSpec(this, _config, {});
+      _classPrivateFieldInitSpec(this, _methods, {});
+      bindContext(this, this.constructor.exports);
+      _classPrivateFieldSet2(_methods, this, {});
+      _classPrivateFieldSet2(_config, this, configSchema({}, options));
+      _classPrivateFieldSet2(_context, this, new EjsContext(_classPrivateFieldGet2(_config, this), _classPrivateFieldGet2(_methods, this)));
+      _classPrivateFieldSet2(_compiler, this, new EjsCompiler(_classPrivateFieldGet2(_config, this)));
+      _classPrivateFieldSet2(_cache, this, new EjsCache(_classPrivateFieldGet2(_config, this)));
+      _classPrivateFieldSet2(_template, this, new EjsTemplate(_classPrivateFieldGet2(_config, this), _classPrivateFieldGet2(_cache, this), _classPrivateFieldGet2(_compiler, this)));
+      this.helpers({
+        render: this.render,
+        require: this.require
+      });
+    }
+    create(options) {
+      return new this.constructor(options);
+    }
+    configure(options) {
+      if (options) {
+        configSchema(_classPrivateFieldGet2(_config, this), options);
+        _classPrivateFieldGet2(_context, this).configure(_classPrivateFieldGet2(_config, this), _classPrivateFieldGet2(_methods, this));
+        _classPrivateFieldGet2(_compiler, this).configure(_classPrivateFieldGet2(_config, this));
+        _classPrivateFieldGet2(_cache, this).configure(_classPrivateFieldGet2(_config, this));
+        _classPrivateFieldGet2(_template, this).configure(_classPrivateFieldGet2(_config, this));
+      }
+      return _classPrivateFieldGet2(_config, this);
+    }
+    createContext(data) {
+      return _classPrivateFieldGet2(_context, this).create(data);
+    }
+    preload(list) {
+      return _classPrivateFieldGet2(_cache, this).load(list || {});
+    }
+    compile(content, path) {
+      return _classPrivateFieldGet2(_compiler, this).compile(content, path);
+    }
+    helpers(methods) {
+      _classPrivateFieldGet2(_context, this).helpers(Object.assign(_classPrivateFieldGet2(_methods, this), methods));
+    }
+    async render(name, params) {
+      const data = this.createContext(params);
+      return _assertClassBrand(_EjsInstance_brand, this, _output).call(this, _assertClassBrand(_EjsInstance_brand, this, _path).call(this, name), data).then(_assertClassBrand(_EjsInstance_brand, this, _outputContent).call(this, name, data));
+    }
+    async require(name) {
+      const data = this.createContext({});
+      return _assertClassBrand(_EjsInstance_brand, this, _output).call(this, _assertClassBrand(_EjsInstance_brand, this, _path).call(this, name), data).then(() => data.getMacro());
+    }
+  }
+  function _path(name) {
+    const ext = name.split('.').pop();
+    if (ext !== _classPrivateFieldGet2(_config, this).extension) {
+      name = [name, _classPrivateFieldGet2(_config, this).extension].join('.');
+    }
+    return name;
+  }
+  function _output(path, data) {
+    return _classPrivateFieldGet2(_template, this).get(path).then(callback => callback.apply(data, [data, data.useComponent(), data.useElement(), data.useBuffer(), data.useEscapeValue()]));
+  }
+  function _renderLayout(name, params, parentTemplate) {
+    const data = this.createContext(params);
+    if (parentTemplate) data.setParentTemplate(parentTemplate);
+    return _assertClassBrand(_EjsInstance_brand, this, _output).call(this, _assertClassBrand(_EjsInstance_brand, this, _path).call(this, name), data).then(_assertClassBrand(_EjsInstance_brand, this, _outputContent).call(this, name, data));
+  }
+  function _outputContent(name, data) {
+    return content => {
+      if (data.getExtend()) {
+        data.setExtend(false);
+        return _assertClassBrand(_EjsInstance_brand, this, _renderLayout).call(this, data.getLayout(), data, name);
+      }
+      return content;
     };
+  }
+  _defineProperty(EjsInstance, "exports", ['configure', 'create', 'createContext', 'render', 'require', 'preload', 'compile', 'helpers']);
 
-    const {
-      render,
-      createContext,
-      compile,
-      helpers,
-      preload,
-      configure,
-      create
-    } = new EjsInstance({
-      resolver: readFile
+  const resolver = async (path$1, template, error) => {
+    return path.readFile(joinPath(path$1, template)).then(contents => contents.toString()).catch(e => {
+      if (e.code === 'ENOENT') {
+        return error(1, "template ".concat(template, " not found"));
+      }
+      return error(0, e);
+    });
+  };
+  const {
+    render,
+    helpers,
+    configure,
+    create,
+    createContext,
+    compile,
+    preload
+  } = new EjsInstance({
+    resolver
+  });
+  const __express = function (name, options, callback) {
+    if (isFunction(options)) {
+      callback = options;
+      options = {};
+    }
+    options = options || {};
+    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(content => {
+      callback(null, content);
+    }).catch(error => {
+      callback(error);
     });
-    const __express = expressRenderer(configure, render);
+  };
 
-    exports.TemplateError = TemplateError;
-    exports.TemplateNotFound = TemplateNotFound;
-    exports.TemplateSyntaxError = TemplateSyntaxError;
-    exports.__express = __express;
-    exports.compile = compile;
-    exports.configure = configure;
-    exports.create = create;
-    exports.createContext = createContext;
-    exports.helpers = helpers;
-    exports.preload = preload;
-    exports.render = render;
+  exports.__express = __express;
+  exports.compile = compile;
+  exports.configure = configure;
+  exports.create = create;
+  exports.createContext = createContext;
+  exports.helpers = helpers;
+  exports.preload = preload;
+  exports.render = render;
 
 }));