@tsed/engines 1.1.4 → 7.0.0-beta.5

package/lib/index.js

@@ -1,1211 +0,0 @@
-var tslib = require('tslib');
-var fs = require('fs-extra');
-var path = require('path');
-var util = require('util');
-var fs$1 = require('fs');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-
-function _extends() {
-  _extends = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-
-  return _extends.apply(this, arguments);
-}
-
-var id = 0;
-
-function _classPrivateFieldLooseKey(name) {
-  return "__private_" + id++ + "_" + name;
-}
-
-function _classPrivateFieldLooseBase(receiver, privateKey) {
-  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
-    throw new TypeError("attempted to use private field on non-instance");
-  }
-
-  return receiver;
-}
-
-var _providers = /*#__PURE__*/_classPrivateFieldLooseKey("providers");
-
-class EnginesContainer {
-  constructor() {
-    Object.defineProperty(this, _providers, {
-      writable: true,
-      value: void 0
-    });
-    _classPrivateFieldLooseBase(this, _providers)[_providers] = new Map();
-  }
-
-  has(key) {
-    return _classPrivateFieldLooseBase(this, _providers)[_providers].has(key);
-  }
-
-  get(key) {
-    const provider = _classPrivateFieldLooseBase(this, _providers)[_providers].get(key);
-
-    if (provider && !provider.instance) {
-      provider.instance = new provider.useClass(provider.name, provider.options);
-    }
-
-    return provider == null ? void 0 : provider.instance;
-  }
-
-  set(key, provider) {
-    _classPrivateFieldLooseBase(this, _providers)[_providers].set(key, provider);
-
-    _classPrivateFieldLooseBase(this, _providers)[_providers].set(provider.name, provider);
-  }
-
-  getSupportedEngines() {
-    return [..._classPrivateFieldLooseBase(this, _providers)[_providers].keys()].filter(key => typeof key === "string");
-  }
-
-}
-const engines = new EnginesContainer();
-
-function ViewEngine(name, options = {}) {
-  return target => {
-    engines.set(target, {
-      name,
-      useClass: target,
-      options
-    });
-  };
-}
-
-const readCache = new Map();
-const cacheStore = new Map();
-const requires = new Map();
-const extend = require("util")._extend;
-function requireEngine(name, toName = name) {
-  if (!requires.has(toName)) {
-    setRequireEngine(name, toName);
-  }
-
-  return requires.get(toName);
-}
-function setRequireEngine(name, toName = name) {
-  requires.set(toName, require(name));
-}
-function setToCache(key, value) {
-  readCache.set(key, value);
-}
-function getFromCache(key) {
-  return readCache.get(key);
-}
-/**
- * Clear the cache.
- *
- * @api public
- */
-
-const clearCache = () => {
-  readCache.clear();
-  cacheStore.clear();
-};
-/**
- * Conditionally cache `compiled` template based
- * on the `options` filename and `.cache` boolean.
- *
- * @param {Object} options
- * @param {Function} compiled
- * @return {Function}
- */
-
-function cache(options, compiled) {
-  // cachable
-  if (compiled && options.filename && options.cache) {
-    readCache.delete(options.filename);
-    cacheStore.set(options.filename, compiled);
-    return compiled;
-  } // check cache
-
-
-  if (options.filename && options.cache) {
-    return cacheStore.get(options.filename);
-  }
-
-  return compiled;
-}
-/**
- * Read `path` with `options` with
- * callback `(err, str)`. When `options.cache`
- * is true the template string will be cached.
- *
- * @param path
- * @param {String} options
- */
-
-async function read(path, options) {
-  let str = readCache.get(path); // cached (only if cached is a string and not a compiled template function)
-
-  if (options.cache && str && typeof str === "string") {
-    return str;
-  } // read
-
-
-  str = await fs__default['default'].readFile(path, "utf8"); // remove extraneous utf8 BOM marker
-
-  str = str.replace(/^\uFEFF/, "");
-
-  if (options.cache) {
-    readCache.set(path, str);
-  }
-
-  return str;
-}
-/**
- * Read `path` with `options` with
- * callback `(err, str)`. When `options.cache`
- * is true the partial string will be cached.
- *
- * @param path
- * @param {String} options
- * @api private
- */
-
-async function readPartials(path$1, options) {
-  if (!options.partials) {
-    return;
-  }
-
-  const keys = Object.keys(options.partials);
-  const partials = {};
-  return new Promise((resolve, reject) => {
-    async function next(index) {
-      if (index === keys.length) {
-        return resolve(partials);
-      }
-
-      const key = keys[index];
-      const partialPath = options.partials[key];
-
-      if (partialPath === undefined || partialPath === null || partialPath === false) {
-        return next(++index);
-      }
-
-      let file;
-
-      if (path.isAbsolute(partialPath)) {
-        if (path.extname(partialPath) !== "") {
-          file = partialPath;
-        } else {
-          file = path.join(partialPath + path.extname(path$1));
-        }
-      } else {
-        file = path.join(path.dirname(path$1), partialPath + path.extname(path$1));
-      }
-
-      try {
-        partials[key] = await read(file, options);
-        next(++index);
-      } catch (err) {
-        reject(err);
-      }
-    }
-
-    next(0);
-  });
-}
-
-class Engine {
-  constructor(name, options) {
-    this.name = name;
-    const reqs = [].concat(options.requires || [name]);
-    reqs.forEach(req => {
-      try {
-        requireEngine(req, name);
-        this.driverName = req;
-      } catch (er) {}
-    });
-  }
-
-  get engine() {
-    return requireEngine(this.name);
-  }
-
-  compile(template, options) {
-    options = this.$cacheOptions(template, options, false);
-    return cache(options) || cache(options, this.$compile.call(this, template, options));
-  }
-
-  compileFile(file, options) {
-    options = this.$cacheOptions(file, options, true);
-    return cache(options) || cache(options, this.$compileFile.call(this, file, options));
-  }
-
-  async render(template, options) {
-    const compile = await this.compile(template, options);
-    return compile(options);
-  }
-
-  async renderFile(file, options) {
-    const opts = await this.readPartials(file, options);
-    const compile = await this.compileFile(file, opts);
-    return compile(opts);
-  }
-
-  async readPartials(file, options) {
-    options.filename = file;
-    const partials = await readPartials(file, options);
-    const opts = extend({}, options);
-    opts.partials = partials;
-    return opts;
-  }
-
-  $cacheOptions(template, options, fromFile) {
-    return options;
-  }
-
-  $compile(template, options) {
-    return this.engine.compile(template, options);
-  }
-
-  async $compileFile(file, options) {
-    const template = await read(file, options);
-    return this.$compile(template, options);
-  }
-
-}
-
-exports.AtplEngine = class AtplEngine extends Engine {};
-exports.AtplEngine = tslib.__decorate([ViewEngine("atpl")], exports.AtplEngine);
-
-exports.BracketEngine = class BracketEngine extends Engine {
-  $compile(template, options) {
-    return this.engine.default.compile(template, options);
-  }
-
-};
-exports.BracketEngine = tslib.__decorate([ViewEngine("bracket", {
-  requires: "bracket-template"
-})], exports.BracketEngine);
-
-exports.DotEngine = class DotEngine extends Engine {
-  getSettings(options) {
-    const settings = extend({}, this.engine.templateSettings);
-    return extend(settings, options ? options.dot : {});
-  }
-
-  $compile(template, options) {
-    return this.engine.template(template, this.getSettings(options), options);
-  }
-
-};
-exports.DotEngine = tslib.__decorate([ViewEngine("dot")], exports.DotEngine);
-
-exports.DustEngine = class DustEngine extends Engine {
-  constructor() {
-    super(...arguments);
-    this.views = ".";
-    this.ext = "dust";
-  }
-
-  configure(options) {
-    if (options) {
-      if (options.ext) {
-        this.ext = options.ext;
-      }
-
-      if (options.views) {
-        this.views = options.views;
-      }
-
-      if (options.settings && options.settings.views) {
-        this.views = options.settings.views;
-      }
-    }
-
-    if (!options || options && !options.cache) this.engine.cache = {};
-
-    this.engine.onLoad = async (path$1, callback) => {
-      if (path.extname(path$1) === "") {
-        path$1 += `.${this.ext}`;
-      }
-
-      if (path$1[0] !== "/") {
-        path$1 = `${this.views}/${path$1}`;
-      }
-
-      try {
-        callback(null, await read(path$1, options));
-      } catch (er) {
-        callback(er);
-      }
-    };
-  }
-
-  $compile(template, options) {
-    this.configure(options);
-    let templateName;
-
-    if (options.filename) {
-      templateName = options.filename.replace(new RegExp("^" + this.views + "/"), "").replace(new RegExp("\\." + this.ext), "");
-    }
-
-    return util.promisify(this.engine.compileFn(template, templateName));
-  }
-
-};
-exports.DustEngine = tslib.__decorate([ViewEngine("dust", {
-  requires: ["dustjs-helpers", "dustjs-linkedin"]
-})], exports.DustEngine);
-
-exports.EctEngine = class EctEngine extends Engine {
-  $compile(template, options) {
-    const ECT = this.engine;
-    const engine = new ECT({
-      root: {
-        page: template
-      }
-    });
-    const compile = util.promisify(engine.render.bind(engine));
-    return options => compile("page", options);
-  }
-
-  async $compileFile(file, options) {
-    const ECT = this.engine;
-    const engine = new ECT(options);
-    engine.configure({
-      cache: options.cache
-    });
-    const compile = util.promisify(engine.render.bind(engine));
-    return options => compile(file, options);
-  }
-
-};
-exports.EctEngine = tslib.__decorate([ViewEngine("ect")], exports.EctEngine);
-
-exports.EjsEngine = class EjsEngine extends Engine {};
-exports.EjsEngine = tslib.__decorate([ViewEngine("ejs")], exports.EjsEngine);
-
-exports.HamlEngine = class HamlEngine extends Engine {
-  $compile(template, options) {
-    return options => {
-      options.locals = options;
-      return Promise.resolve(this.engine.render(template, options).trimLeft());
-    };
-  }
-
-};
-exports.HamlEngine = tslib.__decorate([ViewEngine("haml")], exports.HamlEngine);
-
-exports.HamlCoffeeEngine = class HamlCoffeeEngine extends Engine {};
-exports.HamlCoffeeEngine = tslib.__decorate([ViewEngine("haml-coffee")], exports.HamlCoffeeEngine);
-
-exports.HamletEngine = class HamletEngine extends Engine {
-  $compile(template, options) {
-    return options => {
-      options.locals = options;
-      return Promise.resolve(this.engine.render(template, options).trimLeft());
-    };
-  }
-
-};
-exports.HamletEngine = tslib.__decorate([ViewEngine("hamlet")], exports.HamletEngine);
-
-exports.HandlebarsEngine = class HandlebarsEngine extends Engine {
-  configure(options) {
-    for (const partial in options.partials) {
-      this.engine.registerPartial(partial, options.partials[partial]);
-    }
-
-    for (const helper in options.helpers) {
-      this.engine.registerHelper(helper, options.helpers[helper]);
-    }
-  }
-
-  $compile(template, options) {
-    this.configure(options);
-    return this.engine.compile(template, options);
-  }
-
-};
-exports.HandlebarsEngine = tslib.__decorate([ViewEngine("handlebars")], exports.HandlebarsEngine);
-
-exports.HoganEngine = class HoganEngine extends Engine {
-  $compile(template, options) {
-    const compile = this.engine.compile(template, options);
-    return options => {
-      return compile.render(options, options.partials);
-    };
-  }
-
-};
-exports.HoganEngine = tslib.__decorate([ViewEngine("hogan", {
-  requires: "hogan.js"
-})], exports.HoganEngine);
-
-exports.HtmlingEngine = class HtmlingEngine extends Engine {
-  $compile(template) {
-    const compile = this.engine.string(template);
-    return options => compile.render(options);
-  }
-
-};
-exports.HtmlingEngine = tslib.__decorate([ViewEngine("htmling")], exports.HtmlingEngine);
-
-exports.JazzEngine = class JazzEngine extends Engine {
-  $compile(template, options) {
-    const compile = this.engine.compile(template, options);
-    return options => new Promise(resolve => compile.eval(options, resolve));
-  }
-
-};
-exports.JazzEngine = tslib.__decorate([ViewEngine("jazz")], exports.JazzEngine);
-
-exports.JqtplEngine = class JqtplEngine extends Engine {
-  $compile(template, options) {
-    this.engine.template(template, template);
-    return options => this.engine.tmpl(template, options);
-  }
-
-};
-exports.JqtplEngine = tslib.__decorate([ViewEngine("jqtpl")], exports.JqtplEngine);
-
-exports.JustEngine = class JustEngine extends Engine {
-  $compile(template, options) {
-    const JUST = this.engine;
-    const engine = new JUST({
-      root: {
-        page: template
-      }
-    });
-    const compile = util.promisify(engine.render.bind(engine));
-    return options => compile("page", options);
-  }
-
-  async $compileFile(file, options) {
-    const JUST = this.engine;
-    const engine = new JUST(options);
-    engine.configure({
-      useCache: options.cache
-    });
-    const compile = util.promisify(engine.render.bind(engine));
-    return options => compile(file, options);
-  }
-
-};
-exports.JustEngine = tslib.__decorate([ViewEngine("just")], exports.JustEngine);
-
-exports.LiquorEngine = class LiquorEngine extends Engine {};
-exports.LiquorEngine = tslib.__decorate([ViewEngine("liquor")], exports.LiquorEngine);
-
-exports.LodashEngine = class LodashEngine extends Engine {
-  render(template, options) {
-    const compile = this.compile(template, options);
-    return compile(options).replace(/\n$/, "");
-  }
-
-  $compile(template, options) {
-    return this.engine.template(template, options);
-  }
-
-};
-exports.LodashEngine = tslib.__decorate([ViewEngine("lodash")], exports.LodashEngine);
-
-exports.MarkoEngine = class MarkoEngine extends Engine {
-  $cacheOptions(template, options, fromFile) {
-    options.writeToDisk = !!options.cache;
-
-    if (!fromFile) {
-      options.filename = options.filename || "string.marko";
-    }
-
-    return options;
-  }
-
-  async $compileFile(file, options) {
-    const $cmp = this.engine.load(file, options);
-    return util.promisify($cmp.renderToString.bind($cmp));
-  }
-
-  $compile(template, options) {
-    const $cmp = this.engine.load(options.filename, template, options);
-    return util.promisify($cmp.renderToString.bind($cmp));
-  }
-
-};
-exports.MarkoEngine = tslib.__decorate([ViewEngine("marko")], exports.MarkoEngine);
-
-exports.MoteEngine = class MoteEngine extends Engine {};
-exports.MoteEngine = tslib.__decorate([ViewEngine("mote")], exports.MoteEngine);
-
-exports.MustacheEngine = class MustacheEngine extends Engine {
-  $compile(template, options) {
-    return options => this.engine.render(template, options, options.partials);
-  }
-
-};
-exports.MustacheEngine = tslib.__decorate([ViewEngine("mustache")], exports.MustacheEngine);
-
-exports.NunjucksEngine = class NunjucksEngine extends Engine {
-  configure(options) {
-    const engine = options.nunjucksEnv || this.engine;
-    let env = engine; // deprecated fallback support for express
-    // <https://github.com/tj/consolidate.js/pull/152>
-    // <https://github.com/tj/consolidate.js/pull/224>
-
-    if (options.settings && options.settings.views) {
-      env = engine.configure(options.settings.views);
-    } else if (options.nunjucks && options.nunjucks.configure) {
-      // eslint-disable-next-line prefer-spread
-      env = engine.configure.apply(engine, options.nunjucks.configure);
-    } //
-    // because `renderString` does not initiate loaders
-    // we must manually create a loader for it based off
-    // either `options.settings.views` or `options.nunjucks` or `options.nunjucks.root`
-    //
-    // <https://github.com/mozilla/nunjucks/issues/730>
-    // <https://github.com/crocodilejs/node-email-templates/issues/182>
-    //
-    // so instead we simply check if we passed a custom loader
-    // otherwise we create a simple file based loader
-
-
-    if (options.loader) {
-      return new engine.Environment(options.loader);
-    }
-
-    if (options.settings && options.settings.views) {
-      return new engine.Environment(new engine.FileSystemLoader(options.settings.views));
-    }
-
-    if (options.nunjucks && options.nunjucks.loader) {
-      if (typeof options.nunjucks.loader === "string") {
-        return new engine.Environment(new engine.FileSystemLoader(options.nunjucks.loader));
-      }
-
-      return new engine.Environment(new engine.FileSystemLoader(options.nunjucks.loader[0], options.nunjucks.loader[1]));
-    }
-
-    return env;
-  }
-
-  $compile(template, options) {
-    let engine = this.configure(options);
-    const render = util.promisify(engine.renderString.bind(engine));
-    return options => render(template, options);
-  }
-
-};
-exports.NunjucksEngine = tslib.__decorate([ViewEngine("nunjucks")], exports.NunjucksEngine);
-
-exports.PlatesEngine = class PlatesEngine extends Engine {
-  $compile(template, options) {
-    return options => {
-      const map = options.map || undefined;
-      return this.engine.bind(template, options, map);
-    };
-  }
-
-};
-exports.PlatesEngine = tslib.__decorate([ViewEngine("plates")], exports.PlatesEngine);
-
-exports.PugEngine = class PugEngine extends Engine {
-  $compile(template, options) {
-    return this.engine.compile(template, options);
-  }
-
-  async $compileFile(file, options) {
-    return this.engine.compileFile(file, options);
-  }
-
-};
-exports.PugEngine = tslib.__decorate([ViewEngine("pug", {
-  requires: ["pug", "then-pug"]
-})], exports.PugEngine);
-
-exports.RactiveEngine = class RactiveEngine extends Engine {
-  $compile(template, options) {
-    const Engine = this.engine;
-    const compile = this.engine.parse(template);
-    return options => {
-      options.template = compile;
-      return new Engine(this.clean(options)).toHTML();
-    };
-  }
-
-  clean(options) {
-    if (options.data === null || options.data === undefined) {
-      // Shallow clone the options object
-      options.data = extend({}, options); // Remove consolidate-specific properties from the clone
-
-      let i;
-      let length;
-      let properties = ["template", "filename", "cache", "partials"];
-
-      for (i = 0, length = properties.length; i < length; i++) {
-        const property = properties[i];
-        delete options.data[property];
-      }
-    }
-
-    return options;
-  }
-
-};
-exports.RactiveEngine = tslib.__decorate([ViewEngine("ractive")], exports.RactiveEngine);
-
-exports.ReactEngine = class ReactEngine extends Engine {
-  constructor(name, options) {
-    super(name, options);
-    this.patchRequire();
-  }
-
-  patchRequire() {
-    if (require.extensions) {
-      // Ensure JSX is transformed on require
-      if (!require.extensions[".jsx"]) {
-        require.extensions[".jsx"] = this.requireReact.bind(this);
-      } // Supporting .react extension as well as test cases
-      // Using .react extension is not recommended.
-
-
-      if (!require.extensions[".react"]) {
-        require.extensions[".react"] = this.requireReact.bind(this);
-      }
-    }
-  }
-
-  configure(options) {
-    const base = options.base;
-    delete options.base;
-    const enableCache = options.cache;
-    delete options.cache;
-    const isNonStatic = options.isNonStatic;
-    delete options.isNonStatic;
-    return {
-      base,
-      enableCache,
-      isNonStatic
-    };
-  }
-
-  $compile(template, options) {
-    // Assign HTML Base
-    const {
-      base,
-      enableCache,
-      isNonStatic
-    } = this.configure(options); // Start Conversion
-
-    const ReactDOM = requireEngine("react-dom/server", "ReactDOM");
-    const Code = this.requireReactString(template);
-    const Factory = this.engine.createFactory(Code);
-    return () => {
-      const parsed = new Factory(options);
-      const content = isNonStatic ? ReactDOM.renderToString(parsed) : ReactDOM.renderToStaticMarkup(parsed);
-
-      if (base) {
-        options.content = content;
-        return this.renderWithBase(template, base, enableCache, options);
-      }
-
-      return content;
-    };
-  }
-
-  async $compileFile(file, options) {
-    // Assign HTML Base
-    const {
-      base,
-      enableCache,
-      isNonStatic
-    } = this.configure(options);
-    let path$1 = path.resolve(file);
-    delete require.cache[path$1];
-    const ReactDOM = requireEngine("react-dom/server", "ReactDOM");
-
-    const Code = require(path$1);
-
-    const Factory = this.engine.createFactory(Code);
-    return () => {
-      const parsed = new Factory(options);
-      const content = isNonStatic ? ReactDOM.renderToString(parsed) : ReactDOM.renderToStaticMarkup(parsed);
-
-      if (base) {
-        options.content = content;
-        return this.renderWithBase(file, base, enableCache, options);
-      }
-
-      return content;
-    };
-  }
-
-  renderWithBase(key, base, enableCache, options) {
-    const baseStr = getFromCache(key) || fs$1.readFileSync(path.resolve(base), "utf8");
-
-    if (enableCache) {
-      setToCache(key, baseStr);
-    }
-
-    return this.reactBaseTmpl(baseStr, options);
-  }
-
-  transformFileSync(filename) {
-    try {
-      const babel = requireEngine("@babel/core", "babel");
-      return babel.transformFileSync(filename, {
-        presets: ["@babel/preset-react"]
-      }).code;
-    } catch (err) {
-      const babel = requireEngine("babel-core", "babel");
-      return babel.transformFileSync(filename, {
-        presets: ["react"]
-      }).code;
-    }
-  }
-
-  transform(src) {
-    try {
-      const babel = requireEngine("@babel/core", "babel");
-      return babel.transform(src, {
-        presets: ["@babel/preset-react"]
-      }).code;
-    } catch (err) {
-      const babel = requireEngine("babel-core", "babel");
-      return babel.transform(src, {
-        presets: ["react"]
-      }).code;
-    }
-  }
-
-  requireReact(module, filename) {
-    const compiled = this.transformFileSync(filename);
-    return module._compile(compiled, filename);
-  }
-
-  requireReactString(src, filename) {
-    if (!filename) filename = ""; // @ts-ignore
-
-    const m = new module.constructor();
-    filename = filename || ""; // Compile Using React
-
-    const compiled = this.transform(src); // Compile as a module
-
-    m.paths = module.paths;
-
-    m._compile(compiled, filename);
-
-    return m.exports;
-  }
-
-  reactBaseTmpl(data, options) {
-    let exp;
-    let regex; // Iterates through the keys in file object
-    // and interpolate / replace {{key}} with it's value
-
-    for (const k in options) {
-      if (options.hasOwnProperty(k)) {
-        exp = `{{${k}}}`;
-        regex = new RegExp(exp, "g");
-
-        if (data.match(regex)) {
-          data = data.replace(regex, options[k]);
-        }
-      }
-    }
-
-    return data;
-  }
-
-};
-exports.ReactEngine = tslib.__decorate([ViewEngine("react", {
-  requires: ["react"]
-}), tslib.__metadata("design:paramtypes", [String, Object])], exports.ReactEngine);
-
-exports.SlmEngine = class SlmEngine extends Engine {};
-exports.SlmEngine = tslib.__decorate([ViewEngine("slm")], exports.SlmEngine);
-
-exports.SquirrellyEngine = class SquirrellyEngine extends Engine {
-  $compile(template, options) {
-    for (const partial in options.partials) {
-      this.engine.definePartial(partial, options.partials[partial]);
-    }
-
-    for (const helper in options.helpers) {
-      this.engine.defineHelper(helper, options.helpers[helper]);
-    }
-
-    const compile = this.engine.Compile(template, options);
-    return options => compile(options, this.engine);
-  }
-
-};
-exports.SquirrellyEngine = tslib.__decorate([ViewEngine("squirrelly")], exports.SquirrellyEngine);
-
-exports.SwigEngine = class SwigEngine extends Engine {
-  $compile(template, options) {
-    if (options.cache === true) options.cache = "memory";
-    this.engine.setDefaults({
-      cache: options.cache
-    });
-    return this.engine.compile(template, options);
-  }
-
-};
-exports.SwigEngine = tslib.__decorate([ViewEngine("swig", {
-  requires: ["swig", "swig-templates"]
-})], exports.SwigEngine);
-
-exports.TemplayedEngine = class TemplayedEngine extends Engine {
-  $compile(template, options) {
-    return this.engine(template);
-  }
-
-};
-exports.TemplayedEngine = tslib.__decorate([ViewEngine("templayed")], exports.TemplayedEngine);
-
-exports.ToffeeEngine = class ToffeeEngine extends Engine {
-  $compile(template, options) {
-    const compile = util.promisify(this.engine.str_render.bind(this.engine));
-    return options => compile(template, options);
-  }
-
-  async $compileFile(file, options) {
-    const compile = util.promisify(this.engine.__consolidate_engine_render.bind(this.engine));
-    return options => compile(file, options);
-  }
-
-};
-exports.ToffeeEngine = tslib.__decorate([ViewEngine("toffee")], exports.ToffeeEngine);
-
-exports.TwingEngine = class TwingEngine extends Engine {
-  $compile(template, options) {
-    const engine = this.engine;
-
-    if (!this.instance) {
-      let loader = new engine.TwingLoaderNull();
-
-      if (options.settings && options.settings.views && fs$1.existsSync(options.settings.views)) {
-        loader = new engine.TwingLoaderFilesystem(options.settings.views);
-      }
-
-      this.instance = new engine.TwingEnvironment(loader);
-    }
-
-    const $cmp = this.instance.createTemplate(template);
-    return async options => {
-      const compile = await $cmp;
-      return compile.render(options);
-    };
-  }
-
-};
-exports.TwingEngine = tslib.__decorate([ViewEngine("twing")], exports.TwingEngine);
-
-exports.TwigEngine = class TwigEngine extends Engine {
-  $cacheOptions(template, options) {
-    return _extends({}, options, {
-      data: template,
-      allowInlineIncludes: options.allowInlineIncludes,
-      namespaces: options.namespaces,
-      path: options.path
-    });
-  }
-
-  $compile(template, options) {
-    const {
-      twig: engine
-    } = this.engine;
-    options.data = template;
-    const compile = engine(options);
-    return options => compile.render(options);
-  }
-
-};
-exports.TwigEngine = tslib.__decorate([ViewEngine("twig")], exports.TwigEngine);
-
-exports.UnderscoreEngine = class UnderscoreEngine extends Engine {
-  async render(template, options) {
-    const tpl = await this.compile(template, options)(options);
-    return tpl.replace(/\n$/, "");
-  }
-
-  $cacheOptions(template, options) {
-    const partials = {};
-
-    for (const partial in options.partials) {
-      partials[partial] = this.engine.template(options.partials[partial]);
-    }
-
-    options.partials = partials;
-    return options;
-  }
-
-  $compile(template, options) {
-    return this.engine.template(template, null, options);
-  }
-
-};
-exports.UnderscoreEngine = tslib.__decorate([ViewEngine("underscore")], exports.UnderscoreEngine);
-
-exports.VashEngine = class VashEngine extends Engine {
-  compile(template, options) {
-    if (options.helpers) {
-      for (const key in options.helpers) {
-        if (!options.helpers.hasOwnProperty(key) || typeof options.helpers[key] !== "function") {
-          continue;
-        }
-
-        this.engine.helpers[key] = options.helpers[key];
-      }
-    }
-
-    const compile = util.promisify(this.engine.compile(template, options));
-    return async options => {
-      const ctx = await compile(options);
-      ctx.finishLayout();
-      return ctx.toString();
-    };
-  }
-
-  async render(template, options) {
-    const compile = this.compile(template, options);
-    const tpl = await compile(options);
-    return tpl.replace(/\n$/, "");
-  }
-
-};
-exports.VashEngine = tslib.__decorate([ViewEngine("vash")], exports.VashEngine);
-
-exports.VelocityEngine = class VelocityEngine extends Engine {
-  $compile(template, options) {
-    return async options => {
-      return this.engine.render(template, options).trimLeft();
-    };
-  }
-
-};
-exports.VelocityEngine = tslib.__decorate([ViewEngine("velocityjs")], exports.VelocityEngine);
-
-var _renderToString;
-
-function requireFromString(src, filename) {
-  const Module = module.constructor;
-  const m = new Module();
-
-  m._compile(src, filename);
-
-  return m.exports;
-}
-/**
- *  simple hash a string
- *  https://stackoverflow.com/a/34842797/493756
- */
-
-
-function hashCode(str) {
-  return str.split("").reduce((prevHash, currVal) => (prevHash << 5) - prevHash + currVal.charCodeAt(0), 0);
-}
-
-exports.VueEngine = (_renderToString = /*#__PURE__*/_classPrivateFieldLooseKey("renderToString"), class VueEngine extends Engine {
-  constructor(name, options) {
-    super(name, options);
-    Object.defineProperty(this, _renderToString, {
-      writable: true,
-      value: void 0
-    });
-    const ssrRenderer = this.vueServerRenderer.createRenderer();
-    _classPrivateFieldLooseBase(this, _renderToString)[_renderToString] = util.promisify(ssrRenderer.renderToString.bind(this));
-    requireEngine("vue-pronto/lib/index", "pronto");
-  }
-
-  get pronto() {
-    return requireEngine("pronto");
-  }
-
-  get vueify() {
-    return requireEngine("vueify");
-  }
-
-  get vueServerRenderer() {
-    return requireEngine("vue-server-renderer");
-  }
-
-  $cacheOptions(template, options, fromFile) {
-    const fullPath = path.join(__dirname, `/${hashCode(template)}`);
-
-    if (!fromFile) {
-      return _extends({}, options, {
-        filename: fullPath
-      });
-    }
-
-    return options;
-  }
-
-  $compile(template, options) {
-    // make up a fake path
-    const fullPath = path.join(__dirname, `/${hashCode(template)}`);
-    const promise = this.getComponent(fullPath, template, options);
-    return async options => {
-      return this.renderComponent(await promise, options);
-    };
-  }
-
-  async $compileFile(file, options) {
-    // prontoRenderer assume that the filepath is relative to a passed "rootpath"
-    // and if you don't pass a rootpath it will try to find one
-    // based on its current __dirname
-    // https://github.com/express-vue/vue-pronto/blob/c88e380fee8656bc3ed21c7d3adb2ef331be07d5/lib/utils/findPaths.js#L10-L18
-    const fullPath = path.resolve(file);
-    const rootPath = process.cwd();
-    const filepath = fullPath.replace(`${rootPath}/`, "");
-    const prontoOptions = {
-      rootPath,
-      vueVersion: {
-        disabled: true
-      }
-    };
-
-    if (!options.cache) {
-      // disable pronto lru cache
-      prontoOptions.cacheOptions = {
-        max: 0
-      };
-    }
-
-    let prontoRenderer = new this.pronto.ProntoVueify(prontoOptions);
-
-    if (!options.cache) {
-      // disable pronto internal cache
-      // yup
-      prontoRenderer.internalCache = {
-        get: () => {},
-        set: () => {}
-      };
-    } else {
-      // so, this ties each "renderer" to a rootPath
-      // so I have to create a new prontoRenderer each time
-      // which sucks! because I loose the internal cache of it,
-      // unless, I keep tabs on both lru and internal caches and replace them every time.
-      const internalCache = prontoRenderer.internalCache;
-      prontoRenderer.internalCache = {
-        get: internalCache.get.bind(internalCache),
-
-        set(filename, component) {
-          internalCache.set(filename, _extends({}, component, {
-            data: component.data || (() => options)
-          }));
-        }
-
-      };
-    }
-
-    return options => {
-      return prontoRenderer.RenderToString(filepath, {}, {
-        propsData: options
-      });
-    };
-  }
-
-  async getComponent(fullPath, template, options) {
-    // assume that the str the content of a <template> ... </template>
-    if (/<template/.test(template.trim())) {
-      // assume that the str is a fileContent of a .vue file
-      const compile = util.promisify(this.vueify.compiler.compile.bind(this.vueify.compiler));
-      const cmp = await compile(template, fullPath);
-      return requireFromString(cmp, fullPath);
-    }
-
-    return {
-      template,
-
-      data() {
-        return options;
-      }
-
-    };
-  }
-
-  async renderComponent(Component, options) {
-    let Factory = this.engine.extend(Component);
-    let instance = new Factory({
-      propsData: options
-    });
-    return _classPrivateFieldLooseBase(this, _renderToString)[_renderToString](instance);
-  }
-
-});
-exports.VueEngine = tslib.__decorate([ViewEngine("vue", {
-  requires: "vue"
-}), tslib.__metadata("design:paramtypes", [String, Object])], exports.VueEngine);
-
-exports.WalrusEngine = class WalrusEngine extends Engine {
-  $compile(template, options) {
-    const compile = this.engine.parse(template);
-    return options => compile.compile(options);
-  }
-
-};
-exports.WalrusEngine = tslib.__decorate([ViewEngine("walrus")], exports.WalrusEngine);
-
-const callbackify = async (fn, cb) => {
-  try {
-    const html = await fn();
-    cb && cb(null, html);
-    return html;
-  } catch (er) {
-    if (cb) {
-      cb(er);
-    } else {
-      throw er;
-    }
-  }
-};
-
-function getEngine(name) {
-  const cb = async (path, options, cb) => {
-    return callbackify(() => engines.get(name).renderFile(path, options), cb);
-  };
-
-  cb.render = async (template, options, cb) => {
-    return callbackify(() => engines.get(name).render(template, options), cb);
-  };
-
-  return cb;
-}
-let localEngines;
-function getEngines() {
-  localEngines = localEngines || engines.getSupportedEngines().reduce((acc, key) => {
-    return _extends({}, acc, {
-      [key]: getEngine(key)
-    });
-  }, {});
-  return localEngines;
-}
-
-exports.Engine = Engine;
-exports.EnginesContainer = EnginesContainer;
-exports.ViewEngine = ViewEngine;
-exports.cache = cache;
-exports.clearCache = clearCache;
-exports.engines = engines;
-exports.extend = extend;
-exports.getEngine = getEngine;
-exports.getEngines = getEngines;
-exports.getFromCache = getFromCache;
-exports.read = read;
-exports.readPartials = readPartials;
-exports.requireEngine = requireEngine;
-exports.requires = requires;
-exports.setRequireEngine = setRequireEngine;
-exports.setToCache = setToCache;
-//# sourceMappingURL=index.js.map