@smapiot/pilet-template-angular 0.15.0-beta.4440

package/lib/index.js

@@ -0,0 +1,1385 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+
+// ../../node_modules/ejs/lib/utils.js
+var require_utils = __commonJS({
+  "../../node_modules/ejs/lib/utils.js"(exports) {
+    "use strict";
+    var regExpChars = /[|\\{}()[\]^$+*?.]/g;
+    exports.escapeRegExpChars = function(string) {
+      if (!string) {
+        return "";
+      }
+      return String(string).replace(regExpChars, "\\$&");
+    };
+    var _ENCODE_HTML_RULES = {
+      "&": "&",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&#34;",
+      "'": "&#39;"
+    };
+    var _MATCH_HTML = /[&<>'"]/g;
+    function encode_char(c) {
+      return _ENCODE_HTML_RULES[c] || c;
+    }
+    var escapeFuncStr = `var _ENCODE_HTML_RULES = {
+      "&": "&amp;"
+    , "<": "&lt;"
+    , ">": "&gt;"
+    , '"': "&#34;"
+    , "'": "&#39;"
+    }
+  , _MATCH_HTML = /[&<>'"]/g;
+function encode_char(c) {
+  return _ENCODE_HTML_RULES[c] || c;
+};
+`;
+    exports.escapeXML = function(markup) {
+      return markup == void 0 ? "" : String(markup).replace(_MATCH_HTML, encode_char);
+    };
+    exports.escapeXML.toString = function() {
+      return Function.prototype.toString.call(this) + ";\n" + escapeFuncStr;
+    };
+    exports.shallowCopy = function(to, from) {
+      from = from || {};
+      for (var p in from) {
+        to[p] = from[p];
+      }
+      return to;
+    };
+    exports.shallowCopyFromList = function(to, from, list) {
+      for (var i = 0; i < list.length; i++) {
+        var p = list[i];
+        if (typeof from[p] != "undefined") {
+          to[p] = from[p];
+        }
+      }
+      return to;
+    };
+    exports.cache = {
+      _data: {},
+      set: function(key, val) {
+        this._data[key] = val;
+      },
+      get: function(key) {
+        return this._data[key];
+      },
+      remove: function(key) {
+        delete this._data[key];
+      },
+      reset: function() {
+        this._data = {};
+      }
+    };
+  }
+});
+
+// ../../node_modules/ejs/package.json
+var require_package = __commonJS({
+  "../../node_modules/ejs/package.json"(exports, module2) {
+    module2.exports = {
+      name: "ejs",
+      description: "Embedded JavaScript templates",
+      keywords: [
+        "template",
+        "engine",
+        "ejs"
+      ],
+      version: "2.7.4",
+      author: "Matthew Eernisse <mde@fleegix.org> (http://fleegix.org)",
+      license: "Apache-2.0",
+      main: "./lib/ejs.js",
+      repository: {
+        type: "git",
+        url: "git://github.com/mde/ejs.git"
+      },
+      bugs: "https://github.com/mde/ejs/issues",
+      homepage: "https://github.com/mde/ejs",
+      dependencies: {},
+      devDependencies: {
+        browserify: "^13.1.1",
+        eslint: "^4.14.0",
+        "git-directory-deploy": "^1.5.1",
+        jake: "^10.3.1",
+        jsdoc: "^3.4.0",
+        "lru-cache": "^4.0.1",
+        mocha: "^5.0.5",
+        "uglify-js": "^3.3.16"
+      },
+      engines: {
+        node: ">=0.10.0"
+      },
+      scripts: {
+        test: "mocha",
+        postinstall: "node ./postinstall.js"
+      }
+    };
+  }
+});
+
+// ../../node_modules/ejs/lib/ejs.js
+var require_ejs = __commonJS({
+  "../../node_modules/ejs/lib/ejs.js"(exports) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var utils = require_utils();
+    var scopeOptionWarned = false;
+    var _VERSION_STRING = require_package().version;
+    var _DEFAULT_OPEN_DELIMITER = "<";
+    var _DEFAULT_CLOSE_DELIMITER = ">";
+    var _DEFAULT_DELIMITER = "%";
+    var _DEFAULT_LOCALS_NAME = "locals";
+    var _NAME = "ejs";
+    var _REGEX_STRING = "(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)";
+    var _OPTS_PASSABLE_WITH_DATA = [
+      "delimiter",
+      "scope",
+      "context",
+      "debug",
+      "compileDebug",
+      "client",
+      "_with",
+      "rmWhitespace",
+      "strict",
+      "filename",
+      "async"
+    ];
+    var _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat("cache");
+    var _BOM = /^\uFEFF/;
+    exports.cache = utils.cache;
+    exports.fileLoader = fs.readFileSync;
+    exports.localsName = _DEFAULT_LOCALS_NAME;
+    exports.promiseImpl = new Function("return this;")().Promise;
+    exports.resolveInclude = function(name, filename, isDir) {
+      var dirname = path.dirname;
+      var extname = path.extname;
+      var resolve2 = path.resolve;
+      var includePath = resolve2(isDir ? filename : dirname(filename), name);
+      var ext = extname(name);
+      if (!ext) {
+        includePath += ".ejs";
+      }
+      return includePath;
+    };
+    function getIncludePath(path2, options) {
+      var includePath;
+      var filePath;
+      var views = options.views;
+      var match = /^[A-Za-z]+:\\|^\//.exec(path2);
+      if (match && match.length) {
+        includePath = exports.resolveInclude(path2.replace(/^\/*/, ""), options.root || "/", true);
+      } else {
+        if (options.filename) {
+          filePath = exports.resolveInclude(path2, options.filename);
+          if (fs.existsSync(filePath)) {
+            includePath = filePath;
+          }
+        }
+        if (!includePath) {
+          if (Array.isArray(views) && views.some(function(v) {
+            filePath = exports.resolveInclude(path2, v, true);
+            return fs.existsSync(filePath);
+          })) {
+            includePath = filePath;
+          }
+        }
+        if (!includePath) {
+          throw new Error('Could not find the include file "' + options.escapeFunction(path2) + '"');
+        }
+      }
+      return includePath;
+    }
+    function handleCache(options, template) {
+      var func;
+      var filename = options.filename;
+      var hasTemplate = arguments.length > 1;
+      if (options.cache) {
+        if (!filename) {
+          throw new Error("cache option requires a filename");
+        }
+        func = exports.cache.get(filename);
+        if (func) {
+          return func;
+        }
+        if (!hasTemplate) {
+          template = fileLoader(filename).toString().replace(_BOM, "");
+        }
+      } else if (!hasTemplate) {
+        if (!filename) {
+          throw new Error("Internal EJS error: no file name or template provided");
+        }
+        template = fileLoader(filename).toString().replace(_BOM, "");
+      }
+      func = exports.compile(template, options);
+      if (options.cache) {
+        exports.cache.set(filename, func);
+      }
+      return func;
+    }
+    function tryHandleCache(options, data, cb) {
+      var result;
+      if (!cb) {
+        if (typeof exports.promiseImpl == "function") {
+          return new exports.promiseImpl(function(resolve2, reject) {
+            try {
+              result = handleCache(options)(data);
+              resolve2(result);
+            } catch (err) {
+              reject(err);
+            }
+          });
+        } else {
+          throw new Error("Please provide a callback function");
+        }
+      } else {
+        try {
+          result = handleCache(options)(data);
+        } catch (err) {
+          return cb(err);
+        }
+        cb(null, result);
+      }
+    }
+    function fileLoader(filePath) {
+      return exports.fileLoader(filePath);
+    }
+    function includeFile(path2, options) {
+      var opts = utils.shallowCopy({}, options);
+      opts.filename = getIncludePath(path2, opts);
+      return handleCache(opts);
+    }
+    function includeSource(path2, options) {
+      var opts = utils.shallowCopy({}, options);
+      var includePath;
+      var template;
+      includePath = getIncludePath(path2, opts);
+      template = fileLoader(includePath).toString().replace(_BOM, "");
+      opts.filename = includePath;
+      var templ = new Template(template, opts);
+      templ.generateSource();
+      return {
+        source: templ.source,
+        filename: includePath,
+        template
+      };
+    }
+    function rethrow(err, str, flnm, lineno, esc) {
+      var lines = str.split("\n");
+      var start = Math.max(lineno - 3, 0);
+      var end = Math.min(lines.length, lineno + 3);
+      var filename = esc(flnm);
+      var context = lines.slice(start, end).map(function(line, i) {
+        var curr = i + start + 1;
+        return (curr == lineno ? " >> " : "    ") + curr + "| " + line;
+      }).join("\n");
+      err.path = filename;
+      err.message = (filename || "ejs") + ":" + lineno + "\n" + context + "\n\n" + err.message;
+      throw err;
+    }
+    function stripSemi(str) {
+      return str.replace(/;(\s*$)/, "$1");
+    }
+    exports.compile = function compile(template, opts) {
+      var templ;
+      if (opts && opts.scope) {
+        if (!scopeOptionWarned) {
+          console.warn("`scope` option is deprecated and will be removed in EJS 3");
+          scopeOptionWarned = true;
+        }
+        if (!opts.context) {
+          opts.context = opts.scope;
+        }
+        delete opts.scope;
+      }
+      templ = new Template(template, opts);
+      return templ.compile();
+    };
+    exports.render = function(template, d, o) {
+      var data = d || {};
+      var opts = o || {};
+      if (arguments.length == 2) {
+        utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
+      }
+      return handleCache(opts, template)(data);
+    };
+    exports.renderFile = function() {
+      var args = Array.prototype.slice.call(arguments);
+      var filename = args.shift();
+      var cb;
+      var opts = { filename };
+      var data;
+      var viewOpts;
+      if (typeof arguments[arguments.length - 1] == "function") {
+        cb = args.pop();
+      }
+      if (args.length) {
+        data = args.shift();
+        if (args.length) {
+          utils.shallowCopy(opts, args.pop());
+        } else {
+          if (data.settings) {
+            if (data.settings.views) {
+              opts.views = data.settings.views;
+            }
+            if (data.settings["view cache"]) {
+              opts.cache = true;
+            }
+            viewOpts = data.settings["view options"];
+            if (viewOpts) {
+              utils.shallowCopy(opts, viewOpts);
+            }
+          }
+          utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
+        }
+        opts.filename = filename;
+      } else {
+        data = {};
+      }
+      return tryHandleCache(opts, data, cb);
+    };
+    exports.Template = Template;
+    exports.clearCache = function() {
+      exports.cache.reset();
+    };
+    function Template(text, opts) {
+      opts = opts || {};
+      var options = {};
+      this.templateText = text;
+      this.mode = null;
+      this.truncate = false;
+      this.currentLine = 1;
+      this.source = "";
+      this.dependencies = [];
+      options.client = opts.client || false;
+      options.escapeFunction = opts.escape || opts.escapeFunction || utils.escapeXML;
+      options.compileDebug = opts.compileDebug !== false;
+      options.debug = !!opts.debug;
+      options.filename = opts.filename;
+      options.openDelimiter = opts.openDelimiter || exports.openDelimiter || _DEFAULT_OPEN_DELIMITER;
+      options.closeDelimiter = opts.closeDelimiter || exports.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
+      options.delimiter = opts.delimiter || exports.delimiter || _DEFAULT_DELIMITER;
+      options.strict = opts.strict || false;
+      options.context = opts.context;
+      options.cache = opts.cache || false;
+      options.rmWhitespace = opts.rmWhitespace;
+      options.root = opts.root;
+      options.outputFunctionName = opts.outputFunctionName;
+      options.localsName = opts.localsName || exports.localsName || _DEFAULT_LOCALS_NAME;
+      options.views = opts.views;
+      options.async = opts.async;
+      options.destructuredLocals = opts.destructuredLocals;
+      options.legacyInclude = typeof opts.legacyInclude != "undefined" ? !!opts.legacyInclude : true;
+      if (options.strict) {
+        options._with = false;
+      } else {
+        options._with = typeof opts._with != "undefined" ? opts._with : true;
+      }
+      this.opts = options;
+      this.regex = this.createRegex();
+    }
+    Template.modes = {
+      EVAL: "eval",
+      ESCAPED: "escaped",
+      RAW: "raw",
+      COMMENT: "comment",
+      LITERAL: "literal"
+    };
+    Template.prototype = {
+      createRegex: function() {
+        var str = _REGEX_STRING;
+        var delim = utils.escapeRegExpChars(this.opts.delimiter);
+        var open = utils.escapeRegExpChars(this.opts.openDelimiter);
+        var close = utils.escapeRegExpChars(this.opts.closeDelimiter);
+        str = str.replace(/%/g, delim).replace(/</g, open).replace(/>/g, close);
+        return new RegExp(str);
+      },
+      compile: function() {
+        var src;
+        var fn;
+        var opts = this.opts;
+        var prepended = "";
+        var appended = "";
+        var escapeFn = opts.escapeFunction;
+        var ctor;
+        if (!this.source) {
+          this.generateSource();
+          prepended += '  var __output = "";\n  function __append(s) { if (s !== undefined && s !== null) __output += s }\n';
+          if (opts.outputFunctionName) {
+            prepended += "  var " + opts.outputFunctionName + " = __append;\n";
+          }
+          if (opts.destructuredLocals && opts.destructuredLocals.length) {
+            var destructuring = "  var __locals = (" + opts.localsName + " || {}),\n";
+            for (var i = 0; i < opts.destructuredLocals.length; i++) {
+              var name = opts.destructuredLocals[i];
+              if (i > 0) {
+                destructuring += ",\n  ";
+              }
+              destructuring += name + " = __locals." + name;
+            }
+            prepended += destructuring + ";\n";
+          }
+          if (opts._with !== false) {
+            prepended += "  with (" + opts.localsName + " || {}) {\n";
+            appended += "  }\n";
+          }
+          appended += "  return __output;\n";
+          this.source = prepended + this.source + appended;
+        }
+        if (opts.compileDebug) {
+          src = "var __line = 1\n  , __lines = " + JSON.stringify(this.templateText) + "\n  , __filename = " + (opts.filename ? JSON.stringify(opts.filename) : "undefined") + ";\ntry {\n" + this.source + "} catch (e) {\n  rethrow(e, __lines, __filename, __line, escapeFn);\n}\n";
+        } else {
+          src = this.source;
+        }
+        if (opts.client) {
+          src = "escapeFn = escapeFn || " + escapeFn.toString() + ";\n" + src;
+          if (opts.compileDebug) {
+            src = "rethrow = rethrow || " + rethrow.toString() + ";\n" + src;
+          }
+        }
+        if (opts.strict) {
+          src = '"use strict";\n' + src;
+        }
+        if (opts.debug) {
+          console.log(src);
+        }
+        if (opts.compileDebug && opts.filename) {
+          src = src + "\n//# sourceURL=" + opts.filename + "\n";
+        }
+        try {
+          if (opts.async) {
+            try {
+              ctor = new Function("return (async function(){}).constructor;")();
+            } catch (e) {
+              if (e instanceof SyntaxError) {
+                throw new Error("This environment does not support async/await");
+              } else {
+                throw e;
+              }
+            }
+          } else {
+            ctor = Function;
+          }
+          fn = new ctor(opts.localsName + ", escapeFn, include, rethrow", src);
+        } catch (e) {
+          if (e instanceof SyntaxError) {
+            if (opts.filename) {
+              e.message += " in " + opts.filename;
+            }
+            e.message += " while compiling ejs\n\n";
+            e.message += "If the above error is not helpful, you may want to try EJS-Lint:\n";
+            e.message += "https://github.com/RyanZim/EJS-Lint";
+            if (!opts.async) {
+              e.message += "\n";
+              e.message += "Or, if you meant to create an async function, pass `async: true` as an option.";
+            }
+          }
+          throw e;
+        }
+        var returnedFn = opts.client ? fn : function anonymous(data) {
+          var include = function(path2, includeData) {
+            var d = utils.shallowCopy({}, data);
+            if (includeData) {
+              d = utils.shallowCopy(d, includeData);
+            }
+            return includeFile(path2, opts)(d);
+          };
+          return fn.apply(opts.context, [data || {}, escapeFn, include, rethrow]);
+        };
+        returnedFn.dependencies = this.dependencies;
+        if (opts.filename && typeof Object.defineProperty === "function") {
+          var filename = opts.filename;
+          var basename = path.basename(filename, path.extname(filename));
+          try {
+            Object.defineProperty(returnedFn, "name", {
+              value: basename,
+              writable: false,
+              enumerable: false,
+              configurable: true
+            });
+          } catch (e) {
+          }
+        }
+        return returnedFn;
+      },
+      generateSource: function() {
+        var opts = this.opts;
+        if (opts.rmWhitespace) {
+          this.templateText = this.templateText.replace(/[\r\n]+/g, "\n").replace(/^\s+|\s+$/gm, "");
+        }
+        this.templateText = this.templateText.replace(/[ \t]*<%_/gm, "<%_").replace(/_%>[ \t]*/gm, "_%>");
+        var self = this;
+        var matches = this.parseTemplateText();
+        var d = this.opts.delimiter;
+        var o = this.opts.openDelimiter;
+        var c = this.opts.closeDelimiter;
+        if (matches && matches.length) {
+          matches.forEach(function(line, index) {
+            var opening;
+            var closing;
+            var include;
+            var includeOpts;
+            var includeObj;
+            var includeSrc;
+            if (line.indexOf(o + d) === 0 && line.indexOf(o + d + d) !== 0) {
+              closing = matches[index + 2];
+              if (!(closing == d + c || closing == "-" + d + c || closing == "_" + d + c)) {
+                throw new Error('Could not find matching close tag for "' + line + '".');
+              }
+            }
+            if (opts.legacyInclude && (include = line.match(/^\s*include\s+(\S+)/))) {
+              opening = matches[index - 1];
+              if (opening && (opening == o + d || opening == o + d + "-" || opening == o + d + "_")) {
+                includeOpts = utils.shallowCopy({}, self.opts);
+                includeObj = includeSource(include[1], includeOpts);
+                if (self.opts.compileDebug) {
+                  includeSrc = "    ; (function(){\n      var __line = 1\n      , __lines = " + JSON.stringify(includeObj.template) + "\n      , __filename = " + JSON.stringify(includeObj.filename) + ";\n      try {\n" + includeObj.source + "      } catch (e) {\n        rethrow(e, __lines, __filename, __line, escapeFn);\n      }\n    ; }).call(this)\n";
+                } else {
+                  includeSrc = "    ; (function(){\n" + includeObj.source + "    ; }).call(this)\n";
+                }
+                self.source += includeSrc;
+                self.dependencies.push(exports.resolveInclude(include[1], includeOpts.filename));
+                return;
+              }
+            }
+            self.scanLine(line);
+          });
+        }
+      },
+      parseTemplateText: function() {
+        var str = this.templateText;
+        var pat = this.regex;
+        var result = pat.exec(str);
+        var arr = [];
+        var firstPos;
+        while (result) {
+          firstPos = result.index;
+          if (firstPos !== 0) {
+            arr.push(str.substring(0, firstPos));
+            str = str.slice(firstPos);
+          }
+          arr.push(result[0]);
+          str = str.slice(result[0].length);
+          result = pat.exec(str);
+        }
+        if (str) {
+          arr.push(str);
+        }
+        return arr;
+      },
+      _addOutput: function(line) {
+        if (this.truncate) {
+          line = line.replace(/^(?:\r\n|\r|\n)/, "");
+          this.truncate = false;
+        }
+        if (!line) {
+          return line;
+        }
+        line = line.replace(/\\/g, "\\\\");
+        line = line.replace(/\n/g, "\\n");
+        line = line.replace(/\r/g, "\\r");
+        line = line.replace(/"/g, '\\"');
+        this.source += '    ; __append("' + line + '")\n';
+      },
+      scanLine: function(line) {
+        var self = this;
+        var d = this.opts.delimiter;
+        var o = this.opts.openDelimiter;
+        var c = this.opts.closeDelimiter;
+        var newLineCount = 0;
+        newLineCount = line.split("\n").length - 1;
+        switch (line) {
+          case o + d:
+          case o + d + "_":
+            this.mode = Template.modes.EVAL;
+            break;
+          case o + d + "=":
+            this.mode = Template.modes.ESCAPED;
+            break;
+          case o + d + "-":
+            this.mode = Template.modes.RAW;
+            break;
+          case o + d + "#":
+            this.mode = Template.modes.COMMENT;
+            break;
+          case o + d + d:
+            this.mode = Template.modes.LITERAL;
+            this.source += '    ; __append("' + line.replace(o + d + d, o + d) + '")\n';
+            break;
+          case d + d + c:
+            this.mode = Template.modes.LITERAL;
+            this.source += '    ; __append("' + line.replace(d + d + c, d + c) + '")\n';
+            break;
+          case d + c:
+          case "-" + d + c:
+          case "_" + d + c:
+            if (this.mode == Template.modes.LITERAL) {
+              this._addOutput(line);
+            }
+            this.mode = null;
+            this.truncate = line.indexOf("-") === 0 || line.indexOf("_") === 0;
+            break;
+          default:
+            if (this.mode) {
+              switch (this.mode) {
+                case Template.modes.EVAL:
+                case Template.modes.ESCAPED:
+                case Template.modes.RAW:
+                  if (line.lastIndexOf("//") > line.lastIndexOf("\n")) {
+                    line += "\n";
+                  }
+              }
+              switch (this.mode) {
+                case Template.modes.EVAL:
+                  this.source += "    ; " + line + "\n";
+                  break;
+                case Template.modes.ESCAPED:
+                  this.source += "    ; __append(escapeFn(" + stripSemi(line) + "))\n";
+                  break;
+                case Template.modes.RAW:
+                  this.source += "    ; __append(" + stripSemi(line) + ")\n";
+                  break;
+                case Template.modes.COMMENT:
+                  break;
+                case Template.modes.LITERAL:
+                  this._addOutput(line);
+                  break;
+              }
+            } else {
+              this._addOutput(line);
+            }
+        }
+        if (self.opts.compileDebug && newLineCount) {
+          this.currentLine += newLineCount;
+          this.source += "    ; __line = " + this.currentLine + "\n";
+        }
+      }
+    };
+    exports.escapeXML = utils.escapeXML;
+    exports.__express = exports.renderFile;
+    if (require.extensions) {
+      require.extensions[".ejs"] = function(module3, flnm) {
+        console.log("Deprecated: this API will go away in EJS v2.8");
+        var filename = flnm || module3.filename;
+        var options = {
+          filename,
+          client: true
+        };
+        var template = fileLoader(filename).toString();
+        var fn = exports.compile(template, options);
+        module3._compile("module.exports = " + fn.toString() + ";", filename);
+      };
+    }
+    exports.VERSION = _VERSION_STRING;
+    exports.name = _NAME;
+    if (typeof window != "undefined") {
+      window.ejs = exports;
+    }
+  }
+});
+
+// ../../packages/template-utils/lib/log.js
+var require_log = __commonJS({
+  "../../packages/template-utils/lib/log.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.log = exports.setLogLevel = void 0;
+    var logLevel = "warn";
+    function setLogLevel(level) {
+      logLevel = level;
+    }
+    exports.setLogLevel = setLogLevel;
+    function log(level, message) {
+      if (level === "error") {
+        if (logLevel !== "disabled") {
+          console.error(`[template] ${message}`);
+        }
+      } else if (level === "warn") {
+        if (logLevel !== "error" && logLevel !== "disabled") {
+          console.warn(`[template] ${message}`);
+        }
+      } else if (level === "info") {
+        if (logLevel === "verbose" || logLevel === "info") {
+          console.info(`[template] ${message}`);
+        }
+      } else if (level === "verbose") {
+        if (logLevel === "verbose") {
+          console.log(`[template] ${message}`);
+        }
+      }
+    }
+    exports.log = log;
+  }
+});
+
+// ../../packages/template-utils/lib/template.js
+var require_template = __commonJS({
+  "../../packages/template-utils/lib/template.js"(exports) {
+    "use strict";
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve2, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getFileFromTemplate = void 0;
+    var path_1 = require("path");
+    var ejs_1 = require_ejs();
+    var log_1 = require_log();
+    var findVariable = /<(\w+)>/g;
+    function replaceVariables(str, data) {
+      let match = findVariable.exec(str);
+      while (match) {
+        const [m, id] = match;
+        const val = data[id];
+        if (typeof val === "string") {
+          str = str.replace(m, val);
+        } else {
+          str = str.replace(m, ".");
+        }
+        findVariable.lastIndex = 0;
+        match = findVariable.exec(str);
+      }
+      return str;
+    }
+    function fillTemplate(sourceDir, name, data) {
+      const path = (0, path_1.resolve)(sourceDir, `${name}.ejs`);
+      (0, log_1.log)("verbose", `Filling template of "${path}" ...`);
+      return new Promise((resolve2, reject) => {
+        (0, ejs_1.renderFile)(path, data, (err, str) => {
+          if (err) {
+            (0, log_1.log)("error", `Could not fill template at "${path}": ${err}`);
+            reject(err);
+          } else {
+            (0, log_1.log)("verbose", `Filled template at "${path}" ...`);
+            resolve2(str);
+          }
+        });
+      });
+    }
+    function getFileFromTemplate(sourceDir, source, data) {
+      return __awaiter(this, void 0, void 0, function* () {
+        let { target, name, content } = source;
+        const absPath = replaceVariables(target, data);
+        const path = (0, path_1.isAbsolute)(absPath) ? (0, path_1.relative)(data.projectRoot, absPath) : absPath;
+        if (!content) {
+          (0, log_1.log)("verbose", `Return template "${name}" with path "${path}" (from "${target}")`);
+          content = yield fillTemplate(sourceDir, name, data);
+        } else {
+          (0, log_1.log)("verbose", `Return template "${name}" with content at path "${path}" (from "${target}")`);
+        }
+        return {
+          content: Buffer.from(content, "utf8"),
+          path
+        };
+      });
+    }
+    exports.getFileFromTemplate = getFileFromTemplate;
+  }
+});
+
+// ../../packages/template-utils/lib/version.js
+var require_version = __commonJS({
+  "../../packages/template-utils/lib/version.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.checkVersion = void 0;
+    var log_1 = require_log();
+    var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+    var acceptsAll = ["*", "x", ">=0"];
+    var operatorResMap = {
+      ">": [1],
+      ">=": [0, 1],
+      "=": [0],
+      "<=": [-1, 0],
+      "<": [-1]
+    };
+    function indexOrEnd(str, q) {
+      return str.indexOf(q) === -1 ? str.length : str.indexOf(q);
+    }
+    function splitVersion(v) {
+      var c = v.replace(/^v/, "").replace(/\+.*$/, "");
+      var patchIndex = indexOrEnd(c, "-");
+      var arr = c.substring(0, patchIndex).split(".");
+      arr.push(c.substring(patchIndex + 1));
+      return arr;
+    }
+    function parseSegment(v) {
+      var n = parseInt(v, 10);
+      return isNaN(n) ? v : n;
+    }
+    function validateAndParse(v) {
+      const match = v.match(semver);
+      match.shift();
+      return match;
+    }
+    function compareStrings(a, b) {
+      const ap = parseSegment(a);
+      const bp = parseSegment(b);
+      if (ap > bp) {
+        return 1;
+      } else if (ap < bp) {
+        return -1;
+      } else {
+        return 0;
+      }
+    }
+    function compareSegments(a, b) {
+      for (let i = 0; i < 2; i++) {
+        const r = compareStrings(a[i] || "0", b[i] || "0");
+        if (r !== 0) {
+          return r;
+        }
+      }
+      return 0;
+    }
+    function compareVersions(v1, v2) {
+      const s1 = splitVersion(v1);
+      const s2 = splitVersion(v2);
+      const len = Math.max(s1.length - 1, s2.length - 1);
+      for (let i = 0; i < len; i++) {
+        const n1 = parseInt(s1[i] || "0", 10);
+        const n2 = parseInt(s2[i] || "0", 10);
+        if (n1 > n2) {
+          return 1;
+        } else if (n2 > n1) {
+          return -1;
+        }
+      }
+      const sp1 = s1[s1.length - 1];
+      const sp2 = s2[s2.length - 1];
+      if (sp1 && sp2) {
+        const p1 = sp1.split(".").map(parseSegment);
+        const p2 = sp2.split(".").map(parseSegment);
+        const len2 = Math.max(p1.length, p2.length);
+        for (let i = 0; i < len2; i++) {
+          if (p1[i] === void 0 || typeof p2[i] === "string" && typeof p1[i] === "number") {
+            return -1;
+          } else if (p2[i] === void 0 || typeof p1[i] === "string" && typeof p2[i] === "number") {
+            return 1;
+          } else if (p1[i] > p2[i]) {
+            return 1;
+          } else if (p2[i] > p1[i]) {
+            return -1;
+          }
+        }
+      } else if (sp1 || sp2) {
+        return sp1 ? -1 : 1;
+      }
+      return 0;
+    }
+    function compare(v1, v2, operator) {
+      const res = compareVersions(v1, v2);
+      return operatorResMap[operator].indexOf(res) > -1;
+    }
+    function satisfies(v, r) {
+      if (!acceptsAll.includes(r)) {
+        const match = r.match(/^([<>=~^]+)/);
+        const op = match ? match[1] : "=";
+        if (op !== "^" && op !== "~") {
+          return compare(v, r, op);
+        }
+        const [v1, v2, v3] = validateAndParse(v);
+        const [m1, m2, m3] = validateAndParse(r);
+        if (compareStrings(v1, m1) !== 0) {
+          return false;
+        } else if (op === "^") {
+          return compareSegments([v2, v3], [m2, m3]) >= 0;
+        } else if (compareStrings(v2, m2) !== 0) {
+          return false;
+        }
+        return compareStrings(v3, m3) >= 0;
+      }
+      return true;
+    }
+    function checkVersion(desired, actual) {
+      if (!satisfies(actual, desired)) {
+        (0, log_1.log)("warn", `The template was made for "piral-cli" version "${desired}" but was used with "${actual}".`);
+      }
+    }
+    exports.checkVersion = checkVersion;
+  }
+});
+
+// ../../packages/template-utils/lib/parent.js
+var require_parent = __commonJS({
+  "../../packages/template-utils/lib/parent.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.configure = exports.LogLevels = exports.ForceOverwrite = void 0;
+    var path_1 = require("path");
+    var log_1 = require_log();
+    var version_1 = require_version();
+    var ForceOverwrite;
+    (function(ForceOverwrite2) {
+      ForceOverwrite2[ForceOverwrite2["no"] = 0] = "no";
+      ForceOverwrite2[ForceOverwrite2["prompt"] = 1] = "prompt";
+      ForceOverwrite2[ForceOverwrite2["yes"] = 2] = "yes";
+    })(ForceOverwrite = exports.ForceOverwrite || (exports.ForceOverwrite = {}));
+    var LogLevels;
+    (function(LogLevels2) {
+      LogLevels2[LogLevels2["disabled"] = 0] = "disabled";
+      LogLevels2[LogLevels2["error"] = 1] = "error";
+      LogLevels2[LogLevels2["warning"] = 2] = "warning";
+      LogLevels2[LogLevels2["info"] = 3] = "info";
+      LogLevels2[LogLevels2["verbose"] = 4] = "verbose";
+      LogLevels2[LogLevels2["debug"] = 5] = "debug";
+    })(LogLevels = exports.LogLevels || (exports.LogLevels = {}));
+    function configure(root2, details) {
+      var _a, _b;
+      if (details) {
+        const packageJsonPath = (0, path_1.resolve)(root2, "package.json");
+        const templateProject = require(packageJsonPath);
+        const desiredVersion = (_b = (_a = templateProject.engines) === null || _a === void 0 ? void 0 : _a.piral) !== null && _b !== void 0 ? _b : "*";
+        switch (details.logLevel) {
+          case LogLevels.disabled:
+            (0, log_1.setLogLevel)("disabled");
+            break;
+          case LogLevels.error:
+            (0, log_1.setLogLevel)("error");
+            break;
+          case LogLevels.warning:
+            (0, log_1.setLogLevel)("warn");
+            break;
+          case LogLevels.info:
+            (0, log_1.setLogLevel)("info");
+            break;
+          case LogLevels.verbose:
+          case LogLevels.debug:
+            (0, log_1.setLogLevel)("verbose");
+            break;
+        }
+        (0, version_1.checkVersion)(desiredVersion, details.cliVersion);
+      } else {
+        (0, log_1.log)("warn", `The used version of the "piral-cli" is outdated. The templating may still work - if not you should use a more recent version of the "piral-cli".`);
+      }
+    }
+    exports.configure = configure;
+  }
+});
+
+// ../../packages/template-utils/lib/utils.js
+var require_utils2 = __commonJS({
+  "../../packages/template-utils/lib/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getLanguageExtension = exports.getPlugins = exports.getPiralInstance = exports.getPackageJsonWithSource = void 0;
+    var path_1 = require("path");
+    var fs_1 = require("fs");
+    var log_1 = require_log();
+    function getPackageJsonWithSource(targetDir, fileName) {
+      const path = path_1.posix.join(targetDir, fileName);
+      (0, log_1.log)("verbose", `Adding 'source' to package.json "${path}" ...`);
+      return Promise.resolve({
+        content: Buffer.from(`{"source":${JSON.stringify(path)}}`, "utf8"),
+        path: "package.json"
+      });
+    }
+    exports.getPackageJsonWithSource = getPackageJsonWithSource;
+    function getPiralInstance2(root2, sourceName) {
+      try {
+        const packageJsonPath = require.resolve(`${sourceName}/package.json`, {
+          paths: [root2]
+        });
+        (0, log_1.log)("verbose", `Found package JSON in "${packageJsonPath}"`);
+        const sourcePath = (0, path_1.dirname)(packageJsonPath);
+        const details = require(packageJsonPath);
+        const types = details.types || details.typings;
+        (0, log_1.log)("verbose", `Looking for types in "${types}"`);
+        const typingsPath = types !== void 0 ? (0, path_1.resolve)(sourcePath, types) : void 0;
+        const app = details.app;
+        (0, log_1.log)("verbose", `Looking for types in "${app}"`);
+        const appPath = app !== void 0 ? (0, path_1.resolve)(sourcePath, app) : void 0;
+        return {
+          sourceName,
+          sourcePath,
+          details,
+          appPath,
+          typingsPath
+        };
+      } catch (ex) {
+        (0, log_1.log)("error", `Error when getting Piral instance: ${ex}`);
+      }
+      return void 0;
+    }
+    exports.getPiralInstance = getPiralInstance2;
+    function getPlugins(root2, sourceName) {
+      const plugins = {};
+      (0, log_1.log)("verbose", `Getting the plugins of "${sourceName}/package.json" ...`);
+      const piralInstance = getPiralInstance2(root2, sourceName);
+      const typingsPath = piralInstance === null || piralInstance === void 0 ? void 0 : piralInstance.typingsPath;
+      if (typingsPath) {
+        (0, log_1.log)("verbose", `Reading file in "${typingsPath}"`);
+        const typing = (0, fs_1.readFileSync)(typingsPath, "utf8");
+        const match = /export interface PiletCustomApi extends (.*?) \{/g.exec(typing);
+        const apis = match[1].split(", ");
+        (0, log_1.log)("info", `Found Piral instance plugins "${match[1]}"`);
+        for (const api of apis) {
+          const pluginMatch = /^Pilet(.*)Api$/.exec(api);
+          if (pluginMatch) {
+            const name = pluginMatch[1].toLowerCase();
+            plugins[name] = true;
+          } else {
+            (0, log_1.log)("warn", `Could not find plugin for Pilet API "${api}"`);
+          }
+        }
+      }
+      return plugins;
+    }
+    exports.getPlugins = getPlugins;
+    function getLanguageExtension(language, isJsx = true) {
+      switch (language) {
+        case "js":
+          return isJsx ? ".jsx" : ".js";
+        case "ts":
+        default:
+          return isJsx ? ".tsx" : ".ts";
+      }
+    }
+    exports.getLanguageExtension = getLanguageExtension;
+  }
+});
+
+// ../../packages/template-utils/lib/factory.js
+var require_factory = __commonJS({
+  "../../packages/template-utils/lib/factory.js"(exports) {
+    "use strict";
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve2, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createPiralTemplateFactory = exports.createPiletTemplateFactory = void 0;
+    var path_1 = require("path");
+    var template_1 = require_template();
+    var parent_1 = require_parent();
+    var utils_1 = require_utils2();
+    function createPiletTemplateFactory2(templateRoot, getAllSources, defaultArgs = {}) {
+      const sourceDir = (0, path_1.resolve)(templateRoot, "templates");
+      return (projectRoot, args, details) => {
+        (0, parent_1.configure)(templateRoot, details);
+        const allArgs = Object.assign(Object.assign({}, defaultArgs), args);
+        const { language = "ts", sourceName, src = "<root>/src", plugins = (0, utils_1.getPlugins)(projectRoot, sourceName), mocks = "<src>/mocks" } = allArgs;
+        const allSources = getAllSources(projectRoot, allArgs, details);
+        const sources = allSources.filter((m) => m.languages.includes(language));
+        const data = Object.assign(Object.assign({}, allArgs), {
+          language,
+          plugins,
+          projectRoot,
+          root: ".",
+          sourceName,
+          extension: (0, utils_1.getLanguageExtension)(language),
+          src,
+          mocks
+        });
+        return Promise.all([
+          ...sources.map((source) => (0, template_1.getFileFromTemplate)(sourceDir, source, data)),
+          (0, utils_1.getPackageJsonWithSource)(data.src, `index${data.extension}`)
+        ]);
+      };
+    }
+    exports.createPiletTemplateFactory = createPiletTemplateFactory2;
+    function createPiralTemplateFactory(templateRoot, getAllSources, defaultArgs = {}) {
+      const sourceDir = (0, path_1.resolve)(templateRoot, "templates");
+      return (projectRoot, args, details) => __awaiter(this, void 0, void 0, function* () {
+        (0, parent_1.configure)(templateRoot, details);
+        const allArgs = Object.assign(Object.assign({}, defaultArgs), args);
+        const { language = "ts", packageName = "piral", mocks = "<src>/mocks", src = "<root>/src", title = "My Piral Instance", reactVersion = 17, plugins = [] } = allArgs;
+        const allSources = getAllSources(projectRoot, allArgs, details);
+        const sources = allSources.filter((m) => m.languages.includes(language) && m.frameworks.includes(packageName));
+        const data = Object.assign(Object.assign({}, allArgs), {
+          title,
+          language,
+          plugins,
+          projectRoot,
+          root: ".",
+          reactVersion,
+          packageName,
+          extension: (0, utils_1.getLanguageExtension)(language, packageName !== "piral-base"),
+          src,
+          mocks
+        });
+        return Promise.all(sources.map((source) => (0, template_1.getFileFromTemplate)(sourceDir, source, data)));
+      });
+    }
+    exports.createPiralTemplateFactory = createPiralTemplateFactory;
+  }
+});
+
+// ../../packages/template-utils/lib/types.js
+var require_types = __commonJS({
+  "../../packages/template-utils/lib/types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../packages/template-utils/lib/index.js
+var require_lib = __commonJS({
+  "../../packages/template-utils/lib/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_factory(), exports);
+    __exportStar(require_template(), exports);
+    __exportStar(require_types(), exports);
+    __exportStar(require_utils2(), exports);
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+var import_path = require("path");
+var import_template_utils = __toESM(require_lib());
+
+// src/helpers.ts
+function detectMode(piralInstance) {
+  var _a, _b;
+  const dependencies = ((_a = piralInstance == null ? void 0 : piralInstance.details) == null ? void 0 : _a.dependencies) || {};
+  const devDependencies = ((_b = piralInstance == null ? void 0 : piralInstance.details) == null ? void 0 : _b.devDependencies) || {};
+  const allDependencies = __spreadValues(__spreadValues({}, devDependencies), dependencies);
+  return allDependencies["piral-ng"] === void 0;
+}
+function detectNgVersion(piralInstance) {
+  var _a, _b;
+  const dependencies = ((_a = piralInstance == null ? void 0 : piralInstance.details) == null ? void 0 : _a.dependencies) || {};
+  const devDependencies = ((_b = piralInstance == null ? void 0 : piralInstance.details) == null ? void 0 : _b.devDependencies) || {};
+  const allDependencies = __spreadValues(__spreadValues({}, devDependencies), dependencies);
+  const version = allDependencies["@angular/core"] || "14.0.0";
+  if (typeof version === "string") {
+    const result = /\d+/.exec(version);
+    if (result) {
+      return +result[0];
+    }
+  }
+  return 14;
+}
+function getStandalonePackageJson(cliVersion, ngVersion) {
+  return {
+    importmap: {
+      imports: {
+        "@angular/animations": ".",
+        "@angular/cli": ".",
+        "@angular/common": ".",
+        "@angular/compiler": ".",
+        "@angular/core": ".",
+        "@angular/forms": ".",
+        "@angular/platform-browser": ".",
+        "@angular/platform-browser-dynamic": ".",
+        "@angular/router": "."
+      }
+    },
+    dependencies: {
+      "@angular/animations": ngVersion,
+      "@angular/cli": ngVersion,
+      "@angular/common": ngVersion,
+      "@angular/compiler": ngVersion,
+      "@angular/core": ngVersion,
+      "@angular/forms": ngVersion,
+      "@angular/platform-browser": ngVersion,
+      "@angular/platform-browser-dynamic": ngVersion,
+      "@angular/router": ngVersion,
+      "piral-ng": cliVersion,
+      rxjs: "~7.4",
+      "zone.js": "~0.11"
+    },
+    devDependencies: {
+      "@angular/compiler-cli": ngVersion,
+      "@ngtools/webpack": ngVersion,
+      "copy-webpack-plugin": "^10",
+      "html-loader": "^3",
+      "to-string-loader": "^1"
+    }
+  };
+}
+function getStandardPackageJson(cliVersion, ngVersion) {
+  return {
+    devDependencies: {
+      "@angular/compiler-cli": ngVersion,
+      "@ngtools/webpack": ngVersion,
+      "copy-webpack-plugin": "^10",
+      "html-loader": "^3",
+      "to-string-loader": "^1",
+      "piral-ng": cliVersion
+    }
+  };
+}
+
+// src/index.ts
+var root = (0, import_path.resolve)(__dirname, "..");
+var src_default = (0, import_template_utils.createPiletTemplateFactory)(root, (projectRoot, args, details) => {
+  const { sourceName } = args;
+  const piralInstance = (0, import_template_utils.getPiralInstance)(projectRoot, sourceName);
+  if (typeof args.standalone === "undefined") {
+    args.standalone = detectMode(piralInstance);
+  }
+  if (typeof args.ngVersion !== "number") {
+    args.ngVersion = detectNgVersion(piralInstance);
+  }
+  const ngVersion = `^${args.ngVersion}`;
+  const packageJson = args.standalone ? getStandalonePackageJson(details.cliVersion, ngVersion) : getStandardPackageJson(details.cliVersion, ngVersion);
+  return [
+    {
+      languages: ["ts", "js"],
+      name: "package.json",
+      content: JSON.stringify(packageJson),
+      target: "<root>/package.json"
+    },
+    {
+      languages: ["ts", "js"],
+      name: "webpack.config.js",
+      target: "<root>/webpack.config.js"
+    },
+    {
+      languages: ["js"],
+      name: "index.jsx",
+      target: "<src>/index.jsx"
+    },
+    {
+      languages: ["ts"],
+      name: "app.module.ts",
+      target: "<src>/app/app.module.ts"
+    },
+    {
+      languages: ["ts"],
+      name: "page.component.html",
+      target: "<src>/app/page.component.html"
+    },
+    {
+      languages: ["ts"],
+      name: "page.component.css",
+      target: "<src>/app/page.component.css"
+    },
+    {
+      languages: ["ts"],
+      name: "page.component.ts",
+      target: "<src>/app/page.component.ts"
+    },
+    {
+      languages: ["ts"],
+      name: "index.tsx",
+      target: "<src>/index.tsx"
+    },
+    {
+      languages: ["ts"],
+      name: "tsconfig.json",
+      target: "<root>/tsconfig.json"
+    }
+  ];
+});
+module.exports = __toCommonJS(src_exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});
+/**
+ * @file Embedded JavaScript templating engine. {@link http://ejs.co}
+ * @author Matthew Eernisse <mde@fleegix.org>
+ * @author Tiancheng "Timothy" Gu <timothygu99@gmail.com>
+ * @project EJS
+ * @license {@link http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0}
+ */