@tsed/engines 1.1.5 → 6.112.0

package/lib/index.modern.js

@@ -1,1198 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import fs from 'fs-extra';
-import { isAbsolute, extname, join, dirname, resolve } from 'path';
-import { promisify } from 'util';
-import { readFileSync, existsSync } from '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.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, 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 (isAbsolute(partialPath)) {
-        if (extname(partialPath) !== "") {
-          file = partialPath;
-        } else {
-          file = join(partialPath + extname(path));
-        }
-      } else {
-        file = join(dirname(path), partialPath + extname(path));
-      }
-
-      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);
-  }
-
-}
-
-let AtplEngine = class AtplEngine extends Engine {};
-AtplEngine = __decorate([ViewEngine("atpl")], AtplEngine);
-
-let BracketEngine = class BracketEngine extends Engine {
-  $compile(template, options) {
-    return this.engine.default.compile(template, options);
-  }
-
-};
-BracketEngine = __decorate([ViewEngine("bracket", {
-  requires: "bracket-template"
-})], BracketEngine);
-
-let 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);
-  }
-
-};
-DotEngine = __decorate([ViewEngine("dot")], DotEngine);
-
-let DustEngine = class DustEngine extends Engine {
-  constructor() {
-    super(...arguments);
-    this.views = ".";
-    this.ext = "dust";
-  }
-
-  configure(options) {
-    var _this = this;
-
-    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 function (path, callback) {
-      if (extname(path) === "") {
-        path += `.${_this.ext}`;
-      }
-
-      if (path[0] !== "/") {
-        path = `${_this.views}/${path}`;
-      }
-
-      try {
-        callback(null, await read(path, 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 promisify(this.engine.compileFn(template, templateName));
-  }
-
-};
-DustEngine = __decorate([ViewEngine("dust", {
-  requires: ["dustjs-helpers", "dustjs-linkedin"]
-})], DustEngine);
-
-let EctEngine = class EctEngine extends Engine {
-  $compile(template, options) {
-    const ECT = this.engine;
-    const engine = new ECT({
-      root: {
-        page: template
-      }
-    });
-    const compile = 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 = promisify(engine.render.bind(engine));
-    return options => compile(file, options);
-  }
-
-};
-EctEngine = __decorate([ViewEngine("ect")], EctEngine);
-
-let EjsEngine = class EjsEngine extends Engine {};
-EjsEngine = __decorate([ViewEngine("ejs")], EjsEngine);
-
-let HamlEngine = class HamlEngine extends Engine {
-  $compile(template, options) {
-    return options => {
-      options.locals = options;
-      return Promise.resolve(this.engine.render(template, options).trimLeft());
-    };
-  }
-
-};
-HamlEngine = __decorate([ViewEngine("haml")], HamlEngine);
-
-let HamlCoffeeEngine = class HamlCoffeeEngine extends Engine {};
-HamlCoffeeEngine = __decorate([ViewEngine("haml-coffee")], HamlCoffeeEngine);
-
-let HamletEngine = class HamletEngine extends Engine {
-  $compile(template, options) {
-    return options => {
-      options.locals = options;
-      return Promise.resolve(this.engine.render(template, options).trimLeft());
-    };
-  }
-
-};
-HamletEngine = __decorate([ViewEngine("hamlet")], HamletEngine);
-
-let 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);
-  }
-
-};
-HandlebarsEngine = __decorate([ViewEngine("handlebars")], HandlebarsEngine);
-
-let HoganEngine = class HoganEngine extends Engine {
-  $compile(template, options) {
-    const compile = this.engine.compile(template, options);
-    return options => {
-      return compile.render(options, options.partials);
-    };
-  }
-
-};
-HoganEngine = __decorate([ViewEngine("hogan", {
-  requires: "hogan.js"
-})], HoganEngine);
-
-let HtmlingEngine = class HtmlingEngine extends Engine {
-  $compile(template) {
-    const compile = this.engine.string(template);
-    return options => compile.render(options);
-  }
-
-};
-HtmlingEngine = __decorate([ViewEngine("htmling")], HtmlingEngine);
-
-let JazzEngine = class JazzEngine extends Engine {
-  $compile(template, options) {
-    const compile = this.engine.compile(template, options);
-    return options => new Promise(resolve => compile.eval(options, resolve));
-  }
-
-};
-JazzEngine = __decorate([ViewEngine("jazz")], JazzEngine);
-
-let JqtplEngine = class JqtplEngine extends Engine {
-  $compile(template, options) {
-    this.engine.template(template, template);
-    return options => this.engine.tmpl(template, options);
-  }
-
-};
-JqtplEngine = __decorate([ViewEngine("jqtpl")], JqtplEngine);
-
-let JustEngine = class JustEngine extends Engine {
-  $compile(template, options) {
-    const JUST = this.engine;
-    const engine = new JUST({
-      root: {
-        page: template
-      }
-    });
-    const compile = 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 = promisify(engine.render.bind(engine));
-    return options => compile(file, options);
-  }
-
-};
-JustEngine = __decorate([ViewEngine("just")], JustEngine);
-
-let LiquorEngine = class LiquorEngine extends Engine {};
-LiquorEngine = __decorate([ViewEngine("liquor")], LiquorEngine);
-
-let 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);
-  }
-
-};
-LodashEngine = __decorate([ViewEngine("lodash")], LodashEngine);
-
-let 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 promisify($cmp.renderToString.bind($cmp));
-  }
-
-  $compile(template, options) {
-    const $cmp = this.engine.load(options.filename, template, options);
-    return promisify($cmp.renderToString.bind($cmp));
-  }
-
-};
-MarkoEngine = __decorate([ViewEngine("marko")], MarkoEngine);
-
-let MoteEngine = class MoteEngine extends Engine {};
-MoteEngine = __decorate([ViewEngine("mote")], MoteEngine);
-
-let MustacheEngine = class MustacheEngine extends Engine {
-  $compile(template, options) {
-    return options => this.engine.render(template, options, options.partials);
-  }
-
-};
-MustacheEngine = __decorate([ViewEngine("mustache")], MustacheEngine);
-
-let 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 = promisify(engine.renderString.bind(engine));
-    return options => render(template, options);
-  }
-
-};
-NunjucksEngine = __decorate([ViewEngine("nunjucks")], NunjucksEngine);
-
-let PlatesEngine = class PlatesEngine extends Engine {
-  $compile(template, options) {
-    return options => {
-      const map = options.map || undefined;
-      return this.engine.bind(template, options, map);
-    };
-  }
-
-};
-PlatesEngine = __decorate([ViewEngine("plates")], PlatesEngine);
-
-let PugEngine = class PugEngine extends Engine {
-  $compile(template, options) {
-    return this.engine.compile(template, options);
-  }
-
-  async $compileFile(file, options) {
-    return this.engine.compileFile(file, options);
-  }
-
-};
-PugEngine = __decorate([ViewEngine("pug", {
-  requires: ["pug", "then-pug"]
-})], PugEngine);
-
-let 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;
-  }
-
-};
-RactiveEngine = __decorate([ViewEngine("ractive")], RactiveEngine);
-
-let 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 = resolve(file);
-    delete require.cache[path];
-    const ReactDOM = requireEngine("react-dom/server", "ReactDOM");
-
-    const Code = require(path);
-
-    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) || readFileSync(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;
-  }
-
-};
-ReactEngine = __decorate([ViewEngine("react", {
-  requires: ["react"]
-}), __metadata("design:paramtypes", [String, Object])], ReactEngine);
-
-let SlmEngine = class SlmEngine extends Engine {};
-SlmEngine = __decorate([ViewEngine("slm")], SlmEngine);
-
-let 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);
-  }
-
-};
-SquirrellyEngine = __decorate([ViewEngine("squirrelly")], SquirrellyEngine);
-
-let 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);
-  }
-
-};
-SwigEngine = __decorate([ViewEngine("swig", {
-  requires: ["swig", "swig-templates"]
-})], SwigEngine);
-
-let TemplayedEngine = class TemplayedEngine extends Engine {
-  $compile(template, options) {
-    return this.engine(template);
-  }
-
-};
-TemplayedEngine = __decorate([ViewEngine("templayed")], TemplayedEngine);
-
-let ToffeeEngine = class ToffeeEngine extends Engine {
-  $compile(template, options) {
-    const compile = promisify(this.engine.str_render.bind(this.engine));
-    return options => compile(template, options);
-  }
-
-  async $compileFile(file, options) {
-    const compile = promisify(this.engine.__consolidate_engine_render.bind(this.engine));
-    return options => compile(file, options);
-  }
-
-};
-ToffeeEngine = __decorate([ViewEngine("toffee")], ToffeeEngine);
-
-let 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 && 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 function (options) {
-      const compile = await $cmp;
-      return compile.render(options);
-    };
-  }
-
-};
-TwingEngine = __decorate([ViewEngine("twing")], TwingEngine);
-
-let 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);
-  }
-
-};
-TwigEngine = __decorate([ViewEngine("twig")], TwigEngine);
-
-let 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);
-  }
-
-};
-UnderscoreEngine = __decorate([ViewEngine("underscore")], UnderscoreEngine);
-
-let 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 = promisify(this.engine.compile(template, options));
-    return async function (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$/, "");
-  }
-
-};
-VashEngine = __decorate([ViewEngine("vash")], VashEngine);
-
-let VelocityEngine = class VelocityEngine extends Engine {
-  $compile(template, options) {
-    var _this = this;
-
-    return async function (options) {
-      return _this.engine.render(template, options).trimLeft();
-    };
-  }
-
-};
-VelocityEngine = __decorate([ViewEngine("velocityjs")], 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);
-}
-
-let 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] = 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 = join(__dirname, `/${hashCode(template)}`);
-
-    if (!fromFile) {
-      return _extends({}, options, {
-        filename: fullPath
-      });
-    }
-
-    return options;
-  }
-
-  $compile(template, options) {
-    var _this = this;
-
-    // make up a fake path
-    const fullPath = join(__dirname, `/${hashCode(template)}`);
-    const promise = this.getComponent(fullPath, template, options);
-    return async function (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 = 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 = 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);
-  }
-
-});
-VueEngine = __decorate([ViewEngine("vue", {
-  requires: "vue"
-}), __metadata("design:paramtypes", [String, Object])], VueEngine);
-
-let WalrusEngine = class WalrusEngine extends Engine {
-  $compile(template, options) {
-    const compile = this.engine.parse(template);
-    return options => compile.compile(options);
-  }
-
-};
-WalrusEngine = __decorate([ViewEngine("walrus")], 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;
-}
-
-export { AtplEngine, BracketEngine, DotEngine, DustEngine, EctEngine, EjsEngine, Engine, EnginesContainer, HamlCoffeeEngine, HamlEngine, HamletEngine, HandlebarsEngine, HoganEngine, HtmlingEngine, JazzEngine, JqtplEngine, JustEngine, LiquorEngine, LodashEngine, MarkoEngine, MoteEngine, MustacheEngine, NunjucksEngine, PlatesEngine, PugEngine, RactiveEngine, ReactEngine, SlmEngine, SquirrellyEngine, SwigEngine, TemplayedEngine, ToffeeEngine, TwigEngine, TwingEngine, UnderscoreEngine, VashEngine, VelocityEngine, ViewEngine, VueEngine, WalrusEngine, cache, clearCache, engines, extend, getEngine, getEngines, getFromCache, read, readPartials, requireEngine, requires, setRequireEngine, setToCache };
-//# sourceMappingURL=index.modern.js.map