@kosatyi/ejs 0.0.106 → 0.0.108

package/dist/esm/browser.js

@@ -1,20 +1,114 @@
+/**
+ * @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 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 = (v) => Array.isArray(v);
-const isFunction = (v) => typeof v === 'function';
-const isString = (v) => typeof v === 'string';
-const isBoolean = (v) => typeof v === 'boolean';
-const isUndefined = (v) => typeof v === 'undefined';
-
-const isNodeEnv =
-    Object.prototype.toString.call(
-        typeof process !== 'undefined' ? process : 0
-    ) === '[object process]';
+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
+    })
+};
 
-const isNode = () => isNodeEnv;
+const configSchema = (config, options) => {
+    return Object.assign(config, {
+        path: typeProp(isString, ejsDefaults.path, config.path, options.path),
+        precompiled: typeProp(
+            isString,
+            ejsDefaults.precompiled,
+            config.export,
+            options.export,
+        ),
+        resolver: typeProp(
+            isFunction,
+            ejsDefaults.resolver,
+            config.resolver,
+            options.resolver,
+        ),
+        extension: typeProp(
+            isString,
+            ejsDefaults.extension,
+            config.extension,
+            options.extension,
+        ),
+        strict: typeProp(
+            isBoolean,
+            ejsDefaults.strict,
+            config.strict,
+            options.strict,
+        ),
+        rmWhitespace: typeProp(
+            isBoolean,
+            ejsDefaults.rmWhitespace,
+            config.rmWhitespace,
+            options.rmWhitespace,
+        ),
+        cache: typeProp(
+            isBoolean,
+            ejsDefaults.cache,
+            config.cache,
+            options.cache,
+        ),
+        globals: typeProp(
+            isArray,
+            ejsDefaults.globals,
+            config.globals,
+            isArrayOfVariables(options.globals),
+        ),
+        token: Object.assign(
+            {},
+            ejsDefaults.token,
+            config.token,
+            options.token,
+        ),
+        vars: Object.assign({}, ejsDefaults.vars, config.vars, options.vars),
+    })
+};
 
 const symbolEntities = {
     "'": "'",
@@ -44,14 +138,14 @@ const symbolEntitiesMatch = regexKeys(symbolEntities);
 const entities = (string = '') => {
     return ('' + string).replace(
         htmlEntitiesMatch,
-        (match) => htmlEntities[match]
+        (match) => htmlEntities[match],
     )
 };
 
 const symbols = (string) => {
     return ('' + string).replace(
         symbolEntitiesMatch,
-        (match) => '\\' + symbolEntities[match]
+        (match) => '\\' + symbolEntities[match],
     )
 };
 
@@ -60,8 +154,8 @@ const safeValue = (value, escape) => {
     return check == null
         ? ''
         : Boolean(escape) === true
-        ? entities(check)
-        : check
+          ? entities(check)
+          : check
 };
 
 const getPath = (context, name, strict) => {
@@ -85,25 +179,6 @@ const getPath = (context, name, strict) => {
     return [data, prop]
 };
 
-const ext = (path, defaults) => {
-    const ext = path.split('.').pop();
-    if (ext !== defaults) {
-        path = [path, defaults].join('.');
-    }
-    return path
-};
-
-/**
- * @type {<T extends {}, U, V, W,Y>(T,U,V,W,Y)=> T & U & V & W & Y}
- */
-const extend = (target, ...args) => {
-    return args
-        .filter((source) => source)
-        .reduce((target, source) => Object.assign(target, source), target)
-};
-
-const noop = () => {};
-
 const each = (object, callback) => {
     let prop;
     for (prop in object) {
@@ -113,53 +188,16 @@ const each = (object, callback) => {
     }
 };
 
-const map = (object, callback, context) => {
-    const result = [];
-    each(
-        object,
-        (value, key, object) => {
-            let item = callback(value, key, object);
-            if (isUndefined(item) === false) {
-                result.push(item);
-            }
-        });
-    return result
-};
-
-const filter = (object, callback, context) => {
-    const isArray = object instanceof Array;
-    const result = isArray ? [] : {};
-    each(
-        object,
-        (value, key, object) => {
-            let item = callback(value, key, object);
-            if (isUndefined(item) === false) {
-                if (isArray) {
-                    result.push(item);
-                } else {
-                    result[key] = item;
-                }
-            }
-        });
-    return result
-};
-
 const omit = (object, list) => {
-    return filter(object, (value, key) => {
-        if (list.indexOf(key) === -1) {
-            return value
-        }
-    })
+    const result = { ...object };
+    for (const key of list) {
+        delete result[key];
+    }
+    return result
 };
 
-/**
- *
- * @param object
- * @param prop
- * @return {boolean}
- */
 const hasProp = (object, prop) => {
-    return object && object.hasOwnProperty(prop)
+    return object && Object.hasOwn(object, prop)
 };
 
 const joinPath = (path, template) => {
@@ -168,9 +206,68 @@ const joinPath = (path, template) => {
     return template
 };
 
-const matchTokens = (regex, text, callback) => {
+const bindContext = (object, methods = []) => {
+    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),
+        )
+    }
+}
+
+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;
-    text.replace(regex, function () {
+    content.replace(regex, function () {
         const params = [].slice.call(arguments, 0, -1);
         const offset = params.pop();
         const match = params.shift();
@@ -180,291 +277,167 @@ const matchTokens = (regex, text, callback) => {
     });
 };
 
-const defaults = {};
-
-defaults.export = 'ejsPrecompiled';
-defaults.cache = true;
-defaults.chokidar = null;
-defaults.path = 'views';
-defaults.resolver = function(path, template) {
-    return Promise.resolve(
-        ['resolver is not defined', path, template].join(' ')
-    )
-};
-defaults.extension = 'ejs';
-defaults.rmWhitespace = true;
-defaults.withObject = true;
-defaults.globalHelpers = [];
-defaults.vars = {
-    SCOPE: 'ejs',
-    COMPONENT: 'ui',
-    ELEMENT: 'el',
-    EXTEND: '$$e',
-    BUFFER: '$$a',
-    LAYOUT: '$$l',
-    BLOCKS: '$$b',
-    MACRO: '$$m',
-    SAFE: '$$v'
-};
-defaults.token = {
-    start: '<%',
-    end: '%>',
-    regex: '([\\s\\S]+?)'
-};
-
-const configSchema = (config, options) => {
-    return extend(config, {
-        path: typeProp(isString, defaults.path, config.path, options.path),
-        export: typeProp(
-            isString,
-            defaults.export,
-            config.export,
-            options.export
-        ),
-        resolver: typeProp(
-            isFunction,
-            defaults.resolver,
-            config.resolver,
-            options.resolver
-        ),
-        extension: typeProp(
-            isString,
-            defaults.extension,
-            config.extension,
-            options.extension
-        ),
-        withObject: typeProp(
-            isBoolean,
-            defaults.withObject,
-            config.withObject,
-            options.withObject
-        ),
-        rmWhitespace: typeProp(
-            isBoolean,
-            defaults.rmWhitespace,
-            config.rmWhitespace,
-            options.rmWhitespace
-        ),
-        cache: typeProp(isBoolean, defaults.cache, config.cache, options.cache),
-        token: extend({}, defaults.token, config.token, options.token),
-        vars: extend({}, defaults.vars, config.vars, options.vars),
-        globalHelpers: typeProp(
-            isArray,
-            defaults.globalHelpers,
-            config.globalHelpers,
-            options.globalHelpers
-        ),
-    })
-};
+class Compiler {
+    #config = {}
+    static exports = ['compile']
 
-const Template = (options, cache, compiler) => {
-    const config = {
-        path: null,
-        resolver: null
-    };
-    const resolve = (path) => {
-        return config.resolver(config.path, path)
-    };
-    const result = (template, content) => {
-        cache.set(template, content);
-        return content
-    };
-    const compile = (content, template) => {
-        if (isFunction(content)) {
-            return content
-        } else {
-            return compiler.compile(content, template)
-        }
-    };
-    const get = (template) => {
-        if (cache.exist(template)) {
-            return cache.resolve(template)
-        }
-        return resolve(template).then((content) =>
-            result(template, compile(content, template))
-        )
-    };
-    const configure = (options) => {
-        config.path = options.path;
-        if (isFunction(options.resolver)) {
-            config.resolver = options.resolver;
-        }
-    };
-    configure(options);
-    return {
-        get,
-        configure,
-        compile
+    constructor(options) {
+        bindContext(this, this.constructor.exports);
+        this.configure(options);
     }
-};
-
-const configSymbols = [
-    {
-        symbol: '-',
-        format(value) {
-            return `')\n${this.BUFFER}(${this.SAFE}(${value},1))\n${this.BUFFER}('`
-        },
-    },
-    {
-        symbol: '=',
-        format(value) {
-            return `')\n${this.BUFFER}(${this.SAFE}(${value}))\n${this.BUFFER}('`
-        },
-    },
-    {
-        symbol: '#',
-        format(value) {
-            return `')\n/**${value}**/\n${this.BUFFER}('`
-        },
-    },
-    {
-        symbol: '',
-        format(value) {
-            return `')\n${value.trim()}\n${this.BUFFER}('`
-        },
-    },
-];
 
-const Compiler = (options) => {
-    const config = {};
-    const configure = (options) => {
-        config.withObject = options.withObject;
-        config.rmWhitespace = options.rmWhitespace;
-        config.token = options.token;
-        config.vars = options.vars;
-        config.globalHelpers = options.globalHelpers;
-        config.matches = [];
-        config.formats = [];
-        config.slurp = {
+    configure(options) {
+        this.#config.strict = options.strict;
+        this.#config.rmWhitespace = options.rmWhitespace;
+        this.#config.token = options.token;
+        this.#config.vars = options.vars;
+        this.#config.globals = options.globals;
+        this.#config.legacy = options.legacy ?? true;
+        this.#config.slurp = {
             match: '[s\t\n]*',
-            start: [config.token.start, '_'],
-            end: ['_', config.token.end],
+            start: [this.#config.token.start, '_'],
+            end: ['_', this.#config.token.end],
         };
-        configSymbols.forEach((item) => {
-            config.matches.push(
-                config.token.start
-                    .concat(item.symbol)
-                    .concat(config.token.regex)
-                    .concat(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),
             );
-            config.formats.push(item.format.bind(config.vars));
-        });
-        config.regex = new RegExp(
-            config.matches.join('|').concat('|$'),
-            'g'
+            this.#config.formats.push(format);
+        }
+        this.#config.regex = new RegExp(
+            this.#config.matches.join('|').concat('|$'),
+            'g',
         );
-        config.slurpStart = new RegExp(
-            [config.slurp.match, config.slurp.start.join('')].join(
-                ''
+        this.#config.slurpStart = new RegExp(
+            [this.#config.slurp.match, this.#config.slurp.start.join('')].join(
+                '',
             ),
-            'gm'
+            'gm',
         );
-        config.slurpEnd = new RegExp(
-            [config.slurp.end.join(''), config.slurp.match].join(
-                ''
+        this.#config.slurpEnd = new RegExp(
+            [this.#config.slurp.end.join(''), this.#config.slurp.match].join(
+                '',
             ),
-            'gm'
+            'gm',
         );
-    };
-    const compile = (content, path) => {
-        const { SCOPE, SAFE, BUFFER, COMPONENT, ELEMENT } = config.vars;
-        const GLOBALS = config.globalHelpers;
-        if (config.rmWhitespace) {
+        if (this.#config.globals.length) {
+            if (this.#config.legacy) {
+                this.#config.globalVariables = `const ${this.#config.globals
+                    .map((name) => `${name}=${this.#config.vars.SCOPE}.${name}`)
+                    .join(',')};`;
+            } else {
+                this.#config.globalVariables = `const {${this.#config.globals.join(',')}} = ${this.#config.vars.SCOPE};`;
+            }
+        }
+    }
+    compile(content, path) {
+        const GLOBALS = this.#config.globalVariables;
+        const { SCOPE, SAFE, BUFFER, COMPONENT, ELEMENT } = this.#config.vars;
+        if (this.#config.rmWhitespace) {
             content = String(content)
                 .replace(/[\r\n]+/g, '\n')
                 .replace(/^\s+|\s+$/gm, '');
         }
         content = String(content)
-            .replace(config.slurpStart, config.token.start)
-            .replace(config.slurpEnd, config.token.end);
-        let source = `${BUFFER}('`;
-        matchTokens(config.regex, content, (params, index, offset) => {
-            source += symbols(content.slice(index, offset));
+            .replace(this.#config.slurpStart, this.#config.token.start)
+            .replace(this.#config.slurpEnd, this.#config.token.end);
+        let OUTPUT = `${BUFFER}('`;
+        tokensMatch(this.#config.regex, content, (params, index, offset) => {
+            OUTPUT += symbols(content.slice(index, offset));
             params.forEach((value, index) => {
                 if (value) {
-                    source += config.formats[index](value);
+                    OUTPUT += this.#config.formats[index](
+                        value.trim(),
+                        BUFFER,
+                        SAFE,
+                    );
                 }
             });
         });
-        source += `');`;
-        source = `try{${source}}catch(e){return ${BUFFER}.error(e)}`;
-        if (config.withObject) {
-            source = `with(${SCOPE}){${source}}`;
+        OUTPUT += `');`;
+        OUTPUT = `try{${OUTPUT}}catch(e){return ${BUFFER}.error(e,'${path}')}`;
+        if (this.#config.strict === false) {
+            OUTPUT = `with(${SCOPE}){${OUTPUT}}`;
+        }
+        OUTPUT = `${BUFFER}.start();${OUTPUT}return ${BUFFER}.end();`;
+        OUTPUT += `\n//# sourceURL=${path}`;
+        if (GLOBALS) {
+            OUTPUT = `${GLOBALS}\n${OUTPUT}`;
         }
-        source = `${BUFFER}.start();${source}return ${BUFFER}.end();`;
-        source += `\n//# sourceURL=${path}`;
-        let result = null;
-        let params = [SCOPE, COMPONENT, ELEMENT, BUFFER, SAFE].concat(GLOBALS);
         try {
-            result = Function.apply(null, params.concat(source));
-            result.source = `(function(${params.join(',')}){\n${source}\n});`;
-        } catch (e) {
-            e.filename = path;
-            e.source = source;
-            throw e
+            const params = [SCOPE, COMPONENT, ELEMENT, BUFFER, SAFE];
+            const result = Function.apply(null, params.concat(OUTPUT));
+            result.source = `(function(${params.join(',')}){\n${OUTPUT}\n});`;
+            return result
+        } catch (error) {
+            error.filename = path;
+            error.source = OUTPUT;
+            throw error
         }
-        return result
-    };
-    configure(options);
-    return {
-        configure,
-        compile,
     }
-};
-
-const global = typeof globalThis !== 'undefined' ? globalThis : window || self;
+}
 
-const Cache = (options = {}) => {
-    const config = {};
-    const list = {};
-    const load = (data) => {
-        if (config.enabled) {
-            extend(list, data || {});
+class Cache {
+    static exports = [
+        'load',
+        'set',
+        'get',
+        'exist',
+        'clear',
+        'remove',
+        'resolve',
+    ]
+    #cache = true
+    #precompiled
+    #list = {}
+    constructor(options) {
+        bindContext(this, this.constructor.exports);
+        this.configure(options);
+    }
+    get(key) {
+        if (this.#cache) {
+            return this.#list[key]
         }
-    };
-    const get = (key) => {
-        if (config.enabled) {
-            return list[key]
+    }
+    set(key, value) {
+        if (this.#cache) {
+            this.#list[key] = value;
         }
-    };
-    const set = (key, value) => {
-        if (config.enabled) {
-            list[key] = value;
+    }
+    exist(key) {
+        if (this.#cache) {
+            return this.#list.hasOwnProperty(key)
         }
-    };
-    const exist = (key) => {
-        if (config.enabled) {
-            return hasProp(list, key)
+    }
+    clear() {
+        Object.keys(this.#list).forEach(this.remove);
+    }
+    remove(key) {
+        delete this.#list[key];
+    }
+    resolve(key) {
+        return Promise.resolve(this.get(key))
+    }
+
+    load(data) {
+        if (this.#cache) {
+            Object.assign(this.#list, data || {});
         }
-    };
-    const clear = () => {
-        Object.keys(list).forEach(remove);
-    };
-    const remove = (key) => {
-        delete list[key];
-    };
-    const resolve = (key) => {
-        return Promise.resolve(get(key))
-    };
-    const configure = (options = {}) => {
-        config.enabled = options.cache;
-        config.export = options.export;
-        if (isNode() === false) {
-            load(global[config.export]);
+    }
+
+    configure(options) {
+        this.#cache = options.cache;
+        this.#precompiled = options.precompiled;
+        if (typeof window === 'object') {
+            this.load(window[this.#precompiled]);
         }
-    };
-    configure(options);
-    return {
-        configure,
-        load,
-        set,
-        get,
-        exist,
-        clear,
-        remove,
-        resolve,
     }
-};
+}
 
 const selfClosed = [
     'area',
@@ -490,20 +463,24 @@ const slash = '/';
 const lt = '<';
 const gt = '>';
 
+const eachAttribute = ([key, value]) => {
+    if (value !== null && value !== undefined) {
+        return [entities(key), [quote, entities(value), quote].join('')].join(
+            equal,
+        )
+    }
+};
+
 const element = (tag, attrs, content) => {
     const result = [];
     const hasClosedTag = selfClosed.indexOf(tag) === -1;
-    const attributes = map(attrs, (value, key) => {
-        if (value !== null && value !== undefined) {
-            return [
-                entities(key),
-                [quote, entities(value), quote].join(''),
-            ].join(equal)
-        }
-    }).join(space);
+    const attributes = Object.entries(attrs ?? {})
+        .map(eachAttribute)
+        .filter((e) => e)
+        .join(space);
     result.push([lt, tag, space, attributes, gt].join(''));
     if (content && hasClosedTag) {
-        result.push(content instanceof Array ? content.join('') : content);
+        result.push(Array.isArray(content) ? content.join('') : content);
     }
     if (hasClosedTag) {
         result.push([lt, slash, tag, gt].join(''));
@@ -511,93 +488,73 @@ const element = (tag, attrs, content) => {
     return result.join('')
 };
 
-/**
- *
- * @constructor
- */
-function TemplateError(){
-    TemplateError.call(this);
-}
-Object.setPrototypeOf(TemplateError.prototype, Error.prototype);
-Object.assign(TemplateError.prototype, {
-    code: 0,
-    getCode() {
-        return this.code
-    },
-    getMessage() {
-        return this.message
-    },
-    toString() {
-        return this.getMessage()
+class TemplateError extends Error {
+    name = 'TemplateError'
+    constructor(error) {
+        super(error);
+        if (error instanceof Error) {
+            this.stack = error.stack;
+            this.filename = error.filename;
+            this.lineno = error.lineno;
+        }
     }
-});
+}
 
-/**
- *
- * @constructor
- */
-function TemplateNotFound(){
-    TemplateError.call(this);
+class TemplateNotFound extends TemplateError {
+    name = 'TemplateNotFound'
+    code = 404
 }
-Object.setPrototypeOf(TemplateNotFound.prototype, TemplateError.prototype);
-Object.assign(TemplateNotFound.prototype, { code: 404  });
 
-/**
- *
- * @constructor
- */
-function TemplateSyntaxError(){
-    TemplateError.call(this);
+class TemplateSyntaxError extends TemplateError {
+    name = 'TemplateSyntaxError'
+    code = 500
 }
-Object.setPrototypeOf(TemplateSyntaxError.prototype, TemplateError.prototype);
-Object.assign(TemplateSyntaxError.prototype, { code: 500  });
 
-function resolve(list) {
+const resolve = (list) => {
     return Promise.all(list || [])
         .then((list) => list.join(''))
         .catch((e) => e)
-}
-
-function reject(error) {
-    return Promise.reject(new TemplateSyntaxError(error.message))
-}
+};
 
-/**
- *
- * @return {buffer}
- */
-function createBuffer() {
-    let store = [],
-        array = [];
+const reject = (error) => {
+    return Promise.reject(new TemplateSyntaxError(error))
+};
 
-    const buffer = (value) => {
+const EjsBuffer = () => {
+    let store = [];
+    let array = [];
+    /**
+     *
+     * @param value
+     * @constructor
+     */
+    const EjsBuffer = (value) => {
         array.push(value);
     };
-
-    buffer.start = () => {
+    EjsBuffer.start = () => {
         array = [];
     };
-    buffer.backup = () => {
+    EjsBuffer.backup = () => {
         store.push(array.concat());
         array = [];
     };
-    buffer.restore = () => {
+    EjsBuffer.restore = () => {
         const result = array.concat();
         array = store.pop();
         return resolve(result)
     };
-    buffer.error = (e) => {
+    EjsBuffer.error = (e, filename) => {
         return reject(e)
     };
-    buffer.end = () => {
+    EjsBuffer.end = () => {
         return resolve(array)
     };
-    return buffer
-}
+    return EjsBuffer
+};
 
-const PARENT = Symbol('ContextScope.parentTemplate');
+const PARENT = Symbol('EjsContext.parentTemplate');
 
-const createContextScope = (config, methods) => {
+const createContext$1 = (config, methods) => {
     const {
         BLOCKS,
         MACRO,
@@ -607,70 +564,64 @@ const createContextScope = (config, methods) => {
         SAFE,
         SCOPE,
         COMPONENT,
-        ELEMENT
+        ELEMENT,
     } = config.vars;
-
-    /**
-     *
-     * @type {symbol}
-     */
-
-    /**
-     * @name ContextScope
-     * @param data
-     * @constructor
-     */
-    function ContextScope(data) {
+    const globals = config.globals || [];
+    function EjsContext(data) {
         this[PARENT] = null;
         this[BLOCKS] = {};
         this[MACRO] = {};
         Object.assign(
             this,
-            omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT])
+            omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT]),
         );
     }
-
-    Object.assign(ContextScope.prototype, methods);
-    Object.defineProperty(ContextScope.prototype, BUFFER, {
-        value: createBuffer()
+    Object.entries(methods).forEach(([name, value]) => {
+        if (isFunction(value) && globals.includes(name)) {
+            value = value.bind(EjsContext.prototype);
+        }
+        EjsContext.prototype[name] = value;
     });
-    Object.defineProperty(ContextScope.prototype, BLOCKS, {
+    Object.defineProperty(EjsContext.prototype, BUFFER, {
+        value: EjsBuffer(),
+    });
+    Object.defineProperty(EjsContext.prototype, BLOCKS, {
         value: {},
-        writable: true
+        writable: true,
     });
-    Object.defineProperty(ContextScope.prototype, MACRO, {
+    Object.defineProperty(EjsContext.prototype, MACRO, {
         value: {},
-        writable: true
+        writable: true,
     });
-    Object.defineProperty(ContextScope.prototype, LAYOUT, {
+    Object.defineProperty(EjsContext.prototype, LAYOUT, {
         value: false,
-        writable: true
+        writable: true,
     });
-    Object.defineProperty(ContextScope.prototype, EXTEND, {
+    Object.defineProperty(EjsContext.prototype, EXTEND, {
         value: false,
-        writable: true
+        writable: true,
     });
-    Object.defineProperty(ContextScope.prototype, PARENT, {
+    Object.defineProperty(EjsContext.prototype, PARENT, {
         value: null,
-        writable: true
+        writable: true,
     });
-    Object.defineProperties(ContextScope.prototype, {
+    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
+            get: () => safeValue,
         },
         /** @type {function} */
         useComponent: {
@@ -682,7 +633,7 @@ const createContextScope = (config, methods) => {
                         throw new Error(`${COMPONENT} must be a function`)
                     }
                 }
-            }
+            },
         },
         /** @type {function} */
         useElement: {
@@ -694,51 +645,51 @@ const createContextScope = (config, methods) => {
                         throw new Error(`${ELEMENT} must be a function`)
                     }
                 }
-            }
+            },
         },
-        /** @type {()=>this[MACRO]} */
-        getMacro: {
-            value() {
-                return this[MACRO]
-            }
+        /** @type {function} */
+        useBuffer: {
+            get() {
+                return this[BUFFER]
+            },
         },
         /** @type {function} */
-        getBuffer: {
+        getMacro: {
             value() {
-                return this[BUFFER]
-            }
+                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: {
@@ -748,36 +699,32 @@ const createContextScope = (config, methods) => {
                     filter.push(BLOCKS);
                 }
                 return omit(this, filter)
-            }
+            },
         },
         /** @type {function} */
         extend: {
             value(layout) {
                 this.setExtend(true);
                 this.setLayout(layout);
-            }
+            },
         },
         /** @type {function} */
         echo: {
-            value(layout) {
-                const buffer = this.getBuffer();
-                const params = [].slice.call(arguments);
-                params.forEach(buffer);
-            }
+            value() {
+                return [].slice.call(arguments).forEach(this.useBuffer)
+            },
         },
         /** @type {function} */
         fn: {
             value(callback) {
-                const buffer = this.getBuffer();
-                const context = this;
-                return function() {
+                return () => {
                     if (isFunction(callback)) {
-                        buffer.backup();
-                        buffer(callback.apply(context, arguments));
-                        return buffer.restore()
+                        this.useBuffer.backup();
+                        this.useBuffer(callback.apply(this, arguments));
+                        return this.useBuffer.restore()
                     }
                 }
-            }
+            },
         },
         /** @type {function} */
         macro: {
@@ -785,10 +732,10 @@ const createContextScope = (config, methods) => {
                 const list = this.getMacro();
                 const macro = this.fn(callback);
                 const context = this;
-                list[name] = function() {
+                list[name] = function () {
                     return context.echo(macro.apply(undefined, arguments))
                 };
-            }
+            },
         },
         /** @type {function} */
         call: {
@@ -799,7 +746,7 @@ const createContextScope = (config, methods) => {
                 if (isFunction(macro)) {
                     return macro.apply(macro, params)
                 }
-            }
+            },
         },
         /** @type {function} */
         block: {
@@ -809,55 +756,53 @@ const createContextScope = (config, methods) => {
                 blocks[name].push(this.fn(callback));
                 if (this.getExtend()) return
                 const list = Object.assign([], blocks[name]);
-                const current = () => {
-                    return list.shift()
-                };
+                const shift = () => list.shift();
                 const next = () => {
-                    const parent = current();
+                    const parent = shift();
                     if (parent) {
                         return () => {
                             this.echo(parent(next()));
                         }
                     } else {
-                        return noop
+                        return () => {}
                     }
                 };
-                this.echo(current()(next()));
-            }
+                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 = extend(context, data || {});
+                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) => {
+                    Promise.resolve(this.require(path)).then((exports$1) => {
                         const list = this.getMacro();
-                        each(exports, function(macro, name) {
+                        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: {
@@ -866,7 +811,7 @@ const createContextScope = (config, methods) => {
                 const result = path.shift();
                 const prop = path.pop();
                 return hasProp(result, prop) ? result[prop] : defaults
-            }
+            },
         },
         /** @type {function} */
         set: {
@@ -878,17 +823,17 @@ const createContextScope = (config, methods) => {
                     return result[prop]
                 }
                 return (result[prop] = value)
-            }
+            },
         },
         /** @type {function} */
         each: {
-            value: function(object, callback) {
+            value(object, callback) {
                 if (isString(object)) {
                     object = this.get(object, []);
                 }
                 each(object, callback);
             },
-            writable: true
+            writable: true,
         },
         /** @type {function} */
         el: {
@@ -896,131 +841,163 @@ const createContextScope = (config, methods) => {
                 content = isFunction(content) ? this.fn(content)() : content;
                 this.echo(
                     Promise.resolve(content).then((content) =>
-                        element(tag, attr, content)
-                    )
+                        element(tag, attr, content),
+                    ),
                 );
             },
-            writable: true
+            writable: true,
         },
         /** @type {function} */
         ui: {
-            value(layout) {
-            },
-            writable: true
-        }
+            value(layout) {},
+            writable: true,
+        },
     });
-    return ContextScope
+    return EjsContext
 };
 
-const Context = (options, methods) => {
-    /**
-     * @type {InstanceType<ContextScope>}
-     */
-    let Scope;
-    const create = (data) => {
-        return new Scope(data)
-    };
-    const helpers = (methods) => {
-        extend(Scope.prototype, methods || {});
-    };
-    const configure = (options, methods) => {
-        Scope = createContextScope(options, methods);
-    };
-    configure(options, methods);
-    return {
-        configure,
-        create,
-        helpers
+class Context {
+    #context
+    static exports = ['create', 'globals', 'helpers']
+    constructor(options, methods) {
+        bindContext(this, this.constructor.exports);
+        this.configure(options, methods);
     }
-};
+    create(data) {
+        return new this.#context(data)
+    }
+    helpers(methods) {
+        Object.assign(this.#context.prototype, methods);
+    }
+    configure(options, methods) {
+        this.#context = createContext$1(options, methods);
+    }
+}
 
-const EJS = (options = {}) => {
-    const config = configSchema({}, options);
-    const methods = {};
-    const context = Context(config, methods);
-    const compiler = Compiler(config);
-    const cache = Cache(config);
-    const template = Template(config, cache, compiler);
-    const configure = (options = {}) => {
-        configSchema(config, options || {});
-        context.configure(config, methods);
-        compiler.configure(config);
-        cache.configure(config);
-        template.configure(config);
-        return config
-    };
-    const filePath = (name) => {
-        return ext(name, config.extension)
-    };
-    const require = (name) => {
-        const scope = createContext({});
-        return output(filePath(name), scope).then(() => scope.getMacro())
-    };
-    const render = (name, data) => {
-        const scope = createContext(data);
-        return output(filePath(name), scope).then(outputContent(name, scope))
-    };
-    const outputContent = (name, scope) => {
+class EjsInstance {
+    #cache
+    #context
+    #compiler
+    #template
+    #config = {}
+    #methods = {}
+    static exports = [
+        'configure',
+        'create',
+        'createContext',
+        'render',
+        'require',
+        'preload',
+        'compile',
+        'helpers',
+    ]
+    constructor(options = {}) {
+        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 (scope.getExtend()) {
-                scope.setExtend(false);
-                return renderLayout(scope.getLayout(), scope, name)
+            if (data.getExtend()) {
+                data.setExtend(false);
+                return this.#renderLayout(data.getLayout(), data, name)
             }
             return content
         }
-    };
-    const renderLayout = (name, data, parent) => {
-        const scope = createContext(data);
-        if (parent) scope.setParentTemplate(parent);
-        return output(filePath(name), scope).then(outputContent(name, scope))
-    };
-    const helpers = (extendMethods) => {
-        context.helpers(extend(methods, extendMethods));
-    };
-    const createContext = (data) => {
-        return context.create(data)
-    };
-    const compile = (content, path) => {
-        return compiler.compile(content, path)
-    };
-    const preload = (list) => {
-        return cache.load(list || {})
-    };
-    const create = (config) => {
-        return EJS(config)
-    };
-    const output = (path, scope) => {
-        const params = [scope, scope.useComponent, scope.useElement, scope.getBuffer(), scope.useSafeValue];
-        const globals = config.globalHelpers
-            .filter((name) => isFunction(scope[name]))
-            .map((name) => scope[name].bind(scope));
-        return template
-            .get(path)
-            .then((callback) => callback.apply(scope, params.concat(globals)))
-    };
-    helpers({ render, require });
-    return {
-        configure,
-        create,
-        createContext,
-        render,
-        require,
-        preload,
-        compile,
-        helpers
     }
-};
+}
 
 const httpRequest = (path, template) => {
     return fetch(joinPath(path, template)).then(
-        (response) => response.text(),
-        (reason) => new TemplateError()
+        (response) => {
+            if (response.ok) return response.text()
+            throw new TemplateNotFound(
+                `template ${path} / ${template} not found`,
+            )
+        },
+        (reason) => {
+            return new TemplateError(reason)
+        },
     )
 };
 
-const { render, createContext, compile, helpers, preload, configure, create } =
-    EJS({
-        resolver: httpRequest,
-    });
+const {
+    render,
+    createContext,
+    compile,
+    helpers,
+    preload,
+    configure,
+    create,
+} = new EjsInstance({
+    resolver: httpRequest,
+});
 
 export { TemplateError, TemplateNotFound, TemplateSyntaxError, compile, configure, create, createContext, helpers, preload, render };