@kosatyi/ejs 0.0.25 → 0.0.27

package/dist/ejs.mjs

@@ -1,6 +1,6 @@
 import path from 'path';
 import fs from 'fs';
-import chokidar from 'chokidar';
+import 'chokidar';
 
 const defaults = {};
 
@@ -196,7 +196,7 @@ const slash = '/';
 const lt = '<';
 const gt = '>';
 
-function element(tag, attrs, content) {
+const element = (tag, attrs, content) => {
     const result = [];
     const hasClosedTag = selfClosed.indexOf(tag) === -1;
     const attributes = map(attrs, (value, key) => {
@@ -215,9 +215,9 @@ function element(tag, attrs, content) {
         result.push([lt, slash, tag, gt].join(''));
     }
     return result.join('')
-}
+};
 
-const tags = [
+const tagList = [
     {
         symbol: '-',
         format(value) {
@@ -244,7 +244,7 @@ const tags = [
     },
 ];
 
-const match = (regex, text, callback) => {
+const matchTokens = (regex, text, callback) => {
     let index = 0;
     text.replace(regex, function () {
         const params = [].slice.call(arguments, 0, -1);
@@ -256,45 +256,56 @@ const match = (regex, text, callback) => {
     });
 };
 
-const configureCompiler = (ejs, config) => {
-    const withObject = config.withObject;
-    const token = config.token;
-    const vars = config.vars;
-    const matches = [];
-    const formats = [];
-    const slurp = {
-        match: '[ \\t]*',
-        start: [token.start, '_'],
-        end: ['_', token.end],
-    };
-    tags.forEach((item) => {
-        matches.push(
-            token.start
-                .concat(item.symbol)
-                .concat(token.regex)
-                .concat(token.end)
+class Compiler {
+    constructor(config) {
+        this.configure(config);
+    }
+    configure(config) {
+        this.withObject = config.withObject;
+        this.token = config.token;
+        this.vars = config.vars;
+        this.matches = [];
+        this.formats = [];
+        this.slurp = {
+            match: '[ \\t]*',
+            start: [this.token.start, '_'],
+            end: ['_', this.token.end],
+        };
+        tagList.forEach((item) => {
+            this.matches.push(
+                this.token.start
+                    .concat(item.symbol)
+                    .concat(this.token.regex)
+                    .concat(this.token.end)
+            );
+            this.formats.push(item.format.bind(this.vars));
+        });
+        this.regex = new RegExp(this.matches.join('|').concat('|$'), 'g');
+        this.slurpStart = new RegExp(
+            [this.slurp.match, this.slurp.start].join(''),
+            'gm'
         );
-        formats.push(item.format.bind(vars));
-    });
-    const regex = new RegExp(matches.join('|').concat('|$'), 'g');
-    const slurpStart = new RegExp([slurp.match, slurp.start].join(''), 'gm');
-    const slurpEnd = new RegExp([slurp.end, slurp.match].join(''), 'gm');
-    return function compiler(content, path) {
-        const { SCOPE, SAFE, BUFFER } = vars;
+        this.slurpEnd = new RegExp(
+            [this.slurp.end, this.slurp.match].join(''),
+            'gm'
+        );
+    }
+    compile(content, path) {
+        const { SCOPE, SAFE, BUFFER } = this.vars;
         content = content.replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
         content = content
-            .replace(slurpStart, slurp.start)
-            .replace(slurpEnd, slurp.end);
+            .replace(this.slurpStart, this.slurp.start)
+            .replace(this.slurpEnd, this.slurp.end);
         let source = `${BUFFER}('`;
-        match(regex, content, (params, index, offset) => {
+        matchTokens(this.regex, content, (params, index, offset) => {
             source += symbols(content.slice(index, offset));
-            params.forEach(function (value, index) {
-                if (value) source += formats[index](value);
+            params.forEach((value, index) => {
+                if (value) source += this.formats[index](value);
             });
         });
         source += `');`;
         source = `try{${source}}catch(e){console.info(e)}`;
-        if (withObject) {
+        if (this.withObject) {
             source = `with(${SCOPE}){${source}}`;
         }
         source = `${BUFFER}.start();${source}return ${BUFFER}.end();`;
@@ -310,21 +321,26 @@ const configureCompiler = (ejs, config) => {
         }
         return result
     }
-};
+}
 
-const configureWrapper = (config) => {
-    const name = config.export;
-    const useStrict = config.withObject !== true;
-    return function Wrapper(list) {
+class Bundler {
+    constructor(config) {
+        this.configure(config);
+    }
+    configure(config) {
+        this.namespace = config.export;
+        this.useStrict = config.withObject === false;
+    }
+    wrapper(list) {
         let out = '';
         out += '(function(global,factory){';
         out += 'typeof exports === "object" && typeof module !== "undefined" ?';
         out += 'module.exports = factory():';
         out += 'typeof define === "function" && define.amd ? define(factory):';
         out += '(global = typeof globalThis !== "undefined" ? globalThis:';
-        out += 'global || self,global["' + name + '"] = factory())';
+        out += 'global || self,global["' + this.namespace + '"] = factory())';
         out += '})(this,(function(){';
-        if (useStrict) out += "'use strict';\n";
+        if (this.useStrict) out += "'use strict';\n";
         out += 'var list = {};\n';
         list.forEach((item) => {
             out +=
@@ -337,7 +353,7 @@ const configureWrapper = (config) => {
         out += 'return list;}));\n';
         return out
     }
-};
+}
 
 const httpRequest = (template) => {
     return fetch(template).then((response) => response.text())
@@ -354,52 +370,43 @@ const fileSystem = (template) =>
         });
     });
 
-const enableWatcher = (path, cache) =>
-    chokidar
-        .watch('.', {
-            cwd: path,
-        })
-        .on('change', (name) => {
-            cache.remove(name);
-        })
-        .on('error', (error) => {
-            console.log('watcher error: ' + error);
-        });
+const normalizePath = (path, template) => {
+    template = [path, template].join('/');
+    template = template.replace(/\/\//g, '/');
+    return template
+};
 
-const configureTemplate = (ejs, config) => {
-    const path = config.path;
-    const { cache, compile } = ejs;
-    const resolver = isFunction(config.resolver)
-        ? config.resolver
-        : isNode()
-        ? fileSystem
-        : httpRequest;
-    const normalize = (template) => {
-        template = [path, template].join('/');
-        template = template.replace(/\/\//g, '/');
-        return template
-    };
-    const resolve = (template) => {
-        return resolver(normalize(template))
-    };
-    const result = (content, template) => {
-        cache.set(template, content);
+class Template {
+    constructor(config, cache, compiler) {
+        this.cache = cache;
+        this.compiler = compiler;
+        this.configure(config);
+    }
+    configure(config) {
+        this.path = config.path;
+        this.resolver = isFunction(config.resolver)
+            ? config.resolver
+            : isNode()
+            ? fileSystem
+            : httpRequest;
+    }
+    resolve(template) {
+        return this.resolver(normalizePath(this.path, template))
+    }
+    result(content, template) {
+        this.cache.set(template, content);
         return content
-    };
-    const template = (template) => {
-        if (cache.exist(template)) {
-            return cache.resolve(template)
+    }
+    get(template) {
+        if (this.cache.exist(template)) {
+            return this.cache.resolve(template)
         }
-        const content = resolve(template).then((content) =>
-            result(compile(content, template), template)
+        const content = this.resolve(template).then((content) =>
+            this.result(this.compiler.compile(content, template), template)
         );
-        return result(content, template)
-    };
-    if (config.watch && isNode()) {
-        enableWatcher(path, cache);
+        return this.result(content, template)
     }
-    return template
-};
+}
 
 const resolve = (list) => Promise.all(list).then((list) => list.join(''));
 
@@ -430,362 +437,406 @@ const createBuffer = () => {
     return buffer
 };
 
-const configureScope = (ejs, config) => {
-    const { EXTEND, LAYOUT, BLOCKS, BUFFER, MACRO } = config.vars;
-    function Scope(data = {}) {
-        this.initBlocks();
-        this.initMacro();
-        extend(this, data);
+class Context {
+    constructor(config) {
+        this.configure(config);
     }
-    Scope.helpers = (methods) => {
-        extend(Scope.prototype, methods);
-    };
-    Scope.property = (name, descriptor) => {
-        Object.defineProperty(Scope.prototype, name, descriptor);
-    };
-    Scope.method = (name, method) => {
-        Object.defineProperty(Scope.prototype, name, {
-            value: method,
-            writable: false,
-            configurable: false,
-            enumerable: false,
-        });
-    };
-    Scope.property(BUFFER, {
-        value: createBuffer(),
-        writable: false,
-        configurable: false,
-        enumerable: false,
-    });
-    Scope.property(BLOCKS, {
-        value: {},
-        writable: true,
-        configurable: false,
-        enumerable: false,
-    });
-    Scope.property(MACRO, {
-        value: {},
-        writable: true,
-        configurable: false,
-        enumerable: false,
-    });
-    Scope.property(LAYOUT, {
-        value: false,
-        writable: true,
-        configurable: false,
-        enumerable: false,
-    });
-    Scope.property(EXTEND, {
-        value: false,
-        writable: true,
-        configurable: false,
-        enumerable: false,
-    });
-    Scope.method('initBlocks', function () {
-        this[BLOCKS] = {};
-    });
-    Scope.method('initMacro', function () {
-        this[MACRO] = {};
-    });
-    Scope.method('getMacro', function () {
-        return this[MACRO]
-    });
-    Scope.method('getBuffer', function () {
-        return this[BUFFER]
-    });
-    Scope.method('getBlocks', function () {
-        return this[BLOCKS]
-    });
-    Scope.method('setExtend', function (value) {
-        this[EXTEND] = value;
-    });
-    Scope.method('getExtend', function () {
-        return this[EXTEND]
-    });
-    Scope.method('setLayout', function (layout) {
-        this[LAYOUT] = layout;
-    });
-    Scope.method('getLayout', function () {
-        return this[LAYOUT]
-    });
-    Scope.method('clone', function (exclude_blocks) {
-        const filter = [LAYOUT, EXTEND, BUFFER];
-        if (exclude_blocks === true) {
-            filter.push(BLOCKS);
-        }
-        return omit(this, filter)
-    });
-    Scope.method('extend', function (layout) {
-        this.setExtend(true);
-        this.setLayout(layout);
-    });
-    Scope.method('echo', function () {
-        const buffer = this.getBuffer();
-        const params = [].slice.call(arguments);
-        params.forEach(function (item) {
-            buffer(item);
-        });
-    });
-    Scope.method('fn', function (callback) {
-        const buffer = this.getBuffer();
-        const context = this;
-        return function () {
-            buffer.backup();
-            if (isFunction(callback)) {
-                callback.apply(context, arguments);
-            }
-            return buffer.restore()
-        }
-    });
-    Scope.method('get', function (name, defaults) {
-        const path = getPath(this, name);
-        const result = path.shift();
-        const prop = path.pop();
-        return hasProp(result, prop) ? result[prop] : defaults
-    });
-    Scope.method('set', function (name, value) {
-        const path = getPath(this, name);
-        const result = path.shift();
-        const prop = path.pop();
-        if (this.getExtend() && hasProp(result, prop)) {
-            return result[prop]
-        }
-        return (result[prop] = value)
-    });
-    Scope.method('macro', function (name, callback) {
-        const list = this.getMacro();
-        const macro = this.fn(callback);
-        const context = this;
-        list[name] = function () {
-            return context.echo(macro.apply(undefined, arguments))
+    configure(config) {
+        const { EXTEND, LAYOUT, BLOCKS, BUFFER, MACRO } = config.vars;
+
+        this.create = (data) => {
+            return new Scope(data)
         };
-    });
-    Scope.method('call', function (name) {
-        const list = this.getMacro();
-        const macro = list[name];
-        const params = [].slice.call(arguments, 1);
-        if (isFunction(macro)) {
-            return macro.apply(macro, params)
+
+        this.helpers = (methods) => {
+            extend(Scope.prototype, methods);
+        };
+
+        function Scope(data = {}) {
+            this.initBlocks();
+            this.initMacro();
+            extend(this, data);
         }
-    });
-    Scope.method('block', function (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()
+
+        Scope.helpers = (methods) => {
+            extend(Scope.prototype, methods);
+        };
+        Scope.defineProp = Scope.method = (
+            name,
+            value,
+            writable = false,
+            configurable = false,
+            enumerable = false
+        ) => {
+            Object.defineProperty(Scope.prototype, name, {
+                value,
+                writable,
+                configurable,
+                enumerable,
+            });
         };
-        const next = () => {
-            const parent = current();
-            if (parent) {
-                return () => {
-                    this.echo(parent(next()));
+
+        Scope.defineProp(BUFFER, createBuffer());
+
+        Scope.defineProp(BLOCKS, {}, true);
+
+        Scope.defineProp(MACRO, {}, true);
+
+        Scope.defineProp(LAYOUT, false, true);
+
+        Scope.defineProp(EXTEND, false, true);
+
+        Scope.method('initBlocks', function () {
+            this[BLOCKS] = {};
+        });
+
+        Scope.method('initMacro', function () {
+            this[MACRO] = {};
+        });
+
+        Scope.method('getMacro', function () {
+            return this[MACRO]
+        });
+
+        Scope.method('getBuffer', function () {
+            return this[BUFFER]
+        });
+
+        Scope.method('getBlocks', function () {
+            return this[BLOCKS]
+        });
+
+        Scope.method('setExtend', function (value) {
+            this[EXTEND] = value;
+        });
+
+        Scope.method('getExtend', function () {
+            return this[EXTEND]
+        });
+
+        Scope.method('setLayout', function (layout) {
+            this[LAYOUT] = layout;
+        });
+
+        Scope.method('getLayout', function () {
+            return this[LAYOUT]
+        });
+
+        Scope.method('clone', function (exclude_blocks) {
+            const filter = [LAYOUT, EXTEND, BUFFER];
+            if (exclude_blocks === true) {
+                filter.push(BLOCKS);
+            }
+            return omit(this, filter)
+        });
+
+        Scope.method('extend', function (layout) {
+            this.setExtend(true);
+            this.setLayout(layout);
+        });
+
+        Scope.method('echo', function () {
+            const buffer = this.getBuffer();
+            const params = [].slice.call(arguments);
+            params.forEach(buffer);
+        });
+
+        Scope.method('fn', function (callback) {
+            const buffer = this.getBuffer();
+            const context = this;
+            return function () {
+                buffer.backup();
+                if (isFunction(callback)) {
+                    callback.apply(context, arguments);
                 }
-            } else {
-                return noop
+                return buffer.restore()
             }
-        };
-        this.echo(current()(next()));
-    });
-    Scope.method('include', function (path, data, cx) {
-        const context = cx === false ? {} : this.clone(true);
-        const params = extend(context, data || {});
-        const promise = this.render(path, params);
-        this.echo(promise);
-    });
-    Scope.method('use', function (path, namespace) {
-        const promise = this.require(path);
-        this.echo(
-            resolve$1(
-                promise,
-                function (exports) {
-                    const list = this.getMacro();
-                    each(exports, function (macro, name) {
-                        list[[namespace, name].join('.')] = macro;
-                    });
-                },
-                this
-            )
-        );
-    });
-    Scope.method('async', function (promise, callback) {
-        this.echo(
-            resolve$1(
-                promise,
-                function (data) {
-                    return this.fn(callback)(data)
-                },
-                this
-            )
-        );
-    });
-    Scope.method('el', function (tag, attr, content) {
-        if (isFunction(content)) {
-            content = this.fn(content)();
-        }
-        this.echo(
-            resolve$1(
-                content,
-                function (content) {
-                    return element(tag, attr, content)
-                },
-                this
-            )
-        );
-    });
-    Scope.method('each', function (object, callback) {
-        if (isString(object)) {
-            object = this.get(object, []);
+        });
+        Scope.method('get', function (name, defaults) {
+            const path = getPath(this, name);
+            const result = path.shift();
+            const prop = path.pop();
+            return hasProp(result, prop) ? result[prop] : defaults
+        });
+
+        Scope.method('set', function (name, value) {
+            const path = getPath(this, name);
+            const result = path.shift();
+            const prop = path.pop();
+            if (this.getExtend() && hasProp(result, prop)) {
+                return result[prop]
+            }
+            return (result[prop] = value)
+        });
+
+        Scope.method('macro', function (name, callback) {
+            const list = this.getMacro();
+            const macro = this.fn(callback);
+            const context = this;
+            list[name] = function () {
+                return context.echo(macro.apply(undefined, arguments))
+            };
+        });
+
+        Scope.method('call', function (name) {
+            const list = this.getMacro();
+            const macro = list[name];
+            const params = [].slice.call(arguments, 1);
+            if (isFunction(macro)) {
+                return macro.apply(macro, params)
+            }
+        });
+
+        Scope.method('block', function (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
+                }
+            };
+            this.echo(current()(next()));
+        });
+
+        Scope.method('include', function (path, data, cx) {
+            const context = cx === false ? {} : this.clone(true);
+            const params = extend(context, data || {});
+            const promise = this.render(path, params);
+            this.echo(promise);
+        });
+
+        Scope.method('use', function (path, namespace) {
+            const promise = this.require(path);
+            this.echo(
+                resolve$1(
+                    promise,
+                    function (exports) {
+                        const list = this.getMacro();
+                        each(exports, function (macro, name) {
+                            list[[namespace, name].join('.')] = macro;
+                        });
+                    },
+                    this
+                )
+            );
+        });
+
+        Scope.method('async', function (promise, callback) {
+            this.echo(
+                resolve$1(
+                    promise,
+                    function (data) {
+                        return this.fn(callback)(data)
+                    },
+                    this
+                )
+            );
+        });
+
+        Scope.method('el', function (tag, attr, content) {
+            if (isFunction(content)) {
+                content = this.fn(content)();
+            }
+            this.echo(
+                resolve$1(
+                    content,
+                    function (content) {
+                        return element(tag, attr, content)
+                    },
+                    this
+                )
+            );
+        });
+
+        Scope.method('each', function (object, callback) {
+            if (isString(object)) {
+                object = this.get(object, []);
+            }
+            each(object, callback);
+        });
+    }
+}
+
+const global = typeof globalThis !== 'undefined' ? globalThis : window || self;
+
+class Cache {
+    list = {}
+    constructor(config) {
+        this.configure(config);
+        if (isNode() === false) {
+            this.load(global[this.namespace]);
         }
-        each(object, callback);
+    }
+    configure(config) {
+        this.list = {};
+        this.namespace = config.export;
+    }
+    load(data) {
+        extend(this.list, data);
+        return this
+    }
+    exist(key) {
+        return hasProp(this.list, key)
+    }
+    get(key) {
+        return this.list[key]
+    }
+    remove(key) {
+        delete this.list[key];
+    }
+    resolve(key) {
+        return Promise.resolve(this.get(key))
+    }
+    set(key, value) {
+        this.list[key] = value;
+        return this
+    }
+}
+
+const configSchema = (config, options) => {
+    extend(config, {
+        export: typeProp(isString, defaults.export, options.export),
+        path: typeProp(isString, defaults.path, options.path),
+        resolver: typeProp(isFunction, defaults.resolver, options.resolver),
+        extension: typeProp(isString, defaults.extension, options.extension),
+        withObject: typeProp(
+            isBoolean,
+            defaults.withObject,
+            options.withObject
+        ),
+        token: extend({}, defaults.token, options.token),
+        vars: extend({}, defaults.vars, options.vars),
     });
-    return Scope
 };
 
-const global = typeof globalThis !== 'undefined' ? globalThis : window || self;
+const init = (options) => {
+    /**
+     * EJS template
+     * @module ejs
+     */
+    const config = {};
 
-function configureCache(config) {
-    const namespace = config.export;
-    const list = {};
-    const cache = {
-        preload() {
-            if (isNode() === false) {
-                this.load(global[namespace]);
+    configSchema(config, options || {});
+
+    const context = new Context(config);
+    const compiler = new Compiler(config);
+    const bundler = new Bundler(config);
+    const cache = new Cache(config);
+    const template = new Template(config, cache, compiler);
+
+    const configure = (options) => {
+        configSchema(config, options);
+        context.configure(config);
+        compiler.configure(config);
+        bundler.configure(config);
+        cache.configure(config);
+        template.configure(config);
+    };
+
+    const output = (path, scope) => {
+        return template.get(path).then(function (callback) {
+            return callback.call(scope, scope, scope.getBuffer(), safeValue)
+        })
+    };
+
+    const require = (name) => {
+        const filepath = ext(name, config.extension);
+        const scope = context.create({});
+        return output(filepath, scope).then(() => {
+            return 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 this
-        },
-        exist(key) {
-            return hasProp(list, key)
-        },
-        get(key) {
-            return list[key]
-        },
-        remove(key) {
-            delete list[key];
-        },
-        resolve(key) {
-            return Promise.resolve(this.get(key))
-        },
-        set(key, value) {
-            list[key] = value;
-            return this
-        },
-        load(data) {
-            extend(list, data);
-            return this
-        },
+            return content
+        })
     };
-    return cache.preload()
-}
 
-function create(options) {
-    const config = {};
-    const ejs = {
-        safeValue: safeValue,
-        element: element,
-        output(path, scope) {
-            return ejs.template(path).then(function (template) {
-                return template.call(scope, scope, scope.getBuffer(), safeValue)
-            })
-        },
-        render(name, data) {
-            const filepath = ext(name, config.extension);
-            const scope = new ejs.scope(data);
-            return ejs.output(filepath, scope).then((content) => {
-                if (scope.getExtend()) {
-                    scope.setExtend(false);
-                    const layout = scope.getLayout();
-                    const data = scope.clone();
-                    return ejs.render(layout, data)
-                }
-                return content
+    const helpers = (methods) => {
+        context.helpers(extend(callbacks, methods || {}));
+    };
+
+    const __express = (name, options, callback) => {
+        if (isFunction(options)) {
+            callback = options;
+            options = {};
+        }
+        options = options || {};
+        const settings = extend({}, options.settings);
+        const viewPath = typeProp(isString, settings['views'], defaults.path);
+        const viewCache = typeProp(
+            isBoolean,
+            settings['view cache'],
+            defaults.cache
+        );
+        const viewOptions = extend({}, 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);
             })
-        },
-        require(name) {
-            const filepath = ext(name, config.extension);
-            const scope = new ejs.scope({});
-            return ejs.output(filepath, scope).then(() => {
-                return scope.getMacro()
+            .catch((error) => {
+                callback(error);
             })
-        },
-        helpers(methods) {
-            ejs.scope.helpers(methods);
-        },
-        configure(options) {
-            config.export = typeProp(isString, defaults.export, options.export);
-            config.path = typeProp(isString, defaults.path, options.path);
-            config.resolver = typeProp(
-                isFunction,
-                defaults.resolver,
-                options.resolver
-            );
-            config.extension = typeProp(
-                isString,
-                defaults.extension,
-                options.extension
-            );
-            config.withObject = typeProp(
-                isBoolean,
-                defaults.withObject,
-                options.withObject
-            );
-            config.token = extend({}, defaults.token, options.token);
-            config.vars = extend({}, defaults.vars, options.vars);
-            ejs.scope = configureScope(ejs, config);
-            ejs.compile = configureCompiler(ejs, config);
-            ejs.wrapper = configureWrapper(ejs);
-            ejs.cache = configureCache(ejs);
-            ejs.template = configureTemplate(ejs, config);
-            return ejs
-        },
-        __express(name, options, callback) {
-            if (isFunction(options)) {
-                callback = options;
-                options = {};
-            }
-            options = options || {};
-            const settings = extend({}, options.settings);
-            const viewPath = typeProp(
-                isString,
-                settings['views'],
-                defaults.path
-            );
-            const viewCache = typeProp(
-                isBoolean,
-                settings['view cache'],
-                defaults.cache
-            );
-            const viewOptions = extend({}, settings['view options']);
-            const filename = path.relative(viewPath, name);
-            viewOptions.path = viewPath;
-            viewOptions.cache = viewCache;
-            ejs.configure(viewOptions);
-            return ejs
-                .render(filename, options)
-                .then((content) => {
-                    callback(null, content);
-                })
-                .catch((error) => {
-                    callback(error);
-                })
-        },
     };
-    ejs.configure(options || {});
-    ejs.helpers({
+    const preload = (list) => cache.load(list);
+    const wrapper = (list) => bundler.wrapper(list);
+    const compile = (content, path) => compiler.compile(content, path);
+    const create = (options) => {
+        return init(options)
+    };
+    helpers({
         require(name) {
-            return ejs.require(name, this)
+            return require(name)
         },
         render(name, data) {
-            return ejs.render(name, data)
+            return render(name, data)
         },
     });
-    return ejs
-}
-
-const instance = create();
-
-instance.create = create;
+    return {
+        render,
+        helpers,
+        configure,
+        wrapper,
+        compile,
+        create,
+        preload,
+        __express,
+    }
+};
 
-export { instance as default };
+const {
+    render,
+    helpers,
+    configure,
+    wrapper,
+    compile,
+    create,
+    preload,
+    __express,
+} = init({});
+
+export { __express, compile, configure, create, element, helpers, preload, render, safeValue, wrapper };