@kosatyi/ejs 0.0.109 → 0.0.111

package/dist/cjs/worker.js

@@ -14,11 +14,74 @@ 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;
   });
 };
 
+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}
  */
@@ -92,7 +155,7 @@ const entities = function () {
 const symbols = string => {
   return ('' + string).replace(symbolEntitiesMatch, match => '\\' + symbolEntities[match]);
 };
-const safeValue = (value, escape) => {
+const escapeValue = (value, escape) => {
   const check = value;
   return check == null ? '' : Boolean(escape) === true ? entities(check) : check;
 };
@@ -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];
   }
@@ -146,48 +207,70 @@ const bindContext = function (object) {
   }
 };
 
-class Template {
-  #path;
-  #resolver;
-  #cache;
-  #compiler;
-  static exports = ['configure', 'get', 'compile'];
+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);
+};
+
+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);
-    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));
-    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 => 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 () {
@@ -199,133 +282,138 @@ const tokensMatch = (regex, content, callback) => {
     return match;
   });
 };
-class Compiler {
-  #config = {};
-  static exports = ['compile'];
+var _config$1 = /*#__PURE__*/new WeakMap();
+class EjsCompiler {
   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,'${path}')}`;
-    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']);
 
-class Cache {
-  static exports = ['load', 'set', 'get', 'exist', 'clear', 'remove', 'resolve'];
-  #cache = true;
-  #precompiled;
-  #list = {};
+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 (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 = ' ';
@@ -343,7 +431,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);
@@ -354,31 +442,11 @@ const element = (tag, attrs, content) => {
   return result.join('');
 };
 
-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;
-    }
-  }
-}
-class TemplateNotFound extends TemplateError {
-  name = 'TemplateNotFound';
-  code = 404;
-}
-class TemplateSyntaxError extends TemplateError {
-  name = 'TemplateSyntaxError';
-  code = 500;
-}
-
 const resolve = list => {
-  return Promise.all(list || []).then(list => list.join('')).catch(e => e);
+  return Promise.all(list || []).then(list => list.join('')).catch(e => error(0, e));
 };
-const reject = error => {
-  return Promise.reject(new TemplateSyntaxError(error));
+const reject = e => {
+  return Promise.reject(error(0, e));
 };
 const EjsBuffer = () => {
   let store = [];
@@ -403,7 +471,7 @@ const EjsBuffer = () => {
     array = store.pop();
     return resolve(result);
   };
-  EjsBuffer.error = (e, filename) => {
+  EjsBuffer.error = e => {
     return reject(e);
   };
   EjsBuffer.end = () => {
@@ -414,6 +482,7 @@ const EjsBuffer = () => {
 
 const PARENT = Symbol('EjsContext.parentTemplate');
 const createContext$1 = (config, methods) => {
+  const globals = config.globals || [];
   const {
     BLOCKS,
     MACRO,
@@ -425,130 +494,113 @@ 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.entries(methods).forEach(_ref => {
-    let [name, value] = _ref;
-    if (isFunction(value) && globals.includes(name)) {
-      value = value.bind(EjsContext.prototype);
+  class Context {
+    constructor(data) {
+      this[PARENT] = null;
+      this[BLOCKS] = {};
+      this[MACRO] = {};
+      Object.assign(this, omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT]));
     }
-    EjsContext.prototype[name] = value;
-  });
-  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, {
-    /** @type {function} */
+  }
+  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;
         return this;
       }
     },
-    /** @type {function} */
     getParentTemplate: {
       value() {
         return this[PARENT];
       }
     },
-    /** @type {function} */
-    useSafeValue: {
-      get: () => safeValue
+    useEscapeValue: {
+      value() {
+        return escapeValue;
+      }
     },
-    /** @type {function} */
     useComponent: {
-      get() {
+      value() {
         if (isFunction(this[COMPONENT])) {
           return this[COMPONENT].bind(this);
         } else {
-          return () => {
-            throw new Error(`${COMPONENT} must be a function`);
+          return function () {
+            error(2, "".concat(COMPONENT, " must be a function"));
           };
         }
       }
     },
-    /** @type {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"));
           };
         }
       }
     },
-    /** @type {function} */
     useBuffer: {
-      get() {
+      value() {
         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];
@@ -558,32 +610,30 @@ const createContext$1 = (config, methods) => {
         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);
+        return [].slice.call(arguments).forEach(this.useBuffer());
       }
     },
-    /** @type {function} */
     fn: {
       value(callback) {
-        return () => {
+        const buffer = this.useBuffer();
+        const context = this;
+        return function () {
           if (isFunction(callback)) {
-            this.useBuffer.backup();
-            this.useBuffer(callback.apply(this, arguments));
-            return this.useBuffer.restore();
+            buffer.backup();
+            buffer(callback.apply(context, arguments));
+            return buffer.restore();
           }
         };
       }
     },
-    /** @type {function} */
     macro: {
       value(name, callback) {
         const list = this.getMacro();
@@ -594,7 +644,6 @@ const createContext$1 = (config, methods) => {
         };
       }
     },
-    /** @type {function} */
     call: {
       value(name) {
         const list = this.getMacro();
@@ -605,35 +654,35 @@ const createContext$1 = (config, methods) => {
         }
       }
     },
-    /** @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 context = this;
         const list = Object.assign([], blocks[name]);
-        const shift = () => list.shift();
-        const next = () => {
+        const shift = function () {
+          return list.shift();
+        };
+        const next = function () {
           const parent = shift();
           if (parent) {
-            return () => {
-              this.echo(parent(next()));
+            return function () {
+              context.echo(parent(next()));
             };
           } else {
-            return () => {};
+            return function () {};
           }
         };
         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);
@@ -642,7 +691,6 @@ const createContext$1 = (config, methods) => {
         this.echo(promise);
       }
     },
-    /** @type {function} */
     use: {
       value(path, namespace) {
         this.echo(Promise.resolve(this.require(path)).then(exports$1 => {
@@ -653,13 +701,6 @@ const createContext$1 = (config, methods) => {
         }));
       }
     },
-    /** @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);
@@ -668,7 +709,6 @@ const createContext$1 = (config, methods) => {
         return hasProp(result, prop) ? result[prop] : defaults;
       }
     },
-    /** @type {function} */
     set: {
       value(name, value) {
         const path = getPath(this, name, false);
@@ -680,7 +720,6 @@ const createContext$1 = (config, methods) => {
         return result[prop] = value;
       }
     },
-    /** @type {function} */
     each: {
       value(object, callback) {
         if (isString(object)) {
@@ -690,7 +729,6 @@ const createContext$1 = (config, methods) => {
       },
       writable: true
     },
-    /** @type {function} */
     el: {
       value(tag, attr, content) {
         content = isFunction(content) ? this.fn(content)() : content;
@@ -698,49 +736,75 @@ const createContext$1 = (config, methods) => {
       },
       writable: true
     },
-    /** @type {function} */
     ui: {
-      value(layout) {},
+      value() {},
+      writable: true
+    },
+    require: {
+      value() {},
+      writable: true
+    },
+    render: {
+      value() {},
       writable: true
     }
   });
-  return EjsContext;
+  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;
 };
-class Context {
-  #context;
-  static exports = ['create', 'globals', 'helpers'];
+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);
   }
   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 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);
+    _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
@@ -751,69 +815,73 @@ 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.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;
-    };
+}
+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']);
 
-/**
- * @type {{[p:string]:Function}}
- */
 const templateCache = {};
 const getOrigin = (url, secure) => {
   url = URL.parse(url);
   url.protocol = secure ? 'https:' : 'http:';
   return url.origin;
 };
+const resolver = async (path, name, error) => {
+  if (isFunction(templateCache[name])) {
+    return templateCache[name];
+  }
+  error(1, "template ".concat(name, " not found"));
+};
 const {
   render,
   createContext,
@@ -822,43 +890,21 @@ const {
 } = new EjsInstance({
   cache: false,
   strict: true,
-  async resolver(path, name) {
-    if (isFunction(templateCache[name])) {
-      return templateCache[name];
-    } else {
-      throw new TemplateNotFound(`template ${name} not found`);
-    }
-  }
+  resolver
 });
-
-/**
- * @param {{[p:string],Function}} templates
- */
 function useTemplates() {
   let templates = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   Object.assign(templateCache, templates);
 }
-
-/**
- * @typedef {{[p:string]:any}} HonoContext
- * @property {function(*):Promise<Response>} html
- * @property {function():Promise<Response>} notFound
- * @property {function(methods:{}):void} helpers
- * @property {function(name:string,data:{}):Promise<string>} render
- * @property {function(name:string,data:{}):Promise<string>} ejs
- * @property {EjsContext} data
- */
-/**
- * @param {RendererParams} options
- * @return {(function(c:HonoContext, next): Promise<any>)|*}
- */
 function useRenderer() {
+  var _options$templates;
   let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  useTemplates(options.templates ?? {});
+  useTemplates((_options$templates = options.templates) !== null && _options$templates !== void 0 ? _options$templates : {});
   return async (c, next) => {
+    var _options$secure;
     c.data = createContext({});
     c.data.set('version', options.version);
-    c.data.set('origin', getOrigin(c.req.url, options.secure ?? true));
+    c.data.set('origin', getOrigin(c.req.url, (_options$secure = options.secure) !== null && _options$secure !== void 0 ? _options$secure : true));
     c.data.set('path', c.req.path);
     c.data.set('query', c.req.query());
     c.ejs = async (name, data) => render(name, Object.assign({
@@ -870,9 +916,6 @@ function useRenderer() {
   };
 }
 
-exports.TemplateError = TemplateError;
-exports.TemplateNotFound = TemplateNotFound;
-exports.TemplateSyntaxError = TemplateSyntaxError;
 exports.configure = configure;
 exports.createContext = createContext;
 exports.helpers = helpers;