@kosatyi/ejs 0.0.110 → 0.0.112

package/dist/cjs/browser.js

@@ -1,5 +1,68 @@
 'use strict';
 
+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 + "";
+}
+
 /**
  * @type {EjsConfig}
  */
@@ -46,7 +109,7 @@ 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`);
+    if (valid === false) console.log("ejsConfig.globals: expected '".concat(name, "' to be valid variable name --> skipped"));
     return valid;
   });
 };
@@ -125,9 +188,7 @@ const each = (object, callback) => {
   }
 };
 const omit = (object, list) => {
-  const result = {
-    ...object
-  };
+  const result = _objectSpread2({}, object);
   for (const key of list) {
     delete result[key];
   }
@@ -165,50 +226,56 @@ const error = (code, content) => {
   throw new EjsError(code, content);
 };
 
+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 {
-  #path;
-  #resolver;
-  #cache;
-  #compiler;
-  static exports = ['configure', 'get'];
   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);
-    this.#cache = cache;
-    this.#compiler = compiler;
-    this.configure(options ?? {});
+    _classPrivateFieldSet2(_cache$2, this, cache);
+    _classPrivateFieldSet2(_compiler$1, this, compiler);
+    this.configure(options !== null && options !== void 0 ? options : {});
   }
   configure(options) {
-    this.#path = options.path;
+    _classPrivateFieldSet2(_path$1, this, 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, error));
-    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;
+      _classPrivateFieldSet2(_resolver, this, options.resolver);
     }
   }
   get(template) {
-    return this.#resolve(template).then(content => {
-      return this.#compile(content, 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${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 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 () {
@@ -220,133 +287,138 @@ const tokensMatch = (regex, content, callback) => {
     return match;
   });
 };
+var _config$1 = /*#__PURE__*/new WeakMap();
 class EjsCompiler {
-  #config = {};
-  static exports = ['configure', 'compile'];
   constructor(options) {
+    _classPrivateFieldInitSpec(this, _config$1, {});
     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 = {
+    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: [this.#config.token.start, '_'],
-      end: ['_', this.#config.token.end]
+      start: [_classPrivateFieldGet2(_config$1, this).token.start, '_'],
+      end: ['_', _classPrivateFieldGet2(_config$1, this).token.end]
     };
-    this.#config.matches = [];
-    this.#config.formats = [];
+    _classPrivateFieldGet2(_config$1, this).matches = [];
+    _classPrivateFieldGet2(_config$1, this).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);
+      _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);
     }
-    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(',')};`;
+    _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 {
-        this.#config.globalVariables = `const {${this.#config.globals.join(',')}} = ${this.#config.vars.SCOPE};`;
+        _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 GLOBALS = _classPrivateFieldGet2(_config$1, this).globalVariables;
     const {
       SCOPE,
       SAFE,
       BUFFER,
       COMPONENT,
       ELEMENT
-    } = this.#config.vars;
-    if (this.#config.rmWhitespace) {
+    } = _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(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) => {
+    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 += this.#config.formats[index](value.trim(), BUFFER, SAFE);
+          OUTPUT += _classPrivateFieldGet2(_config$1, this).formats[index](value.trim(), BUFFER, SAFE);
         }
       });
     });
-    OUTPUT += `');`;
-    OUTPUT = `try{${OUTPUT}}catch(e){return ${BUFFER}.error(e)}`;
-    if (this.#config.strict === false) {
-      OUTPUT = `with(${SCOPE}){${OUTPUT}}`;
+    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 = `${BUFFER}.start();${OUTPUT}return ${BUFFER}.end();`;
-    OUTPUT += `\n//# sourceURL=${path}`;
+    OUTPUT = "".concat(BUFFER, ".start();").concat(OUTPUT, "return ").concat(BUFFER, ".end();");
+    OUTPUT += "\n//# sourceURL=".concat(path);
     if (GLOBALS) {
-      OUTPUT = `${GLOBALS}\n${OUTPUT}`;
+      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(${params.join(',')}){\n${OUTPUT}\n});`;
+      result.source = "(function(".concat(params.join(','), "){\n").concat(OUTPUT, "\n});");
       return result;
-    } catch (error) {
-      error.filename = path;
-      error.source = OUTPUT;
-      throw error;
+    } catch (e) {
+      e.filename = path;
+      e.source = OUTPUT;
+      error(0, e);
     }
   }
 }
+_defineProperty(EjsCompiler, "exports", ['configure', 'compile']);
 
+var _cache$1 = /*#__PURE__*/new WeakMap();
+var _precompiled = /*#__PURE__*/new WeakMap();
+var _list = /*#__PURE__*/new WeakMap();
 class EjsCache {
-  static exports = ['load', 'set', 'get', 'exist', 'clear', 'remove', 'resolve'];
-  #cache = true;
-  #precompiled;
-  #list = {};
   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 (this.#cache) {
-      return this.#list[key];
+    if (_classPrivateFieldGet2(_cache$1, this)) {
+      return _classPrivateFieldGet2(_list, this)[key];
     }
   }
   set(key, value) {
-    if (this.#cache) {
-      this.#list[key] = value;
+    if (_classPrivateFieldGet2(_cache$1, this)) {
+      _classPrivateFieldGet2(_list, this)[key] = value;
     }
   }
   exist(key) {
-    if (this.#cache) {
-      return this.#list.hasOwnProperty(key);
+    if (_classPrivateFieldGet2(_cache$1, this)) {
+      return _classPrivateFieldGet2(_list, this).hasOwnProperty(key);
     }
   }
   clear() {
-    Object.keys(this.#list).forEach(this.remove);
+    Object.keys(_classPrivateFieldGet2(_list, this)).forEach(this.remove);
   }
   remove(key) {
-    delete this.#list[key];
+    delete _classPrivateFieldGet2(_list, this)[key];
   }
   resolve(key) {
     return Promise.resolve(this.get(key));
   }
   load(data) {
-    if (this.#cache) {
-      Object.assign(this.#list, data || {});
+    if (_classPrivateFieldGet2(_cache$1, this)) {
+      Object.assign(_classPrivateFieldGet2(_list, this), data || {});
     }
   }
   configure(options) {
-    this.#cache = options.cache;
-    this.#precompiled = options.precompiled;
+    _classPrivateFieldSet2(_cache$1, this, options.cache);
+    _classPrivateFieldSet2(_precompiled, this, options.precompiled);
     if (typeof window === 'object') {
-      this.load(window[this.#precompiled]);
+      this.load(window[_classPrivateFieldGet2(_precompiled, this)]);
     }
   }
 }
+_defineProperty(EjsCache, "exports", ['load', 'set', 'get', 'exist', 'clear', 'remove', 'resolve']);
 
 const selfClosed = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
 const space = ' ';
@@ -364,7 +436,7 @@ const eachAttribute = _ref => {
 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);
+  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);
@@ -376,12 +448,10 @@ const element = (tag, attrs, content) => {
 };
 
 const resolve = list => {
-  return Promise.all(list || []).then(list => list.join('')).catch(e => {
-    return error(500, e);
-  });
+  return Promise.all(list || []).then(list => list.join('')).catch(e => error(0, e));
 };
 const reject = e => {
-  return Promise.reject(error(500, e));
+  return Promise.reject(error(0, e));
 };
 const EjsBuffer = () => {
   let store = [];
@@ -417,6 +487,7 @@ const EjsBuffer = () => {
 
 const PARENT = Symbol('EjsContext.parentTemplate');
 const createContext$1 = (config, methods) => {
+  const globals = config.globals || [];
   const {
     BLOCKS,
     MACRO,
@@ -428,37 +499,38 @@ const createContext$1 = (config, methods) => {
     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.defineProperty(EjsContext.prototype, BUFFER, {
-    value: EjsBuffer()
-  });
-  Object.defineProperty(EjsContext.prototype, BLOCKS, {
-    value: {},
-    writable: true
-  });
-  Object.defineProperty(EjsContext.prototype, MACRO, {
-    value: {},
-    writable: true
-  });
-  Object.defineProperty(EjsContext.prototype, LAYOUT, {
-    value: false,
-    writable: true
-  });
-  Object.defineProperty(EjsContext.prototype, EXTEND, {
-    value: false,
-    writable: true
-  });
-  Object.defineProperty(EjsContext.prototype, PARENT, {
-    value: null,
-    writable: true
-  });
-  Object.defineProperties(EjsContext.prototype, {
+  class Context {
+    constructor(data) {
+      this[PARENT] = null;
+      this[BLOCKS] = {};
+      this[MACRO] = {};
+      Object.assign(this, omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT]));
+    }
+  }
+  Object.defineProperties(Context.prototype, {
+    [BUFFER]: {
+      value: EjsBuffer()
+    },
+    [BLOCKS]: {
+      value: {},
+      writable: true
+    },
+    [MACRO]: {
+      value: {},
+      writable: true
+    },
+    [LAYOUT]: {
+      value: false,
+      writable: true
+    },
+    [EXTEND]: {
+      value: false,
+      writable: true
+    },
+    [PARENT]: {
+      value: null,
+      writable: true
+    },
     setParentTemplate: {
       value(value) {
         this[PARENT] = value;
@@ -471,32 +543,34 @@ const createContext$1 = (config, methods) => {
       }
     },
     useEscapeValue: {
-      get: () => escapeValue
+      value() {
+        return escapeValue;
+      }
     },
     useComponent: {
-      get() {
+      value() {
         if (isFunction(this[COMPONENT])) {
           return this[COMPONENT].bind(this);
         } else {
           return function () {
-            throw new Error(`${COMPONENT} must be a function`);
+            error(2, "".concat(COMPONENT, " must be a function"));
           };
         }
       }
     },
     useElement: {
-      get() {
+      value() {
         if (isFunction(this[ELEMENT])) {
           return this[ELEMENT].bind(this);
         } else {
           return () => {
-            throw new Error(`${ELEMENT} must be a function`);
+            error(2, "".concat(ELEMENT, " must be a function"));
           };
         }
       }
     },
     useBuffer: {
-      get() {
+      value() {
         return this[BUFFER];
       }
     },
@@ -549,17 +623,18 @@ const createContext$1 = (config, methods) => {
     },
     echo: {
       value() {
-        return [].slice.call(arguments).forEach(this.useBuffer);
+        return [].slice.call(arguments).forEach(this.useBuffer());
       }
     },
     fn: {
       value(callback) {
+        const buffer = this.useBuffer();
         const context = this;
         return function () {
           if (isFunction(callback)) {
-            context.useBuffer.backup();
-            context.useBuffer(callback.apply(context, arguments));
-            return context.useBuffer.restore();
+            buffer.backup();
+            buffer(callback.apply(context, arguments));
+            return buffer.restore();
           }
         };
       }
@@ -669,52 +744,72 @@ const createContext$1 = (config, methods) => {
     ui: {
       value() {},
       writable: true
+    },
+    require: {
+      value() {},
+      writable: true
+    },
+    render: {
+      value() {},
+      writable: true
     }
   });
   Object.entries(methods).forEach(_ref => {
     let [name, value] = _ref;
     if (isFunction(value) && globals.includes(name)) {
-      value = value.bind(EjsContext.prototype);
+      value = value.bind(Context.prototype);
     }
-    EjsContext.prototype[name] = value;
+    Context.prototype[name] = value;
   });
-  return EjsContext;
+  return Context;
 };
+var _context$1 = /*#__PURE__*/new WeakMap();
 class EjsContext {
-  #context;
-  static exports = ['create', 'globals', 'helpers'];
   constructor(options, methods) {
+    _classPrivateFieldInitSpec(this, _context$1, void 0);
     bindContext(this, this.constructor.exports);
     this.configure(options, methods);
   }
   create(data) {
-    return new this.#context(data);
+    return new (_classPrivateFieldGet2(_context$1, this))(data);
   }
   helpers(methods) {
-    Object.assign(this.#context.prototype, methods);
+    Object.assign(_classPrivateFieldGet2(_context$1, this).prototype, methods);
   }
   configure(options, methods) {
-    this.#context = createContext$1(options, methods);
+    _classPrivateFieldSet2(_context$1, this, createContext$1(options, methods));
   }
 }
+_defineProperty(EjsContext, "exports", ['create', 'globals', 'helpers']);
 
+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 {
-  #cache;
-  #context;
-  #compiler;
-  #template;
-  #config = {};
-  #methods = {};
-  static exports = ['configure', 'create', 'createContext', 'render', 'require', 'preload', 'compile', 'helpers'];
+  /**
+   *
+   * @param {EjsConfig} options
+   */
   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);
-    this.#methods = {};
-    this.#config = configSchema({}, options);
-    this.#context = new EjsContext(this.#config, this.#methods);
-    this.#compiler = new EjsCompiler(this.#config);
-    this.#cache = new EjsCache(this.#config);
-    this.#template = new EjsTemplate(this.#config, this.#cache, this.#compiler);
+    _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
@@ -725,67 +820,67 @@ class EjsInstance {
   }
   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);
+      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 this.#config;
+    return _classPrivateFieldGet2(_config, this);
   }
   createContext(data) {
-    return this.#context.create(data);
+    return _classPrivateFieldGet2(_context, this).create(data);
   }
   preload(list) {
-    return this.#cache.load(list || {});
+    return _classPrivateFieldGet2(_cache, this).load(list || {});
   }
   compile(content, path) {
-    return this.#compiler.compile(content, path);
+    return _classPrivateFieldGet2(_compiler, this).compile(content, path);
   }
   helpers(methods) {
-    this.#context.helpers(Object.assign(this.#methods, methods));
+    _classPrivateFieldGet2(_context, this).helpers(Object.assign(_classPrivateFieldGet2(_methods, this), methods));
   }
   async render(name, params) {
     const data = this.createContext(params);
-    return this.#output(this.#path(name), data).then(this.#outputContent(name, data));
+    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 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;
+    return _assertClassBrand(_EjsInstance_brand, this, _output).call(this, _assertClassBrand(_EjsInstance_brand, this, _path).call(this, name), data).then(() => data.getMacro());
   }
-  #output(path, data) {
-    return this.#template.get(path).then(callback => callback.apply(data, [data, data.useComponent, data.useElement, data.useBuffer, data.useEscapeValue]));
-  }
-  #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;
-    };
+}
+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 httpRequest = (path, template, error) => {
+const resolver = async (path, template, error) => {
   return fetch(joinPath(path, template)).then(response => {
     if (response.ok) return response.text();
-    return error(404, `template ${template} not found`);
-  }, reason => error(500, reason));
+    return error(1, "template ".concat(template, " not found"));
+  }, reason => error(0, reason));
 };
-
 const {
   render,
   configure,
@@ -795,13 +890,15 @@ const {
   compile,
   preload
 } = new EjsInstance({
-  resolver: httpRequest
+  resolver
 });
 
 exports.compile = compile;
 exports.configure = configure;
 exports.create = create;
 exports.createContext = createContext;
+exports.element = element;
+exports.escapeValue = escapeValue;
 exports.helpers = helpers;
 exports.preload = preload;
 exports.render = render;