@kosatyi/ejs 0.0.97 → 0.0.99

package/dist/esm/worker.js

@@ -57,13 +57,22 @@ const symbols = (string) => {
 
 const safeValue = (value, escape) => {
     const check = value;
-    return check == null ? '' : Boolean(escape) === true ? entities(check) : check
+    return check == null
+        ? ''
+        : Boolean(escape) === true
+        ? entities(check)
+        : check
 };
 
 const instanceOf = (object, instance) => {
     return Boolean(object instanceof instance)
 };
 
+const assertInstanceOf = (object, instance) => {
+    if (instanceOf(object, instance) === false)
+        throw new TypeError(`${object} in not instance of ${instance}`)
+};
+
 const getPath = (context, name, strict) => {
     let data = context;
     let chunks = String(name).split('.');
@@ -85,6 +94,14 @@ const getPath = (context, name, strict) => {
     return [data, prop]
 };
 
+const bindContext = (object, methods = []) => {
+    methods.forEach((name) => {
+        if (name in object) {
+            object[name] = object[name].bind(object);
+        }
+    });
+};
+
 const ext = (path, defaults) => {
     const ext = path.split('.').pop();
     if (ext !== defaults) {
@@ -152,10 +169,28 @@ const omit = (object, list) => {
     })
 };
 
+/**
+ *
+ * @param object
+ * @param prop
+ * @return {boolean}
+ */
 const hasProp = (object, prop) => {
     return object && object.hasOwnProperty(prop)
 };
 
+const matchTokens = (regex, text, callback) => {
+    let index = 0;
+    text.replace(regex, function () {
+        const params = [].slice.call(arguments, 0, -1);
+        const offset = params.pop();
+        const match = params.shift();
+        callback(params, index, offset);
+        index = offset + match.length;
+        return match
+    });
+};
+
 const defaults = {};
 
 defaults.export = 'ejsPrecompiled';
@@ -174,6 +209,7 @@ defaults.globalHelpers = [];
 defaults.vars = {
     SCOPE: 'ejs',
     COMPONENT: 'ui',
+    ELEMENT: 'el',
     EXTEND: '$$e',
     BUFFER: '$$a',
     LAYOUT: '$$l',
@@ -234,159 +270,146 @@ const configSchema = (config, options) => {
 
 const global = typeof globalThis !== 'undefined' ? globalThis : window || self;
 
-function Cache(config) {
-    if (instanceOf(this, Cache) === false) return new Cache()
-    const cache = {
-        enabled: true,
-        list: {},
-    };
-    this.configure = function (config) {
-        cache.enabled = config.cache;
-        if (isNode() === false) {
-            this.load(global[config.export]);
-        }
-    };
-    this.clear = function () {
-        cache.list = {};
-    };
-    this.load = function (data) {
-        if (cache.enabled) {
-            extend(cache.list, data || {});
+class Cache {
+    #enabled = true
+    #list = {}
+    constructor(config) {
+        this.configure(config);
+    }
+    load(data) {
+        if (this.#enabled) {
+            extend(this.#list, data || {});
         }
-        return this
-    };
-    this.get = function (key) {
-        if (cache.enabled) {
-            return cache.list[key]
+    }
+    get(key) {
+        if (this.#enabled) {
+            return this.#list[key]
         }
-    };
-    this.set = function (key, value) {
-        if (cache.enabled) {
-            cache.list[key] = value;
+    }
+    set(key, value) {
+        if (this.#enabled) {
+            this.#list[key] = value;
         }
-        return this
-    };
-    this.resolve = function (key) {
+    }
+    exist(key) {
+        return hasProp(this.#list, key)
+    }
+    clear() {
+        this.#list = {};
+    }
+    remove(key) {
+        delete this.#list[key];
+    }
+    resolve(key) {
         return Promise.resolve(this.get(key))
-    };
-    this.remove = function (key) {
-        delete cache.list[key];
-    };
-    this.exist = function (key) {
-        return hasProp(cache.list, key)
-    };
+    }
+    configure(config) {
+        this.#enabled = config.cache;
+        if (isNode() === false) {
+            this.load(global[config.export]);
+        }
+    }
 }
 
-const tagList = [
-    {
-        symbol: '-',
-        format(value) {
-            return `')\n${this.BUFFER}(${this.SAFE}(${value},1))\n${this.BUFFER}('`
+class Compiler {
+    #config = {}
+    #symbols = [
+        {
+            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${this.BUFFER}(${this.SAFE}(${value}))\n${this.BUFFER}('`
+            },
         },
-    },
-    {
-        symbol: '#',
-        format(value) {
-            return `')\n/**${value}**/\n${this.BUFFER}('`
+        {
+            symbol: '#',
+            format(value) {
+                return `')\n/**${value}**/\n${this.BUFFER}('`
+            },
         },
-    },
-    {
-        symbol: '',
-        format(value) {
-            return `')\n${value.trim()}\n${this.BUFFER}('`
+        {
+            symbol: '',
+            format(value) {
+                return `')\n${value.trim()}\n${this.BUFFER}('`
+            },
         },
-    },
-];
-
-function matchTokens(regex, text, callback) {
-    let index = 0;
-    text.replace(regex, function () {
-        const params = [].slice.call(arguments, 0, -1);
-        const offset = params.pop();
-        const match = params.shift();
-        callback(params, index, offset);
-        index = offset + match.length;
-        return match
-    });
-}
-
-function Compiler(config) {
-    if (instanceOf(this, Compiler) === false) return new Compiler(config)
-
-    const compiler = {};
-
-    this.configure = function (config) {
-        compiler.withObject = config.withObject;
-        compiler.rmWhitespace = config.rmWhitespace;
-        compiler.token = config.token;
-        compiler.vars = config.vars;
-        compiler.globalHelpers = config.globalHelpers;
-        compiler.matches = [];
-        compiler.formats = [];
-        compiler.slurp = {
-            match: '[\s\t\n]*',
-            start: [compiler.token.start, '_'],
-            end: ['_', compiler.token.end],
+    ]
+    constructor(config) {
+        this.configure(config);
+    }
+    configure(config) {
+        this.#config.withObject = config.withObject;
+        this.#config.rmWhitespace = config.rmWhitespace;
+        this.#config.token = config.token;
+        this.#config.vars = config.vars;
+        this.#config.globalHelpers = config.globalHelpers;
+        this.#config.matches = [];
+        this.#config.formats = [];
+        this.#config.slurp = {
+            match: '[s\t\n]*',
+            start: [this.#config.token.start, '_'],
+            end: ['_', this.#config.token.end],
         };
-        tagList.forEach((item) => {
-            compiler.matches.push(
-                compiler.token.start
+        this.#symbols.forEach((item) => {
+            this.#config.matches.push(
+                this.#config.token.start
                     .concat(item.symbol)
-                    .concat(compiler.token.regex)
-                    .concat(compiler.token.end)
+                    .concat(this.#config.token.regex)
+                    .concat(this.#config.token.end)
             );
-            compiler.formats.push(item.format.bind(compiler.vars));
+            this.#config.formats.push(item.format.bind(this.#config.vars));
         });
-        compiler.regex = new RegExp(
-            compiler.matches.join('|').concat('|$'),
+        this.#config.regex = new RegExp(
+            this.#config.matches.join('|').concat('|$'),
             'g'
         );
-        compiler.slurpStart = new RegExp(
-            [compiler.slurp.match, compiler.slurp.start.join('')].join(''),
+        this.#config.slurpStart = new RegExp(
+            [this.#config.slurp.match, this.#config.slurp.start.join('')].join(
+                ''
+            ),
             'gm'
         );
-        compiler.slurpEnd = new RegExp(
-            [compiler.slurp.end.join(''), compiler.slurp.match].join(''),
+        this.#config.slurpEnd = new RegExp(
+            [this.#config.slurp.end.join(''), this.#config.slurp.match].join(
+                ''
+            ),
             'gm'
         );
-    };
-
-    this.compile = function (content, path) {
-        const { SCOPE, SAFE, BUFFER, COMPONENT } = compiler.vars;
-        const GLOBALS = compiler.globalHelpers;
-        content = String(content);
-        if (compiler.rmWhitespace) {
-            content = content
+    }
+    compile(content, path) {
+        const { SCOPE, SAFE, BUFFER, COMPONENT, ELEMENT } = this.#config.vars;
+        const GLOBALS = this.#config.globalHelpers;
+        if (this.#config.rmWhitespace) {
+            content = String(content)
                 .replace(/[\r\n]+/g, '\n')
                 .replace(/^\s+|\s+$/gm, '');
         }
-        content = content
-            .replace(compiler.slurpStart, compiler.token.start)
-            .replace(compiler.slurpEnd, compiler.token.end);
+        content = String(content)
+            .replace(this.#config.slurpStart, this.#config.token.start)
+            .replace(this.#config.slurpEnd, this.#config.token.end);
         let source = `${BUFFER}('`;
-        matchTokens(compiler.regex, content, (params, index, offset) => {
+        matchTokens(this.#config.regex, content, (params, index, offset) => {
             source += symbols(content.slice(index, offset));
             params.forEach((value, index) => {
                 if (value) {
-                    source += compiler.formats[index](value);
+                    source += this.#config.formats[index](value);
                 }
             });
         });
         source += `');`;
         source = `try{${source}}catch(e){return ${BUFFER}.error(e)}`;
-        if (compiler.withObject) {
+        if (this.#config.withObject) {
             source = `with(${SCOPE}){${source}}`;
         }
         source = `${BUFFER}.start();${source}return ${BUFFER}.end();`;
         source += `\n//# sourceURL=${path}`;
         let result = null;
-        let params = [SCOPE, COMPONENT, BUFFER, SAFE].concat(GLOBALS);
+        let params = [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT].concat(GLOBALS);
         try {
             result = Function.apply(null, params.concat(source));
             result.source = `(function(${params.join(',')}){\n${source}\n});`;
@@ -396,57 +419,49 @@ function Compiler(config) {
             throw e
         }
         return result
-    };
-
-    this.configure(config);
+    }
 }
 
-function Template(config, cache, compiler) {
-    if (instanceOf(this, Template) === false)
-        return new Template(config, cache, compiler)
-
-    if (instanceOf(cache, Cache) === false)
-        throw new TypeError('cache is not instance of Cache')
-
-    if (instanceOf(compiler, Compiler) === false)
-        throw new TypeError('compiler is not instance of Compiler')
-
-    const template = {};
-
-    const result = (template, content) => {
-        cache.set(template, content);
+class Template {
+    #path
+    #cache
+    #compiler
+    #resolver
+    constructor(config, cache, compiler) {
+        assertInstanceOf(cache, Cache);
+        assertInstanceOf(compiler, Compiler);
+        this.#cache = cache;
+        this.#compiler = compiler;
+        this.configure(config);
+    }
+    #resolve(path) {
+        return this.#resolver(this.#path, path)
+    }
+    #result(template, content) {
+        this.#cache.set(template, content);
         return content
-    };
-
-    const resolve = (path) => {
-        return template.resolver(template.path, path)
-    };
-
-    const compile = (content, template) => {
+    }
+    #compile(content, template) {
         if (isFunction(content)) {
             return content
         } else {
-            return compiler.compile(content, template)
+            return this.#compiler.compile(content, template)
         }
-    };
-
-    this.configure = function (config) {
-        template.path = config.path;
-        template.cache = config.cache;
+    }
+    configure(config) {
+        this.#path = config.path;
         if (isFunction(config.resolver)) {
-            template.resolver = config.resolver;
+            this.#resolver = config.resolver;
         }
-    };
-
-    this.get = function (template) {
-        if (cache.exist(template)) {
-            return cache.resolve(template)
+    }
+    get(template) {
+        if (this.#cache.exist(template)) {
+            return this.#cache.resolve(template)
         }
-        return resolve(template).then((content) =>
-            result(template, compile(content, template))
+        return this.#resolve(template).then((content) =>
+            this.#result(template, this.#compile(content, template))
         )
-    };
-    this.configure(config);
+    }
 }
 
 const selfClosed = [
@@ -494,542 +509,473 @@ const element = (tag, attrs, content) => {
     return result.join('')
 };
 
-/**
- * @extends Error
- * @property code
- * @param {string} message
- * @constructor
- */
-function TemplateError(message) {
-    this.name = 'TemplateError';
-    this.message = message;
-    Error.call(this);
+class TemplateError extends Error {
+    code = 0
+    constructor(message) {
+        super();
+        this.message = message;
+    }
+    getCode() {
+        return this.code
+    }
+    getMessage() {
+        return this.message
+    }
+    toString() {
+        return this.getMessage()
+    }
 }
 
-/**
- *
- */
-Object.setPrototypeOf(TemplateError.prototype, Error.prototype);
-Object.assign(TemplateError.prototype, {  code: 1 });
-/**
- *
- * @return {number}
- */
-TemplateError.prototype.getCode = function() {
-    return this.code
-};
-/**
- *
- * @return {string}
- */
-TemplateError.prototype.getMessage = function() {
-    return this.message
-};
-/**
- * @return {string}
- */
-TemplateError.prototype.toString = function() {
-    return this.getMessage()
-};
-
-/**
- * @extends TemplateError
- * @param {string} message
- * @constructor
- */
-function TemplateNotFound(message) {
-    TemplateError.call(this);
-    this.name = 'TemplateNotFound';
-    this.message = message;
+class TemplateNotFound extends TemplateError {
+    code = 404
 }
 
-/**
- *
- */
-Object.setPrototypeOf(TemplateNotFound.prototype, TemplateError.prototype);
-Object.assign(TemplateNotFound.prototype, {  code: 404 });
-/**
- * @extends TemplateError
- * @param {string} message
- * @constructor
- */
-function TemplateSyntaxError(message) {
-    TemplateError.call(this);
-    this.name = 'TemplateSyntaxError';
-    this.message = message;
+class TemplateSyntaxError extends TemplateError {
+    code = 500
 }
 
-/**
- *
- */
-Object.setPrototypeOf(TemplateSyntaxError.prototype, TemplateError.prototype);
-Object.assign(TemplateSyntaxError.prototype, {  code: 500 });
-
 function resolve(list) {
-    return Promise.all(list || []).then((list) => list.join('')).catch((e) => e)
+    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 = [];
 
-    function buffer(value) {
+    const buffer = (value) => {
         array.push(value);
-    }
+    };
 
-    buffer.start = function() {
+    buffer.start = () => {
         array = [];
     };
-    buffer.backup = function() {
+    buffer.backup = () => {
         store.push(array.concat());
         array = [];
     };
-    buffer.restore = function() {
+    buffer.restore = () => {
         const result = array.concat();
         array = store.pop();
         return resolve(result)
     };
-    buffer.error = function(e) {
+    buffer.error = (e) => {
         return reject(e)
     };
-    buffer.end = function() {
+    buffer.end = () => {
         return resolve(array)
     };
     return buffer
 }
 
-function Context(config) {
-    if (instanceOf(this, Context) === false) return new Context(config)
-    this.configure = function (config, methods) {
-        const { BLOCKS, MACRO, EXTEND, LAYOUT, BUFFER, COMPONENT } = config.vars;
-
-        this.create = function (data) {
-            return new Scope(data)
-        };
-
-        this.helpers = function (methods) {
-            extend(Scope.prototype, methods || {});
-        };
-        /**
-         * @name ContextScope
-         * @param data
-         * @constructor
-         */
-        function Scope(data) {
-            this[BLOCKS] = {};
-            this[MACRO] = {};
-            extend(this, data || {});
-        }
-
-        Scope.prototype = extend({}, methods || {});
-        Object.defineProperties(Scope.prototype, {
-            [BUFFER]: {
-                value: createBuffer(),
-                writable: true,
-                configurable: false,
-                enumerable: false,
-            },
-            [BLOCKS]: {
-                value: {},
-                writable: true,
-                configurable: false,
-                enumerable: false,
-            },
-            [MACRO]: {
-                value: {},
-                writable: true,
-                configurable: false,
-                enumerable: false,
-            },
-            [LAYOUT]: {
-                value: false,
-                writable: true,
-                configurable: false,
-                enumerable: false,
-            },
-            [EXTEND]: {
-                value: false,
-                writable: true,
-                configurable: false,
-                enumerable: false,
+const createContextScope = (config, methods) => {
+    const {
+        BLOCKS,
+        MACRO,
+        EXTEND,
+        LAYOUT,
+        BUFFER,
+        SAFE,
+        SCOPE,
+        COMPONENT,
+        ELEMENT,
+    } = config.vars;
+    /**
+     * @name ContextScope
+     * @param data
+     * @constructor
+     */
+    function ContextScope(data) {
+        this[BLOCKS] = {};
+        this[MACRO] = {};
+        Object.assign(
+            this,
+            omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT])
+        );
+    }
+    Object.assign(ContextScope.prototype, methods);
+    Object.defineProperties(ContextScope.prototype, {
+        [BUFFER]: {
+            value: createBuffer(),
+        },
+        [BLOCKS]: {
+            value: {},
+            writable: true,
+        },
+        [MACRO]: {
+            value: {},
+            writable: true,
+        },
+        [LAYOUT]: {
+            value: false,
+            writable: true,
+        },
+        [EXTEND]: {
+            value: false,
+            writable: true,
+        },
+        /** @type {function} */
+        useSafeValue: {
+            get: () => safeValue,
+        },
+        /** @type {function} */
+        useComponent: {
+            get() {
+                if (isFunction(this[COMPONENT])) {
+                    return this[COMPONENT].bind(this)
+                } else {
+                    return () => {
+                        throw new Error(`${COMPONENT} must be a function`)
+                    }
+                }
             },
-            getMacro: {
-                value() {
-                    return this[MACRO]
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        useElement: {
+            get() {
+                if (isFunction(this[ELEMENT])) {
+                    return this[ELEMENT].bind(this)
+                } else {
+                    return () => {
+                        throw new Error(`${ELEMENT} must be a function`)
+                    }
+                }
             },
-            getBuffer: {
-                value() {
-                    return this[BUFFER]
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {()=>this[MACRO]} */
+        getMacro: {
+            value() {
+                return this[MACRO]
             },
-            getComponent: {
-                value() {
-                    const context = this;
-                    if (COMPONENT in context) {
-                        return function () {
-                            return context[COMPONENT].apply(context, arguments)
-                        }
-                    }
-                    return function () {
-                        console.log('%s function not defined', COMPONENT);
-                    }
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        getBuffer: {
+            value() {
+                return this[BUFFER]
             },
-            getBlocks: {
-                value() {
-                    return this[BLOCKS]
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        getBlocks: {
+            value() {
+                return this[BLOCKS]
             },
-            setExtend: {
-                value(value) {
-                    this[EXTEND] = value;
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        setExtend: {
+            value(value) {
+                this[EXTEND] = value;
             },
-            getExtend: {
-                value() {
-                    return this[EXTEND]
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        getExtend: {
+            value() {
+                return this[EXTEND]
             },
-            setLayout: {
-                value(layout) {
-                    this[LAYOUT] = layout;
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        setLayout: {
+            value(layout) {
+                this[LAYOUT] = layout;
             },
-            getLayout: {
-                value() {
-                    return this[LAYOUT]
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        getLayout: {
+            value() {
+                return this[LAYOUT]
             },
-            clone: {
-                value(exclude_blocks) {
-                    const filter = [LAYOUT, EXTEND, BUFFER];
-                    if (exclude_blocks === true) {
-                        filter.push(BLOCKS);
-                    }
-                    return omit(this, filter)
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        clone: {
+            value(exclude_blocks) {
+                const filter = [LAYOUT, EXTEND, BUFFER];
+                if (exclude_blocks === true) {
+                    filter.push(BLOCKS);
+                }
+                return omit(this, filter)
             },
-            extend: {
-                value(layout) {
-                    this.setExtend(true);
-                    this.setLayout(layout);
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        extend: {
+            value(layout) {
+                this.setExtend(true);
+                this.setLayout(layout);
             },
-            echo: {
-                value(layout) {
-                    const buffer = this.getBuffer();
-                    const params = [].slice.call(arguments);
-                    params.forEach(buffer);
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        echo: {
+            value(layout) {
+                const buffer = this.getBuffer();
+                const params = [].slice.call(arguments);
+                params.forEach(buffer);
             },
-            fn: {
-                value(callback) {
-                    const buffer = this.getBuffer();
-                    const context = this;
-                    return function () {
+        },
+        /** @type {function} */
+        fn: {
+            value(callback) {
+                const buffer = this.getBuffer();
+                const context = this;
+                return function () {
+                    if (isFunction(callback)) {
                         buffer.backup();
-                        if (isFunction(callback)) {
-                            callback.apply(context, arguments);
-                        }
+                        buffer(callback.apply(context, arguments));
                         return buffer.restore()
                     }
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
-            },
-            get: {
-                value(name, defaults) {
-                    const path = getPath(this, name, true);
-                    const result = path.shift();
-                    const prop = path.pop();
-                    return hasProp(result, prop) ? result[prop] : defaults
-                },
-                writable: true,
-                configurable: true,
-                enumerable: false,
-            },
-            set: {
-                value(name, value) {
-                    const path = getPath(this, name, false);
-                    const result = path.shift();
-                    const prop = path.pop();
-                    if (this.getExtend() && hasProp(result, prop)) {
-                        return result[prop]
-                    }
-                    return (result[prop] = value)
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+                }
             },
-            macro: {
-                value(name, callback) {
-                    const list = this.getMacro();
-                    const macro = this.fn(callback);
-                    const context = this;
-                    list[name] = function () {
-                        return context.echo(macro.apply(undefined, arguments))
-                    };
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        macro: {
+            value(name, callback) {
+                const list = this.getMacro();
+                const macro = this.fn(callback);
+                const context = this;
+                list[name] = function () {
+                    return context.echo(macro.apply(undefined, arguments))
+                };
             },
-            call: {
-                value(name) {
-                    const list = this.getMacro();
-                    const macro = list[name];
-                    const params = [].slice.call(arguments, 1);
-                    if (isFunction(macro)) {
-                        return macro.apply(macro, params)
-                    }
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        call: {
+            value(name) {
+                const list = this.getMacro();
+                const macro = list[name];
+                const params = [].slice.call(arguments, 1);
+                if (isFunction(macro)) {
+                    return macro.apply(macro, params)
+                }
             },
-            block: {
-                value(name, callback) {
-                    const blocks = this.getBlocks();
-                    blocks[name] = blocks[name] || [];
-                    blocks[name].push(this.fn(callback));
-                    if (this.getExtend()) return
-                    const list = Object.assign([], blocks[name]);
-                    const current = function () {
-                        return list.shift()
-                    };
-                    const next = () => {
-                        const parent = current();
-                        if (parent) {
-                            return () => {
-                                this.echo(parent(next()));
-                            }
-                        } else {
-                            return noop
+        },
+        /** @type {function} */
+        block: {
+            value(name, callback) {
+                const blocks = this.getBlocks();
+                blocks[name] = blocks[name] || [];
+                blocks[name].push(this.fn(callback));
+                if (this.getExtend()) return
+                const list = Object.assign([], blocks[name]);
+                const current = () => {
+                    return list.shift()
+                };
+                const next = () => {
+                    const parent = current();
+                    if (parent) {
+                        return () => {
+                            this.echo(parent(next()));
                         }
-                    };
-                    this.echo(current()(next()));
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+                    } else {
+                        return noop
+                    }
+                };
+                this.echo(current()(next()));
             },
-            hasBlock: {
-                value(name) {
-                    return this.getBlocks().hasOwnProperty(name)
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        hasBlock: {
+            value(name) {
+                return this.getBlocks().hasOwnProperty(name)
             },
-            include: {
-                value(path, data, cx) {
-                    const context = cx === false ? {} : this.clone(true);
-                    const params = extend(context, data || {});
-                    const promise = this.render(path, params);
-                    this.echo(promise);
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        include: {
+            value(path, data, cx) {
+                const context = cx === false ? {} : this.clone(true);
+                const params = extend(context, data || {});
+                const promise = this.render(path, params);
+                this.echo(promise);
             },
-            promiseResolve: {
-                value(value, callback) {
-                    return Promise.resolve(
-                        isFunction(value) ? this.fn(value)() : value
-                    ).then(callback.bind(this))
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        use: {
+            value(path, namespace) {
+                this.echo(
+                    Promise.resolve(this.require(path)).then((exports) => {
+                        const list = this.getMacro();
+                        each(exports, function (macro, name) {
+                            list[[namespace, name].join('.')] = macro;
+                        });
+                    })
+                );
             },
-            use: {
-                value(path, namespace) {
-                    this.echo(
-                        this.promiseResolve(
-                            this.require(path),
-                            function (exports) {
-                                const list = this.getMacro();
-                                each(exports, function (macro, name) {
-                                    list[[namespace, name].join('.')] = macro;
-                                });
-                            }
-                        )
-                    );
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        async: {
+            value(promise, callback) {
+                this.echo(Promise.resolve(promise).then(callback));
             },
-            async: {
-                value(promise, callback) {
-                    this.echo(
-                        this.promiseResolve(promise, function (data) {
-                            return this.fn(callback)(data)
-                        })
-                    );
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        get: {
+            value(name, defaults) {
+                const path = getPath(this, name, true);
+                const result = path.shift();
+                const prop = path.pop();
+                return hasProp(result, prop) ? result[prop] : defaults
             },
-            each: {
-                value: function (object, callback) {
-                    if (isString(object)) {
-                        object = this.get(object, []);
-                    }
-                    each(object, callback);
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        set: {
+            value(name, value) {
+                const path = getPath(this, name, false);
+                const result = path.shift();
+                const prop = path.pop();
+                if (this.getExtend() && hasProp(result, prop)) {
+                    return result[prop]
+                }
+                return (result[prop] = value)
             },
-            element: {
-                value(tag, attr, content) {
-                    return element(tag, attr, content)
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+        },
+        /** @type {function} */
+        each: {
+            value: function (object, callback) {
+                if (isString(object)) {
+                    object = this.get(object, []);
+                }
+                each(object, callback);
             },
-            el: {
-                value(tag, attr, content) {
-                    this.echo(
-                        this.promiseResolve(content, function (content) {
-                            return this.element(tag, attr, content)
-                        })
-                    );
-                },
-                writable: false,
-                configurable: false,
-                enumerable: false,
+            writable: true,
+        },
+        /** @type {function} */
+        el: {
+            value(tag, attr, content) {
+                content = isFunction(content) ? this.fn(content)() : content;
+                this.echo(
+                    Promise.resolve(content).then((content) =>
+                        element(tag, attr, content)
+                    )
+                );
             },
-        });
-    };
-    this.configure(config);
-}
-
-function EJS(options) {
-    if (instanceOf(this, EJS) === false) return new EJS(options)
-
-    const scope = {};
-    const config = {};
-
-    configSchema(config, options || {});
+            writable: true,
+        },
+        /** @type {function} */
+        ui: {
+            value(layout) {},
+            writable: true,
+        },
+    });
+    return ContextScope
+};
 
-    const context = new Context(config);
-    const compiler = new Compiler(config);
-    const cache = new Cache();
-    const template = new Template(config, cache, compiler);
+class Context {
+    #scope
+    constructor(config, methods) {
+        this.configure(config, methods);
+    }
+    create(data) {
+        return new this.#scope(data)
+    }
+    configure(config, methods) {
+        this.#scope = createContextScope(config, methods);
+    }
+    helpers(methods) {
+        extend(this.#scope.prototype, methods || {});
+    }
+}
 
-    const output = (path, scope) => {
-        const { globalHelpers } = config;
+class EJS {
+    #config = {}
+    #extend = {}
+    #context
+    #compiler
+    #cache
+    #template
+    constructor(options) {
+        configSchema(this.#config, options || {});
+        this.#context = new Context(this.#config, this.#extend);
+        this.#compiler = new Compiler(this.#config);
+        this.#cache = new Cache(this.#config);
+        this.#template = new Template(this.#config, this.#cache, this.#compiler);
+        //
+        bindContext(this, [
+            'configure',
+            'create',
+            'render',
+            'require',
+            'context',
+            'preload',
+            'compile',
+            'helpers',
+        ]);
+        //
+        this.helpers({ require: this.require, render: this.render });
+    }
+    configure(options) {
+        configSchema(this.#config, options || {});
+        this.#context.configure(this.#config, this.#extend);
+        this.#compiler.configure(this.#config);
+        this.#cache.configure(this.#config);
+        this.#template.configure(this.#config);
+        return this.#config
+    }
+    render(name, data) {
+        const filepath = ext(name, this.#config.extension);
+        const scope = this.context(data);
+        return this.#output(filepath, scope).then((content) => {
+            if (scope.getExtend()) {
+                scope.setExtend(false);
+                const layout = scope.getLayout();
+                const data = scope.clone();
+                return this.render(layout, data)
+            }
+            return content
+        })
+    }
+    helpers(methods) {
+        this.#context.helpers(extend(this.#extend, methods));
+    }
+    context(data) {
+        return this.#context.create(data)
+    }
+    compile(content, path) {
+        return this.#compiler.compile(content, path)
+    }
+    preload(list) {
+        return this.#cache.load(list || {})
+    }
+    create(options) {
+        return new this.constructor(options)
+    }
+    require(name) {
+        const filepath = ext(name, this.#config.extension);
+        const scope = this.context({});
+        return this.#output(filepath, scope).then(() => scope.getMacro())
+    }
+    #output(path, scope) {
+        const { globalHelpers } = this.#config;
         const params = [
             scope,
-            scope.getComponent(),
             scope.getBuffer(),
-            safeValue,
+            scope.useSafeValue,
+            scope.useComponent,
+            scope.useElement,
         ].concat(
             globalHelpers
                 .filter((name) => isFunction(scope[name]))
                 .map((name) => scope[name].bind(scope))
         );
-        return template
+        return this.#template
             .get(path)
             .then((callback) => callback.apply(scope, params))
-    };
-
-    const require = (name) => {
-        const filepath = ext(name, config.extension);
-        const scope = context.create({});
-        return output(filepath, scope).then(() => scope.getMacro())
-    };
-    const render = (name, data) => {
-        const filepath = ext(name, config.extension);
-        const scope = context.create(data);
-        return output(filepath, scope).then((content) => {
-            if (scope.getExtend()) {
-                scope.setExtend(false);
-                const layout = scope.getLayout();
-                const data = scope.clone();
-                return render(layout, data)
-            }
-            return content
-        })
-    };
-    this.configure = function (options) {
-        options = options || {};
-        configSchema(config, options);
-        context.configure(config, scope);
-        compiler.configure(config);
-        cache.configure(config);
-        template.configure(config);
-        return config
-    };
-    this.render = function (name, data) {
-        return render(name, data)
-    };
-    this.helpers = function (methods) {
-        context.helpers(extend(scope, methods));
-    };
-    this.preload = function (list) {
-        return cache.load(list || {})
-    };
-    this.create = function (options) {
-        return new EJS(options)
-    };
-    this.compile = function (content, path) {
-        return compiler.compile(content, path)
-    };
-    this.context = function (data) {
-        return context.create(data)
-    };
-    this.helpers({ require, render });
-    return this
+    }
 }
 
-const hash = Math.floor(Math.random() * 1e12).toString(36);
 const templates = {};
-const ejs = new EJS({
+
+const getOrigin = (url, secure) => {
+    url = new URL(url);
+    url.protocol = secure ? 'https:' : 'http:';
+    return url.origin
+};
+
+const { render, context, helpers, configure, create } = new EJS({
     cache: false,
     withObject: false,
     resolver(path, name) {
@@ -1040,24 +986,19 @@ const ejs = new EJS({
                 reject(new TemplateNotFound(`template ${name} not found`));
             }
         })
-    }
+    },
 });
 
-const { render, context, helpers, configure, create } = ejs;
-
-const getOrigin = (url, secure) => {
-    url = new URL(url);
-    if (secure) url.protocol = 'https:';
-    return url.origin
-};
-
-
+/**
+ *
+ * @param list
+ */
 function setTemplates(list) {
     Object.assign(templates, list || {});
 }
 
 /**
- * @typedef {Object<string,any>} HonoContext
+ * @typedef {{}} HonoContext
  * @property {function(*):Promise<Response>} html
  * @property {function():Promise<Response>} notFound
  * @property {function(methods:{}):void} helpers
@@ -1068,24 +1009,23 @@ function setTemplates(list) {
 
 /**
  * @param {Object<string,any>} options
- * @return {(function(c:Context, next): Promise<any>)|*}
+ * @return {(function(c:HonoContext, next): Promise<any>)|*}
  */
-function setRenderer({ version = hash, secure = true } = {}) {
+function setRenderer({ version, secure = true } = {}) {
     return async (c, next) => {
         c.data = context({});
         c.data.set('version', version);
         c.data.set('origin', getOrigin(c.req.url, secure));
         c.data.set('path', c.req.path);
         c.data.set('query', c.req.query());
-        c.ejs = (name, data) => render(name, Object.assign({
-            param: c.req.param(),
-        }, c.data, data));
+        c.ejs = (name, data) =>
+            render(name, Object.assign({ param: c.req.param() }, c.data, data));
         c.helpers = (methods) => helpers(methods);
         c.render = (name, data) => c.html(c.ejs(name, data));
         await next();
     }
 }
 
-const version = hash;
+//export { render, context, helpers, configure, create }
 
-export { TemplateError, TemplateNotFound, TemplateSyntaxError, configure, context, create, helpers, render, setRenderer, setTemplates, version };
+export { TemplateError, TemplateNotFound, TemplateSyntaxError, configure, context, create, helpers, render, setRenderer, setTemplates };