@kosatyi/ejs 0.0.112 → 0.0.114

package/dist/types/browser.d.ts

@@ -0,0 +1,27 @@
+import { E as EjsInstance } from './index-BiIhwNBq.js';
+import { j as joinPath } from './element-CEdJaM42.js';
+export { e as element, a as escapeValue } from './element-CEdJaM42.js';
+
+const resolver = async (path, template, error) => {
+    return fetch(joinPath(path, template)).then(
+        (response) => {
+            if (response.ok) return response.text()
+            return error(1, `template ${template} not found`)
+        },
+        (reason) => error(0, reason),
+    )
+};
+
+const {
+    render,
+    configure,
+    create,
+    helpers,
+    createContext,
+    compile,
+    preload,
+} = new EjsInstance({
+    resolver,
+});
+
+export { compile, configure, create, createContext, helpers, preload, render };

package/dist/types/bundler.d.ts

@@ -0,0 +1,155 @@
+import fs from 'node:fs/promises';
+import globWatch from 'glob-watcher';
+import { join, dirname } from 'node:path';
+import { glob } from 'glob';
+import { b as bindContext } from './element-CEdJaM42.js';
+import { create } from './index.js';
+import './index-BiIhwNBq.js';
+
+class EjsBundler {
+    #templates = {}
+    #bundlerOptions = {
+        target: [],
+        umd: true,
+        minify: true,
+    }
+    #compile
+    #ejsOptions
+    #buildInProgress
+    static exports = ['build', 'watch', 'concat', 'output']
+
+    constructor(bundlerOptions = {}, ejsOptions = {}) {
+        bindContext(this, this.constructor.exports);
+        const { compile, configure } = create(ejsOptions);
+        Object.assign(this.#bundlerOptions, bundlerOptions);
+        this.#compile = compile;
+        this.#ejsOptions = configure({});
+        this.#buildInProgress = false;
+        this.#templates = {};
+    }
+
+    async #stageRead(path) {
+        return fs
+            .readFile(join(this.#ejsOptions.path, path))
+            .then((response) => response.toString())
+    }
+
+    #stageCompile(content, name) {
+        return this.#compile(content, name).source
+    }
+
+    #getBundle() {
+        const umd = this.#bundlerOptions.umd;
+        const strict = this.#ejsOptions.strict;
+        const module = this.#ejsOptions.precompiled;
+        const out = [];
+        if (umd) {
+            out.push('(function(global,factory){');
+            out.push(
+                'typeof exports === "object" && typeof module !== "undefined" ?',
+            );
+            out.push('module.exports = factory():');
+            out.push(
+                'typeof define === "function" && define.amd ? define(factory):',
+            );
+            out.push(
+                '(global = typeof globalThis !== "undefined" ? globalThis:',
+            );
+            out.push(`global || self,global["${module}"] = factory())`);
+            out.push('})(this,(function(){');
+        }
+        if (strict) out.push(`'use strict'`);
+        out.push('const templates = {}');
+        Object.entries(this.#templates).forEach(([name, content]) => {
+            name = JSON.stringify(name);
+            content = String(content);
+            out.push(`templates[${name}] = ${content}`);
+        });
+        if (umd) {
+            out.push('return templates}))');
+        } else {
+            out.push('export default templates');
+        }
+        return out.join('\n')
+    }
+
+    async build() {
+        if (this.#buildInProgress === true) return false
+        this.#buildInProgress = true;
+        await this.concat().catch(console.error);
+        await this.output().catch(console.error);
+        console.log('✅', 'bundle complete:', this.#bundlerOptions.target);
+        this.#buildInProgress = false;
+    }
+
+    async watch() {
+        console.log('🔍', 'watch directory:', this.#ejsOptions.path);
+        const pattern = '**/*.'.concat(this.#ejsOptions.extension);
+        const watcher = globWatch(pattern, { cwd: this.#ejsOptions.path });
+        const state = { build: null };
+        watcher.on('change', (path) => {
+            if (state.build) return
+            console.log('⟳', 'file change:', path);
+            state.build = this.build().then(() => {
+                state.build = null;
+            });
+        });
+        watcher.on('add', (path) => {
+            if (state.build) return
+            console.log('+', 'file added:', path);
+            state.build = this.build().then(() => {
+                state.build = null;
+            });
+        });
+    }
+
+    async concat() {
+        const pattern = '**/*.'.concat(this.#ejsOptions.extension);
+        const list = await glob(
+            pattern,
+            { cwd: this.#ejsOptions.path },
+            () => {},
+        );
+        for (let template of list) {
+            let content = '';
+            content = await this.#stageRead(template);
+            content = await this.#stageCompile(content, template);
+            this.#templates[template] = content;
+        }
+    }
+
+    async output() {
+        const target = [].concat(this.#bundlerOptions.target);
+        const content = this.#getBundle();
+        for (const file of target) {
+            const folderPath = dirname(file);
+            const folderExists = await fs
+                .stat(folderPath)
+                .then(() => true)
+                .catch(() => false);
+            if (folderExists === false) {
+                await fs.mkdir(folderPath, { recursive: true });
+            }
+            await fs.writeFile(file, content);
+        }
+    }
+}
+
+const bundler = (bundlerOptions = {}, ejsOptions = {}) => {
+    return new EjsBundler(bundlerOptions, ejsOptions)
+};
+
+const ejsRollupBundler = (bundlerOptions, ejsOptions) => {
+    const bundle = bundler(bundlerOptions, ejsOptions);
+    return {
+        name: 'ejs-bundler',
+        async buildStart() {
+            await bundle.concat();
+        },
+        async buildEnd() {
+            await bundle.output();
+        },
+    }
+};
+
+export { EjsBundler, bundler, ejsRollupBundler };

package/dist/types/element-CEdJaM42.d.ts

@@ -0,0 +1,178 @@
+const jsVariableName = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+
+const typeProp = function () {
+    const args = [].slice.call(arguments);
+    const callback = args.shift();
+    return args.filter(callback).pop()
+};
+const isArray = (value) => Array.isArray(value);
+const isFunction = (value) => typeof value === 'function';
+const isString = (value) => typeof value === 'string';
+const isBoolean = (value) => typeof value === 'boolean';
+const isArrayOfVariables = (value) => {
+    if (!isArray(value)) return false
+    return value.filter((name) => {
+        const valid = jsVariableName.test(name);
+        if (valid === false)
+            console.log(
+                `ejsConfig.globals: expected '${name}' to be valid variable name --> skipped`,
+            );
+        return valid
+    })
+};
+
+const symbolEntities = {
+    "'": "'",
+    '\\': '\\',
+    '\r': 'r',
+    '\n': 'n',
+    '\t': 't',
+    '\u2028': 'u2028',
+    '\u2029': 'u2029',
+};
+
+const htmlEntities = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#x27;',
+};
+
+const regexKeys = (obj) =>
+    new RegExp(['[', Object.keys(obj).join(''), ']'].join(''), 'g');
+
+const htmlEntitiesMatch = regexKeys(htmlEntities);
+
+const symbolEntitiesMatch = regexKeys(symbolEntities);
+
+const entities = (string = '') => {
+    return ('' + string).replace(
+        htmlEntitiesMatch,
+        (match) => htmlEntities[match],
+    )
+};
+
+const symbols = (string) => {
+    return ('' + string).replace(
+        symbolEntitiesMatch,
+        (match) => '\\' + symbolEntities[match],
+    )
+};
+
+const escapeValue = (value, escape) => {
+    const check = value;
+    return check == null
+        ? ''
+        : Boolean(escape) === true
+          ? entities(check)
+          : check
+};
+
+const getPath = (context, name, strict) => {
+    let data = context;
+    let chunks = String(name).split('.');
+    let prop = chunks.pop();
+    for (let i = 0; i < chunks.length; i++) {
+        const part = chunks[i];
+        if (isFunction(data['toJSON'])) {
+            data = data.toJSON();
+        }
+        if (strict && data.hasOwnProperty(part) === false) {
+            data = {};
+            break
+        }
+        data = data[part] = data[part] || {};
+    }
+    if (isFunction(data['toJSON'])) {
+        data = data.toJSON();
+    }
+    return [data, prop]
+};
+
+const each = (object, callback) => {
+    let prop;
+    for (prop in object) {
+        if (hasProp(object, prop)) {
+            callback(object[prop], prop, object);
+        }
+    }
+};
+
+const omit = (object, list) => {
+    const result = { ...object };
+    for (const key of list) {
+        delete result[key];
+    }
+    return result
+};
+
+const hasProp = (object, prop) => {
+    return object && Object.hasOwn(object, prop)
+};
+
+const joinPath = (path, template) => {
+    template = [path, template].join('/');
+    template = template.replace(/\/\//g, '/');
+    return template
+};
+
+const bindContext = (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);
+        }
+    }
+};
+
+const selfClosed = [
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+];
+
+const space = ' ';
+const quote = '"';
+const equal = '=';
+const slash = '/';
+const lt = '<';
+const gt = '>';
+
+const eachAttribute = ([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 = Object.entries(attrs ?? {})
+        .map(eachAttribute)
+        .filter((e) => e)
+        .join(space);
+    result.push([lt, tag, space, attributes, gt].join(''));
+    if (content && hasClosedTag) {
+        result.push(Array.isArray(content) ? content.join('') : content);
+    }
+    if (hasClosedTag) {
+        result.push([lt, slash, tag, gt].join(''));
+    }
+    return result.join('')
+};
+
+export { escapeValue as a, bindContext as b, isString as c, isBoolean as d, element as e, isArrayOfVariables as f, isArray as g, each as h, isFunction as i, joinPath as j, getPath as k, hasProp as l, omit as o, symbols as s, typeProp as t };

package/dist/types/element.d.ts

@@ -0,0 +1 @@
+export { e as element, a as escapeValue } from './element-CEdJaM42.js';

package/dist/types/index-BiIhwNBq.d.ts

@@ -0,0 +1,785 @@
+import { t as typeProp, f as isArrayOfVariables, g as isArray, d as isBoolean, c as isString, i as isFunction, b as bindContext, s as symbols, e as element, h as each, k as getPath, l as hasProp, o as omit, a as escapeValue } from './element-CEdJaM42.js';
+
+/**
+ * @type {EjsConfig}
+ */
+const ejsDefaults = {
+    precompiled: 'ejsPrecompiled',
+    cache: true,
+    path: 'views',
+    extension: 'ejs',
+    rmWhitespace: true,
+    strict: true,
+    resolver: (path, template) => {
+        return Promise.resolve(
+            ['resolver is not defined', path, template].join(' '),
+        )
+    },
+    globals: [],
+    vars: {
+        SCOPE: 'ejs',
+        COMPONENT: 'ui',
+        ELEMENT: 'el',
+        EXTEND: '$$e',
+        BUFFER: '$$a',
+        LAYOUT: '$$l',
+        BLOCKS: '$$b',
+        MACRO: '$$m',
+        SAFE: '$$v',
+    },
+    token: {
+        start: '<%',
+        end: '%>',
+        regex: '([\\s\\S]+?)',
+    },
+};
+
+const configSchema = (config, options) => {
+    return Object.assign(config, {
+        path: typeProp(isString, ejsDefaults.path, config.path, options.path),
+        precompiled: typeProp(
+            isString,
+            ejsDefaults.precompiled,
+            config.export,
+            options.export,
+        ),
+        resolver: typeProp(
+            isFunction,
+            ejsDefaults.resolver,
+            config.resolver,
+            options.resolver,
+        ),
+        extension: typeProp(
+            isString,
+            ejsDefaults.extension,
+            config.extension,
+            options.extension,
+        ),
+        strict: typeProp(
+            isBoolean,
+            ejsDefaults.strict,
+            config.strict,
+            options.strict,
+        ),
+        rmWhitespace: typeProp(
+            isBoolean,
+            ejsDefaults.rmWhitespace,
+            config.rmWhitespace,
+            options.rmWhitespace,
+        ),
+        cache: typeProp(
+            isBoolean,
+            ejsDefaults.cache,
+            config.cache,
+            options.cache,
+        ),
+        globals: typeProp(
+            isArray,
+            ejsDefaults.globals,
+            config.globals,
+            isArrayOfVariables(options.globals),
+        ),
+        token: Object.assign(
+            {},
+            ejsDefaults.token,
+            config.token,
+            options.token,
+        ),
+        vars: Object.assign({}, ejsDefaults.vars, config.vars, options.vars),
+    })
+};
+
+class EjsError extends Error {
+    constructor(code, content) {
+        super(content);
+        this.code = code;
+        if (content instanceof Error) {
+            this.stack = content.stack;
+            this.message = content.message;
+        }
+    }
+}
+
+const error = (code, content) => {
+    throw new EjsError(code, content)
+};
+
+class EjsTemplate {
+    #path
+    #resolver
+    #cache
+    #compiler
+    static exports = ['configure', 'get']
+    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, error),
+        );
+        this.#cache.set(template, result);
+        return result
+    }
+    #compile(content, template) {
+        const cached = this.#cache.get(template);
+        if (typeof cached === 'function') return cached
+        if (typeof content === 'string') {
+            content = this.#compiler.compile(content, template);
+        }
+        if (typeof content === 'function') {
+            this.#cache.set(template, content);
+            return content
+        }
+    }
+    get(template) {
+        return this.#resolve(template).then((content) => {
+            return 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;
+    content.replace(regex, function () {
+        const params = [].slice.call(arguments, 0, -1);
+        const offset = params.pop();
+        const match = params.shift();
+        callback(params, index, offset);
+        index = offset + match.length;
+        return match
+    });
+};
+
+class EjsCompiler {
+    #config = {}
+    static exports = ['configure', 'compile']
+    constructor(options) {
+        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 = {
+            match: '[s\t\n]*',
+            start: [this.#config.token.start, '_'],
+            end: ['_', this.#config.token.end],
+        };
+        this.#config.matches = [];
+        this.#config.formats = [];
+        for (const [symbol, format] of tokenList) {
+            this.#config.matches.push(
+                this.#config.token.start
+                    .concat(symbol)
+                    .concat(this.#config.token.regex)
+                    .concat(this.#config.token.end),
+            );
+            this.#config.formats.push(format);
+        }
+        this.#config.regex = new RegExp(
+            this.#config.matches.join('|').concat('|$'),
+            'g',
+        );
+        this.#config.slurpStart = new RegExp(
+            [this.#config.slurp.match, this.#config.slurp.start.join('')].join(
+                '',
+            ),
+            'gm',
+        );
+        this.#config.slurpEnd = new RegExp(
+            [this.#config.slurp.end.join(''), this.#config.slurp.match].join(
+                '',
+            ),
+            'gm',
+        );
+        if (this.#config.globals.length) {
+            if (this.#config.legacy) {
+                this.#config.globalVariables = `const ${this.#config.globals
+                    .map((name) => `${name}=${this.#config.vars.SCOPE}.${name}`)
+                    .join(',')};`;
+            } else {
+                this.#config.globalVariables = `const {${this.#config.globals.join(',')}} = ${this.#config.vars.SCOPE};`;
+            }
+        }
+    }
+    compile(content, path) {
+        const GLOBALS = this.#config.globalVariables;
+        const { SCOPE, SAFE, BUFFER, COMPONENT, ELEMENT } = this.#config.vars;
+        if (this.#config.rmWhitespace) {
+            content = String(content)
+                .replace(/[\r\n]+/g, '\n')
+                .replace(/^\s+|\s+$/gm, '');
+        }
+        content = String(content)
+            .replace(this.#config.slurpStart, this.#config.token.start)
+            .replace(this.#config.slurpEnd, this.#config.token.end);
+        let OUTPUT = `${BUFFER}('`;
+        tokensMatch(this.#config.regex, content, (params, index, offset) => {
+            OUTPUT += symbols(content.slice(index, offset));
+            params.forEach((value, index) => {
+                if (value) {
+                    OUTPUT += this.#config.formats[index](
+                        value.trim(),
+                        BUFFER,
+                        SAFE,
+                    );
+                }
+            });
+        });
+        OUTPUT += `');`;
+        OUTPUT = `try{${OUTPUT}}catch(e){return ${BUFFER}.error(e)}`;
+        if (this.#config.strict === false) {
+            OUTPUT = `with(${SCOPE}){${OUTPUT}}`;
+        }
+        OUTPUT = `${BUFFER}.start();${OUTPUT}return ${BUFFER}.end();`;
+        OUTPUT += `\n//# sourceURL=${path}`;
+        if (GLOBALS) {
+            OUTPUT = `${GLOBALS}\n${OUTPUT}`;
+        }
+        try {
+            const params = [SCOPE, COMPONENT, ELEMENT, BUFFER, SAFE];
+            const result = Function.apply(null, params.concat(OUTPUT));
+            result.source = `(function(${params.join(',')}){\n${OUTPUT}\n});`;
+            return result
+        } catch (e) {
+            e.filename = path;
+            e.source = OUTPUT;
+            error(0, e);
+        }
+    }
+}
+
+class EjsCache {
+    static exports = [
+        'load',
+        'set',
+        'get',
+        'exist',
+        'clear',
+        'remove',
+        'resolve',
+    ]
+    #cache = true
+    #precompiled
+    #list = {}
+    constructor(options) {
+        bindContext(this, this.constructor.exports);
+        this.configure(options);
+    }
+    get(key) {
+        if (this.#cache) {
+            return this.#list[key]
+        }
+    }
+    set(key, value) {
+        if (this.#cache) {
+            this.#list[key] = value;
+        }
+    }
+    exist(key) {
+        if (this.#cache) {
+            return this.#list.hasOwnProperty(key)
+        }
+    }
+    clear() {
+        Object.keys(this.#list).forEach(this.remove);
+    }
+    remove(key) {
+        delete this.#list[key];
+    }
+    resolve(key) {
+        return Promise.resolve(this.get(key))
+    }
+    load(data) {
+        if (this.#cache) {
+            Object.assign(this.#list, data || {});
+        }
+    }
+    configure(options) {
+        this.#cache = options.cache;
+        this.#precompiled = options.precompiled;
+        if (typeof window === 'object') {
+            this.load(window[this.#precompiled]);
+        }
+    }
+}
+
+const resolve = (list) => {
+    return Promise.all(list || [])
+        .then((list) => list.join(''))
+        .catch((e) => error(0, e))
+};
+
+const reject = (e) => {
+    return Promise.reject(error(0, e))
+};
+
+const EjsBuffer = () => {
+    let store = [];
+    let array = [];
+    /**
+     *
+     * @param value
+     * @constructor
+     */
+    const EjsBuffer = (value) => {
+        array.push(value);
+    };
+    EjsBuffer.start = () => {
+        array = [];
+    };
+    EjsBuffer.backup = () => {
+        store.push(array.concat());
+        array = [];
+    };
+    EjsBuffer.restore = () => {
+        const result = array.concat();
+        array = store.pop();
+        return resolve(result)
+    };
+    EjsBuffer.error = (e) => {
+        return reject(e)
+    };
+    EjsBuffer.end = () => {
+        return resolve(array)
+    };
+    return EjsBuffer
+};
+
+const PARENT = Symbol('EjsContext.parentTemplate');
+
+const createContext = (config, methods) => {
+    const globals = config.globals || [];
+    const {
+        BLOCKS,
+        MACRO,
+        EXTEND,
+        LAYOUT,
+        BUFFER,
+        SAFE,
+        SCOPE,
+        COMPONENT,
+        ELEMENT,
+    } = config.vars;
+    class Context {
+        constructor(data) {
+            this[PARENT] = null;
+            this[BLOCKS] = {};
+            this[MACRO] = {};
+            Object.assign(
+                this,
+                omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT]),
+            );
+        }
+    }
+    Object.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
+            },
+        },
+        getParentTemplate: {
+            value() {
+                return this[PARENT]
+            },
+        },
+        useEscapeValue: {
+            value() {
+                return escapeValue
+            },
+        },
+        useComponent: {
+            value() {
+                if (isFunction(this[COMPONENT])) {
+                    return this[COMPONENT].bind(this)
+                } else {
+                    return function () {
+                        error(2, `${COMPONENT} must be a function`);
+                    }
+                }
+            },
+        },
+        useElement: {
+            value() {
+                if (isFunction(this[ELEMENT])) {
+                    return this[ELEMENT].bind(this)
+                } else {
+                    return () => {
+                        error(2, `${ELEMENT} must be a function`);
+                    }
+                }
+            },
+        },
+        useBuffer: {
+            value() {
+                return this[BUFFER]
+            },
+        },
+        getMacro: {
+            value() {
+                return this[MACRO]
+            },
+        },
+        getBlocks: {
+            value() {
+                return this[BLOCKS]
+            },
+        },
+        setExtend: {
+            value(value) {
+                this[EXTEND] = value;
+                return this
+            },
+        },
+        getExtend: {
+            value() {
+                return this[EXTEND]
+            },
+        },
+        setLayout: {
+            value(layout) {
+                this[LAYOUT] = layout;
+                return this
+            },
+        },
+        getLayout: {
+            value() {
+                return this[LAYOUT]
+            },
+        },
+        clone: {
+            value(exclude_blocks) {
+                const filter = [LAYOUT, EXTEND, BUFFER];
+                if (exclude_blocks === true) {
+                    filter.push(BLOCKS);
+                }
+                return omit(this, filter)
+            },
+        },
+        extend: {
+            value(layout) {
+                this.setExtend(true);
+                this.setLayout(layout);
+            },
+        },
+        echo: {
+            value() {
+                return [].slice.call(arguments).forEach(this.useBuffer())
+            },
+        },
+        fn: {
+            value(callback) {
+                const buffer = this.useBuffer();
+                const context = this;
+                return function () {
+                    if (isFunction(callback)) {
+                        buffer.backup();
+                        buffer(callback.apply(context, arguments));
+                        return buffer.restore()
+                    }
+                }
+            },
+        },
+        macro: {
+            value(name, callback) {
+                const list = this.getMacro();
+                const macro = this.fn(callback);
+                const context = this;
+                list[name] = function () {
+                    return context.echo(macro.apply(undefined, arguments))
+                };
+            },
+        },
+        call: {
+            value(name) {
+                const list = this.getMacro();
+                const macro = list[name];
+                const params = [].slice.call(arguments, 1);
+                if (isFunction(macro)) {
+                    return macro.apply(macro, params)
+                }
+            },
+        },
+        block: {
+            value(name, callback) {
+                const blocks = this.getBlocks();
+                blocks[name] = blocks[name] || [];
+                blocks[name].push(this.fn(callback));
+                if (this.getExtend()) return
+                const context = this;
+                const list = Object.assign([], blocks[name]);
+                const shift = function () {
+                    return list.shift()
+                };
+                const next = function () {
+                    const parent = shift();
+                    if (parent) {
+                        return function () {
+                            context.echo(parent(next()));
+                        }
+                    } else {
+                        return function () {}
+                    }
+                };
+                this.echo(shift()(next()));
+            },
+        },
+        hasBlock: {
+            value(name) {
+                return this.getBlocks().hasOwnProperty(name)
+            },
+        },
+        include: {
+            value(path, data, cx) {
+                const context = cx === false ? {} : this.clone(true);
+                const params = Object.assign(context, data || {});
+                const promise = this.render(path, params);
+                this.echo(promise);
+            },
+        },
+        use: {
+            value(path, namespace) {
+                this.echo(
+                    Promise.resolve(this.require(path)).then((exports$1) => {
+                        const list = this.getMacro();
+                        each(exports$1, (macro, name) => {
+                            list[[namespace, name].join('.')] = macro;
+                        });
+                    }),
+                );
+            },
+        },
+        get: {
+            value(name, defaults) {
+                const path = getPath(this, name, true);
+                const result = path.shift();
+                const prop = path.pop();
+                return hasProp(result, prop) ? result[prop] : defaults
+            },
+        },
+        set: {
+            value(name, value) {
+                const path = getPath(this, name, false);
+                const result = path.shift();
+                const prop = path.pop();
+                if (this.getParentTemplate() && hasProp(result, prop)) {
+                    return result[prop]
+                }
+                return (result[prop] = value)
+            },
+        },
+        each: {
+            value(object, callback) {
+                if (isString(object)) {
+                    object = this.get(object, []);
+                }
+                each(object, callback);
+            },
+            writable: true,
+        },
+        el: {
+            value(tag, attr, content) {
+                content = isFunction(content) ? this.fn(content)() : content;
+                this.echo(
+                    Promise.resolve(content).then((content) =>
+                        element(tag, attr, content),
+                    ),
+                );
+            },
+            writable: true,
+        },
+        ui: {
+            value() {},
+            writable: true,
+        },
+        require: {
+            value() {},
+            writable: true,
+        },
+        render: {
+            value() {},
+            writable: true,
+        },
+    });
+    Object.entries(methods).forEach(([name, value]) => {
+        if (isFunction(value) && globals.includes(name)) {
+            value = value.bind(Context.prototype);
+        }
+        Context.prototype[name] = value;
+    });
+    return Context
+};
+
+class EjsContext {
+    #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(options, methods);
+    }
+}
+
+class EjsInstance {
+    #cache
+    #context
+    #compiler
+    #template
+    #config = {}
+    #methods = {}
+    static exports = [
+        'configure',
+        'create',
+        'createContext',
+        'render',
+        'require',
+        'preload',
+        'compile',
+        'helpers',
+    ]
+    /**
+     *
+     * @param {EjsConfig} options
+     */
+    constructor(options = {}) {
+        bindContext(this, this.constructor.exports);
+        this.#methods = {};
+        this.#config = configSchema({}, options);
+        this.#context = new EjsContext(this.#config, this.#methods);
+        this.#compiler = new EjsCompiler(this.#config);
+        this.#cache = new EjsCache(this.#config);
+        this.#template = new EjsTemplate(
+            this.#config,
+            this.#cache,
+            this.#compiler,
+        );
+        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.useEscapeValue(),
+                ]),
+            )
+    }
+    #renderLayout(name, params, parentTemplate) {
+        const data = this.createContext(params);
+        if (parentTemplate) data.setParentTemplate(parentTemplate);
+        return this.#output(this.#path(name), data).then(
+            this.#outputContent(name, data),
+        )
+    }
+    #outputContent(name, data) {
+        return (content) => {
+            if (data.getExtend()) {
+                data.setExtend(false);
+                return this.#renderLayout(data.getLayout(), data, name)
+            }
+            return content
+        }
+    }
+}
+
+export { EjsInstance as E, ejsDefaults as e };

package/dist/types/index.d.ts

@@ -0,0 +1,58 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { j as joinPath, t as typeProp, c as isString, d as isBoolean, i as isFunction } from './element-CEdJaM42.js';
+export { e as element, a as escapeValue } from './element-CEdJaM42.js';
+import { E as EjsInstance, e as ejsDefaults } from './index-BiIhwNBq.js';
+
+const resolver = async (path, template, error) => {
+    return fs
+        .readFile(joinPath(path, template))
+        .then((contents) => contents.toString())
+        .catch((e) => {
+            if (e.code === 'ENOENT') {
+                return error(1, `template ${template} not found`)
+            }
+            return error(0, e)
+        })
+};
+
+const {
+    render,
+    helpers,
+    configure,
+    create,
+    createContext,
+    compile,
+    preload,
+} = new EjsInstance({
+    resolver,
+});
+
+const __express = function (name, options, callback) {
+    if (isFunction(options)) {
+        callback = options;
+        options = {};
+    }
+    options = options || {};
+    const settings = Object.assign({}, options.settings);
+    const viewPath = typeProp(isString, ejsDefaults.path, settings['views']);
+    const viewCache = typeProp(
+        isBoolean,
+        ejsDefaults.cache,
+        settings['view cache'],
+    );
+    const viewOptions = Object.assign({}, settings['view options']);
+    const filename = path.relative(viewPath, name);
+    viewOptions.path = viewPath;
+    viewOptions.cache = viewCache;
+    configure(viewOptions);
+    return render(filename, options)
+        .then((content) => {
+            callback(null, content);
+        })
+        .catch((error) => {
+            callback(error);
+        })
+};
+
+export { __express, compile, configure, create, createContext, helpers, preload, render };

package/dist/types/worker.d.ts

@@ -0,0 +1,46 @@
+import { i as isFunction } from './element-CEdJaM42.js';
+export { e as element, a as escapeValue } from './element-CEdJaM42.js';
+import { E as EjsInstance } from './index-BiIhwNBq.js';
+
+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 ${name} not found`);
+};
+
+const { render, createContext, helpers, configure } = new EjsInstance({
+    cache: false,
+    strict: true,
+    resolver,
+});
+
+function useTemplates(templates = {}) {
+    Object.assign(templateCache, templates);
+}
+
+function useRenderer(options = {}) {
+    useTemplates(options.templates ?? {});
+    return async (c, next) => {
+        c.data = createContext({});
+        c.data.set('version', options.version);
+        c.data.set('origin', getOrigin(c.req.url, 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({ param: c.req.param() }, c.data, data));
+        c.helpers = (methods) => helpers(methods);
+        c.render = async (name, data) => c.html(c.ejs(name, data));
+        await next();
+    }
+}
+
+export { configure, createContext, helpers, render, useRenderer, useTemplates };

package/package.json

@@ -3,7 +3,7 @@
     "description": "EJS Templates",
     "homepage": "https://github.com/kosatyi/ejs",
     "type": "module",
-    "version": "0.0.112",
+    "version": "0.0.114",
     "main": "dist/cjs/index.js",
     "module": "dist/esm/index.js",
     "browser": "dist/umd/browser.js",

package/types/browser.d.ts

@@ -1,3 +1,4 @@
+export { element, escapeValue } from './element.js'
 export {
     create,
     render,

package/types/context.d.ts

@@ -1,6 +1,4 @@
-import { EjsMethods } from './ejs'
-
-export interface EjsContext extends EjsMethods {
+export interface EjsContext {
     /**
      * extend layout with blocks in current template file
      * @param layout

package/types/ejs.d.ts

@@ -1,6 +1,6 @@
 import { EjsContext } from './context.js'
 import { error } from './error.js'
-import { element, escapeValue } from './element.js'
+
 export declare type EjsConfigVars = {
     SCOPE: string
     COMPONENT: string
@@ -78,8 +78,6 @@ declare type configure = <T extends EjsConfig>(options?: T) => EjsConfig & T
 
 declare type compile = (content: string, path: string) => Function
 
-declare type EjsMethods = { [p: string]: any }
-
 declare type createContext = (data: { [p: string]: any }) => EjsContext
 
 declare type render = (
@@ -91,9 +89,7 @@ declare type require = (name: string) => Promise<{ [x: string]: any }>
 
 declare type preload = (list: { [p: string]: any }) => void
 
-declare type helpers<T extends EjsMethods> = (
-    extendMethods: T,
-) => EjsContext & T
+declare type helpers = (extendMethods: Record<string, any>) => EjsContext
 
 declare type create = (config: EjsConfig) => EjsInstance
 
@@ -105,9 +101,7 @@ declare type EjsInterface = {
     require: require
     preload: preload
     compile: compile
-    helpers: helpers<EjsMethods>
-    element: typeof element
-    escapeValue: typeof escapeValue
+    helpers: helpers
 }
 
 declare type EjsInstance = (config: EjsConfig) => EjsInterface
@@ -122,7 +116,7 @@ export const require: require
 
 export const preload: preload
 
-export const helpers: helpers<EjsMethods>
+export const helpers: helpers
 
 export const compile: compile
 

package/types/index.d.ts

@@ -1,3 +1,5 @@
+export { element, escapeValue } from './element.js'
+
 export {
     create,
     render,

package/types/worker.d.ts

@@ -1,3 +1,5 @@
+export { element, escapeValue } from './element.js'
+
 export {
     create,
     render,