chore: disable delete confirmation in VS Code explorer

Disable the confirmation dialog when deleting files in the VS Code explorer to streamline the development workflow and reduce friction during file management operations.

website/node_modules/ejs/lib/cjs/ejs.js

@@ -0,0 +1,845 @@
+/*
+ * EJS Embedded JavaScript templates
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+var utils_js_1 = __importDefault(require("./utils.js"));
+/**
+ * @file Embedded JavaScript templating engine. {@link http://ejs.co}
+ * @author Matthew Eernisse <mde@fleegix.org>
+ * @project EJS
+ * @license {@link http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0}
+ */
+/**
+ * EJS internal functions.
+ *
+ * Technically this "module" lies in the same file as {@link module:ejs}, for
+ * the sake of organization all the private functions re grouped into this
+ * module.
+ *
+ * @module ejs-internal
+ * @private
+ */
+/**
+ * Embedded JavaScript templating engine.
+ *
+ * @module ejs
+ * @public
+ */
+// Keyword used in code generation -- updated to 'var' in CJS build
+var DECLARATION_KEYWORD = 'var';
+var ejs = {};
+/** @type {string} */
+var _DEFAULT_OPEN_DELIMITER = '<';
+var _DEFAULT_CLOSE_DELIMITER = '>';
+var _DEFAULT_DELIMITER = '%';
+var _DEFAULT_LOCALS_NAME = 'locals';
+var _REGEX_STRING = '(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)';
+var _OPTS_PASSABLE_WITH_DATA = ['delimiter', 'scope', 'context', 'debug', 'compileDebug',
+    '_with', 'rmWhitespace', 'strict', 'filename', 'async'];
+// We don't allow 'cache' option to be passed in the data obj for
+// the normal `render` call, but this is where Express 2 & 3 put it
+// so we make an exception for `renderFile`
+var _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat('cache');
+var _BOM = /^\uFEFF/;
+var _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+/**
+ * EJS template function cache. This can be a LRU object from lru-cache NPM
+ * module. By default, it is {@link module:utils.cache}, a simple in-process
+ * cache that grows continuously.
+ *
+ * @type {Cache}
+ */
+ejs.cache = utils_js_1.default.cache;
+/**
+ * Custom file loader. Useful for template preprocessing or restricting access
+ * to a certain part of the filesystem.
+ *
+ * @type {fileLoader}
+ */
+ejs.fileLoader = fs_1.default.readFileSync;
+/**
+ * Name of the object containing the locals.
+ *
+ * This variable is overridden by {@link Options}`.localsName` if it is not
+ * `undefined`.
+ *
+ * @type {String}
+ * @public
+ */
+ejs.localsName = _DEFAULT_LOCALS_NAME;
+/**
+ * Promise implementation -- defaults to the native implementation if available
+ * This is mostly just for testability
+ *
+ * @type {PromiseConstructorLike}
+ * @public
+ */
+ejs.promiseImpl = (new Function('return this;'))().Promise;
+/**
+ * Get the path to the included file from the parent file path and the
+ * specified path.
+ *
+ * @param {String}  name     specified path
+ * @param {String}  filename parent file path
+ * @param {Boolean} [isDir=false] whether the parent file path is a directory
+ * @return {String}
+ */
+ejs.resolveInclude = function (name, filename, isDir) {
+    var dirname = path_1.default.dirname;
+    var extname = path_1.default.extname;
+    var resolve = path_1.default.resolve;
+    var includePath = resolve(isDir ? filename : dirname(filename), name);
+    var ext = extname(name);
+    if (!ext) {
+        includePath += '.ejs';
+    }
+    return includePath;
+};
+/**
+ * Try to resolve file path on multiple directories
+ *
+ * @param  {String}        name  specified path
+ * @param  {Array<String>} paths list of possible parent directory paths
+ * @return {String}
+ */
+function resolvePaths(name, paths) {
+    var filePath;
+    if (paths.some(function (v) {
+        filePath = ejs.resolveInclude(name, v, true);
+        return fs_1.default.existsSync(filePath);
+    })) {
+        return filePath;
+    }
+}
+/**
+ * Get the path to the included file by Options
+ *
+ * @param  {String}  path    specified path
+ * @param  {Options} options compilation options
+ * @return {String}
+ */
+function getIncludePath(path, options) {
+    var includePath;
+    var filePath;
+    var views = options.views;
+    var match = /^[A-Za-z]+:\\|^\//.exec(path);
+    // Abs path
+    if (match && match.length) {
+        path = path.replace(/^\/*/, '');
+        if (Array.isArray(options.root)) {
+            includePath = resolvePaths(path, options.root);
+        }
+        else {
+            includePath = ejs.resolveInclude(path, options.root || '/', true);
+        }
+    }
+    // Relative paths
+    else {
+        // Look relative to a passed filename first
+        if (options.filename) {
+            filePath = ejs.resolveInclude(path, options.filename);
+            if (fs_1.default.existsSync(filePath)) {
+                includePath = filePath;
+            }
+        }
+        // Then look in any views directories
+        if (!includePath && Array.isArray(views)) {
+            includePath = resolvePaths(path, views);
+        }
+        if (!includePath && typeof options.includer !== 'function') {
+            throw new Error('Could not find the include file "' +
+                options.escapeFunction(path) + '"');
+        }
+    }
+    return includePath;
+}
+/**
+ * Get the template from a string or a file, either compiled on-the-fly or
+ * read from cache (if enabled), and cache the template if needed.
+ *
+ * If `template` is not set, the file specified in `options.filename` will be
+ * read.
+ *
+ * If `options.cache` is true, this function reads the file from
+ * `options.filename` so it must be set prior to calling this function.
+ *
+ * @memberof module:ejs-internal
+ * @param {Options} options   compilation options
+ * @param {String} [template] template source
+ * @return {TemplateFunction}
+ * @static
+ */
+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 = ejs.cache.get(filename);
+        if (func) {
+            return func;
+        }
+        if (!hasTemplate) {
+            template = fileLoader(filename).toString().replace(_BOM, '');
+        }
+    }
+    else if (!hasTemplate) {
+        // istanbul ignore if: should not happen at all
+        if (!filename) {
+            throw new Error('Internal EJS error: no file name or template '
+                + 'provided');
+        }
+        template = fileLoader(filename).toString().replace(_BOM, '');
+    }
+    func = ejs.compile(template, options);
+    if (options.cache) {
+        ejs.cache.set(filename, func);
+    }
+    return func;
+}
+/**
+ * Try calling handleCache with the given options and data and call the
+ * callback with the result. If an error occurs, call the callback with
+ * the error. Used by renderFile().
+ *
+ * @memberof module:ejs-internal
+ * @param {Options} options    compilation options
+ * @param {Object} data        template data
+ * @param {RenderFileCallback} cb callback
+ * @static
+ */
+function tryHandleCache(options, data, cb) {
+    var result;
+    if (!cb) {
+        if (typeof ejs.promiseImpl == 'function') {
+            return new ejs.promiseImpl(function (resolve, reject) {
+                try {
+                    result = handleCache(options)(data);
+                    resolve(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);
+    }
+}
+/**
+ * fileLoader is independent
+ *
+ * @param {String} filePath ejs file path.
+ * @return {String} The contents of the specified file.
+ * @static
+ */
+function fileLoader(filePath) {
+    return ejs.fileLoader(filePath);
+}
+/**
+ * Get the template function.
+ *
+ * If `options.cache` is `true`, then the template is cached.
+ *
+ * @memberof module:ejs-internal
+ * @param {String}  path    path for the specified file
+ * @param {Options} options compilation options
+ * @return {TemplateFunction}
+ * @static
+ */
+function includeFile(path, options) {
+    var opts = utils_js_1.default.shallowCopy(utils_js_1.default.createNullProtoObjWherePossible(), options);
+    opts.filename = getIncludePath(path, opts);
+    if (typeof options.includer === 'function') {
+        var includerResult = options.includer(path, opts.filename);
+        if (includerResult) {
+            if (includerResult.filename) {
+                opts.filename = includerResult.filename;
+            }
+            if (includerResult.template) {
+                return handleCache(opts, includerResult.template);
+            }
+        }
+    }
+    return handleCache(opts);
+}
+/**
+ * Re-throw the given `err` in context to the `str` of ejs, `filename`, and
+ * `lineno`.
+ *
+ * @implements {RethrowCallback}
+ * @memberof module:ejs-internal
+ * @param {Error}  err      Error object
+ * @param {String} str      EJS source
+ * @param {String} flnm     file name of the EJS file
+ * @param {Number} lineno   line number of the error
+ * @param {EscapeCallback} esc
+ * @static
+ */
+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);
+    // Error context
+    var context = lines.slice(start, end).map(function (line, i) {
+        var curr = i + start + 1;
+        return (curr == lineno ? ' >> ' : '    ')
+            + curr
+            + '| '
+            + line;
+    }).join('\n');
+    // Alter exception message
+    err.path = filename;
+    err.message = (filename || 'ejs') + ':'
+        + lineno + '\n'
+        + context + '\n\n'
+        + err.message;
+    throw err;
+}
+function stripSemi(str) {
+    return str.replace(/;(\s*$)/, '$1');
+}
+/**
+ * Compile the given `str` of ejs into a template function.
+ *
+ * @param {String}  template EJS template
+ *
+ * @param {Options} [opts] compilation options
+ *
+ * @return {TemplateFunction}
+ * Note that the return type of the function depends on the value of `opts.async`.
+ * @public
+ */
+ejs.compile = function compile(template, opts) {
+    var templ;
+    // v1 compat
+    // 'scope' is 'context'
+    // FIXME: Remove this in a future version
+    if (opts && opts.scope) {
+        console.warn('`scope` option is deprecated and will be removed in future EJS');
+        if (!opts.context) {
+            opts.context = opts.scope;
+        }
+        delete opts.scope;
+    }
+    templ = new Template(template, opts);
+    return templ.compile();
+};
+/**
+ * Render the given `template` of ejs.
+ *
+ * If you would like to include options but not data, you need to explicitly
+ * call this function with `data` being an empty object or `null`.
+ *
+ * @param {String}   template EJS template
+ * @param {Object}  [data={}] template data
+ * @param {Options} [opts={}] compilation and rendering options
+ * @return {(String|Promise<String>)}
+ * Return value type depends on `opts.async`.
+ * @public
+ */
+ejs.render = function (template, d, o) {
+    var data = d || utils_js_1.default.createNullProtoObjWherePossible();
+    var opts = o || utils_js_1.default.createNullProtoObjWherePossible();
+    // No options object -- if there are optiony names
+    // in the data, copy them to options
+    if (arguments.length == 2) {
+        utils_js_1.default.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
+    }
+    return handleCache(opts, template)(data);
+};
+/**
+ * Render an EJS file at the given `path` and callback `cb(err, str)`.
+ *
+ * If you would like to include options but not data, you need to explicitly
+ * call this function with `data` being an empty object or `null`.
+ *
+ * @param {String}             path     path to the EJS file
+ * @param {Object}            [data={}] template data
+ * @param {Options}           [opts={}] compilation and rendering options
+ * @param {RenderFileCallback} cb callback
+ * @public
+ */
+ejs.renderFile = function () {
+    var args = Array.prototype.slice.call(arguments);
+    var filename = args.shift();
+    var cb;
+    var opts = { filename: filename };
+    var data;
+    var viewOpts;
+    // Do we have a callback?
+    if (typeof arguments[arguments.length - 1] == 'function') {
+        cb = args.pop();
+    }
+    // Do we have data/opts?
+    if (args.length) {
+        // Should always have data obj
+        data = args.shift();
+        // Normal passed opts (data obj + opts obj)
+        if (args.length) {
+            // Use shallowCopy so we don't pollute passed in opts obj with new vals
+            utils_js_1.default.shallowCopy(opts, args.pop());
+        }
+        // Special casing for Express (settings + opts-in-data)
+        else {
+            // Express 3 and 4
+            if (utils_js_1.default.hasOwn(data, 'settings') && data.settings) {
+                // Pull a few things from known locations
+                if (data.settings.views) {
+                    opts.views = data.settings.views;
+                }
+                if (data.settings['view cache']) {
+                    opts.cache = true;
+                }
+                // Undocumented after Express 2, but still usable, esp. for
+                // items that are unsafe to be passed along with data, like `root`
+                viewOpts = data.settings['view options'];
+                if (viewOpts) {
+                    utils_js_1.default.shallowCopy(opts, viewOpts);
+                }
+            }
+            // Express 2 and lower, values set in app.locals, or people who just
+            // want to pass options in their data. NOTE: These values will override
+            // anything previously set in settings  or settings['view options']
+            utils_js_1.default.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
+        }
+        opts.filename = filename;
+    }
+    else {
+        data = utils_js_1.default.createNullProtoObjWherePossible();
+    }
+    return tryHandleCache(opts, data, cb);
+};
+/**
+ * Clear intermediate JavaScript cache. Calls {@link Cache#reset}.
+ * @public
+ */
+/**
+ * EJS template class
+ * @public
+ */
+ejs.Template = Template;
+ejs.clearCache = function () {
+    ejs.cache.reset();
+};
+function Template(text, optsParam) {
+    var opts = utils_js_1.default.hasOwnOnlyObject(optsParam);
+    var options = utils_js_1.default.createNullProtoObjWherePossible();
+    this.templateText = text;
+    /** @type {string | null} */
+    this.mode = null;
+    this.truncate = false;
+    this.currentLine = 1;
+    this.source = '';
+    options.escapeFunction = opts.escape || opts.escapeFunction || utils_js_1.default.escapeXML;
+    options.compileDebug = opts.compileDebug !== false;
+    options.debug = !!opts.debug;
+    options.filename = opts.filename;
+    options.openDelimiter = opts.openDelimiter || ejs.openDelimiter || _DEFAULT_OPEN_DELIMITER;
+    options.closeDelimiter = opts.closeDelimiter || ejs.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
+    options.delimiter = opts.delimiter || ejs.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.includer = opts.includer;
+    options.outputFunctionName = opts.outputFunctionName;
+    options.localsName = opts.localsName || ejs.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_js_1.default.escapeRegExpChars(this.opts.delimiter);
+        var open = utils_js_1.default.escapeRegExpChars(this.opts.openDelimiter);
+        var close = utils_js_1.default.escapeRegExpChars(this.opts.closeDelimiter);
+        str = str.replace(/%/g, delim)
+            .replace(/</g, open)
+            .replace(/>/g, close);
+        return new RegExp(str);
+    },
+    compile: function () {
+        /** @type {string} */
+        var src;
+        var fn;
+        var opts = this.opts;
+        var prepended = '';
+        var appended = '';
+        /** @type {EscapeCallback} */
+        var escapeFn = opts.escapeFunction;
+        /** @type {FunctionConstructor} */
+        var ctor;
+        /** @type {string} */
+        var sanitizedFilename = opts.filename ? JSON.stringify(opts.filename) : 'undefined';
+        if (!this.source) {
+            this.generateSource();
+            prepended +=
+                "  ".concat(DECLARATION_KEYWORD, " __output = \"\";\n") +
+                    '  function __append(s) { if (s !== undefined && s !== null) __output += s }\n';
+            if (opts.outputFunctionName) {
+                if (!_JS_IDENTIFIER.test(opts.outputFunctionName)) {
+                    throw new Error('outputFunctionName is not a valid JS identifier.');
+                }
+                prepended += "  ".concat(DECLARATION_KEYWORD, " ") + opts.outputFunctionName + ' = __append;' + '\n';
+            }
+            if (opts.localsName && !_JS_IDENTIFIER.test(opts.localsName)) {
+                throw new Error('localsName is not a valid JS identifier.');
+            }
+            if (opts.destructuredLocals && opts.destructuredLocals.length) {
+                var destructuring = "  ".concat(DECLARATION_KEYWORD, " __locals = (") + opts.localsName + ' || {}),\n';
+                for (var i = 0; i < opts.destructuredLocals.length; i++) {
+                    var name_1 = opts.destructuredLocals[i];
+                    if (!_JS_IDENTIFIER.test(name_1)) {
+                        throw new Error('destructuredLocals[' + i + '] is not a valid JS identifier.');
+                    }
+                    if (i > 0) {
+                        destructuring += ',\n  ';
+                    }
+                    destructuring += name_1 + ' = __locals.' + name_1;
+                }
+                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 = "".concat(DECLARATION_KEYWORD, " __line = 1") + '\n'
+                + '  , __lines = ' + JSON.stringify(this.templateText) + '\n'
+                + '  , __filename = ' + sanitizedFilename + ';' + '\n'
+                + 'try {' + '\n'
+                + this.source
+                + '} catch (e) {' + '\n'
+                + '  rethrow(e, __lines, __filename, __line, escapeFn);' + '\n'
+                + '}' + '\n';
+        }
+        else {
+            src = this.source;
+        }
+        if (opts.strict) {
+            src = '"use strict";\n' + src;
+        }
+        if (opts.debug) {
+            console.log(src);
+        }
+        if (opts.compileDebug && opts.filename) {
+            src = src + '\n'
+                + '//# sourceURL=' + sanitizedFilename + '\n';
+        }
+        try {
+            if (opts.async) {
+                // Have to use generated function for this, since in envs without support,
+                // it breaks in parsing
+                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) {
+            // istanbul ignore else
+            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;
+        }
+        // Return a callable function which will execute the function
+        // created by the source-code, with the passed data as locals
+        // Adds a local `include` function which allows full recursive include
+        var returnedFn = function anonymous(data) {
+            var include = function (path, includeData) {
+                var d = utils_js_1.default.shallowCopy(utils_js_1.default.createNullProtoObjWherePossible(), data);
+                if (includeData) {
+                    d = utils_js_1.default.shallowCopy(d, includeData);
+                }
+                return includeFile(path, opts)(d);
+            };
+            return fn.apply(opts.context, [data || utils_js_1.default.createNullProtoObjWherePossible(), escapeFn, include, rethrow]);
+        };
+        if (opts.filename && typeof Object.defineProperty === 'function') {
+            var filename = opts.filename;
+            var basename = path_1.default.basename(filename, path_1.default.extname(filename));
+            try {
+                Object.defineProperty(returnedFn, 'name', {
+                    value: basename,
+                    writable: false,
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            catch (e) { /* ignore */ }
+        }
+        return returnedFn;
+    },
+    generateSource: function () {
+        var opts = this.opts;
+        if (opts.rmWhitespace) {
+            // Have to use two separate replace here as `^` and `$` operators don't
+            // work well with `\r` and empty lines don't work well with the `m` flag.
+            this.templateText =
+                this.templateText.replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
+        }
+        var self = this;
+        var d = this.opts.delimiter;
+        var o = this.opts.openDelimiter;
+        var c = this.opts.closeDelimiter;
+        // Slurp spaces and tabs before opening whitespace slurp tag and after closing whitespace slurp tag
+        // Build the tags using custom delimiters: openDelimiter + delimiter + '_' and '_' + delimiter + closeDelimiter
+        var openWhitespaceSlurpTag = utils_js_1.default.escapeRegExpChars(o + d + '_');
+        var closeWhitespaceSlurpTag = utils_js_1.default.escapeRegExpChars('_' + d + c);
+        var openWhitespaceSlurpReplacement = o + d + '_';
+        var closeWhitespaceSlurpReplacement = '_' + d + c;
+        this.templateText =
+            this.templateText.replace(new RegExp('[ \\t]*' + openWhitespaceSlurpTag, 'gm'), openWhitespaceSlurpReplacement)
+                .replace(new RegExp(closeWhitespaceSlurpTag + '[ \\t]*', 'gm'), closeWhitespaceSlurpReplacement);
+        var matches = this.parseTemplateText();
+        if (matches && matches.length) {
+            matches.forEach(function (line, index) {
+                var closing;
+                // If this is an opening tag, check for closing tags
+                // FIXME: May end up with some false positives here
+                // Better to store modes as k/v with openDelimiter + delimiter as key
+                // Then this can simply check against the map
+                if (line.indexOf(o + d) === 0 // If it is a tag
+                    && line.indexOf(o + d + d) !== 0) { // and is not escaped
+                    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 + '".');
+                    }
+                }
+                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) {
+            // Only replace single leading linebreak in the line after
+            // -%> tag -- this is the single, trailing linebreak
+            // after the tag that the truncation mode replaces
+            // Handle Win / Unix / old Mac linebreaks -- do the \r\n
+            // combo first in the regex-or
+            line = line.replace(/^(?:\r\n|\r|\n)/, '');
+            this.truncate = false;
+        }
+        if (!line) {
+            return line;
+        }
+        // Preserve literal slashes
+        line = line.replace(/\\/g, '\\\\');
+        // Convert linebreaks
+        line = line.replace(/\n/g, '\\n');
+        line = line.replace(/\r/g, '\\r');
+        // Escape double-quotes
+        // - this will be the delimiter during execution
+        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:
+                // In script mode, depends on type of tag
+                if (this.mode) {
+                    // If '//' is found without a line break, add a line break.
+                    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) {
+                        // Just executing code
+                        case Template.modes.EVAL:
+                            this.source += '    ; ' + line + '\n';
+                            break;
+                        // Exec, esc, and output
+                        case Template.modes.ESCAPED:
+                            this.source += '    ; __append(escapeFn(' + stripSemi(line) + '))' + '\n';
+                            break;
+                        // Exec and output
+                        case Template.modes.RAW:
+                            this.source += '    ; __append(' + stripSemi(line) + ')' + '\n';
+                            break;
+                        case Template.modes.COMMENT:
+                            // Do nothing
+                            break;
+                        // Literal <%% mode, append as raw output
+                        case Template.modes.LITERAL:
+                            this._addOutput(line);
+                            break;
+                    }
+                }
+                // In string mode, just add the output
+                else {
+                    this._addOutput(line);
+                }
+        }
+        if (self.opts.compileDebug && newLineCount) {
+            this.currentLine += newLineCount;
+            this.source += '    ; __line = ' + this.currentLine + '\n';
+        }
+    }
+};
+/**
+ * Escape characters reserved in XML.
+ *
+ * This is simply an export of {@link module:utils.escapeXML}.
+ *
+ * If `markup` is `undefined` or `null`, the empty string is returned.
+ *
+ * @param {String} markup Input string
+ * @return {String} Escaped string
+ * @public
+ * @func
+ * */
+ejs.escapeXML = utils_js_1.default.escapeXML;
+/**
+ * Express.js support.
+ *
+ * This is an alias for {@link module:ejs.renderFile}, in order to support
+ * Express.js out-of-the-box.
+ *
+ * @func
+ */
+ejs.__express = ejs.renderFile;
+/* istanbul ignore if */
+if (typeof window != 'undefined') {
+    window.ejs = ejs;
+}
+if (typeof module != 'undefined') {
+    module.exports = ejs;
+}
+exports.default = ejs;

website/node_modules/ejs/lib/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

website/node_modules/ejs/lib/cjs/parseargs.js

@@ -0,0 +1,125 @@
+/*
+ * EJS Embedded JavaScript templates
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+var parseargs = {};
+var isOpt = function (arg) { return arg.indexOf('-') === 0; };
+var removeOptPrefix = function (opt) { return opt.replace(/^--/, '').replace(/^-/, ''); };
+/**
+ * @constructor
+ * Parses a list of command-line args into a key/value object of
+ * options and an array of positional commands.
+ * @param {Array} opts A list of options in the following format:
+ * [{full: 'foo', abbr: 'f'}, {full: 'bar', abbr: 'b'}]]
+ */
+parseargs.Parser = function (opts) {
+    // A key/value object of matching options parsed out of the args
+    this.opts = {};
+    this.taskNames = null;
+    this.envVars = null;
+    // Data structures used for parsing
+    this.reg = opts;
+    this.shortOpts = {};
+    this.longOpts = {};
+    var self = this;
+    [].forEach.call(opts, function (item) {
+        self.shortOpts[item.abbr] = item;
+        self.longOpts[item.full] = item;
+    });
+};
+parseargs.Parser.prototype = new function () {
+    var _trueOrNextVal = function (argParts, args) {
+        if (argParts[1]) {
+            return argParts[1];
+        }
+        else {
+            return (!args[0] || isOpt(args[0])) ?
+                true : args.shift();
+        }
+    };
+    /**
+     * Parses an array of arguments into options and positional commands
+     * @param {Array} args The command-line args to parse
+     */
+    this.parse = function (args) {
+        var cmds = [];
+        var cmd;
+        var envVars = {};
+        var opts = {};
+        var arg;
+        var argItem;
+        var argParts;
+        var cmdItems;
+        var taskNames = [];
+        var preempt;
+        while (args.length) {
+            arg = args.shift();
+            if (isOpt(arg)) {
+                arg = removeOptPrefix(arg);
+                argParts = arg.split('=');
+                argItem = this.longOpts[argParts[0]] || this.shortOpts[argParts[0]];
+                if (argItem) {
+                    // First-encountered preemptive opt takes precedence -- no further opts
+                    // or possibility of ambiguity, so just look for a value, or set to
+                    // true and then bail
+                    if (argItem.preempts) {
+                        opts[argItem.full] = _trueOrNextVal(argParts, args);
+                        preempt = true;
+                        break;
+                    }
+                    // If the opt requires a value, see if we can get a value from the
+                    // next arg, or infer true from no-arg -- if it's followed by another
+                    // opt, throw an error
+                    if (argItem.expectValue || argItem.allowValue) {
+                        opts[argItem.full] = _trueOrNextVal(argParts, args);
+                        if (argItem.expectValue && !opts[argItem.full]) {
+                            throw new Error(argItem.full + ' option expects a value.');
+                        }
+                    }
+                    else {
+                        opts[argItem.full] = true;
+                    }
+                }
+            }
+            else {
+                cmds.unshift(arg);
+            }
+        }
+        if (!preempt) {
+            // Parse out any env-vars and task-name
+            while ((cmd = cmds.pop())) {
+                cmdItems = cmd.split('=');
+                if (cmdItems.length > 1) {
+                    envVars[cmdItems[0]] = cmdItems[1];
+                }
+                else {
+                    taskNames.push(cmd);
+                }
+            }
+        }
+        return {
+            opts: opts,
+            envVars: envVars,
+            taskNames: taskNames
+        };
+    };
+};
+if (typeof exports != 'undefined') {
+    module.exports = parseargs;
+}
+exports.default = parseargs;

website/node_modules/ejs/lib/cjs/utils.js

@@ -0,0 +1,245 @@
+/*
+ * EJS Embedded JavaScript templates
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+/**
+ * Private utility functions
+ * @module utils
+ * @private
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils = {};
+var regExpChars = /[|\\{}()[\]^$+*?.]/g;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var hasOwn = function (obj, key) { return hasOwnProperty.apply(obj, [key]); };
+utils.hasOwn = hasOwn;
+/**
+ * Escape characters reserved in regular expressions.
+ *
+ * If `string` is `undefined` or `null`, the empty string is returned.
+ *
+ * @param {String} string Input string
+ * @return {String} Escaped string
+ * @static
+ * @private
+ */
+utils.escapeRegExpChars = function (string) {
+    // istanbul ignore if
+    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;
+}
+/**
+ * Stringified version of constants used by {@link module:utils.escapeXML}.
+ *
+ * @readonly
+ * @type {String}
+ */
+var escapeFuncStr = 'var _ENCODE_HTML_RULES = {\n'
+    + '      "&": "&amp;"\n'
+    + '    , "<": "&lt;"\n'
+    + '    , ">": "&gt;"\n'
+    + '    , \'"\': "&#34;"\n'
+    + '    , "\'": "&#39;"\n'
+    + '    }\n'
+    + '  , _MATCH_HTML = /[&<>\'"]/g;\n'
+    + 'function encode_char(c) {\n'
+    + '  return _ENCODE_HTML_RULES[c] || c;\n'
+    + '};\n';
+/**
+ * Escape characters reserved in XML.
+ *
+ * If `markup` is `undefined` or `null`, the empty string is returned.
+ *
+ * @implements {EscapeCallback}
+ * @param {String} markup Input string
+ * @return {String} Escaped string
+ * @static
+ * @private
+ */
+utils.escapeXML = function (markup) {
+    return markup == undefined
+        ? ''
+        : String(markup)
+            .replace(_MATCH_HTML, encode_char);
+};
+function escapeXMLToString() {
+    return Function.prototype.toString.call(this) + ';\n' + escapeFuncStr;
+}
+try {
+    if (typeof Object.defineProperty === 'function') {
+        // If the Function prototype is frozen, the "toString" property is non-writable. This means that any objects which inherit this property
+        // cannot have the property changed using an assignment. If using strict mode, attempting that will cause an error. If not using strict
+        // mode, attempting that will be silently ignored.
+        // However, we can still explicitly shadow the prototype's "toString" property by defining a new "toString" property on this object.
+        Object.defineProperty(utils.escapeXML, 'toString', { value: escapeXMLToString });
+    }
+    else {
+        // If Object.defineProperty() doesn't exist, attempt to shadow this property using the assignment operator.
+        utils.escapeXML.toString = escapeXMLToString;
+    }
+}
+catch (err) {
+    console.warn('Unable to set escapeXML.toString (is the Function prototype frozen?)');
+}
+/**
+ * Naive copy of properties from one object to another.
+ * Does not recurse into non-scalar properties
+ * Does not check to see if the property has a value before copying
+ *
+ * @param  {Object} to   Destination object
+ * @param  {Object} from Source object
+ * @return {Object}      Destination object
+ * @static
+ * @private
+ */
+utils.shallowCopy = function (to, from) {
+    from = from || {};
+    if ((to !== null) && (to !== undefined)) {
+        for (var p in from) {
+            if (!hasOwn(from, p)) {
+                continue;
+            }
+            if (p === '__proto__' || p === 'constructor') {
+                continue;
+            }
+            to[p] = from[p];
+        }
+    }
+    return to;
+};
+/**
+ * Naive copy of a list of key names, from one object to another.
+ * Only copies property if it is actually defined
+ * Does not recurse into non-scalar properties
+ *
+ * @param  {Object} to   Destination object
+ * @param  {Object} from Source object
+ * @param  {Array} list List of properties to copy
+ * @return {Object}      Destination object
+ * @static
+ * @private
+ */
+utils.shallowCopyFromList = function (to, from, list) {
+    list = list || [];
+    from = from || {};
+    if ((to !== null) && (to !== undefined)) {
+        for (var i = 0; i < list.length; i++) {
+            var p = list[i];
+            if (typeof from[p] != 'undefined') {
+                if (!hasOwn(from, p)) {
+                    continue;
+                }
+                if (p === '__proto__' || p === 'constructor') {
+                    continue;
+                }
+                to[p] = from[p];
+            }
+        }
+    }
+    return to;
+};
+/**
+ * Simple in-process cache implementation. Does not implement limits of any
+ * sort.
+ *
+ * @implements {Cache}
+ * @static
+ * @private
+ */
+utils.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 = {};
+    }
+};
+/**
+ * Transforms hyphen case variable into camel case.
+ *
+ * @param {String} string Hyphen case string
+ * @return {String} Camel case string
+ * @static
+ * @private
+ */
+utils.hyphenToCamel = function (str) {
+    return str.replace(/-[a-z]/g, function (match) { return match[1].toUpperCase(); });
+};
+/**
+ * Returns a null-prototype object in runtimes that support it
+ *
+ * @return {Object} Object, prototype will be set to null where possible
+ * @static
+ * @private
+ */
+utils.createNullProtoObjWherePossible = (function () {
+    if (typeof Object.create == 'function') {
+        return function () {
+            return Object.create(null);
+        };
+    }
+    if (!({ __proto__: null } instanceof Object)) {
+        return function () {
+            return { __proto__: null };
+        };
+    }
+    // Not possible, just pass through
+    return function () {
+        return {};
+    };
+})();
+/**
+ * Copies own-properties from one object to a null-prototype object for basic
+ * protection against prototype pollution
+ *
+ * @return {Object} Object with own-properties of input object
+ * @static
+ * @private
+ */
+utils.hasOwnOnlyObject = function (obj) {
+    var o = utils.createNullProtoObjWherePossible();
+    for (var p in obj) {
+        if (hasOwn(obj, p)) {
+            o[p] = obj[p];
+        }
+    }
+    return o;
+};
+if (typeof exports != 'undefined') {
+    module.exports = utils;
+}
+exports.default = utils;

website/node_modules/ejs/lib/esm/ejs.js

@@ -0,0 +1,928 @@
+/*
+ * EJS Embedded JavaScript templates
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+'use strict';
+
+import fs from 'node:fs';
+import path from 'node:path';
+import utils from './utils.js';
+
+/**
+ * @file Embedded JavaScript templating engine. {@link http://ejs.co}
+ * @author Matthew Eernisse <mde@fleegix.org>
+ * @project EJS
+ * @license {@link http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0}
+ */
+
+/**
+ * EJS internal functions.
+ *
+ * Technically this "module" lies in the same file as {@link module:ejs}, for
+ * the sake of organization all the private functions re grouped into this
+ * module.
+ *
+ * @module ejs-internal
+ * @private
+ */
+
+/**
+ * Embedded JavaScript templating engine.
+ *
+ * @module ejs
+ * @public
+ */
+
+// Keyword used in code generation -- updated to 'var' in CJS build
+const DECLARATION_KEYWORD = 'let';
+
+const ejs = {};
+
+/** @type {string} */
+let _DEFAULT_OPEN_DELIMITER = '<';
+let _DEFAULT_CLOSE_DELIMITER = '>';
+let _DEFAULT_DELIMITER = '%';
+let _DEFAULT_LOCALS_NAME = 'locals';
+let _REGEX_STRING = '(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)';
+let _OPTS_PASSABLE_WITH_DATA = ['delimiter', 'scope', 'context', 'debug', 'compileDebug',
+  '_with', 'rmWhitespace', 'strict', 'filename', 'async'];
+// We don't allow 'cache' option to be passed in the data obj for
+// the normal `render` call, but this is where Express 2 & 3 put it
+// so we make an exception for `renderFile`
+let _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat('cache');
+let _BOM = /^\uFEFF/;
+let _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+
+/**
+ * EJS template function cache. This can be a LRU object from lru-cache NPM
+ * module. By default, it is {@link module:utils.cache}, a simple in-process
+ * cache that grows continuously.
+ *
+ * @type {Cache}
+ */
+
+ejs.cache = utils.cache;
+
+/**
+ * Custom file loader. Useful for template preprocessing or restricting access
+ * to a certain part of the filesystem.
+ *
+ * @type {fileLoader}
+ */
+
+ejs.fileLoader = fs.readFileSync;
+
+/**
+ * Name of the object containing the locals.
+ *
+ * This variable is overridden by {@link Options}`.localsName` if it is not
+ * `undefined`.
+ *
+ * @type {String}
+ * @public
+ */
+
+ejs.localsName = _DEFAULT_LOCALS_NAME;
+
+/**
+ * Promise implementation -- defaults to the native implementation if available
+ * This is mostly just for testability
+ *
+ * @type {PromiseConstructorLike}
+ * @public
+ */
+
+ejs.promiseImpl = (new Function('return this;'))().Promise;
+
+/**
+ * Get the path to the included file from the parent file path and the
+ * specified path.
+ *
+ * @param {String}  name     specified path
+ * @param {String}  filename parent file path
+ * @param {Boolean} [isDir=false] whether the parent file path is a directory
+ * @return {String}
+ */
+ejs.resolveInclude = function(name, filename, isDir) {
+  let dirname = path.dirname;
+  let extname = path.extname;
+  let resolve = path.resolve;
+  let includePath = resolve(isDir ? filename : dirname(filename), name);
+  let ext = extname(name);
+  if (!ext) {
+    includePath += '.ejs';
+  }
+  return includePath;
+};
+
+/**
+ * Try to resolve file path on multiple directories
+ *
+ * @param  {String}        name  specified path
+ * @param  {Array<String>} paths list of possible parent directory paths
+ * @return {String}
+ */
+function resolvePaths(name, paths) {
+  let filePath;
+  if (paths.some(function (v) {
+    filePath = ejs.resolveInclude(name, v, true);
+    return fs.existsSync(filePath);
+  })) {
+    return filePath;
+  }
+}
+
+/**
+ * Get the path to the included file by Options
+ *
+ * @param  {String}  path    specified path
+ * @param  {Options} options compilation options
+ * @return {String}
+ */
+function getIncludePath(path, options) {
+  let includePath;
+  let filePath;
+  let views = options.views;
+  let match = /^[A-Za-z]+:\\|^\//.exec(path);
+
+  // Abs path
+  if (match && match.length) {
+    path = path.replace(/^\/*/, '');
+    if (Array.isArray(options.root)) {
+      includePath = resolvePaths(path, options.root);
+    } else {
+      includePath = ejs.resolveInclude(path, options.root || '/', true);
+    }
+  }
+  // Relative paths
+  else {
+    // Look relative to a passed filename first
+    if (options.filename) {
+      filePath = ejs.resolveInclude(path, options.filename);
+      if (fs.existsSync(filePath)) {
+        includePath = filePath;
+      }
+    }
+    // Then look in any views directories
+    if (!includePath && Array.isArray(views)) {
+      includePath = resolvePaths(path, views);
+    }
+    if (!includePath && typeof options.includer !== 'function') {
+      throw new Error('Could not find the include file "' +
+          options.escapeFunction(path) + '"');
+    }
+  }
+  return includePath;
+}
+
+/**
+ * Get the template from a string or a file, either compiled on-the-fly or
+ * read from cache (if enabled), and cache the template if needed.
+ *
+ * If `template` is not set, the file specified in `options.filename` will be
+ * read.
+ *
+ * If `options.cache` is true, this function reads the file from
+ * `options.filename` so it must be set prior to calling this function.
+ *
+ * @memberof module:ejs-internal
+ * @param {Options} options   compilation options
+ * @param {String} [template] template source
+ * @return {TemplateFunction}
+ * @static
+ */
+
+function handleCache(options, template) {
+  let func;
+  let filename = options.filename;
+  let hasTemplate = arguments.length > 1;
+
+  if (options.cache) {
+    if (!filename) {
+      throw new Error('cache option requires a filename');
+    }
+    func = ejs.cache.get(filename);
+    if (func) {
+      return func;
+    }
+    if (!hasTemplate) {
+      template = fileLoader(filename).toString().replace(_BOM, '');
+    }
+  }
+  else if (!hasTemplate) {
+    // istanbul ignore if: should not happen at all
+    if (!filename) {
+      throw new Error('Internal EJS error: no file name or template '
+                    + 'provided');
+    }
+    template = fileLoader(filename).toString().replace(_BOM, '');
+  }
+  func = ejs.compile(template, options);
+  if (options.cache) {
+    ejs.cache.set(filename, func);
+  }
+  return func;
+}
+
+/**
+ * Try calling handleCache with the given options and data and call the
+ * callback with the result. If an error occurs, call the callback with
+ * the error. Used by renderFile().
+ *
+ * @memberof module:ejs-internal
+ * @param {Options} options    compilation options
+ * @param {Object} data        template data
+ * @param {RenderFileCallback} cb callback
+ * @static
+ */
+
+function tryHandleCache(options, data, cb) {
+  let result;
+  if (!cb) {
+    if (typeof ejs.promiseImpl == 'function') {
+      return new ejs.promiseImpl(function (resolve, reject) {
+        try {
+          result = handleCache(options)(data);
+          resolve(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);
+  }
+}
+
+/**
+ * fileLoader is independent
+ *
+ * @param {String} filePath ejs file path.
+ * @return {String} The contents of the specified file.
+ * @static
+ */
+
+function fileLoader(filePath){
+  return ejs.fileLoader(filePath);
+}
+
+/**
+ * Get the template function.
+ *
+ * If `options.cache` is `true`, then the template is cached.
+ *
+ * @memberof module:ejs-internal
+ * @param {String}  path    path for the specified file
+ * @param {Options} options compilation options
+ * @return {TemplateFunction}
+ * @static
+ */
+
+function includeFile(path, options) {
+  let opts = utils.shallowCopy(utils.createNullProtoObjWherePossible(), options);
+  opts.filename = getIncludePath(path, opts);
+  if (typeof options.includer === 'function') {
+    let includerResult = options.includer(path, opts.filename);
+    if (includerResult) {
+      if (includerResult.filename) {
+        opts.filename = includerResult.filename;
+      }
+      if (includerResult.template) {
+        return handleCache(opts, includerResult.template);
+      }
+    }
+  }
+  return handleCache(opts);
+}
+
+/**
+ * Re-throw the given `err` in context to the `str` of ejs, `filename`, and
+ * `lineno`.
+ *
+ * @implements {RethrowCallback}
+ * @memberof module:ejs-internal
+ * @param {Error}  err      Error object
+ * @param {String} str      EJS source
+ * @param {String} flnm     file name of the EJS file
+ * @param {Number} lineno   line number of the error
+ * @param {EscapeCallback} esc
+ * @static
+ */
+
+function rethrow(err, str, flnm, lineno, esc) {
+  let lines = str.split('\n');
+  let start = Math.max(lineno - 3, 0);
+  let end = Math.min(lines.length, lineno + 3);
+  let filename = esc(flnm);
+  // Error context
+  let context = lines.slice(start, end).map(function (line, i){
+    let curr = i + start + 1;
+    return (curr == lineno ? ' >> ' : '    ')
+      + curr
+      + '| '
+      + line;
+  }).join('\n');
+
+  // Alter exception message
+  err.path = filename;
+  err.message = (filename || 'ejs') + ':'
+    + lineno + '\n'
+    + context + '\n\n'
+    + err.message;
+
+  throw err;
+}
+
+function stripSemi(str){
+  return str.replace(/;(\s*$)/, '$1');
+}
+
+/**
+ * Compile the given `str` of ejs into a template function.
+ *
+ * @param {String}  template EJS template
+ *
+ * @param {Options} [opts] compilation options
+ *
+ * @return {TemplateFunction}
+ * Note that the return type of the function depends on the value of `opts.async`.
+ * @public
+ */
+
+ejs.compile = function compile(template, opts) {
+  let templ;
+
+  // v1 compat
+  // 'scope' is 'context'
+  // FIXME: Remove this in a future version
+  if (opts && opts.scope) {
+    console.warn('`scope` option is deprecated and will be removed in future EJS');
+    if (!opts.context) {
+      opts.context = opts.scope;
+    }
+    delete opts.scope;
+  }
+  templ = new Template(template, opts);
+  return templ.compile();
+};
+
+/**
+ * Render the given `template` of ejs.
+ *
+ * If you would like to include options but not data, you need to explicitly
+ * call this function with `data` being an empty object or `null`.
+ *
+ * @param {String}   template EJS template
+ * @param {Object}  [data={}] template data
+ * @param {Options} [opts={}] compilation and rendering options
+ * @return {(String|Promise<String>)}
+ * Return value type depends on `opts.async`.
+ * @public
+ */
+
+ejs.render = function (template, d, o) {
+  let data = d || utils.createNullProtoObjWherePossible();
+  let opts = o || utils.createNullProtoObjWherePossible();
+
+  // No options object -- if there are optiony names
+  // in the data, copy them to options
+  if (arguments.length == 2) {
+    utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
+  }
+
+  return handleCache(opts, template)(data);
+};
+
+/**
+ * Render an EJS file at the given `path` and callback `cb(err, str)`.
+ *
+ * If you would like to include options but not data, you need to explicitly
+ * call this function with `data` being an empty object or `null`.
+ *
+ * @param {String}             path     path to the EJS file
+ * @param {Object}            [data={}] template data
+ * @param {Options}           [opts={}] compilation and rendering options
+ * @param {RenderFileCallback} cb callback
+ * @public
+ */
+
+ejs.renderFile = function () {
+  let args = Array.prototype.slice.call(arguments);
+  let filename = args.shift();
+  let cb;
+  let opts = {filename: filename};
+  let data;
+  let viewOpts;
+
+  // Do we have a callback?
+  if (typeof arguments[arguments.length - 1] == 'function') {
+    cb = args.pop();
+  }
+  // Do we have data/opts?
+  if (args.length) {
+    // Should always have data obj
+    data = args.shift();
+    // Normal passed opts (data obj + opts obj)
+    if (args.length) {
+      // Use shallowCopy so we don't pollute passed in opts obj with new vals
+      utils.shallowCopy(opts, args.pop());
+    }
+    // Special casing for Express (settings + opts-in-data)
+    else {
+      // Express 3 and 4
+      if (utils.hasOwn(data, 'settings') && data.settings) {
+        // Pull a few things from known locations
+        if (data.settings.views) {
+          opts.views = data.settings.views;
+        }
+        if (data.settings['view cache']) {
+          opts.cache = true;
+        }
+        // Undocumented after Express 2, but still usable, esp. for
+        // items that are unsafe to be passed along with data, like `root`
+        viewOpts = data.settings['view options'];
+        if (viewOpts) {
+          utils.shallowCopy(opts, viewOpts);
+        }
+      }
+      // Express 2 and lower, values set in app.locals, or people who just
+      // want to pass options in their data. NOTE: These values will override
+      // anything previously set in settings  or settings['view options']
+      utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
+    }
+    opts.filename = filename;
+  }
+  else {
+    data = utils.createNullProtoObjWherePossible();
+  }
+
+  return tryHandleCache(opts, data, cb);
+};
+
+/**
+ * Clear intermediate JavaScript cache. Calls {@link Cache#reset}.
+ * @public
+ */
+
+/**
+ * EJS template class
+ * @public
+ */
+ejs.Template = Template;
+
+ejs.clearCache = function () {
+  ejs.cache.reset();
+};
+
+function Template(text, optsParam) {
+  let opts = utils.hasOwnOnlyObject(optsParam);
+  let options = utils.createNullProtoObjWherePossible();
+  this.templateText = text;
+  /** @type {string | null} */
+  this.mode = null;
+  this.truncate = false;
+  this.currentLine = 1;
+  this.source = '';
+  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 || ejs.openDelimiter || _DEFAULT_OPEN_DELIMITER;
+  options.closeDelimiter = opts.closeDelimiter || ejs.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
+  options.delimiter = opts.delimiter || ejs.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.includer = opts.includer;
+  options.outputFunctionName = opts.outputFunctionName;
+  options.localsName = opts.localsName || ejs.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 () {
+    let str = _REGEX_STRING;
+    let delim = utils.escapeRegExpChars(this.opts.delimiter);
+    let open = utils.escapeRegExpChars(this.opts.openDelimiter);
+    let close = utils.escapeRegExpChars(this.opts.closeDelimiter);
+    str = str.replace(/%/g, delim)
+      .replace(/</g, open)
+      .replace(/>/g, close);
+    return new RegExp(str);
+  },
+
+  compile: function () {
+    /** @type {string} */
+    let src;
+    let fn;
+    let opts = this.opts;
+    let prepended = '';
+    let appended = '';
+    /** @type {EscapeCallback} */
+    let escapeFn = opts.escapeFunction;
+    /** @type {FunctionConstructor} */
+    let ctor;
+    /** @type {string} */
+    let sanitizedFilename = opts.filename ? JSON.stringify(opts.filename) : 'undefined';
+
+    if (!this.source) {
+      this.generateSource();
+      prepended +=
+        `  ${DECLARATION_KEYWORD} __output = "";\n` +
+        '  function __append(s) { if (s !== undefined && s !== null) __output += s }\n';
+      if (opts.outputFunctionName) {
+        if (!_JS_IDENTIFIER.test(opts.outputFunctionName)) {
+          throw new Error('outputFunctionName is not a valid JS identifier.');
+        }
+        prepended += `  ${DECLARATION_KEYWORD} ` + opts.outputFunctionName + ' = __append;' + '\n';
+      }
+      if (opts.localsName && !_JS_IDENTIFIER.test(opts.localsName)) {
+        throw new Error('localsName is not a valid JS identifier.');
+      }
+      if (opts.destructuredLocals && opts.destructuredLocals.length) {
+        let destructuring = `  ${DECLARATION_KEYWORD} __locals = (` + opts.localsName + ' || {}),\n';
+        for (let i = 0; i < opts.destructuredLocals.length; i++) {
+          let name = opts.destructuredLocals[i];
+          if (!_JS_IDENTIFIER.test(name)) {
+            throw new Error('destructuredLocals[' + i + '] is not a valid JS identifier.');
+          }
+          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 = `${DECLARATION_KEYWORD} __line = 1` + '\n'
+        + '  , __lines = ' + JSON.stringify(this.templateText) + '\n'
+        + '  , __filename = ' + sanitizedFilename + ';' + '\n'
+        + 'try {' + '\n'
+        + this.source
+        + '} catch (e) {' + '\n'
+        + '  rethrow(e, __lines, __filename, __line, escapeFn);' + '\n'
+        + '}' + '\n';
+    }
+    else {
+      src = this.source;
+    }
+
+    if (opts.strict) {
+      src = '"use strict";\n' + src;
+    }
+    if (opts.debug) {
+      console.log(src);
+    }
+    if (opts.compileDebug && opts.filename) {
+      src = src + '\n'
+        + '//# sourceURL=' + sanitizedFilename + '\n';
+    }
+
+    try {
+      if (opts.async) {
+        // Have to use generated function for this, since in envs without support,
+        // it breaks in parsing
+        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) {
+      // istanbul ignore else
+      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;
+    }
+
+    // Return a callable function which will execute the function
+    // created by the source-code, with the passed data as locals
+    // Adds a local `include` function which allows full recursive include
+    let returnedFn = function anonymous(data) {
+      let include = function (path, includeData) {
+        let d = utils.shallowCopy(utils.createNullProtoObjWherePossible(), data);
+        if (includeData) {
+          d = utils.shallowCopy(d, includeData);
+        }
+        return includeFile(path, opts)(d);
+      };
+      return fn.apply(opts.context,
+        [data || utils.createNullProtoObjWherePossible(), escapeFn, include, rethrow]);
+    };
+    if (opts.filename && typeof Object.defineProperty === 'function') {
+      let filename = opts.filename;
+      let basename = path.basename(filename, path.extname(filename));
+      try {
+        Object.defineProperty(returnedFn, 'name', {
+          value: basename,
+          writable: false,
+          enumerable: false,
+          configurable: true
+        });
+      } catch (e) {/* ignore */}
+    }
+    return returnedFn;
+  },
+
+  generateSource: function () {
+    let opts = this.opts;
+
+    if (opts.rmWhitespace) {
+      // Have to use two separate replace here as `^` and `$` operators don't
+      // work well with `\r` and empty lines don't work well with the `m` flag.
+      this.templateText =
+        this.templateText.replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
+    }
+
+    let self = this;
+    let d = this.opts.delimiter;
+    let o = this.opts.openDelimiter;
+    let c = this.opts.closeDelimiter;
+
+    // Slurp spaces and tabs before opening whitespace slurp tag and after closing whitespace slurp tag
+    // Build the tags using custom delimiters: openDelimiter + delimiter + '_' and '_' + delimiter + closeDelimiter
+    let openWhitespaceSlurpTag = utils.escapeRegExpChars(o + d + '_');
+    let closeWhitespaceSlurpTag = utils.escapeRegExpChars('_' + d + c);
+    let openWhitespaceSlurpReplacement = o + d + '_';
+    let closeWhitespaceSlurpReplacement = '_' + d + c;
+    this.templateText =
+      this.templateText.replace(new RegExp('[ \\t]*' + openWhitespaceSlurpTag, 'gm'), openWhitespaceSlurpReplacement)
+        .replace(new RegExp(closeWhitespaceSlurpTag + '[ \\t]*', 'gm'), closeWhitespaceSlurpReplacement);
+
+    let matches = this.parseTemplateText();
+
+    if (matches && matches.length) {
+      matches.forEach(function (line, index) {
+        let closing;
+        // If this is an opening tag, check for closing tags
+        // FIXME: May end up with some false positives here
+        // Better to store modes as k/v with openDelimiter + delimiter as key
+        // Then this can simply check against the map
+        if ( line.indexOf(o + d) === 0        // If it is a tag
+          && line.indexOf(o + d + d) !== 0) { // and is not escaped
+          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 + '".');
+          }
+        }
+        self.scanLine(line);
+      });
+    }
+
+  },
+
+  parseTemplateText: function () {
+    let str = this.templateText;
+    let pat = this.regex;
+    let result = pat.exec(str);
+    let arr = [];
+    let 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) {
+      // Only replace single leading linebreak in the line after
+      // -%> tag -- this is the single, trailing linebreak
+      // after the tag that the truncation mode replaces
+      // Handle Win / Unix / old Mac linebreaks -- do the \r\n
+      // combo first in the regex-or
+      line = line.replace(/^(?:\r\n|\r|\n)/, '');
+      this.truncate = false;
+    }
+    if (!line) {
+      return line;
+    }
+
+    // Preserve literal slashes
+    line = line.replace(/\\/g, '\\\\');
+
+    // Convert linebreaks
+    line = line.replace(/\n/g, '\\n');
+    line = line.replace(/\r/g, '\\r');
+
+    // Escape double-quotes
+    // - this will be the delimiter during execution
+    line = line.replace(/"/g, '\\"');
+    this.source += '    ; __append("' + line + '")' + '\n';
+  },
+
+  scanLine: function (line) {
+    let self = this;
+    let d = this.opts.delimiter;
+    let o = this.opts.openDelimiter;
+    let c = this.opts.closeDelimiter;
+    let 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:
+      // In script mode, depends on type of tag
+      if (this.mode) {
+        // If '//' is found without a line break, add a line break.
+        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) {
+        // Just executing code
+        case Template.modes.EVAL:
+          this.source += '    ; ' + line + '\n';
+          break;
+          // Exec, esc, and output
+        case Template.modes.ESCAPED:
+          this.source += '    ; __append(escapeFn(' + stripSemi(line) + '))' + '\n';
+          break;
+          // Exec and output
+        case Template.modes.RAW:
+          this.source += '    ; __append(' + stripSemi(line) + ')' + '\n';
+          break;
+        case Template.modes.COMMENT:
+          // Do nothing
+          break;
+          // Literal <%% mode, append as raw output
+        case Template.modes.LITERAL:
+          this._addOutput(line);
+          break;
+        }
+      }
+      // In string mode, just add the output
+      else {
+        this._addOutput(line);
+      }
+    }
+
+    if (self.opts.compileDebug && newLineCount) {
+      this.currentLine += newLineCount;
+      this.source += '    ; __line = ' + this.currentLine + '\n';
+    }
+  }
+};
+
+/**
+ * Escape characters reserved in XML.
+ *
+ * This is simply an export of {@link module:utils.escapeXML}.
+ *
+ * If `markup` is `undefined` or `null`, the empty string is returned.
+ *
+ * @param {String} markup Input string
+ * @return {String} Escaped string
+ * @public
+ * @func
+ * */
+ejs.escapeXML = utils.escapeXML;
+
+/**
+ * Express.js support.
+ *
+ * This is an alias for {@link module:ejs.renderFile}, in order to support
+ * Express.js out-of-the-box.
+ *
+ * @func
+ */
+
+ejs.__express = ejs.renderFile;
+
+/* istanbul ignore if */
+if (typeof window != 'undefined') {
+  window.ejs = ejs;
+}
+
+if (typeof module != 'undefined') {
+  module.exports = ejs;
+}
+export default ejs;

website/node_modules/ejs/lib/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

website/node_modules/ejs/lib/esm/parseargs.js

@@ -0,0 +1,139 @@
+/*
+ * EJS Embedded JavaScript templates
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+'use strict';
+
+let parseargs = {};
+let isOpt = function (arg) { return arg.indexOf('-') === 0; };
+let removeOptPrefix = function (opt) { return opt.replace(/^--/, '').replace(/^-/, ''); };
+
+/**
+ * @constructor
+ * Parses a list of command-line args into a key/value object of
+ * options and an array of positional commands.
+ * @param {Array} opts A list of options in the following format:
+ * [{full: 'foo', abbr: 'f'}, {full: 'bar', abbr: 'b'}]]
+ */
+parseargs.Parser = function (opts) {
+  // A key/value object of matching options parsed out of the args
+  this.opts = {};
+  this.taskNames = null;
+  this.envVars = null;
+
+  // Data structures used for parsing
+  this.reg = opts;
+  this.shortOpts = {};
+  this.longOpts = {};
+
+  let self = this;
+  [].forEach.call(opts, function (item) {
+    self.shortOpts[item.abbr] = item;
+    self.longOpts[item.full] = item;
+  });
+};
+
+parseargs.Parser.prototype = new function () {
+
+  let _trueOrNextVal = function (argParts, args) {
+    if (argParts[1]) {
+      return argParts[1];
+    }
+    else {
+      return (!args[0] || isOpt(args[0])) ?
+        true : args.shift();
+    }
+  };
+
+  /**
+   * Parses an array of arguments into options and positional commands
+   * @param {Array} args The command-line args to parse
+   */
+  this.parse = function (args) {
+    let cmds = [];
+    let cmd;
+    let envVars = {};
+    let opts = {};
+    let arg;
+    let argItem;
+    let argParts;
+    let cmdItems;
+    let taskNames = [];
+    let preempt;
+
+    while (args.length) {
+      arg = args.shift();
+
+      if (isOpt(arg)) {
+        arg = removeOptPrefix(arg);
+        argParts = arg.split('=');
+        argItem = this.longOpts[argParts[0]] || this.shortOpts[argParts[0]];
+        if (argItem) {
+          // First-encountered preemptive opt takes precedence -- no further opts
+          // or possibility of ambiguity, so just look for a value, or set to
+          // true and then bail
+          if (argItem.preempts) {
+            opts[argItem.full] = _trueOrNextVal(argParts, args);
+            preempt = true;
+            break;
+          }
+          // If the opt requires a value, see if we can get a value from the
+          // next arg, or infer true from no-arg -- if it's followed by another
+          // opt, throw an error
+          if (argItem.expectValue || argItem.allowValue) {
+            opts[argItem.full] = _trueOrNextVal(argParts, args);
+            if (argItem.expectValue && !opts[argItem.full]) {
+              throw new Error(argItem.full + ' option expects a value.');
+            }
+          }
+          else {
+            opts[argItem.full] = true;
+          }
+        }
+      }
+      else {
+        cmds.unshift(arg);
+      }
+    }
+
+    if (!preempt) {
+      // Parse out any env-vars and task-name
+      while ((cmd = cmds.pop())) {
+        cmdItems = cmd.split('=');
+        if (cmdItems.length > 1) {
+          envVars[cmdItems[0]] = cmdItems[1];
+        }
+        else {
+          taskNames.push(cmd);
+        }
+      }
+
+    }
+
+    return {
+      opts: opts,
+      envVars: envVars,
+      taskNames: taskNames
+    };
+  };
+
+};
+
+if (typeof exports != 'undefined') {
+  module.exports = parseargs;
+}
+export default parseargs;

website/node_modules/ejs/lib/esm/utils.js

@@ -0,0 +1,262 @@
+/*
+ * EJS Embedded JavaScript templates
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+/**
+ * Private utility functions
+ * @module utils
+ * @private
+ */
+
+'use strict';
+
+const utils = {};
+var regExpChars = /[|\\{}()[\]^$+*?.]/g;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var hasOwn = function (obj, key) { return hasOwnProperty.apply(obj, [key]); };
+utils.hasOwn = hasOwn;
+
+/**
+ * Escape characters reserved in regular expressions.
+ *
+ * If `string` is `undefined` or `null`, the empty string is returned.
+ *
+ * @param {String} string Input string
+ * @return {String} Escaped string
+ * @static
+ * @private
+ */
+utils.escapeRegExpChars = function (string) {
+  // istanbul ignore if
+  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;
+}
+
+/**
+ * Stringified version of constants used by {@link module:utils.escapeXML}.
+ *
+ * @readonly
+ * @type {String}
+ */
+
+var escapeFuncStr =
+  'var _ENCODE_HTML_RULES = {\n'
++ '      "&": "&amp;"\n'
++ '    , "<": "&lt;"\n'
++ '    , ">": "&gt;"\n'
++ '    , \'"\': "&#34;"\n'
++ '    , "\'": "&#39;"\n'
++ '    }\n'
++ '  , _MATCH_HTML = /[&<>\'"]/g;\n'
++ 'function encode_char(c) {\n'
++ '  return _ENCODE_HTML_RULES[c] || c;\n'
++ '};\n';
+
+/**
+ * Escape characters reserved in XML.
+ *
+ * If `markup` is `undefined` or `null`, the empty string is returned.
+ *
+ * @implements {EscapeCallback}
+ * @param {String} markup Input string
+ * @return {String} Escaped string
+ * @static
+ * @private
+ */
+
+utils.escapeXML = function (markup) {
+  return markup == undefined
+    ? ''
+    : String(markup)
+      .replace(_MATCH_HTML, encode_char);
+};
+
+function escapeXMLToString() {
+  return Function.prototype.toString.call(this) + ';\n' + escapeFuncStr;
+}
+
+try {
+  if (typeof Object.defineProperty === 'function') {
+  // If the Function prototype is frozen, the "toString" property is non-writable. This means that any objects which inherit this property
+  // cannot have the property changed using an assignment. If using strict mode, attempting that will cause an error. If not using strict
+  // mode, attempting that will be silently ignored.
+  // However, we can still explicitly shadow the prototype's "toString" property by defining a new "toString" property on this object.
+    Object.defineProperty(utils.escapeXML, 'toString', { value: escapeXMLToString });
+  } else {
+    // If Object.defineProperty() doesn't exist, attempt to shadow this property using the assignment operator.
+    utils.escapeXML.toString = escapeXMLToString;
+  }
+} catch (err) {
+  console.warn('Unable to set escapeXML.toString (is the Function prototype frozen?)');
+}
+
+/**
+ * Naive copy of properties from one object to another.
+ * Does not recurse into non-scalar properties
+ * Does not check to see if the property has a value before copying
+ *
+ * @param  {Object} to   Destination object
+ * @param  {Object} from Source object
+ * @return {Object}      Destination object
+ * @static
+ * @private
+ */
+utils.shallowCopy = function (to, from) {
+  from = from || {};
+  if ((to !== null) && (to !== undefined)) {
+    for (var p in from) {
+      if (!hasOwn(from, p)) {
+        continue;
+      }
+      if (p === '__proto__' || p === 'constructor') {
+        continue;
+      }
+      to[p] = from[p];
+    }
+  }
+  return to;
+};
+
+/**
+ * Naive copy of a list of key names, from one object to another.
+ * Only copies property if it is actually defined
+ * Does not recurse into non-scalar properties
+ *
+ * @param  {Object} to   Destination object
+ * @param  {Object} from Source object
+ * @param  {Array} list List of properties to copy
+ * @return {Object}      Destination object
+ * @static
+ * @private
+ */
+utils.shallowCopyFromList = function (to, from, list) {
+  list = list || [];
+  from = from || {};
+  if ((to !== null) && (to !== undefined)) {
+    for (var i = 0; i < list.length; i++) {
+      var p = list[i];
+      if (typeof from[p] != 'undefined') {
+        if (!hasOwn(from, p)) {
+          continue;
+        }
+        if (p === '__proto__' || p === 'constructor') {
+          continue;
+        }
+        to[p] = from[p];
+      }
+    }
+  }
+  return to;
+};
+
+/**
+ * Simple in-process cache implementation. Does not implement limits of any
+ * sort.
+ *
+ * @implements {Cache}
+ * @static
+ * @private
+ */
+utils.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 = {};
+  }
+};
+
+/**
+ * Transforms hyphen case variable into camel case.
+ *
+ * @param {String} string Hyphen case string
+ * @return {String} Camel case string
+ * @static
+ * @private
+ */
+utils.hyphenToCamel = function (str) {
+  return str.replace(/-[a-z]/g, function (match) { return match[1].toUpperCase(); });
+};
+
+/**
+ * Returns a null-prototype object in runtimes that support it
+ *
+ * @return {Object} Object, prototype will be set to null where possible
+ * @static
+ * @private
+ */
+utils.createNullProtoObjWherePossible = (function () {
+  if (typeof Object.create == 'function') {
+    return function () {
+      return Object.create(null);
+    };
+  }
+  if (!({__proto__: null} instanceof Object)) {
+    return function () {
+      return {__proto__: null};
+    };
+  }
+  // Not possible, just pass through
+  return function () {
+    return {};
+  };
+})();
+
+/**
+ * Copies own-properties from one object to a null-prototype object for basic
+ * protection against prototype pollution
+ *
+ * @return {Object} Object with own-properties of input object
+ * @static
+ * @private
+ */
+utils.hasOwnOnlyObject = function (obj) {
+  var o = utils.createNullProtoObjWherePossible();
+  for (var p in obj) {
+    if (hasOwn(obj, p)) {
+      o[p] = obj[p];
+    }
+  }
+  return o;
+};
+
+if (typeof exports != 'undefined') {
+  module.exports = utils;
+}
+export default utils;